possible solution to our naming issue

Author: molpopgen

src/edge_differences.rs

@@ -1,4 +1,3 @@
-use crate::edge_differences::private::EdgeDifferenceIteration;
 use crate::EdgeId;
 use crate::NodeId;
 use crate::Position;
@@ -106,6 +105,7 @@ impl<'ts> EdgeDifferencesIterator<'ts> {
     }
 }
 
+#[derive(Clone)]
 pub struct CurrentTreeEdgeDifferences<'ts> {
     edges_left: &'ts [Position],
     edges_right: &'ts [Position],
@@ -119,27 +119,41 @@ pub struct CurrentTreeEdgeDifferences<'ts> {
     right: f64,
 }
 
-pub struct X<'ts, T: EdgeDifferenceIteration> {
-    edges_left: &'ts [Position],
-    edges_right: &'ts [Position],
-    edges_parent: &'ts [NodeId],
-    edges_child: &'ts [NodeId],
-    order: &'ts [EdgeId],
-    range: (usize, usize),
-    marker: std::marker::PhantomData<T>,
+#[repr(transparent)]
+pub struct EdgeRemovalsIterator<'ts>(CurrentTreeEdgeDifferences<'ts>);
+
+#[repr(transparent)]
+pub struct EdgeInsertionsIterator<'ts>(CurrentTreeEdgeDifferences<'ts>);
+
+impl<'ts> Iterator for EdgeRemovalsIterator<'ts> {
+    type Item = EdgeDifference<Removal>;
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.0.removals.0 < self.0.removals.1 {
+            let index = self.0.removals.0;
+            self.0.removals.0 += 1;
+            Some(Self::Item::new(
+                self.0.edges_left[self.0.removal_order[index].as_usize()],
+                self.0.edges_right[self.0.removal_order[index].as_usize()],
+                self.0.edges_parent[self.0.removal_order[index].as_usize()],
+                self.0.edges_child[self.0.removal_order[index].as_usize()],
+            ))
+        } else {
+            None
+        }
+    }
 }
 
-impl<'ts, T: EdgeDifferenceIteration> Iterator for X<'ts, T> {
-    type Item = EdgeDifference<T>;
+impl<'ts> Iterator for EdgeInsertionsIterator<'ts> {
+    type Item = EdgeDifference<Insertion>;
     fn next(&mut self) -> Option<Self::Item> {
-        if self.range.0 < self.range.1 {
-            let index = self.range.0;
-            self.range.0 += 1;
+        if self.0.insertions.0 < self.0.insertions.1 {
+            let index = self.0.insertions.0;
+            self.0.insertions.0 += 1;
             Some(Self::Item::new(
-                self.edges_left[self.order[index].as_usize()],
-                self.edges_right[self.order[index].as_usize()],
-                self.edges_parent[self.order[index].as_usize()],
-                self.edges_child[self.order[index].as_usize()],
+                self.0.edges_left[self.0.insertion_order[index].as_usize()],
+                self.0.edges_right[self.0.insertion_order[index].as_usize()],
+                self.0.edges_parent[self.0.insertion_order[index].as_usize()],
+                self.0.edges_child[self.0.insertion_order[index].as_usize()],
             ))
         } else {
             None
@@ -149,27 +163,11 @@ impl<'ts, T: EdgeDifferenceIteration> Iterator for X<'ts, T> {
 
 impl<'ts> CurrentTreeEdgeDifferences<'ts> {
     pub fn removals(&self) -> impl Iterator<Item = EdgeRemoval> + '_ {
-        X {
-            edges_left: self.edges_left,
-            edges_right: self.edges_right,
-            edges_parent: self.edges_parent,
-            edges_child: self.edges_child,
-            order: self.removal_order,
-            range: self.removals,
-            marker: std::marker::PhantomData::<Removal> {},
-        }
+        EdgeRemovalsIterator(self.clone())
     }
 
     pub fn insertions(&self) -> impl Iterator<Item = EdgeInsertion> + '_ {
-        X {
-            edges_left: self.edges_left,
-            edges_right: self.edges_right,
-            edges_parent: self.edges_parent,
-            edges_child: self.edges_child,
-            order: self.insertion_order,
-            range: self.insertions,
-            marker: std::marker::PhantomData::<Insertion> {},
-        }
+        EdgeInsertionsIterator(self.clone())
     }
 
     pub fn interval(&self) -> (Position, Position) {