Trait exprz::parse::Parser[−][src]

pub trait Parser<T, E> where
    E: Expression, {
    type AtomParseError;
    fn classify(term: &T) -> SymbolType;

    fn parse_atom_continue<I>(
        iter: &mut Peekable<I>
    ) -> Result<E::Atom, Self::AtomParseError>
    where
        I: Iterator<Item = T>;

    fn parse<I>(iter: I) -> Result<E, Self::AtomParseError>
    where
        E::Group: FromIterator<E>,
        I: IntoIterator<Item = T>,
    { ... }

    fn parse_continue<I>(
        iter: &mut Peekable<I>
    ) -> Result<E, Self::AtomParseError>
    where
        E::Group: FromIterator<E>,
        I: Iterator<Item = T>,
    { ... }

    fn parse_atom<I>(iter: I) -> Result<E::Atom, Self::AtomParseError>
    where
        I: IntoIterator<Item = T>,
    { ... }

    fn parse_atom_expression<I>(iter: I) -> Result<E, Self::AtomParseError>
    where
        I: IntoIterator<Item = T>,
    { ... }

    fn parse_atom_expression_continue<I>(
        iter: &mut Peekable<I>
    ) -> Result<E, Self::AtomParseError>
    where
        I: Iterator<Item = T>,
    { ... }

    fn parse_group<I>(iter: I) -> Result<E::Group, Self::AtomParseError>
    where
        E::Group: FromIterator<E>,
        I: IntoIterator<Item = T>,
    { ... }

    fn parse_group_expression<I>(iter: I) -> Result<E, Self::AtomParseError>
    where
        E::Group: FromIterator<E>,
        I: IntoIterator<Item = T>,
    { ... }

    fn parse_group_continue<I>(
        iter: &mut Peekable<I>
    ) -> Result<E::Group, Self::AtomParseError>
    where
        E::Group: FromIterator<E>,
        I: Iterator<Item = T>,
    { ... }

    fn parse_group_expression_continue<I>(
        iter: &mut Peekable<I>
    ) -> Result<E, Self::AtomParseError>
    where
        E::Group: FromIterator<E>,
        I: Iterator<Item = T>,
    { ... }
}
This is supported on crate feature parse only.

Expression Parser Trait

The parser Parser<T, E> can parse an Expression of type E from an iterator over T.

Associated Types

type AtomParseError[src]

Atom Parsing Error Type

Loading content...

Required methods

fn classify(term: &T) -> SymbolType[src]

Classifies an incoming term.

fn parse_atom_continue<I>(
    iter: &mut Peekable<I>
) -> Result<E::Atom, Self::AtomParseError> where
    I: Iterator<Item = T>, [src]

Tries to parse an Atom from an Iterator over T.

Note

The iterator may still have elements remaining after parsing one Atom. To parse exactly one Atom, consuming the incoming iterator, try parse_atom instead.

Loading content...

Provided methods

fn parse<I>(iter: I) -> Result<E, Self::AtomParseError> where
    E::Group: FromIterator<E>,
    I: IntoIterator<Item = T>, [src]

Parses an Expression from an Iterator over T.

Note

This function consumes the iterator expecting nothing before or after the parsed Expression. To pause parsing after one Expression, try parse_continue instead.

fn parse_continue<I>(iter: &mut Peekable<I>) -> Result<E, Self::AtomParseError> where
    E::Group: FromIterator<E>,
    I: Iterator<Item = T>, [src]

Tries to parse an Expression from an Iterator over T.

Note

The iterator may still have elements remaining after parsing one Expression. To parse exactly one Expression, consuming the incoming iterator, try parse instead.

fn parse_atom<I>(iter: I) -> Result<E::Atom, Self::AtomParseError> where
    I: IntoIterator<Item = T>, [src]

Parses an Atom from an Iterator over T.

Note

This function consumes the iterator expecting nothing before or after the parsed Atom. To pause parsing after one Atom, try parse_atom_continue instead.

fn parse_atom_expression<I>(iter: I) -> Result<E, Self::AtomParseError> where
    I: IntoIterator<Item = T>, [src]

Parses an Atom from an Iterator over T.

Note

This function consumes the iterator expecting nothing before or after the parsed Atom. To pause parsing after one Atom, try parse_atom_continue instead.

fn parse_atom_expression_continue<I>(
    iter: &mut Peekable<I>
) -> Result<E, Self::AtomParseError> where
    I: Iterator<Item = T>, [src]

Tries to parse an Atom from an Iterator over T.

Note

The iterator may still have elements remaining after parsing one Atom. To parse exactly one Atom, consuming the incoming iterator, try parse_atom instead.

fn parse_group<I>(iter: I) -> Result<E::Group, Self::AtomParseError> where
    E::Group: FromIterator<E>,
    I: IntoIterator<Item = T>, [src]

Parses an Group from an Iterator over T.

Note

This function consumes the iterator expecting nothing before or after the parsed Group. To pause parsing after one Group, try parse_group_continue instead.

fn parse_group_expression<I>(iter: I) -> Result<E, Self::AtomParseError> where
    E::Group: FromIterator<E>,
    I: IntoIterator<Item = T>, [src]

Parses an Group from an Iterator over T.

Note

This function consumes the iterator expecting nothing before or after the parsed Group. To pause parsing after one Group, try parse_group_continue instead.

fn parse_group_continue<I>(
    iter: &mut Peekable<I>
) -> Result<E::Group, Self::AtomParseError> where
    E::Group: FromIterator<E>,
    I: Iterator<Item = T>, [src]

Tries to parse a Group from an Iterator over T.

Note

The iterator may still have elements remaining after parsing one Group. To parse exactly one Group, consuming the incoming iterator, try parse_group instead.

fn parse_group_expression_continue<I>(
    iter: &mut Peekable<I>
) -> Result<E, Self::AtomParseError> where
    E::Group: FromIterator<E>,
    I: Iterator<Item = T>, [src]

Tries to parse a Group from an Iterator over T.

Note

The iterator may still have elements remaining after parsing one Group. To parse exactly one Group, consuming the incoming iterator, try parse_group instead.

Loading content...

Implementors

impl<E> Parser<char, E> for FromCharacters where
    E: Expression,
    E::Atom: FromIterator<char>, [src]

type AtomParseError = FromCharactersParseError

Loading content...