Enum Expr

pub enum Expr<'src> {
    ForLoop {
        init: Box<Expr<'src>>,
        cond: Box<Expr<'src>>,
        inc: Box<Expr<'src>>,
        exec: Box<Expr<'src>>,
    },
    WhileLoop {
        condition: Box<Expr<'src>>,
        eval: Box<Expr<'src>>,
    },
    Conditional {
        condition: Box<Expr<'src>>,
        true_branch: Box<Expr<'src>>,
        else_branch: Option<Box<Expr<'src>>>,
    },
    Block(Vec<Expr<'src>>),
    Print(Box<Expr<'src>>),
    Variable(&'src str),
    Assignment(&'src str, Box<Expr<'src>>),
    Binary {
        op: BinaryOp,
        left: Box<Expr<'src>>,
        right: Box<Expr<'src>>,
    },
    Unary {
        op: UnaryOp,
        node: Box<Expr<'src>>,
    },
    Grouping(Box<Expr<'src>>),
    Literal(Literal<'src>),
}

A node in the abstract syntax tree, represents all possible operations that can occur

Variants

ForLoop

A for loop

Fields

init: Box<Expr<'src>>

An inistialization

cond: Box<Expr<'src>>

The conditional check

inc: Box<Expr<'src>>

The update after each run

exec: Box<Expr<'src>>

What is run each time

WhileLoop

A while loop

Fields

condition: Box<Expr<'src>>

The condition checked before running

eval: Box<Expr<'src>>

What runs each time around

Conditional

A conditional executor

Fields

condition: Box<Expr<'src>>

The condition being checked

true_branch: Box<Expr<'src>>

What is executed if the condition is true

else_branch: Option<Box<Expr<'src>>>

What is optionally executed if else

Block(Vec<Expr<'src>>)

A block to be executed

Print(Box<Expr<'src>>)

Print an expression’s literal result

Variable(&'src str)

A variable reference

Assignment(&'src str, Box<Expr<'src>>)

An assignment from an identifier to an expression

Binary

A binary operation between two expressions

Fields

op: BinaryOp

The operator

left: Box<Expr<'src>>

Left hand side

right: Box<Expr<'src>>

Right hand side

Unary

A unary operation on a single expression

Fields

op: UnaryOp

The operator

node: Box<Expr<'src>>

The expression being acted on

Grouping(Box<Expr<'src>>)

( expr )

Literal(Literal<'src>)

A literal

Trait Implementations

impl<'src> Clone for Expr<'src>

fn clone(&self) -> Expr<'src>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'src> Debug for Expr<'src>

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

Formats the value using the given formatter.

impl<'src> PartialEq for Expr<'src>

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'src> StructuralPartialEq for Expr<'src>