Enum Expr 

pub enum Expr<'a> {
    Index {
        item: Box<Expr<'a>>,
        index: Box<Expr<'a>>,
    },
    ForLoop {
        init: Box<Expr<'a>>,
        check: Box<Expr<'a>>,
        update: Box<Expr<'a>>,
        exec: Box<Expr<'a>>,
    },
    WhileLoop {
        condition: Box<Expr<'a>>,
        exec: Box<Expr<'a>>,
    },
    Conditional {
        condition: Box<Expr<'a>>,
        true_branch: Box<Expr<'a>>,
        else_branch: Option<Box<Expr<'a>>>,
    },
    Block(Vec<Expr<'a>>),
    Literal(Literal<'a>),
    List(Vec<Expr<'a>>),
    Variable(&'a str),
    Unary {
        op: UnaryOperator,
        node: Box<Expr<'a>>,
    },
    Roar(Box<Expr<'a>>),
    Print(Box<Expr<'a>>),
    Reassignment {
        name: &'a str,
        val: Box<Expr<'a>>,
    },
    Inc(&'a str, bool),
    AddAssign {
        name: &'a str,
        add: Box<Expr<'a>>,
    },
    Assignment {
        name: &'a str,
        val: Box<Expr<'a>>,
    },
    Binary {
        op: BinaryOperator,
        left: Box<Expr<'a>>,
        right: Box<Expr<'a>>,
    },
    Grouping(Box<Expr<'a>>),
}

An expression node in the AST

Variants

Index

Indexing into a literal

Fields

item: Box<Expr<'a>>

The item we’re indexing in

index: Box<Expr<'a>>

The index into that item

ForLoop

A for style loop that performs some initialization and repeatedly checks a certain equality statement until it is true

Fields

init: Box<Expr<'a>>

Loop initialization

check: Box<Expr<'a>>

What is checked on each run

update: Box<Expr<'a>>

What is run to update

exec: Box<Expr<'a>>

What is executed upon each iteration

WhileLoop

A while style loop that will repeat until the inner condition is false

Fields

condition: Box<Expr<'a>>

Condition being checked

exec: Box<Expr<'a>>

Body being executed until then

Conditional

A conditional executor

Fields

condition: Box<Expr<'a>>

The condition being checked

true_branch: Box<Expr<'a>>

What is executed if the condition is true

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

What is optionally executed if else

Block(Vec<Expr<'a>>)

A block to be executed

Literal(Literal<'a>)

A literal

List(Vec<Expr<'a>>)

A list of expressions that boils down to a list of literals

Variable(&'a str)

A variable

Unary

Unary operation

Fields

op: UnaryOperator

Operator

node: Box<Expr<'a>>

Expression Node

Roar(Box<Expr<'a>>)

Roar the expressions result to stdout

Print(Box<Expr<'a>>)

Print the expressions result to stdout

Reassignment

Assignment operator for an existing variable, fails if variable does not exist

Fields

name: &'a str

The variable name

val: Box<Expr<'a>>

The variable value

Inc(&'a str, bool)

Increment a variable, true if return before and false if return after inc

AddAssign

Add a value to a variable

Fields

name: &'a str

Name of the variable

add: Box<Expr<'a>>

What is added to the existing variable

Assignment

Assignment operator

Fields

name: &'a str

The variable name

val: Box<Expr<'a>>

The variable value

Binary

Binary operation

Fields

op: BinaryOperator

Operator

left: Box<Expr<'a>>

Left expression node

right: Box<Expr<'a>>

Right expression node

Grouping(Box<Expr<'a>>)

A grouping ()

Trait Implementations

impl<'a> Clone for Expr<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Expr<'a>

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

Formats the value using the given formatter.

impl Display for Expr<'_>

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

Formats the value using the given formatter.

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

fn eq(&self, other: &Expr<'a>) -> 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<'a> StructuralPartialEq for Expr<'a>