Enum Expression_ 

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

Variants

Match(Rc<Expression>, Vec<(Pattern, Block)>)

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

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

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

While(Rc<Expression>, Block)

while x { y }

ForIn(LetDestination, Rc<Expression>, Block)

for x in y { z }
for (foo, bar) in y { z }

Break

break

Continue

continue

Assign(Symbol, Rc<Expression>)

x = y

AssignUpdate(Symbol, AssignUpdateKind, Rc<Expression>)

x += y
x -= y

Let(LetDestination, Option<TypeHint>, Rc<Expression>)

let x = y
let x: T = y
let (x, y) = z

Return(Option<Rc<Expression>>)

return x
return // equivalent to `return Unit`

IntLiteral(i64)

123

StringLiteral(String)

"foo"

ListLiteral(Vec<ExpressionWithComma>)

[x, y]

TupleLiteral(Vec<Rc<Expression>>)

()
(x,)
(x, y)

StructLiteral(TypeSymbol, Vec<(Symbol, Rc<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(Rc<Expression>, BinaryOperatorKind, Rc<Expression>)

x + y
x < y
x && y

Variable(Symbol)

x

Call(Rc<Expression>, ParenthesizedArguments)

x()

MethodCall(Rc<Expression>, Symbol, ParenthesizedArguments)

foo.bar(x, y)

DotAccess(Rc<Expression>, Symbol)

foo.bar

FunLiteral(FunInfo)

fun(x, y) { x + y }

Assert(Rc<Expression>)

assert(x)

Parentheses(Position, Rc<Expression>, Position)

Parentheses used for grouping, particularly in nested binary operators.

(x)
x * (y * z)

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 duplicate 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_