Struct simplicity::types::Type

pub struct Type { /* private fields */ }

Source or target type of a Simplicity expression.

Internally this type is essentially just a refcounted pointer; it is therefore quite cheap to clone, but be aware that cloning will not actually create a new independent type, just a second pointer to the first one.

Implementations

impl Type

pub fn free(name: String) -> Self

Return an unbound type with the given name

pub fn unit() -> Self

Return a unit type.

pub fn two_two_n(n: usize) -> Self

Return a precomputed copy of 2^(2^n), for given n.

pub fn sum(a: Self, b: Self) -> Self

Return the sum of the given two types.

pub fn product(a: Self, b: Self) -> Self

Return the product of the given two types.

pub fn shallow_clone(&self) -> Type

Clones the Type.

This is the same as just calling .clone() but has a different name to emphasize that what’s being cloned is merely a ref-counted pointer.

pub fn bind(&self, bound: Arc<Bound>, hint: &'static str) -> Result<(), Error>

Binds the type to a given bound. If this fails, attach the provided hint to the error.

Fails if the type has an existing incompatible bound.

pub fn unify(&self, other: &Self, hint: &'static str) -> Result<(), Error>

Unify the type with another one.

Fails if the bounds on the two types are incompatible

pub fn bound(&self) -> Arc<Bound>

Accessor for this type’s bound

pub fn tmr(&self) -> Option<Tmr>

Accessor for the TMR of this type, if it is final

pub fn final_data(&self) -> Option<Arc<Final>>

Accessor for the data of this type, if it is complete

pub fn is_final(&self) -> bool

Whether this type is known to be final

During type inference this may be false even though the type is, in fact, complete, since its children may have been unified to a complete type. To ensure a type is complete, call Type::finalize.

pub fn finalize(&self) -> Result<Arc<Final>, Error>

Attempts to finalize the type. Returns its TMR on success.

pub fn powers_of_two(n: usize) -> Vec<Self>

Return a vector containing the types 2^(2^i) for i from 0 to n-1.

Trait Implementations

impl Clone for Type

fn clone(&self) -> Type

Returns a copy of the value.

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

Performs copy-assignment from source.

impl DagLike for Type

type Node = Type

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

fn data(&self) -> &Type

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 Type

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

Formats the value using the given formatter.

impl Display for Type

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

Formats the value using the given formatter.

impl From<Bound> for Type

fn from(bound: Bound) -> Type

Promotes a Bound to a type defined by that constraint