Enum Expr 

pub enum Expr {
    Lit(Value),
    UnitLit {
        num: f64,
        unit: String,
    },
    Template(Vec<TPart>),
    Name(String),
    Ctx(String),
    Referrers {
        ty: String,
        member: String,
    },
    Obj(Vec<(String, Rc<Expr>)>),
    Arr(Vec<(bool, Rc<Expr>)>),
    Comp {
        head: Rc<Expr>,
        clauses: Vec<ForClause>,
    },
    MapComp {
        key: Rc<Expr>,
        val: Rc<Expr>,
        clauses: Vec<ForClause>,
    },
    Bin {
        op: String,
        l: Rc<Expr>,
        r: Rc<Expr>,
    },
    Un {
        op: String,
        x: Rc<Expr>,
    },
    Paren(Rc<Expr>),
    If {
        c: Rc<Expr>,
        t: Rc<Expr>,
        f: Rc<Expr>,
    },
    Lambda {
        params: Vec<String>,
        body: Rc<Expr>,
    },
    Call {
        fun: Rc<Expr>,
        args: Vec<Rc<Expr>>,
    },
    Member {
        x: Rc<Expr>,
        name: String,
        safe: bool,
    },
    Index {
        x: Rc<Expr>,
        i: Rc<Expr>,
    },
    With {
        base: Rc<Expr>,
        patch: Rc<Expr>,
    },
    Pattern(String),
    Match {
        subject: Rc<Expr>,
        arms: Vec<MatchArm>,
    },
}

an expression (§4)

Variants

Lit(Value)

a literal

UnitLit

a unit literal

Fields

num: f64

the number

unit: String

the unit

Template(Vec<TPart>)

a template string

Name(String)

a name

Ctx(String)

a context variable ($this, $parent, $root, $key)

Referrers

$referrers(T, "m")

Fields

ty: String

the referring type

member: String

its member

Obj(Vec<(String, Rc<Expr>)>)

a record literal

Arr(Vec<(bool, Rc<Expr>)>)

an array literal: (spread, item)

Comp

an array comprehension

Fields

head: Rc<Expr>

the head

clauses: Vec<ForClause>

the clauses

MapComp

a map comprehension

Fields

key: Rc<Expr>

the key

val: Rc<Expr>

the value

clauses: Vec<ForClause>

the clauses

Bin

a binary operation

Fields

op: String

the operator

l: Rc<Expr>

the left operand

r: Rc<Expr>

the right operand

Un

a unary operation

Fields

op: String

the operator

x: Rc<Expr>

the operand

Paren(Rc<Expr>)

a parenthesized expression

If

if … then … else

Fields

c: Rc<Expr>

the condition

t: Rc<Expr>

the then branch

f: Rc<Expr>

the else branch

Lambda

a function literal

Fields

params: Vec<String>

the parameters

body: Rc<Expr>

the body

Call

a call

Fields

fun: Rc<Expr>

the function

args: Vec<Rc<Expr>>

the arguments

Member

a member access

Fields

x: Rc<Expr>

the record

name: String

the member

safe: bool

?.

Index

an index or key access

Fields

x: Rc<Expr>

the array or map

i: Rc<Expr>

the index or key

With

a record update (with)

Fields

base: Rc<Expr>

the base

patch: Rc<Expr>

the patch

Pattern(String)

a pattern literal

Match

a match

Fields

subject: Rc<Expr>

the subject

arms: Vec<MatchArm>

the arms

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.