Enum Value 

pub enum Value {
    Null,
    Bool(bool),
    Int(i64),
    Float(f64),
    String(Box<str>),
    Tensor(Box<Tensor>),
    Reference(Reference),
    Expression(Box<Expression>),
    List(Box<Vec<Value>>),
}

A scalar value in HEDL.

Optimized memory layout:

• Large variants (String, Tensor, Expression, List) are boxed to keep enum size small
• Small values (Null, Bool, Int, Float) remain inline
• Total enum size: 16 bytes (down from 32+ bytes)
• Reduces memory usage by 40-50% for typical documents

Variants

Null

Null value (~).

Bool(bool)

Boolean value (true/false).

Int(i64)

Integer value.

Float(f64)

Floating-point value.

String(Box<str>)

String value (boxed to reduce enum size).

Tensor(Box<Tensor>)

Tensor (multi-dimensional array, boxed to reduce enum size).

Reference(Reference)

Reference to another node.

Expression(Box<Expression>)

Parsed expression from $(…) (boxed to reduce enum size).

List(Box<Vec<Value>>)

List of scalar values (from (...) syntax).

Distinct from Tensor: lists can contain any scalar types (strings, bools, refs, etc.), while tensors are numeric-only.

Examples

use hedl_core::Value;

// String list: (admin, editor, viewer)
let roles = Value::List(Box::new(vec![
    Value::String("admin".into()),
    Value::String("editor".into()),
    Value::String("viewer".into()),
]));

// Bool list: (true, false, true)
let flags = Value::List(Box::new(vec![
    Value::Bool(true),
    Value::Bool(false),
    Value::Bool(true),
]));

// Empty list: ()
let empty = Value::List(Box::new(vec![]));

Implementations

impl Value

pub fn is_null(&self) -> bool

Returns true if this value is null.

pub fn is_reference(&self) -> bool

Returns true if this value is a reference.

pub fn is_list(&self) -> bool

Returns true if this value is a list.

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

Try to get the value as a list.

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

Try to get the value as a string.

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

Try to get the value as an integer.

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

Try to get the value as a float.

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

Try to get the value as a boolean.

pub fn as_reference(&self) -> Option<&Reference>

Try to get the value as a reference.

impl Value

pub fn as_expression(&self) -> Option<&Expression>

Try to get the expression if this is an Expression variant.

pub fn coerce_to(&self, expected: &ExpectedType) -> CoercionResult

Attempt to coerce this value to the expected type.

Uses lenient mode (equivalent to Standard level) by default.

Examples

use hedl_core::Value;
use hedl_core::types::ExpectedType;

let value = Value::String("42".to_string().into());
let result = value.coerce_to(&ExpectedType::Int);
assert!(result.is_ok());

pub fn can_coerce_to(&self, expected: &ExpectedType) -> bool

Check if this value can be coerced to the expected type.

Returns true if coercion would succeed (either matched or coerced).

Examples

use hedl_core::Value;
use hedl_core::types::ExpectedType;

let value = Value::Int(42);
assert!(value.can_coerce_to(&ExpectedType::Float));

let value = Value::String("42".to_string().into());
assert!(value.can_coerce_to(&ExpectedType::Int));

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: &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 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.

impl StructuralPartialEq for Value