Enum Value 

pub enum Value {
    Null,
    Number(f64),
    Text(Arc<str>),
    Bytes(Arc<Vec<u8>>),
    List(Arc<Vec<Value>>),
    Opaque(Arc<dyn Any + Send + Sync>),
    Map(Arc<Vec<(String, Value)>>),
}

A datum crossing from one node to the next.

Arc wherever the data is heavy, because a value is cloned on every edge and cloning must not copy.

Variants

Null

Nothing. What a root node receives when you pass it no input.

Number(f64)

A number.

Text(Arc<str>)

UTF-8 text.

Bytes(Arc<Vec<u8>>)

Uninterpreted bytes.

List(Arc<Vec<Value>>)

Several values in order.

Opaque(Arc<dyn Any + Send + Sync>)

Something the core carries without looking at it, as dyn Any so the core need not depend on PyO3.

It only exists in this process and in this run, and everything else follows: no content hash, no serialization, and no comparison but identity.

Map(Arc<Vec<(String, Value)>>)

Several named values: what a node with several incoming edges receives, keyed by the node that produced each one.

Ordered, in the edges’ declaration order: a HashMap iterates differently in each process, so a content hash would be useless.

Implementations

impl Value

pub fn number(x: f64) -> Self

A number.

pub fn text(s: impl AsRef<str>) -> Self

Text.

pub fn list(values: impl Into<Vec<Value>>) -> Self

A list.

pub fn map(pairs: impl Into<Vec<(String, Value)>>) -> Self

A map, in the order you pass the pairs.

pub fn get(&self, key: &str) -> Option<&Value>

The value stored under that key, if this is a map and has it.

pub fn values(&self) -> Option<Vec<&Value>>

A map’s values, in order — flattening a map to a list is this.

pub fn opaque(x: impl Any + Send + Sync) -> Self

Wraps something so it crosses the graph untouched.

pub fn downcast<T: Any + Send + Sync>(&self) -> Option<&T>

What is inside an opaque, if it is of this type.

pub fn travels(&self) -> bool

Whether this value, and everything inside it, can leave this process.

false for an Opaque at any depth: what it carries only exists here. Whoever is about to send it asks first, so the refusal names the reason instead of coming out of a serializer.

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

What to call this variant in an error message.

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<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl From<&str> for Value

fn from(s: &str) -> Self

Converts to this type from the input type.

impl From<f64> for Value

fn from(x: f64) -> Self

Converts to this type from the input type.

impl PartialEq for Value

fn eq(&self, other: &Self) -> bool

Two opaques are equal only if they are the same one: the core cannot compare contents it does not look at.

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: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Errors

If anything inside only exists in this process. Ask travels first and the refusal reads better.