Enum Value 

pub enum Value {
    Bool(bool),
    Int(i64),
    Float(OrderedFloat<f64>),
    String(SmolStr),
    List(Arc<Vec<Value>>),
    Tuple(Arc<Vec<Value>>),
    Dict(Arc<ValueDict>),
    Closure(Box<ClosureData>),
    Schema(Arc<SchemaData>),
    EnumSchema(Arc<EnumSchemaData>),
    Type(Box<TypeNode>),
    Wildcard,
}

Aggregate value type produced by the evaluator.

List, Tuple, and Dict payloads are reference-counted: cloning a Value::List, Value::Tuple, or Value::Dict only bumps an Arc and does not copy the underlying collection. Mutations go through Arc::make_mut (see Value::list_mut and Value::dict_mut), which clones the inner value lazily on first write — so existing aliases keep their snapshot semantics. This matters because the evaluator caches resolved paths and module results in shared path_cache/module_cache maps; without Arc-sharing every cache hit would deep-clone the cached structure.

The “heavy” variants (Closure, Schema, EnumSchema) live behind pointers so the enum stays narrow: the comprehension hot loop stores Values in per-iteration scope HashMaps, and the bucket size scales with the enum width. Schema / EnumSchema use Arc (P2-5) — the check_type path clones the schema value out of the type table per typed-field validation, and a deep field-map clone there was a measurable cost; refcount-clone collapses it to a single atomic bump while keeping immutable-snapshot semantics.

Variants

Bool(bool)

Int(i64)

Float(OrderedFloat<f64>)

String(SmolStr)

Short-string-optimized: ≤ 22 byte payloads inline in the value slot (no heap alloc), longer payloads ride a refcounted Arc<str> so clones stay O(1). See SmolStr.

List(Arc<Vec<Value>>)

Tuple(Arc<Vec<Value>>)

Dict(Arc<ValueDict>)

Closure(Box<ClosureData>)

A unified closure (can be used as a function or a decorator). Payload is boxed; see ClosureData.

Schema(Arc<SchemaData>)

A user-defined type schema. Payload is refcounted; see SchemaData.

EnumSchema(Arc<EnumSchemaData>)

A tagged-enum (sum-type) schema: variants by name, each with its own field set. Built from #enum Name { Var1 { ... }, ... } declarations. Construction with Name.Var1 { ... } is dispatched via this value. Payload is refcounted; see EnumSchemaData.

Type(Box<TypeNode>)

A single type description. The payload (TypeNode) carries a TokenRange plus a Vec<TypeNode> of generics that together push the inline size past 100 bytes; boxing keeps the enum compact (matching the rationale for ClosureData et al.).

Wildcard

A wildcard predicate (*)

Implementations

impl Value

pub fn list(items: Vec<Value>) -> Self

Build a Value::List from a Vec, taking ownership and wrapping it in Arc so subsequent clones are O(1).

pub fn tuple(items: Vec<Value>) -> Self

Build a Value::Tuple from a Vec, taking ownership and wrapping it in Arc so subsequent clones are O(1).

pub fn option_some(value: Value) -> Self

Build the standard Some(value) tagged value.

pub fn option_none() -> Self

Build the standard None tagged value.

pub fn result_ok(value: Value) -> Self

Build the standard Ok(value) tagged value.

pub fn result_err(error: Value) -> Self

Build the standard Err(error) tagged value.

pub fn is_option_none(&self) -> bool

True for the standard None tagged value.

pub fn option_some_value(&self) -> Option<&Value>

Return the payload of a standard Option.Some { value } tagged value.

pub fn dict<K, I>(map: I) -> Self

where K: Into<SmolStr>, I: IntoIterator<Item = (K, Value)>,

Build a Value::Dict from any iterable of key/value pairs. The generic key accepts either a SmolStr (zero-cost) or a String (consumed and short-string-optimised via SmolStr::from). Use Value::branded_dict when the dict carries a nominal-type brand.

pub fn branded_dict<K, I>(map: I, brand: Option<String>) -> Self

where K: Into<SmolStr>, I: IntoIterator<Item = (K, Value)>,

Build a Value::Dict with an explicit brand (the typed-dict tag set after a successful User x: { ... } validation, etc.). See Value::dict for the key-type contract.

pub fn variant_dict<K, I>(map: I, variant: String, enum_name: String) -> Self

where K: Into<SmolStr>, I: IntoIterator<Item = (K, Value)>,

Build a Value::Dict representing a tagged-enum variant: carries a brand (the variant name) plus variant_of (the parent enum name). The JSON projector uses variant_of to externally tag the output. See Value::dict for the key-type contract.

pub fn list_mut(&mut self) -> Option<&mut Vec<Value>>

In-place mutable handle to a Value::List’s inner Vec. Clones the inner allocation only if the Arc is shared with another holder. Returns None for non-list values.

pub fn dict_mut(&mut self) -> Option<&mut ValueDict>

In-place mutable handle to a Value::Dict’s inner ValueDict. CoW semantics — see Value::list_mut.

pub fn is_truthy(&self) -> bool

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

pub fn deep_merge(&mut self, patch: &Value)

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<'de> Deserialize<'de> for Value

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Value

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

Formats the value using the given formatter.

impl PartialEq for Value

fn eq(&self, other: &Self) -> 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 Serialize for Value

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.