Enum Value 

pub enum Value {
    Nil,
    True,
    False,
    Number(isize),
    Float(f64),
    Char(char),
    Cons {
        car: ArenaIndex,
        cdr: ArenaIndex,
    },
    Symbol {
        chars: ArenaIndex,
    },
    Lambda {
        data: ArenaIndex,
    },
    Builtin(Builtin),
    StdLib {
        func: StdLib,
        cache: ArenaIndex,
    },
    Array {
        data: ArenaIndex,
        len: usize,
    },
    String {
        data: ArenaIndex,
        len: usize,
    },
    Native {
        id: usize,
        name_hash: usize,
    },
}

A Lisp value

Variants

Nil

The empty list (NOT false - use False for that)

True

Boolean true (#t)

False

Boolean false (#f) - the ONLY false value

Number(isize)

Integer number (exact)

Float(f64)

Floating-point number (inexact)

Char(char)

Single character (used in strings and symbol storage)

Cons

Cons cell (pair)

Fields

car: ArenaIndex

cdr: ArenaIndex

Symbol

Symbol (contains a contiguous string) The chars field points to a Value::String which contains the symbol name. The length is obtained from the String value, providing a single source of truth.

Fields

chars: ArenaIndex

Lambda

Lambda / closure (memory-optimized)

To minimize enum size, lambda data is stored as a linked list in the arena: data points to a cons cell (params . (body . env)) where:

• params: List of parameter symbols
• body: Expression to evaluate
• env: Captured environment (alist)

Use Lisp::lambda() to create and Lisp::lambda_parts() to extract.

Fields

data: ArenaIndex

Builtin(Builtin)

Built-in function (optimized)

StdLib

Standard library function (stored in static memory with caching)

Unlike Lambda which stores code in the arena, StdLib references static function definitions. The function body is parsed on first call and cached, providing good performance while minimizing initial arena cost.

Memory Efficiency

• Function definitions are in static memory (const strings)
• Parsed body and params are cached on first call
• Subsequent calls reuse the cached parsed AST

Cache Field

• cache: NULL until first call, then points to (body . params) cons cell

Use Lisp::stdlib() to create and Lisp::stdlib_cache() to access cache.

Fields

func: StdLib

cache: ArenaIndex

Array

Array (contiguous storage of values in the arena)

Arrays store values contiguously in the arena, similar to how symbols store characters. This provides O(1) indexed access and mutation.

Memory Layout

• data points to the first element in contiguous storage
• Elements are stored at data+0, data+1, …, data+(len-1)

Example

(define arr (make-array 3 0))  ; Create array of 3 zeros
(array-set! arr 1 42)          ; Set index 1 to 42
(array-ref arr 1)              ; => 42
(array-length arr)             ; => 3

Fields

data: ArenaIndex

len: usize

String

String (contiguous storage of Char values in the arena)

Strings store characters contiguously in the arena, similar to arrays. This provides O(1) indexed access and O(1) length lookup.

Memory Layout

• data points to the first character in contiguous storage
• Characters are stored at data+0, data+1, …, data+(len-1)

Example

(string-length "hello")   ; => 5
(string-ref "hello" 0)    ; => #\h

Fields

data: ArenaIndex

len: usize

Native

Native function (Rust function callable from Lisp)

Native functions are registered at runtime and identified by their ID. The actual function pointer is stored in the evaluator’s NativeRegistry.

Fields

• id: Index into the NativeRegistry’s entries array
• name_hash: Hash of the function name for quick comparison

Fields

id: usize

name_hash: usize

Implementations

impl Value

pub const fn is_nil(&self) -> bool

Check if this value is nil (empty list)

pub const fn is_false(&self) -> bool

Check if this value is false (#f) This is the ONLY way to be false in this Lisp

pub const fn is_true(&self) -> bool

Check if this value is true (#t)

pub const fn is_boolean(&self) -> bool

Check if this value is a boolean (#t or #f)

pub const fn is_atom(&self) -> bool

Check if this value is an atom (not a cons cell)

pub const fn is_number(&self) -> bool

Check if this value is a number (integer or float)

pub const fn is_integer(&self) -> bool

Check if this value is an integer

pub const fn is_float(&self) -> bool

Check if this value is a float

pub const fn is_symbol(&self) -> bool

Check if this value is a symbol

pub const fn is_cons(&self) -> bool

Check if this value is a cons cell (pair)

pub const fn is_lambda(&self) -> bool

Check if this value is a lambda

pub const fn is_builtin(&self) -> bool

Check if this value is a builtin

pub const fn is_stdlib(&self) -> bool

Check if this value is a stdlib function

pub const fn is_native(&self) -> bool

Check if this value is a native (Rust) function

pub const fn is_procedure(&self) -> bool

Check if this value is a procedure (lambda, builtin, stdlib, or native function)

pub const fn is_array(&self) -> bool

Check if this value is an array

pub const fn is_string(&self) -> bool

Check if this value is a string

pub const fn as_number(&self) -> Option<isize>

Get the number value if this is an integer

pub const fn as_float(&self) -> Option<f64>

Get the float value if this is a float

pub const fn as_f64(&self) -> Option<f64>

Get any numeric value as f64

pub const fn as_char(&self) -> Option<char>

Get the char value if this is a char

pub const fn type_name(&self) -> &'static str

Get a human-readable type name

Trait Implementations

impl Clone for Value

fn clone(&self) -> Value

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Value

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

Formats the value using the given formatter.

impl PartialEq for Value

fn eq(&self, other: &Value) -> 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<const N: usize> Trace<Value, N> for Value

Implement Trace for GC support

fn trace<F>(&self, tracer: F)

where F: FnMut(ArenaIndex),

Trace all ArenaIndex references contained in this value.

impl Copy for Value

impl StructuralPartialEq for Value