Enum Materialized 

pub enum Materialized {
    Lit(i64),
    FloatLit(u64),
    FloatOp {
        op: BinOp,
        lhs: Box<Materialized>,
        rhs: Box<Materialized>,
    },
    IntToFloat(Box<Materialized>),
    FloatToInt(Box<Materialized>),
    DecimalLit(i64),
    DecimalOp {
        op: BinOp,
        lhs: Box<Materialized>,
        rhs: Box<Materialized>,
    },
    IntToDecimal(Box<Materialized>),
    DecimalToInt(Box<Materialized>),
    DecimalRaw(Box<Materialized>),
    Bool(bool),
    Not(Box<Materialized>),
    Str(String),
    StrLen(Box<Materialized>),
    StrLower(Box<Materialized>),
    StrFromCode(Box<Materialized>),
    StrConcat(Box<Materialized>, Box<Materialized>),
    StrSlice {
        s: Box<Materialized>,
        start: Box<Materialized>,
        len: Box<Materialized>,
    },
    StrEq(Box<Materialized>, Box<Materialized>),
    StrContains {
        haystack: Box<Materialized>,
        needle: Box<Materialized>,
    },
    StrStartsWith {
        s: Box<Materialized>,
        prefix: Box<Materialized>,
    },
    StrIndexOf {
        haystack: Box<Materialized>,
        needle: Box<Materialized>,
    },
    NumberToStr(Box<Materialized>),
    StrToNumber(Box<Materialized>),
    StrToNumberOpt(Box<Materialized>),
    Now,
    List(Vec<Materialized>),
    ListEmpty {
        elem: Type,
    },
    ListCons {
        head: Box<Materialized>,
        tail: Box<Materialized>,
    },
    OptionSome(Box<Materialized>),
    OptionNone {
        elem: Type,
    },
    OptionElse {
        opt: Box<Materialized>,
        default: Box<Materialized>,
    },
    OptionMatch {
        opt: Box<Materialized>,
        some_bind: String,
        some_body: Box<Materialized>,
        none_body: Box<Materialized>,
    },
    ListTryGet {
        list: Box<Materialized>,
        index: Box<Materialized>,
    },
    ListLen(Box<Materialized>),
    ListGet {
        list: Box<Materialized>,
        index: Box<Materialized>,
    },
    Map(Vec<(Materialized, Materialized)>),
    MapGet {
        map: Box<Materialized>,
        key: Box<Materialized>,
    },
    MapTryGet {
        map: Box<Materialized>,
        key: Box<Materialized>,
    },
    MapLen(Box<Materialized>),
    Log(Box<Materialized>),
    Publish(Box<Materialized>),
    SetHeader {
        name: Box<Materialized>,
        value: Box<Materialized>,
    },
    Rand,
    MutNew(Box<Materialized>),
    MutGet(Box<Materialized>),
    MutSet {
        cell: Box<Materialized>,
        value: Box<Materialized>,
    },
    DiskWrite {
        path: Box<Materialized>,
        content: Box<Materialized>,
    },
    DiskRead(Box<Materialized>),
    NetGet(Box<Materialized>),
    DbQuery {
        sql: Box<Materialized>,
        params: Box<Materialized>,
    },
    Ref(String),
    Call {
        func: String,
        args: Vec<Materialized>,
    },
    FuncRef(String),
    CallValue {
        callee: Box<Materialized>,
        args: Vec<Materialized>,
    },
    Lambda {
        params: Vec<Param>,
        body: Box<Materialized>,
    },
    Hole {
        expects: String,
    },
    Step {
        binding: String,
        value: Box<Materialized>,
    },
    BinOp {
        op: BinOp,
        lhs: Box<Materialized>,
        rhs: Box<Materialized>,
    },
    If {
        cond: Box<Materialized>,
        then_branch: Box<Materialized>,
        else_branch: Box<Materialized>,
    },
    Fail(String),
    Handle {
        body: Box<Materialized>,
        handlers: Vec<(String, Materialized)>,
    },
    Function {
        name: String,
        type_params: Vec<String>,
        params: Vec<Param>,
        produces: Produces,
        requires: BTreeSet<Effect>,
        on_failure: Vec<String>,
        body: Vec<Materialized>,
        result: Box<Materialized>,
    },
    Module {
        name: String,
        types: Vec<Materialized>,
        functions: Vec<Materialized>,
    },
    RecordDef {
        name: String,
        fields: Vec<(String, Type)>,
    },
    Record {
        type_name: String,
        fields: Vec<(String, Materialized)>,
    },
    Field {
        base: Box<Materialized>,
        type_name: String,
        field: String,
    },
    VariantDef {
        name: String,
        cases: Vec<(String, Vec<(String, Type)>)>,
    },
    Variant {
        type_name: String,
        case: String,
        fields: Vec<(String, Materialized)>,
    },
    Match {
        scrutinee: Box<Materialized>,
        type_name: String,
        arms: Vec<(String, Vec<String>, Materialized)>,
    },
}

A subtree loaded back out of the store, children inlined, for inspection and equality checks.

Variants

Lit(i64)

FloatLit(u64)

FloatOp

Fields

op: BinOp

lhs: Box<Materialized>

rhs: Box<Materialized>

IntToFloat(Box<Materialized>)

FloatToInt(Box<Materialized>)

DecimalLit(i64)

DecimalOp

Fields

op: BinOp

lhs: Box<Materialized>

rhs: Box<Materialized>

IntToDecimal(Box<Materialized>)

DecimalToInt(Box<Materialized>)

DecimalRaw(Box<Materialized>)

Bool(bool)

Not(Box<Materialized>)

Str(String)

StrLen(Box<Materialized>)

StrLower(Box<Materialized>)

StrFromCode(Box<Materialized>)

StrConcat(Box<Materialized>, Box<Materialized>)

StrSlice

Fields

s: Box<Materialized>

start: Box<Materialized>

len: Box<Materialized>

StrEq(Box<Materialized>, Box<Materialized>)

StrContains

Fields

haystack: Box<Materialized>

needle: Box<Materialized>

StrStartsWith

Fields

s: Box<Materialized>

prefix: Box<Materialized>

StrIndexOf

Fields

haystack: Box<Materialized>

needle: Box<Materialized>

NumberToStr(Box<Materialized>)

StrToNumber(Box<Materialized>)

StrToNumberOpt(Box<Materialized>)

Now

List(Vec<Materialized>)

ListEmpty

Fields

elem: Type

ListCons

Fields

head: Box<Materialized>

tail: Box<Materialized>

OptionSome(Box<Materialized>)

OptionNone

Fields

elem: Type

OptionElse

Fields

opt: Box<Materialized>

default: Box<Materialized>

OptionMatch

Fields

opt: Box<Materialized>

some_bind: String

some_body: Box<Materialized>

none_body: Box<Materialized>

ListTryGet

Fields

list: Box<Materialized>

index: Box<Materialized>

ListLen(Box<Materialized>)

ListGet

Fields

list: Box<Materialized>

index: Box<Materialized>

Map(Vec<(Materialized, Materialized)>)

MapGet

Fields

map: Box<Materialized>

key: Box<Materialized>

MapTryGet

Fields

map: Box<Materialized>

key: Box<Materialized>

MapLen(Box<Materialized>)

Log(Box<Materialized>)

Publish(Box<Materialized>)

SetHeader

Fields

name: Box<Materialized>

value: Box<Materialized>

Rand

MutNew(Box<Materialized>)

MutGet(Box<Materialized>)

MutSet

Fields

cell: Box<Materialized>

value: Box<Materialized>

DiskWrite

Fields

path: Box<Materialized>

content: Box<Materialized>

DiskRead(Box<Materialized>)

NetGet(Box<Materialized>)

DbQuery

Fields

sql: Box<Materialized>

params: Box<Materialized>

Ref(String)

Call

Fields

func: String

args: Vec<Materialized>

FuncRef(String)

CallValue

Fields

callee: Box<Materialized>

args: Vec<Materialized>

Lambda

Fields

params: Vec<Param>

body: Box<Materialized>

Hole

Fields

expects: String

Step

Fields

binding: String

value: Box<Materialized>

BinOp

Fields

op: BinOp

lhs: Box<Materialized>

rhs: Box<Materialized>

If

Fields

cond: Box<Materialized>

then_branch: Box<Materialized>

else_branch: Box<Materialized>

Fail(String)

Handle

Fields

body: Box<Materialized>

handlers: Vec<(String, Materialized)>

Function

Fields

name: String

type_params: Vec<String>

params: Vec<Param>

produces: Produces

requires: BTreeSet<Effect>

on_failure: Vec<String>

body: Vec<Materialized>

result: Box<Materialized>

Module

Fields

name: String

types: Vec<Materialized>

functions: Vec<Materialized>

RecordDef

Fields

name: String

fields: Vec<(String, Type)>

Record

Fields

type_name: String

fields: Vec<(String, Materialized)>

Field

Fields

base: Box<Materialized>

type_name: String

field: String

VariantDef

Fields

name: String

cases: Vec<(String, Vec<(String, Type)>)>

Variant

Fields

type_name: String

case: String

fields: Vec<(String, Materialized)>

Match

Fields

scrutinee: Box<Materialized>

type_name: String

arms: Vec<(String, Vec<String>, Materialized)>

Trait Implementations

impl Clone for Materialized

fn clone(&self) -> Materialized

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Materialized

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

Formats the value using the given formatter.

impl PartialEq for Materialized

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

impl StructuralPartialEq for Materialized