core:value
Dynamically-typed, format-agnostic value type.
Value represents any value the serde data model can carry, shared by
every self-describing format (core:json, core:cbor). It implements
Serialize and Deserialize, so it round-trips through from_bytes /
to_bytes with no per-type work. to_value and from_value convert
between a typed value and a Value directly, and merge overlays one
Value on another, as layered configuration does.
It is a general dynamic value, so it deliberately contains no
format-specific concepts (no CBOR Tag, no Simple): a single opaque
escape hatch, Unknown, carries the raw encoded bytes of anything the
model cannot represent. Bytes (a semantic byte-string value) and
Unknown (raw, format-specific encoded bytes) are distinct and must not
be conflated.
Synopsis
assert to_value(&[1, 2, 3]) matches { Ok(List(items)) && items.len() == 3 };
assert to_value(&"wado") matches { Ok(String(s)) && s == "wado" };
let v: Value = from_bytes("{\"x\":1,\"y\":[true,null]}").unwrap();
assert v matches { Object(fields) && fields.len() == 2 };
assert to_bytes::<Value>(&v) matches { Ok(bytes) && bytes.len() > 0 };
Functions
pub fn to_value<T: Serialize>(value: &T) -> Result<Value, SerializeError>
Build a Value from any Serialize value — the serde to_value analog.
Direct: it drives a Value-building Serializer with no intermediate
encoding, so it preserves the data model (Int vs UInt vs Float,
object key order, variant shape) that a round-trip through a text format
like JSON would flatten.
pub fn from_value<T: Deserialize>(value: &Value) -> Result<T, DeserializeError>
Build a typed value from a Value — the serde from_value analog.
It reads what to_value and every self-describing format produce: a whole
Float reads as an integer, and a string as an integer or a byte string
where core:json would write one that way. A Value carries no position,
so an error's offset is -1.
pub fn merge(base: Value, overlay: Value) -> Value
overlay laid over base: where both are objects, each key of overlay
merges into base's value for it, and a key base lacks is appended.
Anywhere else overlay wins whole, a list and an explicit Null included.
Structs
pub struct ValueSerializer
Fields are private.
impl Serializer for ValueSerializer
fn serialize_i32(&mut self, v: i32) -> Result<(), SerializeError>
fn serialize_i64(&mut self, v: i64) -> Result<(), SerializeError>
fn serialize_u32(&mut self, v: u32) -> Result<(), SerializeError>
fn serialize_u64(&mut self, v: u64) -> Result<(), SerializeError>
fn serialize_i128(&mut self, v: i128) -> Result<(), SerializeError>
fn serialize_u128(&mut self, v: u128) -> Result<(), SerializeError>
fn serialize_f32(&mut self, v: f32) -> Result<(), SerializeError>
fn serialize_f64(&mut self, v: f64) -> Result<(), SerializeError>
fn serialize_bool(&mut self, v: bool) -> Result<(), SerializeError>
fn serialize_char(&mut self, v: char) -> Result<(), SerializeError>
fn serialize_string<S: AsStrSlice>(&mut self, v: S) -> Result<(), SerializeError>
fn serialize_null(&mut self) -> Result<(), SerializeError>
fn serialize_bytes(&mut self, v: ByteSlice) -> Result<(), SerializeError>
fn begin_seq(&mut self, len: i32) -> Result<ValueSeqSerializer, SerializeError>
fn begin_map(&mut self, len: i32) -> Result<ValueMapSerializer, SerializeError>
fn begin_struct<S: AsStrSlice>(&mut self, name: S, fields: i32) -> Result<ValueStructSerializer, SerializeError>
fn serialize_unit_variant<S: AsStrSlice, S1: AsStrSlice>(&mut self, type_name: S, variant_name: S1, disc: i32) -> Result<(), SerializeError>
fn begin_variant<S: AsStrSlice, S1: AsStrSlice>(&mut self, type_name: S, variant_name: S1, disc: i32) -> Result<ValueVariantSerializer, SerializeError>
pub struct ValueSeqSerializer
Fields are private.
impl SerializeSeq for ValueSeqSerializer
fn element<T: Serialize>(&mut self, value: &T) -> Result<(), SerializeError>
fn end(&mut self) -> Result<(), SerializeError>
pub struct ValueMapSerializer
Fields are private.
impl SerializeMap for ValueMapSerializer
fn key<T: Serialize>(&mut self, key: &T) -> Result<(), SerializeError>
fn value<T: Serialize>(&mut self, value: &T) -> Result<(), SerializeError>
fn end(&mut self) -> Result<(), SerializeError>
pub struct ValueStructSerializer
Fields are private.
impl SerializeStruct for ValueStructSerializer
fn field<T: Serialize, S: AsStrSlice>(&mut self, name: S, value: &T) -> Result<(), SerializeError>
fn end(&mut self) -> Result<(), SerializeError>
pub struct ValueVariantSerializer
Fields are private.
impl SerializeVariant for ValueVariantSerializer
fn payload<T: Serialize>(&mut self, value: &T) -> Result<(), SerializeError>
fn end(&mut self) -> Result<(), SerializeError>
pub struct ValueDeserializer
Reads a typed value out of the Value it points at.
Fields are private.
impl Deserializer for ValueDeserializer
fn deserialize_i32(&mut self) -> Result<i32, DeserializeError>
fn deserialize_i64(&mut self) -> Result<i64, DeserializeError>
fn deserialize_u32(&mut self) -> Result<u32, DeserializeError>
fn deserialize_u64(&mut self) -> Result<u64, DeserializeError>
fn deserialize_i128(&mut self) -> Result<i128, DeserializeError>
fn deserialize_u128(&mut self) -> Result<u128, DeserializeError>
fn deserialize_f32(&mut self) -> Result<f32, DeserializeError>
fn deserialize_f64(&mut self) -> Result<f64, DeserializeError>
fn deserialize_f16(&mut self) -> Result<f16, DeserializeError>
fn deserialize_bf16(&mut self) -> Result<bf16, DeserializeError>
fn deserialize_bool(&mut self) -> Result<bool, DeserializeError>
fn deserialize_char(&mut self) -> Result<char, DeserializeError>
fn deserialize_string(&mut self) -> Result<String, DeserializeError>
fn deserialize_bytes(&mut self) -> Result<ByteList, DeserializeError>
fn is_null(&mut self) -> Result<bool, DeserializeError>
fn begin_seq(&mut self) -> Result<ValueSeqAccess, DeserializeError>
fn begin_map(&mut self) -> Result<ValueObjectAccess, DeserializeError>
fn begin_struct<S: AsStrSlice>(&mut self, name: S, num_fields: i32) -> Result<ValueObjectAccess, DeserializeError>
fn begin_variant<S: AsStrSlice>(&mut self, type_name: S, num_cases: i32) -> Result<ValueVariantAccess, DeserializeError>
fn deserialize_any<V: Visitor>(&mut self, visitor: &mut V) -> Result<V::Value, DeserializeError>
pub struct ValueSeqAccess
Reads the elements of a List value.
Fields are private.
impl DeserializeSeq for ValueSeqAccess
fn next_element<T: Deserialize>(&mut self) -> Result<Option<T>, DeserializeError>
fn end(&mut self) -> Result<(), DeserializeError>
pub struct ValueObjectAccess
Serves both a map and a struct: a Value spells them the same way.
Fields are private.
impl DeserializeMap for ValueObjectAccess
fn next_key<K: Deserialize>(&mut self) -> Result<Option<K>, DeserializeError>
fn next_value<V: Deserialize>(&mut self) -> Result<V, DeserializeError>
fn end(&mut self) -> Result<(), DeserializeError>
impl DeserializeStruct for ValueObjectAccess
fn next_field<S: FieldSchema>(&mut self) -> Result<Option<i32>, DeserializeError>
fn value<T: Deserialize>(&mut self) -> Result<T, DeserializeError>
fn skip(&mut self) -> Result<(), DeserializeError>
fn end(&mut self) -> Result<(), DeserializeError>
pub struct ValueVariantAccess
Reads a variant case: a bare name, or a single-key object holding the payload.
Fields are private.
impl DeserializeVariant for ValueVariantAccess
fn variant_name(&mut self) -> Result<String, DeserializeError>
fn disc(&mut self) -> Result<i32, DeserializeError>
fn payload<T: Deserialize>(&mut self) -> Result<T, DeserializeError>
fn is_unit(&mut self) -> Result<bool, DeserializeError>
fn end(&mut self) -> Result<(), DeserializeError>
Variants
pub variant Value
A dynamically-typed, format-agnostic value.
JSON only ever produces Null / Bool / Float / String / List /
Object (it has no integer/float distinction and no byte strings); the
remaining arms are produced by binary formats such as CBOR.