Applicative functor interface

[asajeffrey]

Really, the interface should be an applicative functor. The idea would be:

interface Parser { ... fn apply<P>(self, p: P) -> Apply<Self, P> { ... } ... }
impl<P,Q,Str> Uncommitted<Str> for Apply<P,Q> 
    where P: Uncommitted<Str>,
          Q: Committed<Str>,
          P::Output: Function<Q::Output>, 
{ ... }

so you could write something like:

character(...).emitting(myfun).apply(this).apply(that);

This would support Kleene Star as well, with something like:

interface Parser { ... fn apply_star<P>(self, p: P) -> ApplyStar<Self, P> { ... } ... }
impl<P,Q,Str> Uncommitted<Str> for ApplyStar<P,Q> 
    where P: Uncommitted<Str>,
          Q: Uncommitted<Str>,
          P::Output: Function<Q::Output, Output = P::Output>, 
{ ... }

For example, the current p.star(f) would be:

emit(f).apply_star(p)

and the current p.plus(f) would be:

p.map(|x| f().apply(x)).apply_star(p)

this uses F: FnOnce(X) -> F as a replacement for Consumer<F>.