Enum arithmetic_parser::Expr

#[non_exhaustive]
pub enum Expr<'a, T: Grammar> {
    Variable,
    Literal(T::Lit),
    FnDefinition(FnDefinition<'a, T>),
    TypeCast {
        value: Box<SpannedExpr<'a, T>>,
        ty: Spanned<'a, T::Type<'a>>,
    },
    Function {
        name: Box<SpannedExpr<'a, T>>,
        args: Vec<SpannedExpr<'a, T>>,
    },
    FieldAccess {
        name: Box<SpannedExpr<'a, T>>,
        receiver: Box<SpannedExpr<'a, T>>,
    },
    Method {
        name: Box<SpannedExpr<'a, T>>,
        receiver: Box<SpannedExpr<'a, T>>,
        separator: Spanned<'a>,
        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>),
    Object(ObjectExpr<'a, T>),
}

Arithmetic expression with an abstract types for type annotations 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 }.

TypeCast

Type cast, e.g., x as Bool.

Fields

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

Value being cast, e.g., x in x as Bool.

ty: Spanned<'a, T::Type<'a>>

Type annotation for the case, e.g., Bool in x as Bool.

Function

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

Fields

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.

FieldAccess

Field access, e.g., foo.bar.

Fields

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

Name of the called method, e.g. bar in foo.bar.

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

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

Method

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

Fields

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

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).

separator: Spanned<'a>

Separator between the receiver and the called method, e.g., . 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

op: Spanned<'a, UnaryOp>

Operator.

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

Inner expression.

Binary

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

Fields

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 }.

Object(ObjectExpr<'a, T>)

Object expression, e.g., #{ x, y: x + 2 }.

Implementations

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

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

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

pub fn binary_rhs(&self) -> Option<&SpannedExpr<'a, 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<'a, T: Grammar> Clone for Expr<'a, T>

fn clone(&self) -> Self

Returns a copy of the value.

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, T::Type<'a>: Debug,

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

Formats the value using the given formatter.

impl<'a, T> PartialEq for Expr<'a, T>

where T: Grammar, T::Lit: PartialEq, T::Type<'a>: PartialEq,

fn eq(&self, other: &Self) -> 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.