Struct Parser

pub struct Parser<T> {
    pub expectation: String,
    /* private fields */
}

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

Fields

expectation: String

Implementations

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.

Examples found in repository

examples/json.rs (lines 53-64)

fn main() {
    println!(
        "{:#?}",
        json().parse(
            r#"
{
    "testing" : null,
    "recursion" : {
        "WOW": 1.2345
    },
    "array": [1, 2, {"test": "123"}, 4],
    "test": "testing"
}
"#
        )
    );
}

examples/calculator.rs (line 107)

fn main() {
    loop {
        let output = input(">>> ");

        match math().parse(&output) {
            Ok(m) => println!("{:#?}\n\nResult: {}", m.clone(), eval(m)),
            Err(_) => println!("Invalid math expression!"),
        }
    }
}

examples/language.rs (lines 7-30)

fn main() {
    println!(
        "{:?}",
        (token() * (..)).parse(
            r#"

h123213ey
jasdf2212eude
"hey jude dude"
1234 jude


fn testing() {
    println("hello world!");
}


struct Point {
    fn testing() {
        println!(
            "yo dude", 3, []
        );
    }
}

"#
        )
    );
}

examples/markup.rs (lines 43-70)

fn main() {
    println!(
        "{:#?}",
        (markup() * (1..)).parse(
            r#"

row {
    column1 {
        width { 5 }
        height { 10 }
    }

    column2 {
        width { 5 }
        height { 10 }
    }

    column3 {
        width { 5 }
        height { 10 }
    }

    columnlist {
        - 1
        - 2
        - 3
    }
}

"#
        )
    );
}

examples/sentence.rs (lines 50-66)

fn main() {
    println!(
        "{:#?}",
        paragraph().parse(
            r#"

I look at you all see the love there thats sleeping,
While my guitar gently weeps.
I look at the floor and I see it needs sweeping
Still my guitar gently weeps.
I dont know why nobody told you
How to unfold your love.
I dont know how someone controlled you.
They bought and sold you.
I look at the world and I notice its turning
While my guitar gently weeps.
With every mistake we must surely be learning,
Still my guitar gently weeps.
"#
        )
    );
}

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.

Examples found in repository

examples/calculator.rs (line 30)

fn operation(symbol: char, map_fn: fn((Math, Math)) -> Math) -> Parser<Math> {
    (number() - to_number - Math::Number | rec(math))
        .suffix(space() & sym(symbol) & space())
        .and(rec(math))
        - map_fn
}

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.

Examples found in repository

examples/sentence.rs (line 36)

fn sentence() -> Parser<Sentence> {
    (word().is() >> (((word() << opt(seq_no_ws(","))) * (1..)) & punctuation()))
        - |phrase: (Vec<Word>, Punctuation)| Sentence {
            words: phrase.0,
            punctuation: phrase.1,
        }
}

examples/calculator.rs (line 64)

fn math() -> Parser<Math> {
    exit()
        | eof() - (|_| Math::EOF)
        | clear()
        | token("(") >> rec(math) << token(")")
        | (number().is()
            >> (multiply() | divide() | add() | subtract() | (number() - to_number - Math::Number)))
}

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.

Examples found in repository

examples/calculator.rs (line 31)

fn operation(symbol: char, map_fn: fn((Math, Math)) -> Math) -> Parser<Math> {
    (number() - to_number - Math::Number | rec(math))
        .suffix(space() & sym(symbol) & space())
        .and(rec(math))
        - map_fn
}

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<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 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<T: Clone> Clone for Parser<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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<T: 'static + Clone, S: ToString> Rem<S> 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 rem(self, rhs: S) -> 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<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.