Enum parsel::ast::RightAssoc

pub enum RightAssoc<O, L> {
    Binary {
        lhs: L,
        op: O,
        rhs: Box<Self>,
    },
    Lhs(L),
}

Helper type for parsing right-associative binary infix operators.

Reduces deep right-recursion by parsing a stream of binary infix operators iteratively, then transforming the sequence of nodes into a right-leaning tree.

• L is the type of the left-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:

RightAssoc = L O RightAssoc
           | L

Examples

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

type Expr = RightAssoc<
    Or,
    RightAssoc<
        And,
        Term
    >
>;

let actual: Expr = parse_quote!((~false | a) & ~(b & c & true));
let expected = RightAssoc::<Or, _>::Lhs(RightAssoc::<And, _>::Binary {
    lhs: Term::Group(Box::new(Paren::from(
        RightAssoc::<Or, _>::Binary {
           lhs: RightAssoc::<And, _>::Lhs(Term::Not(
               Tilde::default(),
               Box::new(Term::Lit(LitBool::from(false)))
           )),
           op: Or::default(),
           rhs: Box::new(RightAssoc::<Or, _>::Lhs(
               RightAssoc::<And, _>::Lhs(
                   Term::Var(ident("a"))
               )
           )),
       }
    ))),
    op: And::default(),
    rhs: Box::new(RightAssoc::<And, _>::Lhs(
        Term::Not(
            Tilde::default(),
            Box::new(Term::Group(Box::new(Paren::from(
                RightAssoc::<Or, _>::Lhs(RightAssoc::<And, _>::Binary {
                    lhs: Term::Var(ident("b")),
                    op: And::default(),
                    rhs: Box::new(RightAssoc::<And, _>::Binary {
                        lhs: Term::Var(ident("c")),
                        op: And::default(),
                        rhs: Box::new(RightAssoc::<And, _>::Lhs(
                            Term::Lit(LitBool::from(true)),
                        )),
                    }),
                })
            ))))
        )
    )),
});

assert_eq!(actual, expected);
assert_eq!(actual.to_string(), expected.to_string());

Variants

Binary

A right-associative binary infix operator was found.

Fields

lhs: L

Left-hand side of the binary operation.

op: O

The infix binary operator.

rhs: Box<Self>

Right-hand side of the binary operation.

Lhs(L)

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

Trait Implementations

impl<O: Clone, L: Clone> Clone for RightAssoc<O, L>

fn clone(&self) -> RightAssoc<O, L>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<O, L> Debug for RightAssoc<O, L>

where O: Debug, L: Debug,

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

Formats the value using the given formatter.

impl<O, L> Display for RightAssoc<O, L>

where O: ToTokens, L: ToTokens,

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

Formats the value using the given formatter.

impl<O, L> From<L> for RightAssoc<O, L>

fn from(lhs: L) -> Self

Converts to this type from the input type.

impl<O, L> FromStr for RightAssoc<O, L>

where O: Parse, L: 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, L: Hash> Hash for RightAssoc<O, L>

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, L> Parse for RightAssoc<O, L>

where O: Parse, L: Parse,

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

impl<O: PartialEq, L: PartialEq> PartialEq for RightAssoc<O, L>

fn eq(&self, other: &RightAssoc<O, L>) -> 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, L> ToTokens for RightAssoc<O, L>

where O: ToTokens, L: 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, L: Eq> Eq for RightAssoc<O, L>

impl<O, L> StructuralPartialEq for RightAssoc<O, L>