Enum ExpressionKind

pub enum ExpressionKind {
    Get(Assignable),
    TypeConstant(Type),
    Add(Box<Expression>, Box<Expression>),
    Sub(Box<Expression>, Box<Expression>),
    Mul(Box<Expression>, Box<Expression>),
    Div(Box<Expression>, Box<Expression>),
    Neg(Box<Expression>),
    Is(Box<Expression>, Box<Expression>),
    Eq(Box<Expression>, Box<Expression>),
    Neq(Box<Expression>, Box<Expression>),
    Gt(Box<Expression>, Box<Expression>),
    Gteq(Box<Expression>, Box<Expression>),
    Lt(Box<Expression>, Box<Expression>),
    Lteq(Box<Expression>, Box<Expression>),
    AssertEq(Box<Expression>, Box<Expression>),
    In(Box<Expression>, Box<Expression>),
    And(Box<Expression>, Box<Expression>),
    Or(Box<Expression>, Box<Expression>),
    Not(Box<Expression>),
    IfExpression {
        condition: Box<Expression>,
        pass: Box<Expression>,
        fail: Box<Expression>,
    },
    Duplicate(Box<Expression>),
    IfShort {
        condition: Box<Expression>,
        fail: Box<Expression>,
    },
    Function {
        name: String,
        params: Vec<(Identifier, Type)>,
        ret: Type,
        body: Box<Statement>,
    },
    Instance {
        blob: Assignable,
        fields: Vec<(String, Expression)>,
    },
    Tuple(Vec<Expression>),
    List(Vec<Expression>),
    Set(Vec<Expression>),
    Dict(Vec<Expression>),
    Float(f64),
    Int(i64),
    Str(String),
    Bool(bool),
    Nil,
}

The different kinds of Expressions.

Expressions are recursive and evaluate to some kind of value.

Variants

Get(Assignable)

Read from an Assignable. Variables, function calls, module accesses, blob fields, list indexing, tuple indexing and dict indexing end up here.

TypeConstant(Type)

A type as a value

Add(Box<Expression>, Box<Expression>)

a + b

Sub(Box<Expression>, Box<Expression>)

a - b

Mul(Box<Expression>, Box<Expression>)

a * b

Div(Box<Expression>, Box<Expression>)

a / b

Neg(Box<Expression>)

-a

Is(Box<Expression>, Box<Expression>)

a is b

Eq(Box<Expression>, Box<Expression>)

a == b

Neq(Box<Expression>, Box<Expression>)

a != b

Gt(Box<Expression>, Box<Expression>)

a > b

Gteq(Box<Expression>, Box<Expression>)

a >= b

Lt(Box<Expression>, Box<Expression>)

a < b

Lteq(Box<Expression>, Box<Expression>)

a <= b

AssertEq(Box<Expression>, Box<Expression>)

a <=> b

In(Box<Expression>, Box<Expression>)

a in b

And(Box<Expression>, Box<Expression>)

a && b

Or(Box<Expression>, Box<Expression>)

a || b

Not(Box<Expression>)

!a

IfExpression

Inline If-statements

Fields

condition: Box<Expression>

pass: Box<Expression>

fail: Box<Expression>

Duplicate(Box<Expression>)

Copies a value - small hack to simplify shorthand implementation.

IfShort

Inline If-statements

Fields

condition: Box<Expression>

fail: Box<Expression>

Function

Functions and closures.

Fields

name: String

params: Vec<(Identifier, Type)>

ret: Type

body: Box<Statement>

Instance

A new instance of a blob.

Fields

blob: Assignable

fields: Vec<(String, Expression)>

Tuple(Vec<Expression>)

(a, b, ..)

List(Vec<Expression>)

[a, b, ..]

Set(Vec<Expression>)

{a, b, ..}

Dict(Vec<Expression>)

{ a: b, c: d, .. }

Float(f64)

Int(i64)

Str(String)

Bool(bool)

Nil

Trait Implementations

impl Clone for ExpressionKind

fn clone(&self) -> ExpressionKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExpressionKind

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

Formats the value using the given formatter.