Enum Value 

pub enum Value {
    Bool(bool),
    Int(i64),
    Float(f64),
    Str(String),
    Bytes(Vec<u8>),
    CidLink(String),
    Blob {
        ref_: String,
        mime: String,
        size: u64,
    },
    Token(String),
    Null,
    Opaque {
        type_: String,
        fields: HashMap<String, Self>,
    },
    Unknown(HashMap<String, Self>),
    List(Vec<Self>),
}

A concrete data value in an instance.

This is the ADT of leaf-or-opaque data carried by a W-type node. It mirrors the free term algebra of JSON-like values and forms a faithful round-trip target for any schema-unanchored data that parses into the instance (e.g. values landing in extra_fields).

Category-theoretically, the variants partition into:

• Primitive atoms (Self::Bool, Self::Int, Self::Float, Self::Str, Self::Bytes, Self::CidLink, Self::Blob, Self::Token, Self::Null) — generators of the ADT.
• Records (Self::Opaque, Self::Unknown) — finite products indexed by string field names (heterogeneous, unordered).
• Lists (Self::List) — the free monoid / list object, an ordered collection with anonymous positions. This is the list constructor needed to faithfully embed JSON arrays and, more generally, any ordered-collection leaf value.

The Unknown and List variants together give the enum closure under the two fundamental JSON constructors (object and array) so that values with no schema anchor still round-trip losslessly.

Variants

Bool(bool)

Boolean value.

Int(i64)

64-bit signed integer.

Float(f64)

64-bit floating-point number.

Str(String)

UTF-8 string.

Bytes(Vec<u8>)

Raw bytes.

CidLink(String)

A content-identifier link (CID).

Blob

A blob reference.

Fields

ref_: String

Reference identifier.

mime: String

MIME type.

size: u64

Size in bytes.

Token(String)

A token (enum variant name).

Null

Explicit null.

Opaque

An opaque typed value (protocol-specific extension).

Fields

type_: String

The type identifier.

fields: HashMap<String, Self>

Opaque fields.

Unknown(HashMap<String, Self>)

An unknown record value: a finite product of name/value pairs. Used for schema-unanchored objects that must round-trip.

List(Vec<Self>)

An ordered list of values: the free-monoid list object over Value. Used for schema-unanchored arrays and for transforms that operate on ordered collections carried in extra_fields.

Implementations

impl Value

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

Returns a human-readable type name for this 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 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