Enum Value 

pub enum Value {
    Nil,
    Boolean(bool),
    Number(isize),
    Symbol(ArenaIndex),
    Cons {
        car: ArenaIndex,
        cdr: ArenaIndex,
    },
    String {
        len: usize,
        data: ArenaIndex,
    },
    Char(char),
    Operative {
        params_envparam: ArenaIndex,
        body_env: ArenaIndex,
    },
    Applicative(ArenaIndex),
    Builtin(BuiltinId),
    Environment {
        bindings: ArenaIndex,
        parents: ArenaIndex,
    },
    Inert,
    Ignore,
}

A Lisp value stored in the arena. Variants can only inline max two arenaindex sized data.

Variants

Nil

The empty list / nil.

Boolean(bool)

Number(isize)

Integer number.

Symbol(ArenaIndex)

A symbol, pointing to a String value that holds the name.

Cons

A cons cell (pair) with inline car and cdr.

Fields

car: ArenaIndex

cdr: ArenaIndex

String

A string with inline length and pointer to character data.

Fields

len: usize

data: ArenaIndex

Char(char)

A character.

Operative

Compound operative (vau closure / fexpr). Created by (vau params env-param body). params_envparam = (params . env-param), body_env = (body . closed-env)

Fields

params_envparam: ArenaIndex

body_env: ArenaIndex

Applicative(ArenaIndex)

Applicative wrapper: evaluates arguments, then calls inner combiner. Created by (wrap combiner). The inner combiner is any callable: Operative, Builtin, or even another Applicative.

Builtin(BuiltinId)

Rust-native primitive operative. Always an operative — receives unevaluated args + caller env. Applicative primitives (like +) are (wrap (Builtin id)) at init time.

Environment

A first-class environment with lexical parent chain. bindings: alist of (symbol . value) pairs in this frame. parents: cons-list of parent environments, or NIL for top-level.

Fields

bindings: ArenaIndex

parents: ArenaIndex

Inert

The inert value, written #inert. Returned by combiners whose primary purpose is side-effect (e.g. $define!).

Ignore

The ignore value, written #ignore. Used specifically for parameter matching in formal parameter trees.

Implementations

impl Value

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

Returns the type name as a static string (for error messages).

pub fn is_self_evaluating(self) -> bool

True for self-evaluating forms (literals, closures, builtins).

Self-evaluating values exclude symbols and cons cells (which require lookup / dispatch).

pub fn is_immutable(self) -> bool

True for immutable, encapsulated types whose identity is determined by value rather than arena slot (used by eq?).

pub fn as_number(self) -> Result<isize, ArenaError>

Extract the numeric value, or Err(TypeError) if not a number.

pub fn as_cons(self) -> Result<(ArenaIndex, ArenaIndex), ArenaError>

Extract the car and cdr of a cons cell.

pub fn as_symbol(self) -> Result<ArenaIndex, ArenaError>

Extract the symbol’s string index.

pub fn as_bool(self) -> Result<bool, ArenaError>

Extract the boolean value, or Err(TypeError) if not a boolean.

pub fn as_applicative(self) -> Result<ArenaIndex, ArenaError>

Extract the inner combiner of an applicative, or Err(TypeError).

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

Formats the value using the given formatter.

impl Display for Value

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

Formats the value using the given formatter.

impl From<BuiltinId> for Value

fn from(v: BuiltinId) -> Self

Converts to this type from the input type.

impl From<bool> for Value

fn from(v: bool) -> Self

Converts to this type from the input type.

impl From<char> for Value

fn from(v: char) -> Self

Converts to this type from the input type.

impl From<isize> for Value

fn from(v: isize) -> Self

Converts to this type from the input type.

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

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

Trace all ArenaIndex references contained in this value.

fn trace_with_arena<F: FnMut(ArenaIndex)>( &self, arena: &Arena<Value, N>, tracer: F, )

Trace with arena access for types that store metadata in the arena.

impl Copy for Value

impl StructuralPartialEq for Value