Enum CoreExpr 

pub enum CoreExpr {
    Const(Value),
    Var(Spur),
    If {
        test: Box<CoreExpr>,
        then: Box<CoreExpr>,
        else_: Box<CoreExpr>,
    },
    Begin(Vec<CoreExpr>),
    Set(Spur, Box<CoreExpr>),
    Lambda(LambdaDef),
    Call {
        func: Box<CoreExpr>,
        args: Vec<CoreExpr>,
        tail: bool,
    },
    Define(Spur, Box<CoreExpr>),
    Let {
        bindings: Vec<(Spur, CoreExpr)>,
        body: Vec<CoreExpr>,
    },
    LetStar {
        bindings: Vec<(Spur, CoreExpr)>,
        body: Vec<CoreExpr>,
    },
    Letrec {
        bindings: Vec<(Spur, CoreExpr)>,
        body: Vec<CoreExpr>,
    },
    NamedLet {
        name: Spur,
        bindings: Vec<(Spur, CoreExpr)>,
        body: Vec<CoreExpr>,
    },
    Do(DoLoop),
    Try {
        body: Vec<CoreExpr>,
        catch_var: Spur,
        handler: Vec<CoreExpr>,
    },
    Throw(Box<CoreExpr>),
    And(Vec<CoreExpr>),
    Or(Vec<CoreExpr>),
    Quote(Value),
    MakeList(Vec<CoreExpr>),
    MakeVector(Vec<CoreExpr>),
    MakeMap(Vec<(CoreExpr, CoreExpr)>),
    Defmacro {
        name: Spur,
        params: Vec<Spur>,
        rest: Option<Spur>,
        body: Vec<CoreExpr>,
    },
    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<CoreExpr>,
    },
    Import {
        path: Box<CoreExpr>,
        selective: Vec<Spur>,
    },
    Load(Box<CoreExpr>),
    Eval(Box<CoreExpr>),
    Prompt(Vec<PromptEntry>),
    Message {
        role: Box<CoreExpr>,
        parts: Vec<CoreExpr>,
    },
    Deftool {
        name: Spur,
        description: Box<CoreExpr>,
        parameters: Box<CoreExpr>,
        handler: Box<CoreExpr>,
    },
    Defagent {
        name: Spur,
        options: Box<CoreExpr>,
    },
    Delay(Box<CoreExpr>),
    Force(Box<CoreExpr>),
    Macroexpand(Box<CoreExpr>),
}

Desugared core language. Variables referenced by name (Spur). The variable resolver replaces names with slot indices in a later pass.

Variants

Const(Value)

Literal constant

Var(Spur)

Variable reference

If

if-then-else

Fields

test: Box<CoreExpr>

then: Box<CoreExpr>

else_: Box<CoreExpr>

Begin(Vec<CoreExpr>)

Sequence of expressions

Set(Spur, Box<CoreExpr>)

Variable mutation (set!)

Lambda(LambdaDef)

Closure creation

Call

Function call (tail flag for TCO)

Fields

func: Box<CoreExpr>

args: Vec<CoreExpr>

tail: bool

Define(Spur, Box<CoreExpr>)

Variable definition (define)

Let

Parallel binding

Fields

bindings: Vec<(Spur, CoreExpr)>

body: Vec<CoreExpr>

LetStar

Sequential binding

Fields

bindings: Vec<(Spur, CoreExpr)>

body: Vec<CoreExpr>

Letrec

Recursive binding

Fields

bindings: Vec<(Spur, CoreExpr)>

body: Vec<CoreExpr>

NamedLet

Named let (loop construct)

Fields

name: Spur

bindings: Vec<(Spur, CoreExpr)>

body: Vec<CoreExpr>

Do(DoLoop)

Do loop

Try

Try/catch

Fields

body: Vec<CoreExpr>

catch_var: Spur

handler: Vec<CoreExpr>

Throw(Box<CoreExpr>)

Throw exception

And(Vec<CoreExpr>)

Short-circuit and

Or(Vec<CoreExpr>)

Short-circuit or

Quote(Value)

Quoted value (no evaluation)

MakeList(Vec<CoreExpr>)

List constructor (evaluate elements)

MakeVector(Vec<CoreExpr>)

Vector constructor (evaluate elements)

MakeMap(Vec<(CoreExpr, CoreExpr)>)

Map constructor (evaluate key-value pairs)

Defmacro

Macro definition (runtime)

Fields

name: Spur

params: Vec<Spur>

rest: Option<Spur>

body: Vec<CoreExpr>

DefineRecordType

Record type definition

Fields

type_name: Spur

ctor_name: Spur

pred_name: Spur

field_names: Vec<Spur>

field_specs: Vec<(Spur, Spur)>

Module

Module declaration

Fields

name: Spur

exports: Vec<Spur>

body: Vec<CoreExpr>

Import

Import a module

Fields

path: Box<CoreExpr>

selective: Vec<Spur>

Load(Box<CoreExpr>)

Load a file in current env

Eval(Box<CoreExpr>)

Dynamic eval

Prompt(Vec<PromptEntry>)

Prompt (LLM data constructor)

Message

Message (LLM data constructor)

Fields

role: Box<CoreExpr>

parts: Vec<CoreExpr>

Deftool

Tool definition (LLM)

Fields

name: Spur

description: Box<CoreExpr>

parameters: Box<CoreExpr>

handler: Box<CoreExpr>

Defagent

Agent definition (LLM)

Fields

name: Spur

options: Box<CoreExpr>

Delay(Box<CoreExpr>)

Delay (create thunk)

Force(Box<CoreExpr>)

Force (evaluate thunk)

Macroexpand(Box<CoreExpr>)

Macroexpand

Trait Implementations

impl Clone for CoreExpr

fn clone(&self) -> CoreExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CoreExpr

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

Formats the value using the given formatter.