Enum parsel::ast::LeftAssoc

pub enum LeftAssoc<O, R> {
    Binary {
        lhs: Box<Self>,
        op: O,
        rhs: R,
    },
    Rhs(R),
}

Helper type for parsing left-associative binary infix operators.

Prevents infinite left-recursion by parsing a stream of binary infix operators iteratively, then transforming the sequence of nodes into a left-leaning tree.

• R is the type of the right-hand side of the production, i.e., the sub-production at the next highest precedence level.
• O is the type of the interleaved binary operator itself.

That is, a production in EBNF style would look like:

LeftAssoc = LeftAssoc O R
          | R

Examples

#[derive(PartialEq, Eq, Debug, Parse, ToTokens)]
enum AddOp {
    Add(token::Plus),
    Sub(token::Minus),
}

#[derive(PartialEq, Eq, Debug, Parse, ToTokens)]
enum MulOp {
    Mul(token::Star),
    Div(token::Slash),
}

#[derive(PartialEq, Eq, Debug, Parse, ToTokens)]
enum Term {
    Literal(Lit),
    Variable(Ident),
    Group(
        #[parsel(recursive)]
        Paren<Box<Expr>>
    ),
}

type Expr = LeftAssoc<
    AddOp,
    LeftAssoc<
        MulOp,
        Term
    >
>;

let actual: Expr = parsel::parse_quote!{
    10 - 2.99 + p / 42.0 - (q - -24.314) * -13
};
let expected = LeftAssoc::Binary {
    lhs: Box::new(LeftAssoc::Binary {
        lhs: Box::new(LeftAssoc::Binary {
            lhs: Box::new(LeftAssoc::Rhs(LeftAssoc::Rhs(
                Term::Literal(LitUint::from(10).into())
            ))),
            op: AddOp::Sub(Default::default()),
            rhs: LeftAssoc::Rhs(Term::Literal(
                LitFloat::try_from(2.99).unwrap().into()
            )),
        }),
        op: AddOp::Add(Default::default()),
        rhs: LeftAssoc::Binary {
            lhs: Box::new(LeftAssoc::Rhs(
                Term::Variable(ident("p"))
            )),
            op: MulOp::Div(Default::default()),
            rhs: Term::Literal(LitFloat::try_from(42.0).unwrap().into()),
        },
    }),
    op: AddOp::Sub(Default::default()),
    rhs: LeftAssoc::Binary {
        lhs: Box::new(LeftAssoc::Rhs(
            Term::Group(Paren::from(Box::new(
                LeftAssoc::Binary {
                    lhs: Box::new(LeftAssoc::Rhs(LeftAssoc::Rhs(
                        Term::Variable(ident("q"))
                    ))),
                    op: AddOp::Sub(Default::default()),
                    rhs: LeftAssoc::Rhs(Term::Literal(
                        LitFloat::try_from(-24.314).unwrap().into()
                    )),
                }
            )))
        )),
        op: MulOp::Mul(Default::default()),
        rhs: Term::Literal(LitInt::from(-13).into()),
    }
};

assert_eq!(actual, expected);
assert_eq!(actual.to_string(), expected.to_string());
assert_eq!(
    expected.to_string(),
    str::trim(r#"
10 - 2.99 + p / 42.0 - (
    q - - 24.314
)
* - 13
    "#),
);

Variants

Binary

A left-associative binary infix operator was found.

Fields

lhs: Box<Self>

Left-hand side of the binary operation.

op: O

The infix binary operator.

rhs: R

Right-hand side of the binary operation.

Rhs(R)

No binary operator was found at this level of precedence, so simply forward to the next level.

Trait Implementations

impl<O: Clone, R: Clone> Clone for LeftAssoc<O, R>

fn clone(&self) -> LeftAssoc<O, R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<O, R> Debug for LeftAssoc<O, R>

where O: Debug, R: Debug,

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<O, R> Display for LeftAssoc<O, R>

where O: ToTokens, R: ToTokens,

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<O, R> From<R> for LeftAssoc<O, R>

fn from(rhs: R) -> Self

Converts to this type from the input type.

impl<O, R> FromStr for LeftAssoc<O, R>

where O: Parse, R: Parse,

type Err = Error

The associated error which can be returned from parsing.

fn from_str(string: &str) -> Result<Self>

Parses a string s to return a value of this type.

impl<O: Hash, R: Hash> Hash for LeftAssoc<O, R>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<O, R> Parse for LeftAssoc<O, R>

where O: Parse, R: Parse,

fn parse(input: ParseStream<'_>) -> Result<Self>

impl<O: PartialEq, R: PartialEq> PartialEq for LeftAssoc<O, R>

fn eq(&self, other: &LeftAssoc<O, R>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<O, R> ToTokens for LeftAssoc<O, R>

where O: ToTokens, R: ToTokens,

fn to_tokens(&self, tokens: &mut TokenStream)

Write self to the given TokenStream.

fn to_token_stream(&self) -> TokenStream

Convert self directly into a TokenStream object.

fn into_token_stream(self) -> TokenStream

where Self: Sized,

Convert self directly into a TokenStream object.

impl<O: Eq, R: Eq> Eq for LeftAssoc<O, R>

impl<O, R> StructuralPartialEq for LeftAssoc<O, R>