Enum Expr 

pub enum Expr {
    Literal(LiteralType),
    Str(IStr),
    Num(f64),
    Var(IStr),
    Arr(Vec<LocExpr>),
    ArrComp(LocExpr, Vec<CompSpec>),
    Obj(ObjBody),
    ObjExtend(LocExpr, ObjBody),
    Parened(LocExpr),
    UnaryOp(UnaryOpType, LocExpr),
    BinaryOp(LocExpr, BinaryOpType, LocExpr),
    AssertExpr(AssertStmt, LocExpr),
    LocalExpr(Vec<BindSpec>, LocExpr),
    Import(PathBuf),
    ImportStr(PathBuf),
    ErrorStmt(LocExpr),
    Apply(LocExpr, ArgsDesc, bool),
    Index(LocExpr, LocExpr),
    Function(ParamsDesc, LocExpr),
    Intrinsic(IStr),
    IfElse {
        cond: IfSpecData,
        cond_then: LocExpr,
        cond_else: Option<LocExpr>,
    },
    Slice(LocExpr, SliceDesc),
}

Syntax base

Variants

Literal(LiteralType)

Str(IStr)

String value: “hello”

Num(f64)

Number: 1, 2.0, 2e+20

Var(IStr)

Variable name: test

Arr(Vec<LocExpr>)

Array of expressions: [1, 2, “Hello”]

ArrComp(LocExpr, Vec<CompSpec>)

Array comprehension:

 ingredients: [
   { kind: kind, qty: 4 / 3 }
   for kind in [
     'Honey Syrup',
     'Lemon Juice',
     'Farmers Gin',
   ]
 ],

Obj(ObjBody)

Object: {a: 2}

ObjExtend(LocExpr, ObjBody)

Object extension: var1 {b: 2}

Parened(LocExpr)

(obj)

UnaryOp(UnaryOpType, LocExpr)

-2

BinaryOp(LocExpr, BinaryOpType, LocExpr)

2 - 2

AssertExpr(AssertStmt, LocExpr)

assert 2 == 2 : “Math is broken”

LocalExpr(Vec<BindSpec>, LocExpr)

local a = 2; { b: a }

Import(PathBuf)

import “hello”

ImportStr(PathBuf)

importStr “file.txt”

ErrorStmt(LocExpr)

error “I’m broken”

Apply(LocExpr, ArgsDesc, bool)

a(b, c)

Index(LocExpr, LocExpr)

a[b]

Function(ParamsDesc, LocExpr)

function(x) x

Intrinsic(IStr)

std.primitiveEquals

IfElse

if true == false then 1 else 2

Fields

cond: IfSpecData

cond_then: LocExpr

cond_else: Option<LocExpr>

Slice(LocExpr, SliceDesc)

Trait Implementations

impl Debug for Expr

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

Formats the value using the given formatter.

impl Finalize for Expr

fn finalize(&self)

impl PartialEq for Expr

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

unsafe fn trace(&self)

Marks all contained Gcs.

unsafe fn root(&self)

Increments the root-count of all contained Gcs.

unsafe fn unroot(&self)

Decrements the root-count of all contained Gcs.

fn finalize_glue(&self)

Runs Finalize::finalize() on this object and all contained subobjects

impl StructuralPartialEq for Expr