Enum Literal 

pub enum Literal {
    Bool(bool),
    Int(i64),
    Float(f64),
    Str(String),
    Bytes(Vec<u8>),
    Null,
    Record(Vec<(Arc<str>, Self)>),
    List(Vec<Self>),
    Closure {
        param: Arc<str>,
        body: Box<Expr>,
        env: Vec<(Arc<str>, Self)>,
    },
}

A literal value in the expression language.

This is the result type of expression evaluation and the leaf node type for literal expressions. Kept minimal — just the primitives needed for schema transforms.

Variants

Bool(bool)

Boolean value.

Int(i64)

64-bit signed integer.

Float(f64)

64-bit IEEE 754 float.

Str(String)

UTF-8 string.

Bytes(Vec<u8>)

Raw bytes.

Null

Null / absent value.

Record(Vec<(Arc<str>, Self)>)

A record (ordered map of fields to values).

List(Vec<Self>)

A list of values.

Closure

A closure: a lambda expression captured with its environment.

Closures are first-class values produced by evaluating a Lam expression. They capture the parameter name, body, and the environment at the point of creation, enabling proper lexical scoping.

Fields

param: Arc<str>

The parameter name bound by this lambda.

body: Box<Expr>

The body expression (serialized as the AST).

env: Vec<(Arc<str>, Self)>

Captured environment bindings at the point of closure creation.

Implementations

impl Literal

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

Returns a human-readable type name for error messages.

pub const fn is_null(&self) -> bool

Returns true if this is a Literal::Null.

pub const fn as_bool(&self) -> Option<bool>

Attempts to extract a boolean value.

pub const fn as_int(&self) -> Option<i64>

Attempts to extract an integer value.

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

Attempts to extract a float value.

pub fn as_str(&self) -> Option<&str>

Attempts to extract a string reference.

pub fn as_record(&self) -> Option<&[(Arc<str>, Self)]>

Attempts to extract a record reference.

pub fn as_list(&self) -> Option<&[Self]>

Attempts to extract a list reference.

pub fn field(&self, name: &str) -> Option<&Self>

Look up a field in a record by name.

Trait Implementations

impl Clone for Literal

fn clone(&self) -> Literal

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Literal

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Literal

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Literal

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

Formats the value using the given formatter.

impl Hash for Literal

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Literal

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 Literal

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Literal