Enum ResolvedExpr 

pub enum ResolvedExpr {
    Const(Value),
    Var(VarRef),
    If {
        test: Box<ResolvedExpr>,
        then: Box<ResolvedExpr>,
        else_: Box<ResolvedExpr>,
    },
    Begin(Vec<ResolvedExpr>),
    Set(VarRef, Box<ResolvedExpr>),
    Lambda(ResolvedLambda),
    Call {
        func: Box<ResolvedExpr>,
        args: Vec<ResolvedExpr>,
        tail: bool,
    },
    Define(Spur, Box<ResolvedExpr>),
    Let {
        bindings: Vec<(VarRef, ResolvedExpr)>,
        body: Vec<ResolvedExpr>,
    },
    LetStar {
        bindings: Vec<(VarRef, ResolvedExpr)>,
        body: Vec<ResolvedExpr>,
    },
    Letrec {
        bindings: Vec<(VarRef, ResolvedExpr)>,
        body: Vec<ResolvedExpr>,
    },
    NamedLet {
        name: VarRef,
        bindings: Vec<(VarRef, ResolvedExpr)>,
        body: Vec<ResolvedExpr>,
    },
    Do(ResolvedDoLoop),
    Try {
        body: Vec<ResolvedExpr>,
        catch_var: VarRef,
        handler: Vec<ResolvedExpr>,
    },
    Throw(Box<ResolvedExpr>),
    And(Vec<ResolvedExpr>),
    Or(Vec<ResolvedExpr>),
    Quote(Value),
    MakeList(Vec<ResolvedExpr>),
    MakeVector(Vec<ResolvedExpr>),
    MakeMap(Vec<(ResolvedExpr, ResolvedExpr)>),
    Defmacro {
        name: Spur,
        params: Vec<Spur>,
        rest: Option<Spur>,
        body: Vec<ResolvedExpr>,
    },
    DefineRecordType {
        type_name: Spur,
        ctor_name: Spur,
        pred_name: Spur,
        field_names: Vec<Spur>,
        field_specs: Vec<(Spur, Spur)>,
    },
    Module {
        name: Spur,
        exports: Vec<Spur>,
        body: Vec<ResolvedExpr>,
    },
    Import {
        path: Box<ResolvedExpr>,
        selective: Vec<Spur>,
    },
    Load(Box<ResolvedExpr>),
    Eval(Box<ResolvedExpr>),
    Prompt(Vec<ResolvedPromptEntry>),
    Message {
        role: Box<ResolvedExpr>,
        parts: Vec<ResolvedExpr>,
    },
    Deftool {
        name: Spur,
        description: Box<ResolvedExpr>,
        parameters: Box<ResolvedExpr>,
        handler: Box<ResolvedExpr>,
    },
    Defagent {
        name: Spur,
        options: Box<ResolvedExpr>,
    },
    Delay(Box<ResolvedExpr>),
    Force(Box<ResolvedExpr>),
    Macroexpand(Box<ResolvedExpr>),
}

Resolved expression: like CoreExpr but variables are resolved to slots/upvalues/globals.

Variants

Const(Value)

Var(VarRef)

If

Fields

test: Box<ResolvedExpr>

then: Box<ResolvedExpr>

else_: Box<ResolvedExpr>

Begin(Vec<ResolvedExpr>)

Set(VarRef, Box<ResolvedExpr>)

Lambda(ResolvedLambda)

Call

Fields

func: Box<ResolvedExpr>

args: Vec<ResolvedExpr>

tail: bool

Define(Spur, Box<ResolvedExpr>)

Let

Fields

bindings: Vec<(VarRef, ResolvedExpr)>

body: Vec<ResolvedExpr>

LetStar

Fields

bindings: Vec<(VarRef, ResolvedExpr)>

body: Vec<ResolvedExpr>

Letrec

Fields

bindings: Vec<(VarRef, ResolvedExpr)>

body: Vec<ResolvedExpr>

NamedLet

Fields

name: VarRef

bindings: Vec<(VarRef, ResolvedExpr)>

body: Vec<ResolvedExpr>

Do(ResolvedDoLoop)

Try

Fields

body: Vec<ResolvedExpr>

catch_var: VarRef

handler: Vec<ResolvedExpr>

Throw(Box<ResolvedExpr>)

And(Vec<ResolvedExpr>)

Or(Vec<ResolvedExpr>)

Quote(Value)

MakeList(Vec<ResolvedExpr>)

MakeVector(Vec<ResolvedExpr>)

MakeMap(Vec<(ResolvedExpr, ResolvedExpr)>)

Defmacro

Fields

name: Spur

params: Vec<Spur>

rest: Option<Spur>

body: Vec<ResolvedExpr>

DefineRecordType

Fields

type_name: Spur

ctor_name: Spur

pred_name: Spur

field_names: Vec<Spur>

field_specs: Vec<(Spur, Spur)>

Module

Fields

name: Spur

exports: Vec<Spur>

body: Vec<ResolvedExpr>

Import

Fields

path: Box<ResolvedExpr>

selective: Vec<Spur>

Load(Box<ResolvedExpr>)

Eval(Box<ResolvedExpr>)

Prompt(Vec<ResolvedPromptEntry>)

Message

Fields

role: Box<ResolvedExpr>

parts: Vec<ResolvedExpr>

Deftool

Fields

name: Spur

description: Box<ResolvedExpr>

parameters: Box<ResolvedExpr>

handler: Box<ResolvedExpr>

Defagent

Fields

name: Spur

options: Box<ResolvedExpr>

Delay(Box<ResolvedExpr>)

Force(Box<ResolvedExpr>)

Macroexpand(Box<ResolvedExpr>)

Trait Implementations

impl Clone for ResolvedExpr

fn clone(&self) -> ResolvedExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ResolvedExpr

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

Formats the value using the given formatter.