Implement DoubleEndedIterator for fn children

Author: lmondada

hugr-persistent/Cargo.toml

@@ -18,7 +18,12 @@ name = "persistent_walker_example"
 [dependencies]
 hugr-core = { path = "../hugr-core", version = "0.23.0" }
 
-derive_more = { workspace = true, features = ["display", "error", "from"] }
+derive_more = { workspace = true, features = [
+    "display",
+    "error",
+    "from",
+    "debug",
+] }
 delegate.workspace = true
 itertools.workspace = true
 petgraph.workspace = true

hugr-persistent/src/trait_impls.rs

@@ -25,6 +25,9 @@ use super::{
     InvalidCommit, PatchNode, PersistentHugr, PersistentReplacement, state_space::CommitData,
 };
 
+mod utils;
+use utils::DoubleEndedIteratorAdapter;
+
 impl Patch<PersistentHugr> for PersistentReplacement {
     type Outcome = CommitId;
     const UNCHANGED_ON_FAILURE: bool = true;
@@ -226,14 +229,15 @@ impl HugrView for PersistentHugr {
         let cm = self.get_commit(node.owner());
         let commit_hugr = cm.commit_hugr();
         let children = commit_hugr.children(node.1).map(|n| cm.to_patch_node(n));
-        if OpTag::DataflowParent.is_superset(self.get_optype(node).tag()) {
+        let it = if OpTag::DataflowParent.is_superset(self.get_optype(node).tag()) {
             // we must filter out children nodes that are invalidated by later commits, and
             // on the other hand add nodes in those commits
             Either::Left(IterValidNodes::new(self, children.fuse()))
         } else {
             // children are precisely children of the commit hugr
             Either::Right(children)
-        }
+        };
+        DoubleEndedIteratorAdapter::from(it)
     }
 
     fn descendants(&self, node: Self::Node) -> impl Iterator<Item = Self::Node> + Clone {
@@ -407,11 +411,7 @@ impl<I: FusedIterator<Item = PatchNode>> Iterator for IterValidNodes<'_, I> {
     }
 }
 
-impl<I: FusedIterator<Item = PatchNode>> DoubleEndedIterator for IterValidNodes<'_, I> {
-    fn next_back(&mut self) -> Option<Self::Item> {
-        unimplemented!("cannot go backwards")
-    }
-}
+impl<I: FusedIterator<Item = PatchNode>> FusedIterator for IterValidNodes<'_, I> {}
 
 #[cfg(test)]
 mod tests {

hugr-persistent/src/trait_impls/utils.rs

@@ -0,0 +1,65 @@
+use std::iter::FusedIterator;
+
+/// An adapter that allows an `Iterator` to implement `DoubleEndedIterator`
+/// by collecting its items when `next_back` is called.
+///
+/// If `next_back` is never called, the original iterator is used directly,
+/// avoiding the overhead of collecting items into a vector.
+#[derive(Clone, Debug)]
+pub enum DoubleEndedIteratorAdapter<I: Iterator> {
+    Iter(I),
+    CollectedIter(std::vec::IntoIter<I::Item>),
+}
+
+impl<I: Iterator> DoubleEndedIteratorAdapter<I> {
+    /// Creates a new `DoubleEndedIteratorAdapter` from the given iterator.
+    pub fn new(iter: I) -> Self {
+        Self::Iter(iter)
+    }
+
+    fn collect_self(&mut self) {
+        match self {
+            DoubleEndedIteratorAdapter::Iter(iter) => {
+                let collected: Vec<I::Item> = iter.collect();
+                *self = DoubleEndedIteratorAdapter::CollectedIter(collected.into_iter());
+            }
+            DoubleEndedIteratorAdapter::CollectedIter(_) => {}
+        }
+    }
+}
+
+impl<I: Iterator> From<I> for DoubleEndedIteratorAdapter<I> {
+    fn from(iter: I) -> Self {
+        Self::new(iter)
+    }
+}
+
+impl<I: Iterator> Iterator for DoubleEndedIteratorAdapter<I> {
+    type Item = I::Item;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self {
+            DoubleEndedIteratorAdapter::Iter(iter) => iter.next(),
+            DoubleEndedIteratorAdapter::CollectedIter(iter) => iter.next(),
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        match self {
+            DoubleEndedIteratorAdapter::Iter(iter) => iter.size_hint(),
+            DoubleEndedIteratorAdapter::CollectedIter(iter) => iter.size_hint(),
+        }
+    }
+}
+
+impl<I: FusedIterator> FusedIterator for DoubleEndedIteratorAdapter<I> {}
+
+impl<I: Iterator> DoubleEndedIterator for DoubleEndedIteratorAdapter<I> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.collect_self();
+        match self {
+            DoubleEndedIteratorAdapter::CollectedIter(iter) => iter.next_back(),
+            _ => unreachable!("just collected self"),
+        }
+    }
+}