Use a boxed slice instead of a vec (#718)

firewood/src/stream.rs

@@ -375,6 +375,7 @@ enum PathIteratorState<'a> {
 }
 
 /// Iterates over all nodes on the path to a given key starting from the root.
+///
 /// All nodes are branch nodes except possibly the last, which may be a leaf.
 /// All returned nodes have keys which are a prefix of the given key.
 /// If the given key is in the trie, the last node is at that key.
@@ -1262,9 +1263,8 @@ mod tests {
         let mut merkle = create_test_merkle();
 
         let keys: Vec<_> = children
-            .map(|key| {
-                merkle.insert(&key, key.clone().into()).unwrap();
-                key
+            .inspect(|key| {
+                merkle.insert(key, key.clone().into()).unwrap();
             })
             .collect();
 

firewood/src/v2/propose.rs

@@ -68,7 +68,7 @@ impl<T: api::DbView> Clone for ProposalBase<T> {
 #[derive(Debug)]
 pub struct Proposal<T> {
     pub(crate) base: ProposalBase<T>,
-    pub(crate) delta: BTreeMap<Vec<u8>, KeyOp<Vec<u8>>>,
+    pub(crate) delta: BTreeMap<Box<[u8]>, KeyOp<Box<[u8]>>>,
 }
 
 // Implement Clone because T doesn't need to be Clone
@@ -90,12 +90,15 @@ impl<T> Proposal<T> {
         let delta = batch
             .into_iter()
             .map(|op| match op {
-                api::BatchOp::Put { key, value } => {
-                    (key.as_ref().to_vec(), KeyOp::Put(value.as_ref().to_vec()))
+                api::BatchOp::Put { key, value } => (
+                    key.as_ref().to_vec().into_boxed_slice(),
+                    KeyOp::Put(value.as_ref().to_vec().into_boxed_slice()),
+                ),
+                api::BatchOp::Delete { key } => {
+                    (key.as_ref().to_vec().into_boxed_slice(), KeyOp::Delete)
                 }
-                api::BatchOp::Delete { key } => (key.as_ref().to_vec(), KeyOp::Delete),
             })
-            .collect();
+            .collect::<BTreeMap<_, _>>();
 
         Arc::new(Self { base, delta })
     }
@@ -115,7 +118,7 @@ impl<T: api::DbView + Send + Sync> api::DbView for Proposal<T> {
         match self.delta.get(key.as_ref()) {
             Some(change) => match change {
                 // key in proposal, check for Put or Delete
-                KeyOp::Put(val) => Ok(Some(val.clone().into_boxed_slice())),
+                KeyOp::Put(val) => Ok(Some(val.clone())),
                 KeyOp::Delete => Ok(None), // key was deleted in this proposal
             },
             None => match &self.base {

storage/src/nodestore.rs

@@ -240,6 +240,7 @@ impl<S: ReadableStorage> NodeStore<Committed, S> {
 }
 
 /// Some nodestore kinds implement Parentable.
+///
 /// This means that the nodestore can have children.
 /// Only [ImmutableProposal] and [Committed] implement this trait.
 /// [MutableProposal] does not implement this trait because it is not a valid parent.
@@ -709,6 +710,7 @@ where
 }
 
 /// Contains the state of a revision of a merkle trie.
+///
 /// The first generic parameter is the type of the revision, which supports reading nodes from parent proposals.
 /// The second generic parameter is the type of the storage used, either
 /// in-memory or on-disk.