Enum arithmetic_parser::Expr

#[non_exhaustive]pub enum Expr<'a, T: Grammar> {
    Variable,
    Literal(T::Lit),
    FnDefinition(FnDefinition<'a, T>),
    Function {
        name: Box<SpannedExpr<'a, T>>,
        args: Vec<SpannedExpr<'a, T>>,
    },
    Method {
        name: Spanned<'a>,
        receiver: Box<SpannedExpr<'a, T>>,
        args: Vec<SpannedExpr<'a, T>>,
    },
    Unary {
        op: Spanned<'a, UnaryOp>,
        inner: Box<SpannedExpr<'a, T>>,
    },
    Binary {
        lhs: Box<SpannedExpr<'a, T>>,
        op: Spanned<'a, BinaryOp>,
        rhs: Box<SpannedExpr<'a, T>>,
    },
    Tuple(Vec<SpannedExpr<'a, T>>),
    Block(Block<'a, T>),
}

Arithmetic expression with an abstract types for type hints and literals.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Variable

Variable use, e.g., x.

Literal(T::Lit)

Literal (semantic depends on T).

FnDefinition(FnDefinition<'a, T>)

Function definition, e.g., |x, y| { x + y }.

Function

Function call, e.g., foo(x, y) or |x| { x + 5 }(3).

Fields of Function

name: Box<SpannedExpr<'a, T>>

Function value. In the simplest case, this is a variable, but may also be another kind of expression, such as |x| { x + 5 } in |x| { x + 5 }(3).

args: Vec<SpannedExpr<'a, T>>

Function arguments.

Method

Method call, e.g., foo.bar(x, 5).

Fields of Method

name: Spanned<'a>

Name of the called method, e.g. bar in foo.bar(x, 5).

receiver: Box<SpannedExpr<'a, T>>

Receiver of the call, e.g., foo in foo.bar(x, 5).

args: Vec<SpannedExpr<'a, T>>

Arguments; e.g., x, 5 in foo.bar(x, 5).

Unary

Unary operation, e.g., -x.

Fields of Unary

op: Spanned<'a, UnaryOp>

Operator.

inner: Box<SpannedExpr<'a, T>>

Inner expression.

Binary

Binary operation, e.g., x + 1.

Fields of Binary

lhs: Box<SpannedExpr<'a, T>>

LHS of the operation.

op: Spanned<'a, BinaryOp>

Operator.

rhs: Box<SpannedExpr<'a, T>>

RHS of the operation.

Tuple(Vec<SpannedExpr<'a, T>>)

Tuple expression, e.g., (x, y + z).

Block(Block<'a, T>)

Block expression, e.g., { x = 3; x + y }.

Implementations

impl<T: Grammar, '_> Expr<'_, T>

pub fn binary_lhs(&self) -> Option<&SpannedExpr<'_, T>>

Returns LHS of the binary expression. If this is not a binary expression, returns None.

pub fn binary_rhs(&self) -> Option<&SpannedExpr<'_, T>>

Returns RHS of the binary expression. If this is not a binary expression, returns None.

pub fn ty(&self) -> ExprType

Returns the type of this expression.

Trait Implementations

impl<T: Grammar, '_> Clone for Expr<'_, T>

pub fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, T: Debug + Grammar> Debug for Expr<'a, T> where
    T::Lit: Debug, 

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

Formats the value using the given formatter.

impl<T, '_> PartialEq<Expr<'_, T>> for Expr<'_, T> where
    T: Grammar,
    T::Lit: PartialEq,
    T::Type: PartialEq, 

pub fn eq(&self, other: &Self) -> bool

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.