Renaming ZipperMovingPriv trait to ZipperPathBuffer trait, and promoting it from internal to external interface, and removing ZipperMoving dependency on that trait. Now, in effect, ZipperMoving is no longer a sealed trait

Author: luketpeterson

src/arena_compact.rs

@@ -81,7 +81,7 @@ use crate::{
     utils::{BitMask, ByteMask, find_prefix_overlap},
     zipper::{
         Zipper, ZipperValues, ZipperForking, ZipperAbsolutePath, ZipperIteration,
-        ZipperMoving, ZipperMovingPriv, ZipperReadOnlyValues,
+        ZipperMoving, ZipperPathBuffer, ZipperReadOnlyValues,
         ZipperConcretePriv, ZipperConcrete,
     },
 };
@@ -1381,7 +1381,7 @@ where Storage: AsRef<[u8]>
     }
 }
 
-impl<'tree, Storage> ZipperMovingPriv for ACTZipper<'tree, Storage>
+impl<'tree, Storage> ZipperPathBuffer for ACTZipper<'tree, Storage>
 where Storage: AsRef<[u8]>
 {
     unsafe fn origin_path_assert_len(&self, len: usize) -> &[u8] {

src/experimental.rs

@@ -17,7 +17,7 @@ impl Zipper for FullZipper {
     fn child_mask(&self) -> ByteMask { [!0u64, !0u64, !0u64, !0u64].into() }
 }
 
-impl ZipperMovingPriv for FullZipper {
+impl ZipperPathBuffer for FullZipper {
     unsafe fn origin_path_assert_len(&self, len: usize) -> &[u8] {
         assert!(len <= self.path.capacity());
         unsafe{ core::slice::from_raw_parts(self.path.as_ptr(), len) }

src/morphisms.rs

@@ -317,7 +317,7 @@ impl SplitCataJumping {
     }
 }
 
-impl<'a, Z, V: 'a> Catamorphism<V> for Z where Z: Zipper + ZipperReadOnlyValues<'a, V> + ZipperConcrete + ZipperAbsolutePath {
+impl<'a, Z, V: 'a> Catamorphism<V> for Z where Z: Zipper + ZipperReadOnlyValues<'a, V> + ZipperConcrete + ZipperAbsolutePath + ZipperPathBuffer {
     fn into_cata_side_effect_fallible<W, Err, AlgF>(self, mut alg_f: AlgF) -> Result<W, Err>
         where AlgF: FnMut(&ByteMask, &mut [W], Option<&V>, &[u8]) -> Result<W, Err>,
     {
@@ -392,7 +392,7 @@ impl<V: 'static + Clone + Send + Sync + Unpin> Catamorphism<V> for BytesTrieMap<
 #[inline]
 fn cata_side_effect_body<'a, Z, V: 'a, W, Err, AlgF, const JUMPING: bool>(mut z: Z, mut alg_f: AlgF) -> Result<W, Err>
     where
-    Z: Zipper + ZipperReadOnlyValues<'a, V> + ZipperAbsolutePath,
+    Z: Zipper + ZipperReadOnlyValues<'a, V> + ZipperAbsolutePath + ZipperPathBuffer,
     AlgF: FnMut(&ByteMask, &mut [W], usize, Option<&V>, &[u8]) -> Result<W, Err>
 {
     //`stack` holds a "frame" at each forking point above the zipper position.  No frames exist for values
@@ -469,7 +469,7 @@ fn ascend_to_fork<'a, Z, V: 'a, W, Err, AlgF, const JUMPING: bool>(z: &mut Z,
         alg_f: &mut AlgF, children: &mut [W]
 ) -> Result<W, Err>
     where
-    Z: Zipper + ZipperReadOnlyValues<'a, V> + ZipperAbsolutePath,
+    Z: Zipper + ZipperReadOnlyValues<'a, V> + ZipperAbsolutePath + ZipperPathBuffer,
     AlgF: FnMut(&ByteMask, &mut [W], usize, Option<&V>, &[u8]) -> Result<W, Err>
 {
     let mut w;
@@ -716,7 +716,7 @@ fn into_cata_cached_body<'a, Z, V: 'a, W, E, AlgF, Cache, const JUMPING: bool>(
 ) -> Result<W, E>
     where
     Cache: CacheStrategy<W>,
-    Z: Zipper + ZipperReadOnlyValues<'a, V> + ZipperConcrete + ZipperAbsolutePath,
+    Z: Zipper + ZipperReadOnlyValues<'a, V> + ZipperConcrete + ZipperAbsolutePath + ZipperPathBuffer,
     AlgF: FnMut(&ByteMask, &mut [W], usize, Option<&V>, &[u8]) -> Result<W, E>
 {
     use gxhash::HashMapExt;

src/product_zipper.rs

@@ -293,7 +293,7 @@ impl<V: Clone + Send + Sync + Unpin> zipper_priv::ZipperPriv for ProductZipper<'
     fn try_borrow_focus(&self) -> Option<&dyn TrieNode<Self::V>> { self.z.try_borrow_focus() }
 }
 
-impl<V: Clone + Send + Sync + Unpin> zipper_priv::ZipperMovingPriv for ProductZipper<'_, '_, V> {
+impl<V: Clone + Send + Sync + Unpin + Unpin> ZipperPathBuffer for ProductZipper<'_, '_, V> {
     unsafe fn origin_path_assert_len(&self, len: usize) -> &[u8] { unsafe{ self.z.origin_path_assert_len(len) } }
     fn prepare_buffers(&mut self) { self.z.prepare_buffers() }
     fn reserve_buffers(&mut self, path_len: usize, stack_depth: usize) { self.z.reserve_buffers(path_len, stack_depth) }

src/write_zipper.rs

@@ -277,7 +277,7 @@ impl<'a, 'path, V: Clone + Send + Sync> zipper_priv::ZipperPriv for WriteZipperT
     fn try_borrow_focus(&self) -> Option<&dyn TrieNode<Self::V>> { self.z.try_borrow_focus() }
 }
 
-impl<'a, 'path, V: Clone + Send + Sync> zipper_priv::ZipperMovingPriv for WriteZipperTracked<'a, 'path, V> {
+impl<'a, 'path, V: Clone + Send + Sync + Unpin> ZipperPathBuffer for WriteZipperTracked<'a, 'path, V> {
     unsafe fn origin_path_assert_len(&self, len: usize) -> &[u8] { unsafe{ self.z.origin_path_assert_len(len) } }
     fn prepare_buffers(&mut self) { self.z.prepare_buffers() }
     fn reserve_buffers(&mut self, path_len: usize, stack_depth: usize) { self.z.reserve_buffers(path_len, stack_depth) }
@@ -414,7 +414,7 @@ impl<'a, 'k, V: Clone + Send + Sync> zipper_priv::ZipperPriv for WriteZipperUntr
     fn try_borrow_focus(&self) -> Option<&dyn TrieNode<Self::V>> { self.z.try_borrow_focus() }
 }
 
-impl<'a, 'k, V: Clone + Send + Sync> zipper_priv::ZipperMovingPriv for WriteZipperUntracked<'a, 'k, V> {
+impl<'a, 'k, V: Clone + Send + Sync + Unpin> ZipperPathBuffer for WriteZipperUntracked<'a, 'k, V> {
     unsafe fn origin_path_assert_len(&self, len: usize) -> &[u8] { unsafe{ self.z.origin_path_assert_len(len) } }
     fn prepare_buffers(&mut self) { self.z.prepare_buffers() }
     fn reserve_buffers(&mut self, path_len: usize, stack_depth: usize) { self.z.reserve_buffers(path_len, stack_depth) }
@@ -575,7 +575,7 @@ impl<V: Clone + Send + Sync> zipper_priv::ZipperPriv for WriteZipperOwned<V> {
     fn try_borrow_focus(&self) -> Option<&dyn TrieNode<Self::V>> { self.z.try_borrow_focus() }
 }
 
-impl<V: Clone + Send + Sync> zipper_priv::ZipperMovingPriv for WriteZipperOwned<V> {
+impl<V: Clone + Send + Sync + Unpin> ZipperPathBuffer for WriteZipperOwned<V> {
     unsafe fn origin_path_assert_len(&self, len: usize) -> &[u8] { unsafe{ self.z.origin_path_assert_len(len) } }
     fn prepare_buffers(&mut self) { self.z.prepare_buffers() }
     fn reserve_buffers(&mut self, path_len: usize, stack_depth: usize) { self.z.reserve_buffers(path_len, stack_depth) }
@@ -872,7 +872,7 @@ impl<V: Clone + Send + Sync + Unpin> ZipperMoving for WriteZipperCore<'_, '_, V>
     }
 }
 
-impl<'a, 'k, V: Clone + Send + Sync> zipper_priv::ZipperPriv for WriteZipperCore<'a, 'k, V> {
+impl<'a, 'k, V: Clone + Send + Sync > zipper_priv::ZipperPriv for WriteZipperCore<'a, 'k, V> {
     type V = V;
 
     fn get_focus(&self) -> AbstractNodeRef<Self::V> {
@@ -895,7 +895,7 @@ impl<'a, 'k, V: Clone + Send + Sync> zipper_priv::ZipperPriv for WriteZipperCore
     }
 }
 
-impl<'a, 'k, V: Clone + Send + Sync> zipper_priv::ZipperMovingPriv for WriteZipperCore<'a, 'k, V> {
+impl<'a, 'k, V: Clone + Send + Sync + Unpin> ZipperPathBuffer for WriteZipperCore<'a, 'k, V> {
     unsafe fn origin_path_assert_len(&self, _len: usize) -> &[u8] {
         unimplemented!()
     }

src/zipper.rs

@@ -113,7 +113,7 @@ pub trait ZipperSubtries<V: Clone + Send + Sync>: ZipperValues<V> + zipper_priv:
 /// A zipper's **origin** is always equal-to-or-above the zipper's root.  The position of the origin depends
 /// on how the zipper was created, and the origin will never be below the root.  The origin of a given zipper
 /// will never change.
-pub trait ZipperMoving: Zipper + ZipperMovingPriv {
+pub trait ZipperMoving: Zipper {
     /// Returns `true` if the zipper's focus is at its root, and it cannot ascend further, otherwise returns `false`
     fn at_root(&self) -> bool {
         self.path().len() == 0
@@ -501,6 +501,24 @@ pub trait ZipperConcrete: zipper_priv::ZipperConcretePriv {
     fn is_shared(&self) -> bool;
 }
 
+/// Provides more direct control over a [ZipperMoving] zipper's path buffer
+pub trait ZipperPathBuffer: ZipperMoving {
+    /// Internal method to get the path, beyond its length.  Panics if `len` > the path's capacity, or
+    /// if the zipper is relative and doesn't have an `origin_path`
+    ///
+    /// This method is unsafe because it relies on the caller to not read uninitialized memory, even if
+    /// the memory has been allocated.
+    unsafe fn origin_path_assert_len(&self, len: usize) -> &[u8];
+
+    /// Make sure the path buffer is allocated, to facilitate zipper movement
+    fn prepare_buffers(&mut self);
+
+    /// Reserve buffer space within the zipper's path buffer and node stack
+    ///
+    /// This method will only grow the buffers and will never shrink them.
+    fn reserve_buffers(&mut self, path_len: usize, stack_depth: usize);
+}
+
 pub(crate) mod zipper_priv {
     use super::*;
 
@@ -547,23 +565,6 @@ pub(crate) mod zipper_priv {
         fn try_borrow_focus(&self) -> Option<&dyn TrieNode<Self::V>>;
     }
 
-    pub trait ZipperMovingPriv {
-        /// Internal method to get the path, beyond its length.  Panics if `len` > the path's capacity, or
-        /// if the zipper is relative and doesn't have an `origin_path`
-        ///
-        /// This method is unsafe because it relies on the caller to not read uninitialized memory, even if
-        /// the memory has been allocated.
-        unsafe fn origin_path_assert_len(&self, len: usize) -> &[u8];
-
-        /// Make sure the path buffer is allocated, to facilitate zipper movement
-        fn prepare_buffers(&mut self);
-
-        /// Reserve buffer space within the zipper's path buffer and node stack
-        ///
-        /// This method will only grow the buffers and will never shrink them.
-        fn reserve_buffers(&mut self, path_len: usize, stack_depth: usize);
-    }
-
     pub trait ZipperReadOnlyPriv<'a, V: Clone + Send + Sync> {
         /// Internal method returns the minimal components that compose the zipper, which are:
         ///
@@ -595,7 +596,7 @@ pub(crate) mod zipper_priv {
     }
 }
 use zipper_priv::*;
-pub use zipper_priv::{ZipperMovingPriv, ZipperConcretePriv};
+pub use zipper_priv::ZipperConcretePriv;
 
 impl<Z> Zipper for &mut Z where Z: Zipper {
     fn path_exists(&self) -> bool { (**self).path_exists() }
@@ -671,7 +672,7 @@ impl<V: Clone + Send + Sync, Z> ZipperPriv for &mut Z where Z: ZipperPriv<V=V> {
     fn try_borrow_focus(&self) -> Option<&dyn TrieNode<Self::V>> { (**self).try_borrow_focus() }
 }
 
-impl<Z> ZipperMovingPriv for &mut Z where Z: ZipperMovingPriv {
+impl<Z> ZipperPathBuffer for &mut Z where Z: ZipperPathBuffer {
     unsafe fn origin_path_assert_len(&self, len: usize) -> &[u8] { (**self).origin_path_assert_len(len) }
     fn prepare_buffers(&mut self) { (**self).prepare_buffers() }
     fn reserve_buffers(&mut self, path_len: usize, stack_depth: usize) { (**self).reserve_buffers(path_len, stack_depth) }
@@ -781,7 +782,7 @@ impl<V: Clone + Send + Sync + Unpin> zipper_priv::ZipperPriv for ReadZipperTrack
     fn try_borrow_focus(&self) -> Option<&dyn TrieNode<Self::V>> { self.z.try_borrow_focus() }
 }
 
-impl<V: Clone + Send + Sync + Unpin> zipper_priv::ZipperMovingPriv for ReadZipperTracked<'_, '_, V> {
+impl<V: Clone + Send + Sync + Unpin> ZipperPathBuffer for ReadZipperTracked<'_, '_, V> {
     unsafe fn origin_path_assert_len(&self, len: usize) -> &[u8] { unsafe{ self.z.origin_path_assert_len(len) } }
     fn prepare_buffers(&mut self) { self.z.prepare_buffers() }
     fn reserve_buffers(&mut self, path_len: usize, stack_depth: usize) { self.z.reserve_buffers(path_len, stack_depth) }
@@ -931,7 +932,7 @@ impl<V: Clone + Send + Sync + Unpin> zipper_priv::ZipperPriv for ReadZipperUntra
     fn try_borrow_focus(&self) -> Option<&dyn TrieNode<Self::V>> { self.z.try_borrow_focus() }
 }
 
-impl<V: Clone + Send + Sync + Unpin> zipper_priv::ZipperMovingPriv for ReadZipperUntracked<'_, '_, V> {
+impl<V: Clone + Send + Sync + Unpin> ZipperPathBuffer for ReadZipperUntracked<'_, '_, V> {
     unsafe fn origin_path_assert_len(&self, len: usize) -> &[u8] { unsafe{ self.z.origin_path_assert_len(len) } }
     fn prepare_buffers(&mut self) { self.z.prepare_buffers() }
     fn reserve_buffers(&mut self, path_len: usize, stack_depth: usize) { self.z.reserve_buffers(path_len, stack_depth) }
@@ -1130,7 +1131,7 @@ impl<V: Clone + Send + Sync + Unpin> zipper_priv::ZipperPriv for ReadZipperOwned
     fn try_borrow_focus(&self) -> Option<&dyn TrieNode<Self::V>> { self.z.try_borrow_focus() }
 }
 
-impl<V: Clone + Send + Sync + Unpin> zipper_priv::ZipperMovingPriv for ReadZipperOwned<V> {
+impl<V: Clone + Send + Sync + Unpin> ZipperPathBuffer for ReadZipperOwned<V> {
     unsafe fn origin_path_assert_len(&self, len: usize) -> &[u8] { unsafe{ self.z.origin_path_assert_len(len) } }
     fn prepare_buffers(&mut self) { self.z.prepare_buffers() }
     fn reserve_buffers(&mut self, path_len: usize, stack_depth: usize) { self.z.reserve_buffers(path_len, stack_depth) }
@@ -1617,7 +1618,7 @@ pub(crate) mod read_zipper_core {
         }
     }
 
-    impl<V: Clone + Send + Sync + Unpin> zipper_priv::ZipperMovingPriv for ReadZipperCore<'_, '_, V> {
+    impl<V: Clone + Send + Sync + Unpin> ZipperPathBuffer for ReadZipperCore<'_, '_, V> {
         unsafe fn origin_path_assert_len(&self, len: usize) -> &[u8] {
             if self.prefix_buf.capacity() > 0 {
                 assert!(len <= self.prefix_buf.capacity());