Enum DxValue 

pub enum DxValue {
    Null,
    Bool(bool),
    Int(i64),
    Float(f64),
    String(String),
    Array(DxArray),
    Object(DxObject),
    Table(DxTable),
    Ref(usize),
}

The core value type for the DX machine format (binary, zero-copy).

DxValue represents all possible values in the DX binary format, optimized for maximum parsing performance and zero-copy deserialization.

Relationship to DxLlmValue

DX provides two value types for different use cases:

• DxValue (this type): For the binary machine format. Use when you need maximum performance, zero-copy parsing, or runtime data structures.

• DxLlmValue: For the text LLM format. Use when preparing data for LLM context windows or when token efficiency matters.

The two types have different variant sets because they serve different purposes:

• DxValue has separate Int and Float variants for type precision
• DxLlmValue has a single Num variant since LLMs don’t distinguish
• DxValue has Object and Table for structured data
• DxLlmValue has Ref for reference pointers in the Dx Serializer format

When to Use DxValue

Choose DxValue when:

• Performance is critical: Binary format parses faster than text
• Zero-copy is needed: Large datasets can be memory-mapped
• Type precision matters: Separate Int/Float types preserve precision
• Building runtime structures: Objects and Tables provide efficient access

Examples

Creating Values

use serializer::DxValue;

// Primitive values
let null = DxValue::Null;
let boolean = DxValue::Bool(true);
let integer = DxValue::Int(42);
let float = DxValue::Float(3.14);
let string = DxValue::String("hello".to_string());

Working with Arrays

use serializer::{DxValue, DxArray};

let mut arr = DxArray::new();
arr.values.push(DxValue::Int(1));
arr.values.push(DxValue::Int(2));
arr.values.push(DxValue::Int(3));

let array_value = DxValue::Array(arr);

Working with Objects

use serializer::{DxValue, DxObject};

let mut obj = DxObject::new();
obj.insert("name".to_string(), DxValue::String("Alice".to_string()));
obj.insert("age".to_string(), DxValue::Int(30));

let object_value = DxValue::Object(obj);

Type Inspection

use serializer::DxValue;

let value = DxValue::Int(42);
assert_eq!(value.type_name(), "int");
assert_eq!(value.as_int(), Some(42));

Thread Safety

DxValue implements Send + Sync and can be safely shared between threads. This is verified at compile time via static assertions.

See Also

• DxLlmValue - Value type for the LLM text format
• DxArray - Array container type
• DxObject - Object/map container type
• DxTable - Schema-defined table type

Variants

Null

Null value, represented as ~ in DX format.

Bool(bool)

Boolean value, represented as + (true) or - (false) in DX format.

Int(i64)

64-bit signed integer.

Note: DxLlmValue uses a single Num variant for all numbers since LLMs don’t distinguish integer vs float.

Float(f64)

64-bit floating-point number.

Note: DxLlmValue uses a single Num variant for all numbers since LLMs don’t distinguish integer vs float.

String(String)

String value. In machine format, strings don’t require quotes.

Array(DxArray)

Array/List of values. See DxArray for details.

Object(DxObject)

Object/Map with key-value pairs. See DxObject for details.

Table(DxTable)

Table with schema-defined columns. See DxTable for details.

Tables are a DX-specific feature for efficient tabular data representation.

Ref(usize)

Reference to an anchor by index (@N in DX format).

Anchors allow deduplication of repeated values in the document.

Implementations

impl DxValue

pub fn is_empty(&self) -> bool

Check if this value is “empty” for ditto logic

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

Get type name for error messages

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

Convert to boolean if possible

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

Convert to integer if possible

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

Convert to float if possible

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

Convert to string if possible

Trait Implementations

impl Clone for DxValue

fn clone(&self) -> DxValue

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DxValue

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

Formats the value using the given formatter.

impl PartialEq for DxValue

fn eq(&self, other: &DxValue) -> 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 StructuralPartialEq for DxValue