Struct Hiding 

pub struct Hiding<'brand, N> { /* private fields */ }

Wrapper that allows a node to be “hidden” during program construction.

Program construction

When a program is constructed in post-order, the parent node is created based on its children. We use this fact to introduce special branching logic:

1. A case node with a left “hidden” child and a right non-hidden child becomes assertr.
2. A case node with a left non-hidden child and a right “hidden” child becomes assertl.
3. Otherwise, any node with “hidden” children becomes itself “hidden” with an updated CMR.
4. Any node with non-hidden children remains unchanged.

The program can be extracted from the wrapper when construction is finished. The program is invalid if the root node is “hidden”.

Wrapping

A node can be wrapped via Hiding::from to add hiding support. A wrapped node can be converted into a “hidden” node via Hiding::hide. Finally, a “hidden” node can be manually created via Hiding::hidden.

Virtual hidden nodes

The wrapper merely simulates hidden nodes. At no point are actual hidden nodes created. To stress this fact, I write “hidden” in quotation marks.

Implementations

impl<'brand, N> Hiding<'brand, N>

pub fn hidden(cmr: Cmr, ctx: &Context<'brand>) -> Self

Create a “hidden” node with the given CMR.

To enable the construction of possible parent nodes, the inference context of the current program must be passed.

pub fn map_ref<M>( &self, mapfn: impl FnOnce(&N) -> M, cmrfn: impl FnOnce(Cmr) -> Cmr, ) -> Hiding<'brand, M>

If the node is not hidden, apply a function to the underlying node. If it is hidden, apply a function to its CMR.

pub fn map_ref_result<M, Err>( &self, mapfn: impl FnOnce(&N) -> Result<M, Err>, cmrfn: impl FnOnce(Cmr) -> Cmr, ) -> Result<Hiding<'brand, M>, Err>

If the node is not hidden, apply a function to the underlying node. If it is hidden, do nothing.

pub fn as_node(&self) -> Option<&N>

Access the non-hidden node inside in the wrapper.

Return None if the wrapped node is “hidden”.

pub fn into_node(self) -> Option<N>

Consume the wrapper and return the non-hidden node that was inside.

Return None if the wrapped node is “hidden”.

impl<'brand, N: HasCmr + CoreConstructible<'brand>> Hiding<'brand, N>

pub fn hide(self) -> Self

Replace the node, if any, with its CMR; replace its type arrow with a new free arrow.

Once hidden, a node’s original type arrow loses its original bounds. In effect, a hidden node is a completely separate node from its “original” node and is typechecked and shared independently.

Trait Implementations

impl<'brand, N: Clone> Clone for Hiding<'brand, N>

fn clone(&self) -> Hiding<'brand, N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'brand, N: HasCmr + CoreConstructible<'brand>> CoreConstructible<'brand> for Hiding<'brand, N>

fn iden(inference_context: &Context<'brand>) -> Self

fn unit(inference_context: &Context<'brand>) -> Self

fn injl(child: &Self) -> Self

fn injr(child: &Self) -> Self

fn take(child: &Self) -> Self

fn drop_(child: &Self) -> Self

fn comp(left: &Self, right: &Self) -> Result<Self, Error>

fn case(left: &Self, right: &Self) -> Result<Self, Error>

fn assertl(left: &Self, right: Cmr) -> Result<Self, Error>

fn assertr(left: Cmr, right: &Self) -> Result<Self, Error>

fn pair(left: &Self, right: &Self) -> Result<Self, Error>

fn fail(inference_context: &Context<'brand>, entropy: FailEntropy) -> Self

fn const_word(inference_context: &Context<'brand>, word: Word) -> Self

fn jet(inference_context: &Context<'brand>, jet: &dyn Jet) -> Self

fn arrow(&self) -> &Arrow<'brand>

fn inference_context(&self) -> &Context<'brand>

Accessor for the type inference context used to create the object.

fn scribe(ctx: &Context<'brand>, value: &Value) -> Self

Create an expression that produces the given value.

fn bit_false(inference_context: &Context<'brand>) -> Self

Create a DAG that takes any input and returns bit 0 as constant output.

fn bit_true(inference_context: &Context<'brand>) -> Self

Create a DAG that takes any input and returns bit 1 as constant output.

fn cond(left: &Self, right: &Self) -> Result<Self, Error>

Create a DAG that takes a bit and an input, such that the left child is evaluated on the input if the bit is 1 (if branch) and the right child is evaluated on the input otherwise (else branch).

fn assert(child: &Self, hash: Cmr) -> Result<Self, Error>

Create a DAG that asserts that its child returns true, and fails otherwise. The hash identifies the assertion and is returned upon failure.

fn not(child: &Self) -> Result<Self, Error>

Create a DAG that computes Boolean NOT of the child.

fn and(left: &Self, right: &Self) -> Result<Self, Error>

Create a DAG that computes Boolean AND of the left and right child.

fn or(left: &Self, right: &Self) -> Result<Self, Error>

Create a DAG that computes Boolean OR of the left and right.

impl<'brand, N: Debug> Debug for Hiding<'brand, N>

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

Formats the value using the given formatter.

impl<'brand, X, N> DisconnectConstructible<'brand, Option<X>> for Hiding<'brand, N>

where N: DisconnectConstructible<'brand, Option<X>> + CoreConstructible<'brand> + HasCmr,

fn disconnect(left: &Self, right: &Option<X>) -> Result<Self, Error>

impl<'brand, N> From<N> for Hiding<'brand, N>

fn from(node: N) -> Self

Converts to this type from the input type.

impl<N: HasCmr> HasCmr for Hiding<'_, N>

fn cmr(&self) -> Cmr

Access the Commitment Merkle Root.

impl<'brand, W, N> WitnessConstructible<'brand, W> for Hiding<'brand, N>

where N: WitnessConstructible<'brand, W> + CoreConstructible<'brand>,

fn witness(inference_context: &Context<'brand>, witness: W) -> Self