script/research/dark-forest: use wrapper struct for DarkLeaf in DarkTree so flattened vector don't contain node's index

script/research/dark-forest/src/lib.rs

@@ -25,8 +25,8 @@ use error::{DarkTreeError, DarkTreeResult};
 #[cfg(test)]
 mod tests;
 
-/// This struct represents a Leaf of a [`DarkTree`],
-/// holding this tree node data, along with positional
+/// This struct represents the information hold by a
+/// [`DarkTreeLeaf`], namely its data, along with positional
 /// indexes information, based on tree's traversal order.
 /// These indexes are only here to enable referencing
 /// connected nodes, and are *not* used as pointers by the
@@ -38,9 +38,6 @@ where
 {
     /// Data holded by this leaf
     data: T,
-    /// Index showcasing this leaf's position, when all
-    /// leafs are in order.
-    index: usize,
     /// Index showcasing this leaf's parent tree, when all
     /// leafs are in order. None indicates that this leaf
     /// has no parent.
@@ -51,25 +48,41 @@ where
     children_indexes: Vec<usize>,
 }
 
-impl<T: std::clone::Clone> DarkLeaf<T> {
-    /// Every [`DarkLeaf`] is initiated using default indexes.
-    fn new(data: T) -> DarkLeaf<T> {
-        Self { data, index: 0, parent_index: None, children_indexes: vec![] }
+/// This struct represents a Leaf of a [`DarkTree`],
+/// holding this tree node data, along with its positional
+/// index, based on tree's traversal order.
+#[derive(Clone, Debug, PartialEq)]
+struct DarkTreeLeaf<T>
+where
+    T: Clone,
+{
+    /// Index showcasing this leaf's position, when all
+    /// leafs are in order.
+    index: usize,
+    /// Leaf's data, along with its parent and children
+    /// indexes information.
+    info: DarkLeaf<T>,
+}
+
+impl<T: std::clone::Clone> DarkTreeLeaf<T> {
+    /// Every [`DarkTreeLeaf`] is initiated using default indexes.
+    fn new(data: T) -> DarkTreeLeaf<T> {
+        Self { index: 0, info: DarkLeaf { data, parent_index: None, children_indexes: vec![] } }
     }
 
-    /// Set [`DarkLeaf`]'s index
+    /// Set [`DarkTreeLeaf`]'s index
     fn set_index(&mut self, index: usize) {
         self.index = index;
     }
 
-    /// Set [`DarkLeaf`]'s parent index
+    /// Set [`DarkTreeLeaf`]'s parent index
     fn set_parent_index(&mut self, parent_index: Option<usize>) {
-        self.parent_index = parent_index;
+        self.info.parent_index = parent_index;
     }
 
-    /// Set [`DarkLeaf`]'s children index
+    /// Set [`DarkTreeLeaf`]'s children index
     fn set_children_indexes(&mut self, children_indexes: Vec<usize>) {
-        self.children_indexes = children_indexes;
+        self.info.children_indexes = children_indexes;
     }
 }
 
@@ -83,7 +96,7 @@ impl<T: std::clone::Clone> DarkLeaf<T> {
 #[derive(Debug, PartialEq)]
 struct DarkTree<T: std::clone::Clone> {
     /// This tree's leaf information, along with its data
-    leaf: DarkLeaf<T>,
+    leaf: DarkTreeLeaf<T>,
     /// Vector containing all tree's branches(children tree)
     children: Vec<DarkTree<T>>,
     /// Min capacity of the tree, including all children nodes
@@ -123,7 +136,7 @@ impl<T: std::clone::Clone> DarkTree<T> {
         } else {
             1
         };
-        let leaf = DarkLeaf::new(data);
+        let leaf = DarkTreeLeaf::new(data);
         Self { leaf, children, min_capacity, max_capacity }
     }
 
@@ -142,7 +155,7 @@ impl<T: std::clone::Clone> DarkTree<T> {
     /// all the leafs in DFS post-order traversal order.
     fn build_vec(&mut self) -> DarkTreeResult<Vec<DarkLeaf<T>>> {
         self.build()?;
-        Ok(self.iter().cloned().collect())
+        Ok(self.iter().cloned().map(|x| x.info).collect())
     }
 
     /// Return the count of all [`DarkTree`] leafs.
@@ -223,7 +236,7 @@ impl<T: std::clone::Clone> DarkTree<T> {
     /// and trigger the check of its children indexes.
     fn check_parent_children_indexes(&self, parent_index: Option<usize>) -> DarkTreeResult<()> {
         // Check our leafs parent index
-        if self.leaf.parent_index != parent_index {
+        if self.leaf.info.parent_index != parent_index {
             return Err(DarkTreeError::InvalidLeafParentIndex(self.leaf.index))
         }
 
@@ -236,7 +249,7 @@ impl<T: std::clone::Clone> DarkTree<T> {
         }
 
         // Check our leafs children indexes
-        if self.leaf.children_indexes != children_indexes {
+        if self.leaf.info.children_indexes != children_indexes {
             return Err(DarkTreeError::InvalidLeafChildrenIndexes(self.leaf.index))
         }
 
@@ -307,7 +320,7 @@ impl<T: std::clone::Clone> Default for DarkTreeIter<'_, T> {
 }
 
 impl<'a, T: std::clone::Clone> Iterator for DarkTreeIter<'a, T> {
-    type Item = &'a DarkLeaf<T>;
+    type Item = &'a DarkTreeLeaf<T>;
 
     /// Grab next item iterator visits and return
     /// its immutable reference, or recursively
@@ -346,7 +359,7 @@ impl<T: std::clone::Clone> FusedIterator for DarkTreeIter<'_, T> {}
 /// loops directly, without using .iter() method
 /// of [`DarkTree`].
 impl<'a, T: std::clone::Clone> IntoIterator for &'a DarkTree<T> {
-    type Item = &'a DarkLeaf<T>;
+    type Item = &'a DarkTreeLeaf<T>;
 
     type IntoIter = DarkTreeIter<'a, T>;
 
@@ -360,7 +373,7 @@ impl<'a, T: std::clone::Clone> IntoIterator for &'a DarkTree<T> {
 struct DarkTreeIterMut<'a, T: std::clone::Clone> {
     children: &'a mut [DarkTree<T>],
     parent: Option<Box<DarkTreeIterMut<'a, T>>>,
-    parent_leaf: Option<&'a mut DarkLeaf<T>>,
+    parent_leaf: Option<&'a mut DarkTreeLeaf<T>>,
 }
 
 impl<T: std::clone::Clone> Default for DarkTreeIterMut<'_, T> {
@@ -370,7 +383,7 @@ impl<T: std::clone::Clone> Default for DarkTreeIterMut<'_, T> {
 }
 
 impl<'a, T: std::clone::Clone> Iterator for DarkTreeIterMut<'a, T> {
-    type Item = &'a mut DarkLeaf<T>;
+    type Item = &'a mut DarkTreeLeaf<T>;
 
     /// Grab next item iterator visits and return
     /// its mutable reference, or recursively
@@ -409,7 +422,7 @@ impl<'a, T: std::clone::Clone> Iterator for DarkTreeIterMut<'a, T> {
 /// in loops directly, without using .iter_mut()
 /// method of [`DarkTree`].
 impl<'a, T: std::clone::Clone> IntoIterator for &'a mut DarkTree<T> {
-    type Item = &'a mut DarkLeaf<T>;
+    type Item = &'a mut DarkTreeLeaf<T>;
 
     type IntoIter = DarkTreeIterMut<'a, T>;
 
@@ -433,7 +446,7 @@ impl<T: std::clone::Clone> Default for DarkTreeIntoIter<T> {
 }
 
 impl<T: std::clone::Clone> Iterator for DarkTreeIntoIter<T> {
-    type Item = DarkLeaf<T>;
+    type Item = DarkTreeLeaf<T>;
 
     /// Move next item iterator visits from the tree
     /// to the iterator consumer, if it has no children.
@@ -475,7 +488,7 @@ impl<T: std::clone::Clone> FusedIterator for DarkTreeIntoIter<T> {}
 /// method, to consume the [`DarkTree`] and iterate
 /// over it.
 impl<T: std::clone::Clone> IntoIterator for DarkTree<T> {
-    type Item = DarkLeaf<T>;
+    type Item = DarkTreeLeaf<T>;
 
     type IntoIter = DarkTreeIntoIter<T>;
 
@@ -527,41 +540,23 @@ fn dark_leaf_vec_integrity_check<T: std::clone::Clone>(
 
     // Check each leaf indexes
     for (index, leaf) in leafs.iter().enumerate() {
-        // Check our own index is same as traversal index
-        if index != leaf.index {
-            return Err(DarkTreeError::InvalidLeafIndex(leaf.index, index))
-        }
-
-        // Check our parent index corresponds to correct
-        // leaf in the vector
+        // Parent must have our index in their children
         if let Some(parent_index) = leaf.parent_index {
-            let parent = &leafs[parent_index];
-            if parent_index != parent.index {
-                return Err(DarkTreeError::InvalidLeafParentIndex(leaf.index))
-            }
-
-            // Parent must have our index in their children
-            if !parent.children_indexes.contains(&leaf.index) {
-                return Err(DarkTreeError::InvalidLeafChildrenIndexes(parent.index))
+            if !leafs[parent_index].children_indexes.contains(&index) {
+                return Err(DarkTreeError::InvalidLeafChildrenIndexes(parent_index))
             }
         }
 
-        // Check our children indexes correspond to the
-        // correct leafs in the vector
+        // Children must have its parent set to us
         for child_index in &leaf.children_indexes {
-            let child = &leafs[*child_index];
-            if child_index != &child.index {
-                return Err(DarkTreeError::InvalidLeafChildrenIndexes(leaf.index))
-            }
-
             // Children must have its parent set to us
-            match child.parent_index {
+            match leafs[*child_index].parent_index {
                 Some(parent_index) => {
-                    if parent_index != leaf.index {
-                        return Err(DarkTreeError::InvalidLeafParentIndex(child.index))
+                    if parent_index != index {
+                        return Err(DarkTreeError::InvalidLeafParentIndex(*child_index))
                     }
                 }
-                None => return Err(DarkTreeError::InvalidLeafParentIndex(child.index)),
+                None => return Err(DarkTreeError::InvalidLeafParentIndex(*child_index)),
             }
         }
     }

script/research/dark-forest/src/tests.rs

@@ -16,7 +16,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-use crate::{dark_leaf_vec_integrity_check, DarkLeaf, DarkTree, DarkTreeResult};
+use crate::{dark_leaf_vec_integrity_check, DarkLeaf, DarkTree, DarkTreeLeaf, DarkTreeResult};
 
 /// Gereate a predefined [`DarkTree`] along with its
 /// expected traversal order.
@@ -107,7 +107,7 @@ pub fn test_darktree_iterator() -> DarkTreeResult<()> {
 
     // Use [`DarkTree`] iterator to collect current
     // data, in order
-    let nums: Vec<i32> = tree.iter().map(|x| x.data).collect();
+    let nums: Vec<i32> = tree.iter().map(|x| x.info.data).collect();
 
     // Verify iterator collected the data in the expected
     // traversal order.
@@ -116,7 +116,7 @@ pub fn test_darktree_iterator() -> DarkTreeResult<()> {
     // Verify using iterator indexing methods to retrieve
     // data from it, returns the expected one, as per
     // expected traversal order.
-    assert_eq!(tree.iter().nth(1).unwrap().data, traversal_order[1]);
+    assert_eq!(tree.iter().nth(1).unwrap().info.data, traversal_order[1]);
 
     // Thanks for reading
     Ok(())
@@ -127,47 +127,47 @@ fn test_darktree_traversal_order() -> DarkTreeResult<()> {
     let (mut tree, traversal_order) = generate_tree()?;
 
     // Loop using the fusion immutable iterator,
-    // verifying we grab the correct [`DarkLeaf`]
+    // verifying we grab the correct [`DarkTreeLeaf`]
     // immutable reference, as per expected
     // traversal order.
     let mut index = 0;
     for leaf in &tree {
-        assert_eq!(leaf.data, traversal_order[index]);
+        assert_eq!(leaf.info.data, traversal_order[index]);
         index += 1;
     }
 
     // Loop using the fusion mutable iterator,
-    // verifying we grab the correct [`DarkLeaf`]
+    // verifying we grab the correct [`DarkTreeLeaf`]
     // mutable reference, as per expected traversal
     // order.
     index = 0;
     for leaf in &mut tree {
-        assert_eq!(leaf.data, traversal_order[index]);
+        assert_eq!(leaf.info.data, traversal_order[index]);
         index += 1;
     }
 
     // Loop using [`DarkTree`] .iter_mut() mutable
-    // iterator, verifying we grab the correct [`DarkLeaf`]
+    // iterator, verifying we grab the correct [`DarkTreeLeaf`]
     // mutable reference, as per expected traversal
     // order.
     for (index, leaf) in tree.iter_mut().enumerate() {
-        assert_eq!(leaf.data, traversal_order[index]);
+        assert_eq!(leaf.info.data, traversal_order[index]);
     }
 
     // Loop using [`DarkTree`] .iter() immutable
-    // iterator, verifying we grab the correct [`DarkLeaf`]
+    // iterator, verifying we grab the correct [`DarkTreeLeaf`]
     // immutable reference, as per expected traversal
     // order.
     for (index, leaf) in tree.iter().enumerate() {
-        assert_eq!(leaf.data, traversal_order[index]);
+        assert_eq!(leaf.info.data, traversal_order[index]);
     }
 
     // Loop using [`DarkTree`] .into_iter() iterator,
     // which consumes (moves) the tree, verifying we
-    // collect the correct [`DarkLeaf`], as per expected
+    // collect the correct [`DarkTreeLeaf`], as per expected
     // traversal order.
     for (index, leaf) in tree.into_iter().enumerate() {
-        assert_eq!(leaf.data, traversal_order[index]);
+        assert_eq!(leaf.info.data, traversal_order[index]);
     }
 
     // Thanks for reading
@@ -180,16 +180,16 @@ fn test_darktree_mut_iterator() -> DarkTreeResult<()> {
 
     // Loop using [`DarkTree`] .iter_mut() mutable
     // iterator, grabing a mutable reference over a
-    // [`DarkLeaf`], and mutating its inner data.
+    // [`DarkTreeLeaf`], and mutating its inner data.
     for leaf in tree.iter_mut() {
-        leaf.data += 1;
+        leaf.info.data += 1;
     }
 
     // Loop using the fusion mutable iterator,
     // grabing a mutable reference over a
-    // [`DarkLeaf`], and mutating its inner data.
+    // [`DarkTreeLeaf`], and mutating its inner data.
     for leaf in &mut tree {
-        leaf.data += 1;
+        leaf.info.data += 1;
     }
 
     // Verify performed mutation actually happened
@@ -198,46 +198,52 @@ fn test_darktree_mut_iterator() -> DarkTreeResult<()> {
     assert_eq!(
         tree,
         DarkTree {
-            leaf: DarkLeaf {
-                data: 24,
+            leaf: DarkTreeLeaf {
                 index: 22,
-                parent_index: None,
-                children_indexes: vec![10, 14, 21]
+                info: DarkLeaf { data: 24, parent_index: None, children_indexes: vec![10, 14, 21] },
             },
             children: vec![
                 DarkTree {
-                    leaf: DarkLeaf {
-                        data: 12,
+                    leaf: DarkTreeLeaf {
                         index: 10,
-                        parent_index: Some(22),
-                        children_indexes: vec![2, 4, 6, 9]
+                        info: DarkLeaf {
+                            data: 12,
+                            parent_index: Some(22),
+                            children_indexes: vec![2, 4, 6, 9],
+                        },
                     },
                     children: vec![
                         DarkTree {
-                            leaf: DarkLeaf {
-                                data: 4,
+                            leaf: DarkTreeLeaf {
                                 index: 2,
-                                parent_index: Some(10),
-                                children_indexes: vec![0, 1]
+                                info: DarkLeaf {
+                                    data: 4,
+                                    parent_index: Some(10),
+                                    children_indexes: vec![0, 1],
+                                },
                             },
                             children: vec![
                                 DarkTree {
-                                    leaf: DarkLeaf {
-                                        data: 2,
+                                    leaf: DarkTreeLeaf {
                                         index: 0,
-                                        parent_index: Some(2),
-                                        children_indexes: vec![]
+                                        info: DarkLeaf {
+                                            data: 2,
+                                            parent_index: Some(2),
+                                            children_indexes: vec![],
+                                        },
                                     },
                                     children: vec![],
                                     min_capacity: 1,
                                     max_capacity: None,
                                 },
                                 DarkTree {
-                                    leaf: DarkLeaf {
-                                        data: 3,
+                                    leaf: DarkTreeLeaf {
                                         index: 1,
-                                        parent_index: Some(2),
-                                        children_indexes: vec![]
+                                        info: DarkLeaf {
+                                            data: 3,
+                                            parent_index: Some(2),
+                                            children_indexes: vec![],
+                                        },
                                     },
                                     children: vec![],
                                     min_capacity: 1,
@@ -248,18 +254,22 @@ fn test_darktree_mut_iterator() -> DarkTreeResult<()> {
                             max_capacity: None,
                         },
                         DarkTree {
-                            leaf: DarkLeaf {
-                                data: 6,
+                            leaf: DarkTreeLeaf {
                                 index: 4,
-                                parent_index: Some(10),
-                                children_indexes: vec![3]
+                                info: DarkLeaf {
+                                    data: 6,
+                                    parent_index: Some(10),
+                                    children_indexes: vec![3],
+                                },
                             },
                             children: vec![DarkTree {
-                                leaf: DarkLeaf {
-                                    data: 5,
+                                leaf: DarkTreeLeaf {
                                     index: 3,
-                                    parent_index: Some(4),
-                                    children_indexes: vec![]
+                                    info: DarkLeaf {
+                                        data: 5,
+                                        parent_index: Some(4),
+                                        children_indexes: vec![],
+                                    },
                                 },
                                 children: vec![],
                                 min_capacity: 1,
@@ -269,18 +279,22 @@ fn test_darktree_mut_iterator() -> DarkTreeResult<()> {
                             max_capacity: None,
                         },
                         DarkTree {
-                            leaf: DarkLeaf {
-                                data: 8,
+                            leaf: DarkTreeLeaf {
                                 index: 6,
-                                parent_index: Some(10),
-                                children_indexes: vec![5]
+                                info: DarkLeaf {
+                                    data: 8,
+                                    parent_index: Some(10),
+                                    children_indexes: vec![5],
+                                },
                             },
                             children: vec![DarkTree {
-                                leaf: DarkLeaf {
-                                    data: 7,
+                                leaf: DarkTreeLeaf {
                                     index: 5,
-                                    parent_index: Some(6),
-                                    children_indexes: vec![]
+                                    info: DarkLeaf {
+                                        data: 7,
+                                        parent_index: Some(6),
+                                        children_indexes: vec![],
+                                    },
                                 },
                                 children: vec![],
                                 min_capacity: 1,
@@ -290,30 +304,36 @@ fn test_darktree_mut_iterator() -> DarkTreeResult<()> {
                             max_capacity: None,
                         },
                         DarkTree {
-                            leaf: DarkLeaf {
-                                data: 11,
+                            leaf: DarkTreeLeaf {
                                 index: 9,
-                                parent_index: Some(10),
-                                children_indexes: vec![7, 8]
+                                info: DarkLeaf {
+                                    data: 11,
+                                    parent_index: Some(10),
+                                    children_indexes: vec![7, 8],
+                                },
                             },
                             children: vec![
                                 DarkTree {
-                                    leaf: DarkLeaf {
-                                        data: 9,
+                                    leaf: DarkTreeLeaf {
                                         index: 7,
-                                        parent_index: Some(9),
-                                        children_indexes: vec![]
+                                        info: DarkLeaf {
+                                            data: 9,
+                                            parent_index: Some(9),
+                                            children_indexes: vec![],
+                                        },
                                     },
                                     children: vec![],
                                     min_capacity: 1,
                                     max_capacity: None,
                                 },
                                 DarkTree {
-                                    leaf: DarkLeaf {
-                                        data: 10,
+                                    leaf: DarkTreeLeaf {
                                         index: 8,
-                                        parent_index: Some(9),
-                                        children_indexes: vec![]
+                                        info: DarkLeaf {
+                                            data: 10,
+                                            parent_index: Some(9),
+                                            children_indexes: vec![],
+                                        },
                                     },
                                     children: vec![],
                                     min_capacity: 1,
@@ -328,26 +348,32 @@ fn test_darktree_mut_iterator() -> DarkTreeResult<()> {
                     max_capacity: None,
                 },
                 DarkTree {
-                    leaf: DarkLeaf {
-                        data: 16,
+                    leaf: DarkTreeLeaf {
                         index: 14,
-                        parent_index: Some(22),
-                        children_indexes: vec![12, 13]
+                        info: DarkLeaf {
+                            data: 16,
+                            parent_index: Some(22),
+                            children_indexes: vec![12, 13],
+                        },
                     },
                     children: vec![
                         DarkTree {
-                            leaf: DarkLeaf {
-                                data: 14,
+                            leaf: DarkTreeLeaf {
                                 index: 12,
-                                parent_index: Some(14),
-                                children_indexes: vec![11]
+                                info: DarkLeaf {
+                                    data: 14,
+                                    parent_index: Some(14),
+                                    children_indexes: vec![11],
+                                },
                             },
                             children: vec![DarkTree {
-                                leaf: DarkLeaf {
-                                    data: 13,
+                                leaf: DarkTreeLeaf {
                                     index: 11,
-                                    parent_index: Some(12),
-                                    children_indexes: vec![]
+                                    info: DarkLeaf {
+                                        data: 13,
+                                        parent_index: Some(12),
+                                        children_indexes: vec![],
+                                    },
                                 },
                                 children: vec![],
                                 min_capacity: 1,
@@ -357,11 +383,13 @@ fn test_darktree_mut_iterator() -> DarkTreeResult<()> {
                             max_capacity: None,
                         },
                         DarkTree {
-                            leaf: DarkLeaf {
-                                data: 15,
+                            leaf: DarkTreeLeaf {
                                 index: 13,
-                                parent_index: Some(14),
-                                children_indexes: vec![]
+                                info: DarkLeaf {
+                                    data: 15,
+                                    parent_index: Some(14),
+                                    children_indexes: vec![],
+                                },
                             },
                             children: vec![],
                             min_capacity: 1,
@@ -372,38 +400,46 @@ fn test_darktree_mut_iterator() -> DarkTreeResult<()> {
                     max_capacity: None,
                 },
                 DarkTree {
-                    leaf: DarkLeaf {
-                        data: 23,
+                    leaf: DarkTreeLeaf {
                         index: 21,
-                        parent_index: Some(22),
-                        children_indexes: vec![17, 18, 20]
+                        info: DarkLeaf {
+                            data: 23,
+                            parent_index: Some(22),
+                            children_indexes: vec![17, 18, 20],
+                        },
                     },
                     children: vec![
                         DarkTree {
-                            leaf: DarkLeaf {
-                                data: 19,
+                            leaf: DarkTreeLeaf {
                                 index: 17,
-                                parent_index: Some(21),
-                                children_indexes: vec![15, 16]
+                                info: DarkLeaf {
+                                    data: 19,
+                                    parent_index: Some(21),
+                                    children_indexes: vec![15, 16],
+                                },
                             },
                             children: vec![
                                 DarkTree {
-                                    leaf: DarkLeaf {
-                                        data: 17,
+                                    leaf: DarkTreeLeaf {
                                         index: 15,
-                                        parent_index: Some(17),
-                                        children_indexes: vec![]
+                                        info: DarkLeaf {
+                                            data: 17,
+                                            parent_index: Some(17),
+                                            children_indexes: vec![],
+                                        },
                                     },
                                     children: vec![],
                                     min_capacity: 1,
                                     max_capacity: None,
                                 },
                                 DarkTree {
-                                    leaf: DarkLeaf {
-                                        data: 18,
+                                    leaf: DarkTreeLeaf {
                                         index: 16,
-                                        parent_index: Some(17),
-                                        children_indexes: vec![]
+                                        info: DarkLeaf {
+                                            data: 18,
+                                            parent_index: Some(17),
+                                            children_indexes: vec![],
+                                        },
                                     },
                                     children: vec![],
                                     min_capacity: 1,
@@ -414,29 +450,35 @@ fn test_darktree_mut_iterator() -> DarkTreeResult<()> {
                             max_capacity: None,
                         },
                         DarkTree {
-                            leaf: DarkLeaf {
-                                data: 20,
+                            leaf: DarkTreeLeaf {
                                 index: 18,
-                                parent_index: Some(21),
-                                children_indexes: vec![]
+                                info: DarkLeaf {
+                                    data: 20,
+                                    parent_index: Some(21),
+                                    children_indexes: vec![],
+                                },
                             },
                             children: vec![],
                             min_capacity: 1,
                             max_capacity: None,
                         },
                         DarkTree {
-                            leaf: DarkLeaf {
-                                data: 22,
+                            leaf: DarkTreeLeaf {
                                 index: 20,
-                                parent_index: Some(21),
-                                children_indexes: vec![19]
+                                info: DarkLeaf {
+                                    data: 22,
+                                    parent_index: Some(21),
+                                    children_indexes: vec![19]
+                                },
                             },
                             children: vec![DarkTree {
-                                leaf: DarkLeaf {
-                                    data: 21,
+                                leaf: DarkTreeLeaf {
                                     index: 19,
-                                    parent_index: Some(20),
-                                    children_indexes: vec![]
+                                    info: DarkLeaf {
+                                        data: 21,
+                                        parent_index: Some(20),
+                                        children_indexes: vec![],
+                                    },
                                 },
                                 children: vec![],
                                 min_capacity: 1,
@@ -459,7 +501,7 @@ fn test_darktree_mut_iterator() -> DarkTreeResult<()> {
 
     // Use [`DarkTree`] iterator to collect current
     // data, in order
-    let nums: Vec<i32> = tree.iter().map(|x| x.data).collect();
+    let nums: Vec<i32> = tree.iter().map(|x| x.info.data).collect();
 
     // Verify iterator collected the data in the expected
     // traversal order.
@@ -478,7 +520,10 @@ pub fn test_darktree_min_capacity() -> DarkTreeResult<()> {
     assert_eq!(
         tree,
         DarkTree {
-            leaf: DarkLeaf { data: 0, index: 0, parent_index: None, children_indexes: vec![] },
+            leaf: DarkTreeLeaf {
+                index: 0,
+                info: DarkLeaf { data: 0, parent_index: None, children_indexes: vec![] },
+            },
             children: vec![],
             min_capacity: 1,
             max_capacity: None
@@ -492,7 +537,10 @@ pub fn test_darktree_min_capacity() -> DarkTreeResult<()> {
     // Generate a new [`DarkTree`] manually with
     // min capacity 0
     let mut tree = DarkTree {
-        leaf: DarkLeaf { data: 0, index: 0, parent_index: None, children_indexes: vec![] },
+        leaf: DarkTreeLeaf {
+            index: 0,
+            info: DarkLeaf { data: 0, parent_index: None, children_indexes: vec![] },
+        },
         children: vec![],
         min_capacity: 0,
         max_capacity: None,
@@ -531,22 +579,34 @@ pub fn test_darktree_max_capacity() -> DarkTreeResult<()> {
     // Generate a new [`DarkTree`] manually with
     // max capacity 1
     let mut tree = DarkTree {
-        leaf: DarkLeaf { data: 0, index: 0, parent_index: None, children_indexes: vec![] },
+        leaf: DarkTreeLeaf {
+            index: 0,
+            info: DarkLeaf { data: 0, parent_index: None, children_indexes: vec![] },
+        },
         children: vec![
             DarkTree {
-                leaf: DarkLeaf { data: 0, index: 0, parent_index: None, children_indexes: vec![] },
+                leaf: DarkTreeLeaf {
+                    index: 0,
+                    info: DarkLeaf { data: 0, parent_index: None, children_indexes: vec![] },
+                },
                 children: vec![],
                 min_capacity: 1,
                 max_capacity: None,
             },
             DarkTree {
-                leaf: DarkLeaf { data: 0, index: 0, parent_index: None, children_indexes: vec![] },
+                leaf: DarkTreeLeaf {
+                    index: 0,
+                    info: DarkLeaf { data: 0, parent_index: None, children_indexes: vec![] },
+                },
                 children: vec![],
                 min_capacity: 1,
                 max_capacity: None,
             },
             DarkTree {
-                leaf: DarkLeaf { data: 0, index: 0, parent_index: None, children_indexes: vec![0] },
+                leaf: DarkTreeLeaf {
+                    index: 0,
+                    info: DarkLeaf { data: 0, parent_index: None, children_indexes: vec![0] },
+                },
                 children: vec![],
                 min_capacity: 1,
                 max_capacity: None,
@@ -604,9 +664,9 @@ pub fn test_darktree_flattened_vec() -> DarkTreeResult<()> {
     // corresponding to a [`DarkTree`] with a 2 children,
     // with erroneous indexes
     let vec = vec![
-        DarkLeaf { data: 0, index: 0, parent_index: Some(2), children_indexes: vec![] },
-        DarkLeaf { data: 0, index: 1, parent_index: Some(2), children_indexes: vec![] },
-        DarkLeaf { data: 0, index: 2, parent_index: None, children_indexes: vec![0, 2] },
+        DarkLeaf { data: 0, parent_index: Some(2), children_indexes: vec![] },
+        DarkLeaf { data: 0, parent_index: Some(2), children_indexes: vec![] },
+        DarkLeaf { data: 0, parent_index: None, children_indexes: vec![0, 2] },
     ];
 
     // Verify vector integrity will fail