provide drop_left(_shallow) drop_right(_shallow) for different purposes; tag 0.0.9

Author: tiye

Cargo.toml

@@ -1,7 +1,7 @@
 
 [package]
 name = "im_ternary_tree"
-version = "0.0.8"
+version = "0.0.9"
 edition = "2021"
 authors = ["jiyinyiyong <jiyinyiyong@gmail.com>"]
 license = "MIT"

benches/creating.rs

@@ -139,6 +139,38 @@ fn criterion_benchmark(c: &mut Criterion) {
     })
   });
 
+  c.bench_function("drop-left-shallow", |b| {
+    let mut data = TernaryTreeList::Empty;
+
+    for idx in 0..1000 {
+      data = data.push(idx);
+    }
+
+    b.iter(move || {
+      let mut d = data.to_owned();
+
+      while d.len() > 1 {
+        d = d.drop_left_shallow()
+      }
+    })
+  });
+
+  c.bench_function("drop-right-shallow", |b| {
+    let mut data = TernaryTreeList::Empty;
+
+    for idx in 0..1000 {
+      data = data.push(idx);
+    }
+
+    b.iter(move || {
+      let mut d = data.to_owned();
+
+      while d.len() > 1 {
+        d = d.drop_right_shallow()
+      }
+    })
+  });
+
   c.bench_function("drop-left from push_right", |b| {
     let mut data = TernaryTreeList::Empty;
 

src/lib.rs

@@ -238,8 +238,21 @@ where
     }
   }
 
-  /// optimized for amortized `O(1)` at best cases
   pub fn drop_left(&self) -> Self {
+    match self {
+      Empty => TernaryTreeList::Empty,
+      Tree(t) => {
+        if t.len() == 1 {
+          Self::Empty
+        } else {
+          Self::Tree(t.drop_left())
+        }
+      }
+    }
+  }
+
+  /// optimized for amortized `O(1)` at best cases, but copies a lot
+  pub fn drop_left_shallow(&self) -> Self {
     match self {
       Empty => TernaryTreeList::Empty,
       Tree(t) => {
@@ -255,8 +268,21 @@ where
     }
   }
 
-  /// optimized for amortized `O(1)` at best cases
   pub fn drop_right(&self) -> Self {
+    match self {
+      Empty => Self::Empty,
+      Tree(t) => {
+        if t.len() == 1 {
+          Self::Empty
+        } else {
+          Self::Tree(t.drop_right())
+        }
+      }
+    }
+  }
+
+  /// optimized for amortized `O(1)` at best cases, but copies a lot
+  pub fn drop_right_shallow(&self) -> Self {
     match self {
       Empty => Self::Empty,
       Tree(t) => {

src/tree/finger.rs

@@ -630,4 +630,202 @@ where
       }
     }
   }
+
+  pub fn drop_left(&self) -> Self {
+    match self {
+      Leaf(_) => {
+        unreachable!("not expected empty node inside tree")
+      }
+      Branch2 { size, left, middle, .. } => {
+        if left.len() == 1 {
+          (**middle).to_owned()
+        } else {
+          let changed_branch = left.drop_left();
+          match changed_branch {
+            Branch2 {
+              left: b_left,
+              middle: b_middle,
+              ..
+            } => Branch3 {
+              size: size - 1,
+              left: b_left,
+              middle: b_middle,
+              right: middle.to_owned(),
+            },
+            Branch3 {
+              left: b_left,
+              middle: b_middle,
+              right: b_right,
+              ..
+            } => {
+              let internal_branch = Branch2 {
+                size: b_middle.len() + b_right.len(),
+                left: b_middle,
+                middle: b_right,
+              };
+              Branch3 {
+                size: size - 1,
+                left: b_left,
+                middle: Arc::new(internal_branch),
+                right: middle.to_owned(),
+              }
+            }
+            _ => Branch2 {
+              size: size - 1,
+              left: Arc::new(changed_branch),
+              middle: middle.to_owned(),
+            },
+          }
+        }
+      }
+      Branch3 {
+        size, left, middle, right, ..
+      } => {
+        if left.len() == 1 {
+          match &**middle {
+            Branch2 {
+              left: b_left,
+              middle: b_middle,
+              ..
+            } => Branch3 {
+              size: size - 1,
+              left: b_left.to_owned(),
+              middle: b_middle.to_owned(),
+              right: right.to_owned(),
+            },
+            Branch3 {
+              left: b_left,
+              middle: b_middle,
+              right: b_right,
+              ..
+            } => {
+              let internal_branch = Branch2 {
+                size: b_middle.len() + b_right.len(),
+                left: b_middle.to_owned(),
+                middle: b_right.to_owned(),
+              };
+              Branch3 {
+                size: size - 1,
+                left: b_left.to_owned(),
+                middle: Arc::new(internal_branch),
+                right: right.to_owned(),
+              }
+            }
+            _ => Branch2 {
+              size: size - 1,
+              left: middle.to_owned(),
+              middle: right.to_owned(),
+            },
+          }
+        } else {
+          let changed_branch = left.drop_left();
+          Branch3 {
+            size: size - 1,
+            left: Arc::new(changed_branch),
+            middle: middle.to_owned(),
+            right: right.to_owned(),
+          }
+        }
+      }
+    }
+  }
+
+  pub fn drop_right(&self) -> Self {
+    match self {
+      Leaf(_) => {
+        unreachable!("not expected empty node inside tree")
+      }
+      Branch2 { size, left, middle, .. } => {
+        if middle.len() == 1 {
+          (**left).to_owned()
+        } else {
+          let changed_branch = middle.drop_right();
+          match changed_branch {
+            Branch2 {
+              left: b_left,
+              middle: b_middle,
+              ..
+            } => Branch3 {
+              size: size - 1,
+              left: left.to_owned(),
+              middle: b_left,
+              right: b_middle,
+            },
+            Branch3 {
+              left: b_left,
+              middle: b_middle,
+              right: b_right,
+              ..
+            } => {
+              let internal_branch = Branch2 {
+                size: b_middle.len() + b_left.len(),
+                left: b_left,
+                middle: b_middle,
+              };
+              Branch3 {
+                size: size - 1,
+                left: left.to_owned(),
+                middle: Arc::new(internal_branch),
+                right: b_right,
+              }
+            }
+            _ => Branch2 {
+              size: size - 1,
+              left: left.to_owned(),
+              middle: Arc::new(changed_branch),
+            },
+          }
+        }
+      }
+      Branch3 {
+        size, right, middle, left, ..
+      } => {
+        if right.len() == 1 {
+          match &**middle {
+            Branch2 {
+              left: b_left,
+              middle: b_middle,
+              ..
+            } => Branch3 {
+              size: size - 1,
+              left: left.to_owned(),
+              middle: b_left.to_owned(),
+              right: b_middle.to_owned(),
+            },
+            Branch3 {
+              left: b_left,
+              middle: b_middle,
+              right: b_right,
+              ..
+            } => {
+              let internal_branch = Branch2 {
+                size: b_middle.len() + b_left.len(),
+                left: b_left.to_owned(),
+                middle: b_middle.to_owned(),
+              };
+              Branch3 {
+                size: size - 1,
+                left: left.to_owned(),
+                middle: Arc::new(internal_branch),
+                right: b_right.to_owned(),
+              }
+            }
+            _ => Branch2 {
+              size: size - 1,
+              left: left.to_owned(),
+              middle: middle.to_owned(),
+            },
+          }
+        } else {
+          let changed_branch = right.drop_right();
+          Branch3 {
+            size: size - 1,
+            left: left.to_owned(),
+            middle: middle.to_owned(),
+            right: Arc::new(changed_branch),
+          }
+        }
+      }
+    }
+  }
 }

tests/list_tests.rs

@@ -144,6 +144,44 @@ fn drop_right_data() -> Result<(), String> {
   Ok(())
 }
 
+#[test]
+fn drop_left_shallow() -> Result<(), String> {
+  let mut data: Vec<usize> = vec![];
+  for idx in 0..200 {
+    data.push(idx);
+  }
+  let mut tree: TernaryTreeList<usize> = TernaryTreeList::from(data.to_owned());
+
+  // do once less than the length
+  for _ in 0..data.len() {
+    tree = tree.drop_left_shallow();
+    tree.check_structure()?;
+    data.remove(0);
+    assert_eq!(tree, TernaryTreeList::from(data.to_owned()));
+  }
+
+  Ok(())
+}
+
+#[test]
+fn drop_right_shallow() -> Result<(), String> {
+  let mut data: Vec<usize> = vec![];
+  for idx in 0..200 {
+    data.push(idx);
+  }
+  let mut tree: TernaryTreeList<usize> = TernaryTreeList::from(data.to_owned());
+
+  // do once less than the length
+  for _ in 0..data.len() {
+    tree = tree.drop_right_shallow();
+    tree.check_structure()?;
+    data.remove(data.len() - 1);
+    assert_eq!(tree, TernaryTreeList::from(data.to_owned()));
+  }
+
+  Ok(())
+}
+
 #[test]
 fn dissoc() -> Result<(), String> {
   let data = TernaryTreeList::from(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);