Enum axon_parser::ast::Expr

pub enum Expr {
    Add(Box<Add>),
    And(Box<And>),
    Cmp(Box<Cmp>),
    Div(Box<Div>),
    Eq(Box<Eq>),
    Gt(Box<Gt>),
    Gte(Box<Gte>),
    Lt(Box<Lt>),
    Lte(Box<Lte>),
    Mul(Box<Mul>),
    Ne(Box<Ne>),
    Or(Box<Or>),
    Sub(Box<Sub>),
    Assign(Assign),
    Block(Block),
    Call(Call),
    Def(Def),
    Dict(Dict),
    DotCall(DotCall),
    Func(Box<Func>),
    Id(Id),
    If(Box<If>),
    List(List),
    Lit(Lit),
    Neg(Box<Neg>),
    Not(Box<Not>),
    PartialCall(PartialCall),
    Range(Box<Range>),
    Return(Box<Return>),
    Throw(Box<Throw>),
    TrapCall(Box<TrapCall>),
    TryCatch(Box<TryCatch>),
}

Enumerates the types of Axon expression.

Variants

Add(Box<Add>)

Tuple Fields of Add

0: Box<Add>

And(Box<And>)

Tuple Fields of And

0: Box<And>

Cmp(Box<Cmp>)

Tuple Fields of Cmp

0: Box<Cmp>

Div(Box<Div>)

Tuple Fields of Div

0: Box<Div>

Eq(Box<Eq>)

Tuple Fields of Eq

0: Box<Eq>

Gt(Box<Gt>)

Tuple Fields of Gt

0: Box<Gt>

Gte(Box<Gte>)

Tuple Fields of Gte

0: Box<Gte>

Lt(Box<Lt>)

Tuple Fields of Lt

0: Box<Lt>

Lte(Box<Lte>)

Tuple Fields of Lte

0: Box<Lte>

Mul(Box<Mul>)

Tuple Fields of Mul

0: Box<Mul>

Ne(Box<Ne>)

Tuple Fields of Ne

0: Box<Ne>

Or(Box<Or>)

Tuple Fields of Or

0: Box<Or>

Sub(Box<Sub>)

Tuple Fields of Sub

0: Box<Sub>

Assign(Assign)

Tuple Fields of Assign

0: Assign

Block(Block)

Tuple Fields of Block

0: Block

Call(Call)

Tuple Fields of Call

0: Call

Def(Def)

Tuple Fields of Def

0: Def

Dict(Dict)

Tuple Fields of Dict

0: Dict

DotCall(DotCall)

Tuple Fields of DotCall

0: DotCall

Func(Box<Func>)

Tuple Fields of Func

0: Box<Func>

Id(Id)

Tuple Fields of Id

0: Id

If(Box<If>)

Tuple Fields of If

0: Box<If>

List(List)

Tuple Fields of List

0: List

Lit(Lit)

Tuple Fields of Lit

0: Lit

Neg(Box<Neg>)

Tuple Fields of Neg

0: Box<Neg>

Not(Box<Not>)

Tuple Fields of Not

0: Box<Not>

PartialCall(PartialCall)

Tuple Fields of PartialCall

0: PartialCall

Range(Box<Range>)

Tuple Fields of Range

0: Box<Range>

Return(Box<Return>)

Tuple Fields of Return

0: Box<Return>

Throw(Box<Throw>)

Tuple Fields of Throw

0: Box<Throw>

TrapCall(Box<TrapCall>)

Tuple Fields of TrapCall

0: Box<TrapCall>

TryCatch(Box<TryCatch>)

Tuple Fields of TryCatch

0: Box<TryCatch>

Implementations

impl Expr

pub fn is_if(&self) -> bool

pub fn is_block(&self) -> bool

pub fn is_func(&self) -> bool

pub fn precedence(&self) -> Option<usize>

May return an int representing how high the expression’s precendence is, where 1 is the highest precedence.

pub fn associativity(&self) -> Option<Associativity>

pub fn is_bin_op(&self) -> bool

Returns true if this expression is a binary operation.

pub fn blockify(self) -> Self

If the expression is not a block, wrap the expression in a block.

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl PartialEq<Expr> for Expr

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

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

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

This method tests for !=.

impl TryFrom<&'_ Val> for Expr

type Error = ()

The type returned in the event of a conversion error.

fn try_from(val: &Val) -> Result<Self, Self::Error>

Performs the conversion.

impl StructuralPartialEq for Expr