Enum parsel::ast::RightAssoc

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

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

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.

A right-associative binary infix operator was found.

§

Lhs(L)

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

Trait Implementations§

source§

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

source§

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

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

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

source§

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

Formats the value using the given formatter. Read more
source§

impl<O, L> Display for RightAssoc<O, L>where O: ToTokens, L: ToTokens,

source§

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

Formats the value using the given formatter. Read more
source§

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

source§

fn from(lhs: L) -> Self

Converts to this type from the input type.
source§

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.
source§

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

Parses a string s to return a value of this type. Read more
source§

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

source§

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

Feeds this value into the given Hasher. Read more
1.3.0 · source§

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

Feeds a slice of this type into the given Hasher. Read more
source§

impl<O, L> Parse for RightAssoc<O, L>where O: Parse, L: Parse,

source§

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

source§

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

source§

fn eq(&self, other: &RightAssoc<O, L>) -> bool

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

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.
source§

impl<O, L> ToTokens for RightAssoc<O, L>where O: ToTokens, L: ToTokens,

source§

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

Write self to the given TokenStream. Read more
source§

fn to_token_stream(&self) -> TokenStream

Convert self directly into a TokenStream object. Read more
source§

fn into_token_stream(self) -> TokenStreamwhere Self: Sized,

Convert self directly into a TokenStream object. Read more
source§

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

source§

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

source§

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

Auto Trait Implementations§

§

impl<O, L> RefUnwindSafe for RightAssoc<O, L>where L: RefUnwindSafe, O: RefUnwindSafe,

§

impl<O, L> Send for RightAssoc<O, L>where L: Send, O: Send,

§

impl<O, L> Sync for RightAssoc<O, L>where L: Sync, O: Sync,

§

impl<O, L> Unpin for RightAssoc<O, L>where L: Unpin, O: Unpin,

§

impl<O, L> UnwindSafe for RightAssoc<O, L>where L: UnwindSafe, O: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

const: unstable · source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

const: unstable · source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<!> for T

const: unstable · source§

fn from(t: !) -> T

Converts to this type from the input type.
source§

impl<T> From<T> for T

const: unstable · source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for Twhere U: From<T>,

const: unstable · source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> Spanned for Twhere T: Spanned + ?Sized,

source§

fn span(&self) -> Span

Returns a Span covering the complete contents of this syntax tree node, or Span::call_site() if this node is empty.
source§

impl<T> SpannedExt for Twhere T: Spanned + ?Sized,

source§

fn byte_range(&self, source: &str) -> Range<usize>

TODO(H2CO3): a faster, less naive implementation would be great. We should use the byte offset of start to compute that of end, sparing the double scan of the source up until the start location.

let source = r#"
   -3.667
  1248  "string ű literal"
      "wíőzs"
"#;
let tokens: Many<Lit> = source.parse()?;

assert_eq!(tokens.len(), 4);
assert_eq!(tokens[0].byte_range(source),  4..10);
assert_eq!(tokens[1].byte_range(source), 13..17);
assert_eq!(tokens[2].byte_range(source), 19..38);
assert_eq!(tokens[3].byte_range(source), 45..54);
source§

fn char_range(&self, source: &str) -> Range<usize>

TODO(H2CO3): a faster, less naive implementation would be great. We should use the char offset of start to compute that of end, sparing the double scan of the source up until the start location.

let source = r#"
   -3.667
  1248  "string ű literal"
      "wíőzs"
"#;
let tokens: Many<Lit> = source.parse()?;

assert_eq!(tokens.len(), 4);
assert_eq!(tokens[0].char_range(source),  4..10);
assert_eq!(tokens[1].char_range(source), 13..17);
assert_eq!(tokens[2].char_range(source), 19..37);
assert_eq!(tokens[3].char_range(source), 44..51);
source§

fn format_span(&self) -> SpanDisplay

source§

impl<T> ToOwned for Twhere T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T> ToString for Twhere T: Display + ?Sized,

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
const: unstable · source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
const: unstable · source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.