Enum Datum 

pub enum Datum {
    Nil,
    Bool(bool),
    Number(NumberLiteral),
    Symbol(Symbol),
    String(String),
    Bytes(Vec<u8>),
    List(Vec<Datum>),
    Vector(Vec<Datum>),
    Map(Vec<(Datum, Datum)>),
    Set(Vec<Datum>),
    Node {
        tag: Symbol,
        fields: Vec<(Symbol, Datum)>,
    },
}

Content-addressable data form of the substrate.

A Datum is the canonical, hashable projection of an Expr: the same value always hashes to the same ContentId, independent of how it was written. The kernel fixes the datum shape and its content-hash algorithm; libraries supply the DatumStores that intern and resolve data.

Examples

let datum = Datum::String("hello".to_owned());
let id = datum.content_id().unwrap();
// The same datum always hashes to the same content id.
assert_eq!(id, Datum::String("hello".to_owned()).content_id().unwrap());

Variants

Nil

The nil datum.

Bool(bool)

A boolean datum.

Number(NumberLiteral)

A number literal in some domain.

Symbol(Symbol)

A symbol datum.

String(String)

A UTF-8 string datum.

Bytes(Vec<u8>)

A byte-string datum.

List(Vec<Datum>)

An ordered list datum.

Vector(Vec<Datum>)

An ordered vector datum.

Map(Vec<(Datum, Datum)>)

A map datum as ordered key/value pairs; duplicate keys are rejected when hashing.

Set(Vec<Datum>)

A set datum; duplicate entries are rejected when hashing.

Node

A tagged node datum with named fields, the datum form of an Expr::Extension.

Fields

tag: Symbol

Node tag symbol.

fields: Vec<(Symbol, Datum)>

Named field bindings in declaration order.

Implementations

impl Datum

pub fn canonical_bytes(&self) -> Result<Vec<u8>>

Returns the canonical byte encoding used to compute the content id.

The encoding is deterministic: equal data produces equal bytes, with map and set entries ordered by their hashes so member order does not affect the result. Returns an error when the datum cannot be canonicalized (for example, a map with duplicate keys).

pub fn content_id(&self) -> Result<ContentId>

Returns the content id of this datum under the kernel datum algorithm.

Trait Implementations

impl Clone for Datum

fn clone(&self) -> Datum

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Datum

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

Formats the value using the given formatter.

impl Eq for Datum

impl From<Datum> for Expr

fn from(datum: Datum) -> Self

Converts to this type from the input type.

impl Hash for Datum

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 Datum

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

impl TryFrom<Expr> for Datum

type Error = Error

The type returned in the event of a conversion error.

fn try_from(expr: Expr) -> Result<Self>

Performs the conversion.