Adapt DagIterable

Author: uncomputable

src/core/commit.rs

@@ -14,6 +14,7 @@
 //
 
 use crate::core::Value;
+use crate::impl_ref_wrapper;
 use crate::jet::{Application, JetNode};
 use crate::merkle::cmr;
 use crate::merkle::cmr::Cmr;
@@ -358,3 +359,9 @@ impl<Witness, App: Application> CommitNode<Witness, App> {
         }
     }
 }
+
+/// Wrapper of references to [`CommitNode`].
+#[derive(Debug)]
+pub struct RefWrapper<'a, Witness, App: Application>(pub &'a CommitNode<Witness, App>);
+
+impl_ref_wrapper!(RefWrapper);

src/core/iter.rs

@@ -14,24 +14,19 @@
 
 //! Iterators over DAGs
 
-use crate::core::Term;
-use crate::jet::Application;
 use std::collections::HashSet;
 use std::hash::Hash;
 
 /// Structure that can be iterated like a DAG _(directed acyclic graph)_.
-pub trait DagIterable: Sized {
-    /// Node in the DAG
-    type Node: Copy + Eq + Hash;
-
+pub trait DagIterable: Copy + Eq + Hash {
     /// Return the DAG root, if the DAG is nonempty.
-    fn root(&self) -> Option<Self::Node>;
+    fn root(self) -> Option<Self>;
 
     /// Return the left child of the given `node`.
-    fn left_of(&self, node: Self::Node) -> Option<Self::Node>;
+    fn get_left(self) -> Option<Self>;
 
     /// Return the right child of the given `node`.
-    fn right_of(&self, node: Self::Node) -> Option<Self::Node>;
+    fn get_right(self) -> Option<Self>;
 
     /// Return a post-order iterator over the DAG.
     fn iter_post_order(&self) -> PostOrderIter<Self> {
@@ -43,34 +38,32 @@ pub trait DagIterable: Sized {
 /// That means, left children appear before right ones, and children appear before their parent.
 /// Shared nodes appear only once at their leftmost position.
 #[derive(Clone, Debug)]
-pub struct PostOrderIter<'a, D: DagIterable> {
-    dag: &'a D,
-    stack: Vec<D::Node>,
-    maybe_current: Option<D::Node>,
-    visited: HashSet<D::Node>,
+pub struct PostOrderIter<D: DagIterable> {
+    stack: Vec<D>,
+    maybe_current: Option<D>,
+    visited: HashSet<D>,
 }
 
-impl<'a, D: DagIterable> PostOrderIter<'a, D> {
+impl<D: DagIterable> PostOrderIter<D> {
     /// Create a new iterator from the given `dag`.
-    pub fn new(dag: &'a D) -> Self {
+    pub fn new(dag: &D) -> Self {
         PostOrderIter {
-            dag,
             stack: Vec::new(),
             maybe_current: dag.root(),
             visited: HashSet::new(),
         }
     }
 }
 
-impl<'a, D: DagIterable> Iterator for PostOrderIter<'a, D> {
-    type Item = D::Node;
+impl<D: DagIterable> Iterator for PostOrderIter<D> {
+    type Item = D;
 
     fn next(&mut self) -> Option<Self::Item> {
         loop {
             if let Some(current) = self.maybe_current {
                 self.stack.push(current);
 
-                if let Some(left) = self.dag.left_of(current) {
+                if let Some(left) = current.get_left() {
                     if !self.visited.contains(&left) {
                         self.maybe_current = Some(left);
                         continue;
@@ -79,7 +72,7 @@ impl<'a, D: DagIterable> Iterator for PostOrderIter<'a, D> {
                 // else
                 self.maybe_current = None;
             } else if let Some(top) = self.stack.last() {
-                if let Some(right) = self.dag.right_of(*top) {
+                if let Some(right) = top.get_right() {
                     if !self.visited.contains(&right) {
                         self.maybe_current = Some(right);
                         continue;
@@ -97,6 +90,55 @@ impl<'a, D: DagIterable> Iterator for PostOrderIter<'a, D> {
     }
 }
 
+/// Convenience macro for wrappers of references to structures over
+/// `<Witness, App: Application>`.
+///
+/// Implements `Clone`, `Copy`, `Eq` and `Hash` using pointers.
+/// Implements [`DagIterable`] using `self.0.get_left()` and `self.0.get_right()`.
+#[macro_export]
+macro_rules! impl_ref_wrapper {
+    ($wrapper:ident) => {
+        impl<'a, Witness, App: Application> Clone for $wrapper<'a, Witness, App> {
+            fn clone(&self) -> Self {
+                $wrapper(&(self.0).clone())
+            }
+        }
+
+        impl<'a, Witness, App: Application> Copy for $wrapper<'a, Witness, App> {}
+
+        impl<'a, Witness, App: Application> PartialEq for $wrapper<'a, Witness, App> {
+            fn eq(&self, other: &Self) -> bool {
+                std::ptr::eq(self.0, other.0)
+            }
+        }
+
+        impl<'a, Witness, App: Application> Eq for $wrapper<'a, Witness, App> {}
+
+        impl<'a, Witness, App: Application> std::hash::Hash for $wrapper<'a, Witness, App> {
+            fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+                std::ptr::hash(self.0, state)
+            }
+        }
+
+        impl<'a, Witness, App: Application> $crate::core::iter::DagIterable
+            for $wrapper<'a, Witness, App>
+        {
+            fn root(self) -> Option<Self> {
+                Some(self)
+            }
+
+            fn get_left(self) -> Option<Self> {
+                self.0.get_left().map(|x| RefWrapper(x))
+            }
+
+            fn get_right(self) -> Option<Self> {
+                self.0.get_right().map(|x| RefWrapper(x))
+            }
+        }
+    };
+}
+
+/*
 /// Convert the given iterator over [`Term`]s into an iterator over the contained `Witness` values.
 pub fn into_witness<'a, Witness, App: Application, I>(
     iter: I,
@@ -113,3 +155,4 @@ where
         }
     })
 }
+*/

src/core/mod.rs

@@ -17,8 +17,8 @@
 //!
 //! Defines Simplicity terms, values, types, DAGs and programs.
 
-// pub mod iter;
 pub mod commit;
+pub mod iter;
 pub mod node;
 #[allow(dead_code)]
 pub mod types;

src/core/node.rs

@@ -13,6 +13,7 @@
 //
 
 use crate::core::types::Type;
+use crate::impl_ref_wrapper;
 use crate::jet::{Application, JetNode};
 use crate::merkle::cmr::Cmr;
 use crate::merkle::imr::Imr;
@@ -142,3 +143,9 @@ impl<Witness, App: Application> Node<Witness, App> {
         }
     }
 }
+
+/// Wrapper of references to [`Node`].
+#[derive(Debug)]
+pub struct RefWrapper<'a, Witness, App: Application>(pub &'a Node<Witness, App>);
+
+impl_ref_wrapper!(RefWrapper);