Struct honeycomb::Parser

pub struct Parser<T> {
    pub expectation: String,
    // some fields omitted
}

A Parser has a function that consumes input and returns an object of type Output.

Fields

expectation: String

Methods

impl<T> Parser<T> where
    T: 'static + Clone, 

pub fn new(
    parser: impl Fn(&str) -> Output<T> + 'static,
    expectation: impl ToString
) -> Self

Create a new parser from a function that returns an Output. This is mainly used to define the atomic combinators

pub fn expects(self, expectation: impl ToString) -> Self

pub fn parse(&self, input: &str) -> Result<T, Error>

This parses a string using this combinator, and returns a result containing either the successfully lexed and parsed data, or an error containing info about the failure.

pub fn parse_internal(&self, input: &str) -> Output<T>

This is used by the atomic combinators for things like control flow and passing the output of one parser into another.

pub fn map<O>(self, map_fn: fn(_: T) -> O) -> Parser<O> where
    O: 'static + Clone, 

This method takes a function that takes the output of this Parser, and converts it to the output of another data type. This allows us to lex our input as we parse it.

pub fn convert<O, E>(self, convert_fn: fn(_: T) -> Result<O, E>) -> Parser<O> where
    O: 'static + Clone,
    E: 'static, 

This method takes a function that takes the output of this Parser, and TRIES to convert it to the output of another data type. If the given function returns an Err, this parser fails.

pub fn prefixes<O>(self, operand: Parser<O>) -> Parser<O> where
    O: 'static + Clone, 

This parser "prefixes" another. When the returned parser is used, it will require this parser and the operand parser to succeed, and return the result of the second.

pub fn suffix<O>(self, operand: Parser<O>) -> Parser<T> where
    O: 'static + Clone, 

This parser will use the operand as a "suffix". The parser will only succeed if the "suffix" parser succeeds afterwards, but the input of the "suffix" parser will be discarded.

pub fn is(self) -> Parser<()>

This method returns a parser that does not consume input, but succeeds if this parser succeeds. This can be used to make assertions for our input.

pub fn isnt(self) -> Parser<()>

This method returns a parser that does not consume input, but succeeds if this parser does not succeed. This can be used to make assertions for our input.

pub fn and<O>(self, operand: Parser<O>) -> Parser<(T, O)> where
    O: 'static + Clone, 

Combine two parsers into one, and combine their consumed inputs into a tuple. Parser & Parser -> Parser<A, B>. The resulting parser will only succeed if BOTH sub-parsers succeed.

pub fn or(self, operand: Self) -> Self

If this parser does not succeed, try this other parser

pub fn repeat(self, range: impl RangeBounds<usize>) -> Parser<Vec<T>>

Repeat this parser N..M times This can also be repeated ..N times, N.. times, or even .. times

Trait Implementations

impl<T: 'static + Clone, S: ToString> Rem<S> for Parser<T>

The | operator can be used as an alternative to the .or method

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: S) -> Self::Output

Performs the % operation.

impl<O, T> Sub<fn(T) -> O> for Parser<T> where
    O: 'static + Clone,
    T: 'static + Clone, 

The - operator is used as an alternative to the .map method.

type Output = Parser<O>

The resulting type after applying the - operator.

fn sub(self, rhs: fn(_: T) -> O) -> Self::Output

Performs the - operation.

impl<T: 'static + Clone, R: RangeBounds<usize>> Mul<R> for Parser<T>

A parser can be multiplied by a range as an alternative to .repeat. Here's an example: sym('a') * (..7)

type Output = Parser<Vec<T>>

The resulting type after applying the * operator.

fn mul(self, rhs: R) -> Self::Output

Performs the * operation.

impl<T: 'static + Clone> Not for Parser<T>

The ! operator can be used as an alternative to the .not method

type Output = Parser<()>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<A: 'static + Clone, B: 'static + Clone> BitAnd<Parser<B>> for Parser<A>

The & operator can be used as an alternative to the .and method

type Output = Parser<(A, B)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Parser<B>) -> Self::Output

Performs the & operation.

impl<T: 'static + Clone> BitOr<Parser<T>> for Parser<T>

The | operator can be used as an alternative to the .or method

type Output = Parser<T>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<O, T, E> BitXor<fn(T) -> Result<O, E>> for Parser<T> where
    O: 'static + Clone,
    T: 'static + Clone,
    E: 'static, 

The ^ operator is used as an alternative to the .convert method.

type Output = Parser<O>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: fn(_: T) -> Result<O, E>) -> Self::Output

Performs the ^ operation.

impl<A: 'static + Clone, B: 'static + Clone> Shl<Parser<B>> for Parser<A>

Discard the consumed data of the RHS

type Output = Parser<A>

The resulting type after applying the << operator.

fn shl(self, rhs: Parser<B>) -> Self::Output

Performs the << operation.

impl<A: 'static + Clone, B: 'static + Clone> Shr<Parser<B>> for Parser<A>

Discard the consumed data of the LHS

type Output = Parser<B>

The resulting type after applying the >> operator.

fn shr(self, rhs: Parser<B>) -> Self::Output

Performs the >> operation.

impl<T: Clone> Clone for Parser<T>

fn clone(&self) -> Parser<T>

Returns a copy of the value.

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

Performs copy-assignment from source.