Enum simplicity::Value

pub enum Value {
    Unit,
    SumL(Arc<Value>),
    SumR(Arc<Value>),
    Prod(Arc<Value>, Arc<Value>),
}

Value of some type.

The unit value is the only value of the unit type. This is the basis for everything we are doing. Because there is only a single unit value, there is no information contained in it. Instead, we wrap unit values in sum and product values to encode information.

A sum value wraps another value. The left sum value L(a) wraps a value a from the left type A. The right sum value R(b) wraps a value b from the right type B. The type of the sum value is the sum type A + B of the left type and the right type.

We represent the false bit as a left value that wraps a unit value. The true bit is represented as a right value that wraps a unit value.

A product value (a, b) wraps two values: a value a from the left type A and a value b from the right type B. The type of the product value is the product type A × B of the left type and the right type.

We represent bit strings (tuples of bits) as trees of nested product values that have bit values (sum values wrapping the unit value) at their leaves.

Variants

Unit

Unit value

SumL(Arc<Value>)

Sum value that wraps a left value

SumR(Arc<Value>)

Sum value that wraps a right value

Prod(Arc<Value>, Arc<Value>)

Product value that wraps a left and a right value

Implementations

impl Value

pub fn unit() -> Arc<Self>

Create the unit value.

pub fn sum_l(left: Arc<Self>) -> Arc<Self>

Create a sum value that wraps a left value.

pub fn sum_r(right: Arc<Self>) -> Arc<Self>

Create a sum value that wraps a right value.

pub fn prod(left: Arc<Self>, right: Arc<Self>) -> Arc<Self>

Create a product value that wraps a left and a right value.

pub fn len(&self) -> usize

The length, in bits, of the value when encoded in the Bit Machine

pub fn u1(n: u8) -> Arc<Self>

Encode a single bit as a value. Will panic if the input is out of range

pub fn u2(n: u8) -> Arc<Self>

Encode a two-bit number as a value. Will panic if the input is out of range

pub fn u4(n: u8) -> Arc<Self>

Encode a four-bit number as a value. Will panic if the input is out of range

pub fn u8(n: u8) -> Arc<Self>

Encode an eight-bit number as a value

pub fn u16(n: u16) -> Arc<Self>

Encode a 16-bit number as a value

pub fn u32(n: u32) -> Arc<Self>

Encode a 32-bit number as a value

pub fn u64(n: u64) -> Arc<Self>

Encode a 64-bit number as a value

pub fn u128(n: u128) -> Arc<Self>

Encode a 128-bit number as a value

pub fn u256_from_slice(v: &[u8]) -> Arc<Self>

Encode a 32-byte number as a value

Useful for encoding public keys and hashes

pub fn u512_from_slice(v: &[u8]) -> Arc<Self>

Encode a 64-byte number as a value

Useful for encoding signatures

pub fn power_of_two(v: &[u8]) -> Arc<Self>

Encode a byte slice as a value.

The length of the slice must be a power of two.

pub fn do_each_bit<F>(&self, f: F)

where F: FnMut(bool),

Execute function f on each bit of the encoding of the value.

pub fn try_to_bytes(&self) -> Result<Vec<u8>, &str>

Encode value as big-endian byte string. Fails if underlying bit string has length not divisible by 8

pub fn to_bytes_len(&self) -> (Vec<u8>, usize)

Encode value as big-endian byte string. Trailing zeroes are added as padding if underlying bit string has length not divisible by 8. The length of said bit string is returned as second argument

Trait Implementations

impl Clone for Value

fn clone(&self) -> Value

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> DagLike for &'a Value

type Node = Value

The type of the DAG node, with no references or wrappers

fn data(&self) -> &Value

A pointer to the underlying data

fn as_dag_node(&self) -> Dag<Self>

Interpret the node as a DAG node

fn left_child(&self) -> Option<Self>

Accessor for the left child of the node, if one exists

fn right_child(&self) -> Option<Self>

Accessor for the right child of the node, if one exists

fn n_children(&self) -> usize

Number of children that the node has.

fn rtl_post_order_iter<S: SharingTracker<SwapChildren<Self>> + Default>( self ) -> RtlPostOrderIter<Self, S>

Obtains an iterator of all the nodes rooted at the DAG, in right-to-left post order.

fn pre_order_iter<S: SharingTracker<Self> + Default>( self ) -> PreOrderIter<Self, S>

Obtains an iterator of all the nodes rooted at the DAG, in pre-order.

fn verbose_pre_order_iter<S: SharingTracker<Self> + Default>( self ) -> VerbosePreOrderIter<Self, S>

where Self: Clone,

Obtains a verbose iterator of all the nodes rooted at the DAG, in pre-order.

fn post_order_iter<S: SharingTracker<Self> + Default>( self ) -> PostOrderIter<Self, S>

Obtains an iterator of all the nodes rooted at the DAG, in post order.

fn is_shared_as<S: SharingTracker<Self> + Default>(self) -> bool

where Self: Clone,

Checks whether a DAG’s internal sharing (as expressed by shared pointers) matches the given target sharing.

fn post_order_iter_with_tracker<S: SharingTracker<Self>>( self, tracker: S ) -> PostOrderIter<Self, S>

Obtains an post-order iterator of all the nodes rooted at DAG, using the given tracker.

impl Debug for Value

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

Formats the value using the given formatter.

impl Display for Value

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

Formats the value using the given formatter.

impl Hash for Value

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 Ord for Value

fn cmp(&self, other: &Value) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Value

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

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Value

fn partial_cmp(&self, other: &Value) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for Value

impl StructuralPartialEq for Value