named: replace ad-hoc ConstructNode/CommitNode/WitnessNode with generic ones

Now we have a marker type WithNames which wraps a marker type from
rust-simplicity, erasing its disconnect nodes and replacing its witness
nodes with names. This gets us an analogue of ConstructNode, CommitNode,
WitnessNode, RedeemNode, etc., all at once.

Then replace:

* to_commit_node, whose role was to forget names and finalize types, with
  a general method forget_names, which just forgets the names (then the
  user can call .finalize_types() themselves if they want)
* to_witness_node, whose role was to replace names with actual witnesses,
  with a general method populate_witnesses, which does this

(Actually, `to_witness_node` is not very general at all. It specifically
converts a WtihNames<ConstructNode> to an unnamed ConstructNode. In this
commit, it's possible to implement it in a general way, converting an
arbitrary Node<WithNames<M>> to a Node<M>. But in a couple commits, when
we replace ConstructNode with CommitNode in CompiledProgram, we will be
forced to fix its signature to convert a CommitNode to a RedeemNode. The
diff will be easier to read starting from this non-generic version than
it would be if we started from the generic version.)

Along the way, use core::convert::Infallible for error types so that we
don't need to unwrap errors.

This leaves the precondition on `populate_witnesses` that the user call
`is_consistent` on witness nodes before converting from SimplicityHL to
Simplicity. I believe I can remove this precondition and return an error
if the witness values don't match the Simplicity node, but I need to
update the library to get the IncompleteType type first, so that I can
return a useful error. So I will defer this improvement.

Author: apoelstra

src/lib.rs

@@ -1,6 +1,6 @@
 //! Library for parsing and compiling SimplicityHL
 
-pub type ProgNode = Arc<named::ConstructNode>;
+pub type ProgNode = Arc<named::ConstructNode<Elements>>;
 
 pub mod array;
 pub mod ast;
@@ -123,7 +123,8 @@ impl CompiledProgram {
 
     /// Access the Simplicity target code, without witness data.
     pub fn commit(&self) -> Arc<CommitNode<Elements>> {
-        named::to_commit_node(&self.simplicity)
+        named::forget_names(&self.simplicity)
+            .finalize_types()
             .expect("Compiled SimplicityHL program has type 1 -> 1")
     }
 
@@ -152,7 +153,7 @@ impl CompiledProgram {
         witness_values
             .is_consistent(&self.witness_types)
             .map_err(|e| e.to_string())?;
-        let simplicity_witness = named::to_witness_node(&self.simplicity, witness_values);
+        let simplicity_witness = named::populate_witnesses(&self.simplicity, witness_values);
         let simplicity_redeem = match env {
             Some(env) => simplicity_witness.finalize_pruned(env),
             None => simplicity_witness.finalize_unpruned(),

src/named.rs

@@ -1,96 +1,126 @@
 use std::sync::Arc;
 
 use simplicity::dag::{InternalSharing, PostOrderIterItem};
-use simplicity::jet::{Elements, Jet};
+use simplicity::jet::Jet;
 use simplicity::node::{
-    self, CommitData, ConstructData as WitnessData, Constructible, Converter, CoreConstructible,
-    Inner, JetConstructible, NoDisconnect, NoWitness, Node, WitnessConstructible,
+    self, Converter, CoreConstructible, Inner, NoDisconnect, NoWitness, Node, WitnessConstructible,
 };
-use simplicity::types::arrow::Arrow;
-use simplicity::{types, CommitNode, FailEntropy};
-use simplicity::{Cmr, ConstructNode as WitnessNode};
+use simplicity::Cmr;
+use simplicity::{types, FailEntropy};
 
 use crate::str::WitnessName;
 use crate::value::StructuralValue;
 use crate::witness::WitnessValues;
 
-/// Marker for [`ConstructNode`].
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
-pub struct Construct<N> {
-    /// Makes the type non-constructible.
-    never: std::convert::Infallible,
-    /// Required by Rust.
-    phantom: std::marker::PhantomData<N>,
-}
-
-/// Sharing ID of [`ConstructNode`].
-/// Cannot be constructed because there is no sharing.
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
-pub enum ConstructId {}
+pub struct WithNames<T>(T);
 
-impl<J: Jet> node::Marker for Construct<J> {
-    type CachedData = ConstructData<J>;
+impl<M: node::Marker> node::Marker for WithNames<M> {
+    type CachedData = M::CachedData;
     type Witness = WitnessName;
+    // It's quite difficult to wrap M::Disconnect because of Rust's lack of HKTs, and
+    // we don't use disconnect in this library right now, so punt on it for now.
     type Disconnect = NoDisconnect;
-    type SharingId = ConstructId;
-    type Jet = J;
+    type SharingId = M::SharingId;
+    type Jet = M::Jet;
+
+    fn compute_sharing_id(cmr: Cmr, cached_data: &Self::CachedData) -> Option<Self::SharingId> {
+        M::compute_sharing_id(cmr, cached_data)
+    }
+}
+
+/// Helper trait so we can abstract over witness and disconnects of any type,
+/// as long as we can produce them from a no-witness no-disconnect object.
+pub trait Nullable {
+    fn none() -> Self;
+}
 
-    fn compute_sharing_id(_: Cmr, _cached_data: &Self::CachedData) -> Option<Self::SharingId> {
+impl<T> Nullable for Option<T> {
+    fn none() -> Self {
         None
     }
 }
 
+impl Nullable for NoWitness {
+    fn none() -> Self {
+        NoWitness
+    }
+}
+
+impl Nullable for NoDisconnect {
+    fn none() -> Self {
+        NoDisconnect
+    }
+}
+
 /// [`simplicity::ConstructNode`] with named witness nodes.
 ///
 /// Nodes other than witness don't have names.
-pub type ConstructNode = Node<Construct<Elements>>;
+pub type ConstructNode<J> = Node<WithNames<node::Construct<J>>>;
+
+/// [`simplicity::CommitNode`] with named witness nodes.
+///
+/// Nodes other than witness don't have names.
+pub type CommitNode<J> = Node<WithNames<node::Commit<J>>>;
 
 // FIXME: The following methods cannot be implemented for simplicity::node::Node because that is a foreign type
 
 /// Convert [`ConstructNode`] into [`CommitNode`] by dropping the name of witness nodes.
-pub fn to_commit_node(node: &ConstructNode) -> Result<Arc<CommitNode<Elements>>, types::Error> {
+pub fn forget_names<M>(node: &Node<WithNames<M>>) -> Arc<Node<M>>
+where
+    M: node::Marker,
+    M::Disconnect: Nullable,
+    M::Witness: Nullable,
+{
     struct Forgetter;
 
-    impl<J: Jet> Converter<Construct<J>, node::Commit<J>> for Forgetter {
-        type Error = types::Error;
+    impl<M> Converter<WithNames<M>, M> for Forgetter
+    where
+        M: node::Marker,
+        M::Disconnect: Nullable,
+        M::Witness: Nullable,
+    {
+        type Error = core::convert::Infallible;
 
         fn convert_witness(
             &mut self,
-            _: &PostOrderIterItem<&Node<Construct<J>>>,
+            _: &PostOrderIterItem<&Node<WithNames<M>>>,
             _: &WitnessName,
-        ) -> Result<NoWitness, Self::Error> {
-            Ok(NoWitness)
+        ) -> Result<M::Witness, Self::Error> {
+            Ok(M::Witness::none())
         }
 
         fn convert_disconnect(
             &mut self,
-            _: &PostOrderIterItem<&Node<Construct<J>>>,
-            _: Option<&Arc<CommitNode<J>>>,
+            _: &PostOrderIterItem<&Node<WithNames<M>>>,
+            _: Option<&Arc<Node<M>>>,
             _: &NoDisconnect,
-        ) -> Result<NoDisconnect, Self::Error> {
-            Ok(NoDisconnect)
+        ) -> Result<M::Disconnect, Self::Error> {
+            Ok(M::Disconnect::none())
         }
 
         fn convert_data(
             &mut self,
-            data: &PostOrderIterItem<&Node<Construct<J>>>,
-            inner: Inner<&Arc<CommitNode<J>>, J, &NoDisconnect, &NoWitness>,
-        ) -> Result<Arc<CommitData<J>>, Self::Error> {
-            let arrow = data.node.cached_data().arrow();
-            let inner = inner.map(Arc::as_ref).map(CommitNode::<J>::cached_data);
-            CommitData::new(arrow, inner).map(Arc::new)
+            data: &PostOrderIterItem<&Node<WithNames<M>>>,
+            _: Inner<&Arc<Node<M>>, M::Jet, &M::Disconnect, &M::Witness>,
+        ) -> Result<M::CachedData, Self::Error> {
+            Ok(data.node.cached_data().clone())
         }
     }
 
-    node.convert::<InternalSharing, _, _>(&mut Forgetter)
+    match node.convert::<InternalSharing, _, _>(&mut Forgetter) {
+        Ok(ret) => ret,
+        Err(inf) => match inf {},
+    }
 }
 
-/// Convert [`ConstructNode`] into [`WitnessNode`] by populating witness nodes with their assigned values.
+/// Converts a named [`ConstructNode`] into a standard [`node::ConstructNode`], by populating
+/// witness nodes with their assigned values.
 ///
 /// Each witness node has a name. If there is no value assigned to this name,
 /// then the node is left empty.
 ///
-/// When [`WitnessNode`] is finalized to [`node::RedeemNode`], there will be an error if any witness
+/// When [`node::ConstructNode`] is finalized to [`node::RedeemNode`], there will be an error if any witness
 /// node on a used (unpruned) branch is empty. It is the responsibility of the caller to ensure that
 /// all used witness nodes have an assigned value.
 ///
@@ -99,18 +129,20 @@ pub fn to_commit_node(node: &ConstructNode) -> Result<Arc<CommitNode<Elements>>,
 /// It is the responsibility of the caller to ensure that the given witness `values` match the
 /// types in the construct `node`. This can be done by calling [`WitnessValues::is_consistent`]
 /// on the original SimplicityHL program before it is compiled to Simplicity.
-pub fn to_witness_node(node: &ConstructNode, values: WitnessValues) -> Arc<WitnessNode<Elements>> {
+pub fn populate_witnesses<J: Jet>(
+    node: &ConstructNode<J>,
+    values: WitnessValues,
+) -> Arc<node::ConstructNode<J>> {
     struct Populator {
         values: WitnessValues,
-        inference_context: types::Context,
     }
 
-    impl<J: Jet> Converter<Construct<J>, node::Construct<J>> for Populator {
-        type Error = ();
+    impl<J: Jet> Converter<WithNames<node::Construct<J>>, node::Construct<J>> for Populator {
+        type Error = core::convert::Infallible;
 
         fn convert_witness(
             &mut self,
-            _: &PostOrderIterItem<&Node<Construct<J>>>,
+            _: &PostOrderIterItem<&ConstructNode<J>>,
             witness: &WitnessName,
         ) -> Result<Option<simplicity::Value>, Self::Error> {
             let maybe_value = self
@@ -123,129 +155,40 @@ pub fn to_witness_node(node: &ConstructNode, values: WitnessValues) -> Arc<Witne
 
         fn convert_disconnect(
             &mut self,
-            _: &PostOrderIterItem<&Node<Construct<J>>>,
-            _: Option<&Arc<WitnessNode<J>>>,
+            _: &PostOrderIterItem<&ConstructNode<J>>,
+            _: Option<&Arc<node::ConstructNode<J>>>,
             _: &NoDisconnect,
-        ) -> Result<Option<Arc<WitnessNode<J>>>, Self::Error> {
+        ) -> Result<Option<Arc<node::ConstructNode<J>>>, Self::Error> {
             Ok(None)
         }
 
         fn convert_data(
             &mut self,
-            _: &PostOrderIterItem<&Node<Construct<J>>>,
-            inner: Inner<
-                &Arc<WitnessNode<J>>,
+            data: &PostOrderIterItem<&ConstructNode<J>>,
+            _: Inner<
+                &Arc<node::ConstructNode<J>>,
                 J,
-                &Option<Arc<WitnessNode<J>>>,
+                &Option<Arc<node::ConstructNode<J>>>,
                 &Option<simplicity::Value>,
             >,
-        ) -> Result<WitnessData<J>, Self::Error> {
-            let inner = inner
-                .map(Arc::as_ref)
-                .map(WitnessNode::<J>::cached_data)
-                .map_witness(Option::<simplicity::Value>::clone);
-            Ok(WitnessData::from_inner(&self.inference_context, inner).unwrap())
-        }
-    }
-
-    let mut populator = Populator {
-        inference_context: types::Context::new(),
-        values,
-    };
-    node.convert::<InternalSharing, _, _>(&mut populator)
-        .unwrap()
-}
-
-/// Copy of [`node::ConstructData`] with an implementation of [`WitnessConstructible<WitnessName>`].
-#[derive(Clone, Debug)]
-pub struct ConstructData<J> {
-    arrow: Arrow,
-    phantom: std::marker::PhantomData<J>,
-}
-
-impl<J> ConstructData<J> {
-    /// Access the arrow of the node.
-    pub fn arrow(&self) -> &Arrow {
-        &self.arrow
-    }
-}
-
-impl<J> From<Arrow> for ConstructData<J> {
-    fn from(arrow: Arrow) -> Self {
-        Self {
-            arrow,
-            phantom: std::marker::PhantomData,
+        ) -> Result<node::ConstructData<J>, Self::Error> {
+            Ok(data.node.cached_data().clone())
         }
     }
-}
-
-impl<J> CoreConstructible for ConstructData<J> {
-    fn iden(inference_context: &types::Context) -> Self {
-        Arrow::iden(inference_context).into()
-    }
-
-    fn unit(inference_context: &types::Context) -> Self {
-        Arrow::unit(inference_context).into()
-    }
-
-    fn injl(child: &Self) -> Self {
-        Arrow::injl(&child.arrow).into()
-    }
-
-    fn injr(child: &Self) -> Self {
-        Arrow::injr(&child.arrow).into()
-    }
-
-    fn take(child: &Self) -> Self {
-        Arrow::take(&child.arrow).into()
-    }
-
-    fn drop_(child: &Self) -> Self {
-        Arrow::drop_(&child.arrow).into()
-    }
-
-    fn comp(left: &Self, right: &Self) -> Result<Self, types::Error> {
-        Arrow::comp(&left.arrow, &right.arrow).map(Self::from)
-    }
-
-    fn case(left: &Self, right: &Self) -> Result<Self, types::Error> {
-        Arrow::case(&left.arrow, &right.arrow).map(Self::from)
-    }
-
-    fn assertl(left: &Self, right: Cmr) -> Result<Self, types::Error> {
-        Arrow::assertl(&left.arrow, right).map(Self::from)
-    }
-
-    fn assertr(left: Cmr, right: &Self) -> Result<Self, types::Error> {
-        Arrow::assertr(left, &right.arrow).map(Self::from)
-    }
-
-    fn pair(left: &Self, right: &Self) -> Result<Self, types::Error> {
-        Arrow::pair(&left.arrow, &right.arrow).map(Self::from)
-    }
-
-    fn fail(inference_context: &types::Context, entropy: FailEntropy) -> Self {
-        Arrow::fail(inference_context, entropy).into()
-    }
-
-    fn const_word(inference_context: &types::Context, word: simplicity::Word) -> Self {
-        Arrow::const_word(inference_context, word).into()
-    }
-
-    fn inference_context(&self) -> &types::Context {
-        self.arrow.inference_context()
-    }
-}
 
-impl<J: Jet> JetConstructible<J> for ConstructData<J> {
-    fn jet(inference_context: &types::Context, jet: J) -> Self {
-        Arrow::jet(inference_context, jet).into()
+    let mut populator = Populator { values };
+    match node.convert::<InternalSharing, _, _>(&mut populator) {
+        Ok(ret) => ret,
+        Err(inf) => match inf {},
     }
 }
 
-impl<J> WitnessConstructible<WitnessName> for ConstructData<J> {
+// This awkward construction is required by rust-simplicity to implement WitnessConstructible
+// for Node<WithNames<Construct>>. See
+//     https://docs.rs/simplicity-lang/latest/simplicity/node/trait.WitnessConstructible.html#foreign-impls
+impl<J: Jet> WitnessConstructible<WitnessName> for node::ConstructData<J> {
     fn witness(inference_context: &types::Context, _: WitnessName) -> Self {
-        Arrow::witness(inference_context, ()).into()
+        WitnessConstructible::<Option<_>>::witness(inference_context, None)
     }
 }