Struct parsell::impls::Emit

pub struct Emit<F>(_);

Methods

impl<T> Emit<T>

fn new(t: T) -> Self

Trait Implementations

impl<F> Parser for Emit<F>

fn or_else<P>(self, other: P) -> OrElse<Self, P> where Self: Sized, P: Parser

fn and_then<P>(self, other: P) -> AndThen<Self, P> where Self: Sized, P: Parser

fn try_and_then<P>(self, other: P) -> Map<AndThen<Self, P>, TryZip> where Self: Sized, P: Parser

fn and_then_try<P>(self, other: P) -> Map<AndThen<Self, P>, ZipTry> where Self: Sized, P: Parser

fn try_and_then_try<P>(self, other: P) -> VariantMap<AndThen<Self, P>, TryZipTry> where Self: Sized, P: Parser

fn plus<F>(self, factory: F) -> Plus<Self, F> where Self: Sized, F: Factory

fn star<F>(self, factory: F) -> Star<Self, F> where Self: Sized, F: Factory

fn map<F>(self, f: F) -> Map<Self, F> where Self: Sized

fn map2<F>(self, f: F) -> Map<Self, Function2<F>> where Self: Sized

fn map3<F>(self, f: F) -> Map<Self, Function3<F>> where Self: Sized

fn map4<F>(self, f: F) -> Map<Self, Function4<F>> where Self: Sized

fn map5<F>(self, f: F) -> Map<Self, Function5<F>> where Self: Sized

fn map6<F>(self, f: F) -> Map<Self, Function6<F>> where Self: Sized

fn try_map<F>(self, f: F) -> Map<Self, Try<F>> where Self: Sized

fn try_map2<F>(self, f: F) -> Map<Self, Try<Function2<F>>> where Self: Sized

fn try_map3<F>(self, f: F) -> Map<Self, Try<Function3<F>>> where Self: Sized

fn try_map4<F>(self, f: F) -> Map<Self, Try<Function4<F>>> where Self: Sized

fn try_map5<F>(self, f: F) -> Map<Self, Try<Function5<F>>> where Self: Sized

fn try_map6<F>(self, f: F) -> Map<Self, Try<Function6<F>>> where Self: Sized

fn map_ref<F>(self, f: F) -> Map<Self, Dereference<F>> where Self: Sized

fn variant_map<F>(self, f: F) -> VariantMap<Self, F> where Self: Sized

fn discard_and_then<P>(self, other: P) -> VariantMap<AndThen<Discard<Self>, P>, Second> where Self: Sized, P: Parser

fn and_then_discard<P>(self, other: P) -> VariantMap<AndThen<Self, Discard<P>>, First> where Self: Sized, P: Parser

fn try_discard_and_then<P>(self, other: P) -> VariantMap<Map<AndThen<Map<Self, TryDiscard>, P>, TryZip>, Try<Second>> where Self: Sized, P: Parser

fn and_then_try_discard<P>(self, other: P) -> VariantMap<Map<AndThen<Self, Map<P, TryDiscard>>, ZipTry>, Try<First>> where Self: Sized, P: Parser

fn try_discard_and_then_try<P>(self, other: P) -> VariantMap<VariantMap<AndThen<Map<Self, TryDiscard>, P>, TryZipTry>, Try<Second>> where Self: Sized, P: Parser

fn try_and_then_try_discard<P>(self, other: P) -> VariantMap<VariantMap<AndThen<Self, Map<P, TryDiscard>>, TryZipTry>, Try<First>> where Self: Sized, P: Parser

fn opt(self) -> Opt<Self> where Self: Sized

fn try_opt(self) -> VariantMap<Opt<Self>, TryOpt> where Self: Sized

fn discard(self) -> Discard<Self> where Self: Sized

fn try_discard(self) -> Map<Self, TryDiscard> where Self: Sized

fn boxed<F>(self, f: F) -> Boxed<Self, F> where Self: Sized

fn in_state<State>(self, state: State) -> InState<Self, State> where Self: Sized

fn buffer(self) -> Buffered<Self> where Self: Sized

impl<F, Ch, Str> Stateful<Ch, Str, F::Output> for Emit<F> where F: Factory

fn more(self, _: &mut Str) -> ParseResult<Self, F::Output>

fn done(self) -> F::Output

fn last(self, string: &mut Str) -> Output where Self: Sized

impl<F, Ch, Str> HasOutput<Ch, Str> for Emit<F> where F: Factory

type Output = F::Output

impl<F, Ch, Str> Uncommitted<Ch, Str, F::Output> for Emit<F> where Str: PeekableIterator, F: 'static + Copy + Factory

type State = Self

fn init(&self, string: &mut Str) -> Option<ParseResult<Self, F::Output>>

impl<F, Ch, Str> Committed<Ch, Str, F::Output> for Emit<F> where Str: PeekableIterator, F: 'static + Copy + Factory

fn empty(&self) -> F::Output

Derived Implementations

impl<F: Debug> Debug for Emit<F>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

impl<F: Clone> Clone for Emit<F>

fn clone(&self) -> Emit<F>

fn clone_from(&mut self, source: &Self)

impl<F: Copy> Copy for Emit<F>