RFC: Blind zippers

benches/oeis.rs

@@ -1,21 +1,21 @@
 use std::io::Read;
 use std::usize;
 use pathmap::PathMap;
-use pathmap::zipper::{Zipper, ZipperValues, ZipperMoving, ZipperWriting, ZipperCreation};
+use pathmap::zipper::{Zipper, ZipperValues, ZipperMoving, ZipperPath, ZipperWriting, ZipperCreation};
 use num::BigInt;
 use divan::{Divan, Bencher, black_box};
 
 const MAX_OFFSET: u8 = 10;
 
-fn drop_symbol_head_byte<Z: ZipperWriting<usize> + Zipper + ZipperMoving>(loc: &mut Z) {
+fn drop_symbol_head_byte<Z: ZipperWriting<usize> + Zipper + ZipperMoving + ZipperPath>(loc: &mut Z) {
   let mut it = loc.child_mask().iter();
 
   let p = loc.path().to_vec();
   while let Some(b) = it.next() {
     if b == 0 { continue }
     loc.descend_to_existing_byte(b);
     loc.join_k_path_into(b as usize, true);
-    assert!(loc.ascend(1));
+    assert_eq!(loc.ascend(1), 1);
   }
   loc.reset();
   loc.descend_to(&p[..]);

pathmap-book/src/1.02.00_zippers.md

@@ -16,6 +16,7 @@ Zipper capabilities are defined across a number of traits.  There are many diffe
 | [`ZipperValues`](./1.02.02_zipper_values.md#zippervalues)   | Access values    |
 | [`ZipperReadOnlyValues`](./1.02.02_zipper_values.md#zipperreadonlyvalues)   | Access values with extended lifetime  |
 | [`ZipperReadOnlyConditionalValues`](./1.02.02_zipper_values.md#zipperreadonlyconditionalvalues)   | Access values with `witness` pattern  |
+| [`ZipperPath`](./1.02.03_zipper_paths.md#zipper_relative_path)   | Get basic path information  |
 | [`ZipperAbsolutePath`](./1.02.03_zipper_paths.md#zipperabsolutepath)   | Get more complete path information  |
 | [`ZipperPathBuffer`](./1.02.03_zipper_paths.md#zipperpathbuffer)   | Control zipper's internal buffer allocation  |
 | [`ZipperMoving`](./1.02.04_zipper_moving.md)   | Moves the zipper's focus within the trie |

pathmap-book/src/1.02.03_zipper_paths.md

@@ -1,10 +1,10 @@
 # Paths and Absolute Paths
-Some zippers maintain can expose their focus position within the trie as a `path`. The following traits expose access to the path buffer in some way.
+Some zippers maintain and can expose their focus position within the trie as a contiguous `path` of type `&[u8]`. The following traits expose access to the path buffer in some way.
 
 ## Zipper Relative Path
-The [`path`] method in [`ZipperMoving`] returns the current path from the zipper's root to its focus as a byte slice. This represents the sequence of bytes traversed to reach the current focus position.
+The [`path`] method in the [`ZipperPath`] trait returns the current path from the zipper's root to its focus, as a byte slice. This represents the sequence of bytes traversed to reach the current focus position.
 
-Note that this path is relative to the zipper's root, which may not be the same as the absolute path from the original data structure's root if the zipper was created with a prefix or from a subtrie.
+Note that this path is relative to the zipper's root, which may not be the same as the absolute path from the original data structure's root if the zipper was created with a prefix or from within a subtrie.
 
 ## ZipperAbsolutePath
 The [`ZipperAbsolutePath`] trait provides methods to access a more complete path slice, including the [`origin_path`], and may extend above the zipper's root.

pathmap-derive/src/lib.rs

@@ -213,6 +213,24 @@ pub fn derive_poly_zipper(input: TokenStream) -> TokenStream {
     //     }
     // };
 
+    // Generate ZipperPath trait implementation
+    let zipper_path_impl = {
+        let variant_arms = &variant_arms;
+        quote! {
+            impl #impl_generics pathmap::zipper::ZipperPath for #enum_name #ty_generics
+            where
+                #(#inner_types: pathmap::zipper::ZipperPath,)*
+                #where_clause
+            {
+                fn path(&self) -> &[u8] {
+                    match self {
+                        #(#variant_arms => inner.path(),)*
+                    }
+                }
+            }
+        }
+    };
+
     // Generate ZipperMoving trait implementation
     let zipper_moving_impl = {
         let variant_arms = &variant_arms;
@@ -222,9 +240,22 @@ pub fn derive_poly_zipper(input: TokenStream) -> TokenStream {
                 #(#inner_types: pathmap::zipper::ZipperMoving,)*
                 #where_clause
             {
-                fn path(&self) -> &[u8] {
+                fn at_root(&self) -> bool {
                     match self {
-                        #(#variant_arms => inner.path(),)*
+                        #(#variant_arms => inner.at_root(),)*
+                    }
+                }
+
+                #[inline]
+                fn focus_byte(&self) -> Option<u8> {
+                    match self {
+                        #(#variant_arms => inner.focus_byte(),)*
+                    }
+                }
+
+                fn reset(&mut self) {
+                    match self {
+                        #(#variant_arms => inner.reset(),)*
                     }
                 }
 
@@ -240,6 +271,18 @@ pub fn derive_poly_zipper(input: TokenStream) -> TokenStream {
                     }
                 }
 
+                fn descend_to_existing<K: AsRef<[u8]>>(&mut self, k: K) -> usize {
+                    match self {
+                        #(#variant_arms => inner.descend_to_existing(k),)*
+                    }
+                }
+
+                fn descend_to_val<K: AsRef<[u8]>>(&mut self, k: K) -> usize {
+                    match self {
+                        #(#variant_arms => inner.descend_to_val(k),)*
+                    }
+                }
+
                 fn descend_to_check<K: AsRef<[u8]>>(&mut self, k: K) -> bool {
                     match self {
                         #(#variant_arms => inner.descend_to_check(k),)*
@@ -260,23 +303,71 @@ pub fn derive_poly_zipper(input: TokenStream) -> TokenStream {
                     }
                 }
 
-                fn ascend(&mut self, steps: usize) -> bool {
+                fn descend_indexed_byte(&mut self, idx: usize) -> Option<u8> {
+                    match self {
+                        #(#variant_arms => inner.descend_indexed_byte(idx),)*
+                    }
+                }
+
+                fn descend_first_byte(&mut self) -> Option<u8> {
+                    match self {
+                        #(#variant_arms => inner.descend_first_byte(),)*
+                    }
+                }
+
+                fn descend_last_byte(&mut self) -> Option<u8> {
+                    match self {
+                        #(#variant_arms => inner.descend_last_byte(),)*
+                    }
+                }
+
+                fn descend_until<Obs: pathmap::zipper::PathObserver>(&mut self, obs: &mut Obs) -> bool {
+                    match self {
+                        #(#variant_arms => inner.descend_until(obs),)*
+                    }
+                }
+
+                fn ascend(&mut self, steps: usize) -> usize {
                     match self {
                         #(#variant_arms => inner.ascend(steps),)*
                     }
                 }
 
-                fn ascend_until(&mut self) -> bool {
+                fn ascend_byte(&mut self) -> bool {
+                    match self {
+                        #(#variant_arms => inner.ascend_byte(),)*
+                    }
+                }
+
+                fn ascend_until(&mut self) -> usize {
                     match self {
                         #(#variant_arms => inner.ascend_until(),)*
                     }
                 }
 
-                fn ascend_until_branch(&mut self) -> bool {
+                fn ascend_until_branch(&mut self) -> usize {
                     match self {
                         #(#variant_arms => inner.ascend_until_branch(),)*
                     }
                 }
+
+                fn to_next_sibling_byte(&mut self) -> Option<u8> {
+                    match self {
+                        #(#variant_arms => inner.to_next_sibling_byte(),)*
+                    }
+                }
+
+                fn to_prev_sibling_byte(&mut self) -> Option<u8> {
+                    match self {
+                        #(#variant_arms => inner.to_prev_sibling_byte(),)*
+                    }
+                }
+
+                fn to_next_step(&mut self) -> bool {
+                    match self {
+                        #(#variant_arms => inner.to_next_step(),)*
+                    }
+                }
             }
         }
     };
@@ -447,6 +538,7 @@ pub fn derive_poly_zipper(input: TokenStream) -> TokenStream {
         #zipper_read_only_values_impl
         #zipper_read_only_conditional_values_impl
         // #zipper_forking_impl
+        #zipper_path_impl
         #zipper_moving_impl
         #zipper_concrete_impl
         #zipper_absolute_path_impl