Enum garden_lang_parser::ast::Expression_

pub enum Expression_ {
    Match(Box<Expression>, Vec<(Pattern, Box<Expression>)>),
    If(Box<Expression>, Block, Option<Block>),
    While(Box<Expression>, Block),
    ForIn(Symbol, Box<Expression>, Block),
    Break,
    Continue,
    Assign(Symbol, Box<Expression>),
    Let(Symbol, Option<TypeHint>, Box<Expression>),
    Return(Option<Box<Expression>>),
    IntLiteral(i64),
    StringLiteral(String),
    ListLiteral(Vec<Expression>),
    TupleLiteral(Vec<Expression>),
    StructLiteral(TypeSymbol, Vec<(Symbol, Expression)>),
    BinaryOperator(Box<Expression>, BinaryOperatorKind, Box<Expression>),
    Variable(Symbol),
    Call(Box<Expression>, ParenthesizedArguments),
    MethodCall(Box<Expression>, Symbol, ParenthesizedArguments),
    DotAccess(Box<Expression>, Symbol),
    FunLiteral(FunInfo),
    Block(Block),
    Invalid,
}

Variants

Match(Box<Expression>, Vec<(Pattern, Box<Expression>)>)

match x {
    None => { get_value() }
    Some(y) => y + 1,
    _ => error("yikes"),
}

If(Box<Expression>, Block, Option<Block>)

if x { y }
if x { y } else { z }

While(Box<Expression>, Block)

while x { y z }

ForIn(Symbol, Box<Expression>, Block)

for x in y { z }

Break

break

Continue

continue

Assign(Symbol, Box<Expression>)

x = y

Let(Symbol, Option<TypeHint>, Box<Expression>)

let x = y
let x: T = y

Return(Option<Box<Expression>>)

return x
return // equivalent to `return Unit`

IntLiteral(i64)

123

StringLiteral(String)

"foo"

ListLiteral(Vec<Expression>)

[x, y]

TupleLiteral(Vec<Expression>)

()
(x,)
(x, y)

StructLiteral(TypeSymbol, Vec<(Symbol, Expression)>)

Foo { x: 1, y: bar() }

Field values are executed in the order they occur in source code, so we want an ordered data type here.

BinaryOperator(Box<Expression>, BinaryOperatorKind, Box<Expression>)

x + y
x < y
x && y

Variable(Symbol)

x

Call(Box<Expression>, ParenthesizedArguments)

x()

MethodCall(Box<Expression>, Symbol, ParenthesizedArguments)

foo.bar(x, y)

DotAccess(Box<Expression>, Symbol)

foo.bar

FunLiteral(FunInfo)

fun(x, y) { x + y }

Block(Block)

{ x y }

Invalid

We had a parse error in this position, so there’s no expression.

Trait Implementations

impl Clone for Expression_

fn clone(&self) -> Expression_

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Expression_

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

Formats the value using the given formatter.

impl PartialEq for Expression_

fn eq(&self, other: &Expression_) -> 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 Eq for Expression_

impl StructuralPartialEq for Expression_