diff --git a/src/layer/builder.rs b/src/layer/builder.rs
index d7e64034..f0b8f3d5 100644
--- a/src/layer/builder.rs
+++ b/src/layer/builder.rs
@@ -65,11 +65,8 @@ impl<F: 'static + FileLoad + FileStore> DictionarySetFileBuilder<F> {
     ///
     /// Panics if the given predicate string is not a lexical successor of the previous node string.
     pub fn add_predicate(&mut self, predicate: &str) -> u64 {
-        let id = self
-            .predicate_dictionary_builder
-            .add(Bytes::copy_from_slice(predicate.as_bytes()));
-
-        id
+        self.predicate_dictionary_builder
+            .add(Bytes::copy_from_slice(predicate.as_bytes()))
     }
 
     pub fn add_predicate_bytes(&mut self, predicate: Bytes) -> u64 {
@@ -82,9 +79,7 @@ impl<F: 'static + FileLoad + FileStore> DictionarySetFileBuilder<F> {
     ///
     /// Panics if the given value string is not a lexical successor of the previous value string.
     pub fn add_value(&mut self, value: TypedDictEntry) -> u64 {
-        let id = self.value_dictionary_builder.add(value);
-
-        id
+        self.value_dictionary_builder.add(value)
     }
 
     /// Add nodes from an iterable.
diff --git a/src/layer/internal/base.rs b/src/layer/internal/base.rs
index d1b2033d..ad83b0d9 100644
--- a/src/layer/internal/base.rs
+++ b/src/layer/internal/base.rs
@@ -173,9 +173,7 @@ impl<F: 'static + FileLoad + FileStore + Clone> BaseLayerFileBuilder<F> {
     ///
     /// Panics if the given node string is not a lexical successor of the previous node string.
     pub fn add_node(&mut self, node: &str) -> u64 {
-        let id = self.builder.add_node(node);
-
-        id
+        self.builder.add_node(node)
     }
 
     pub fn add_node_bytes(&mut self, node: Bytes) -> u64 {
@@ -186,9 +184,7 @@ impl<F: 'static + FileLoad + FileStore + Clone> BaseLayerFileBuilder<F> {
     ///
     /// Panics if the given predicate string is not a lexical successor of the previous node string.
     pub fn add_predicate(&mut self, predicate: &str) -> u64 {
-        let id = self.builder.add_predicate(predicate);
-
-        id
+        self.builder.add_predicate(predicate)
     }
 
     pub fn add_predicate_bytes(&mut self, predicate: Bytes) -> u64 {
@@ -199,9 +195,7 @@ impl<F: 'static + FileLoad + FileStore + Clone> BaseLayerFileBuilder<F> {
     ///
     /// Panics if the given value string is not a lexical successor of the previous value string.
     pub fn add_value(&mut self, value: TypedDictEntry) -> u64 {
-        let id = self.builder.add_value(value);
-
-        id
+        self.builder.add_value(value)
     }
 
     /// Add nodes from an iterable.
@@ -215,9 +209,7 @@ impl<F: 'static + FileLoad + FileStore + Clone> BaseLayerFileBuilder<F> {
         <I as std::iter::IntoIterator>::IntoIter: Unpin + Send + Sync,
         I: Unpin + Sync,
     {
-        let ids = self.builder.add_nodes(nodes);
-
-        ids
+        self.builder.add_nodes(nodes)
     }
 
     pub fn add_nodes_bytes<I: 'static + IntoIterator<Item = Bytes> + Send>(
@@ -244,9 +236,7 @@ impl<F: 'static + FileLoad + FileStore + Clone> BaseLayerFileBuilder<F> {
         <I as std::iter::IntoIterator>::IntoIter: Unpin + Send + Sync,
         I: Unpin + Sync,
     {
-        let ids = self.builder.add_predicates(predicates);
-
-        ids
+        self.builder.add_predicates(predicates)
     }
 
     pub fn add_predicates_bytes<I: 'static + IntoIterator<Item = Bytes> + Send>(
@@ -273,9 +263,7 @@ impl<F: 'static + FileLoad + FileStore + Clone> BaseLayerFileBuilder<F> {
         <I as std::iter::IntoIterator>::IntoIter: Unpin + Send + Sync,
         I: Unpin + Sync,
     {
-        let ids = self.builder.add_values(values);
-
-        ids
+        self.builder.add_values(values)
     }
 
     /// Turn this builder into a phase 2 builder that will take triple data.
diff --git a/src/layer/internal/mod.rs b/src/layer/internal/mod.rs
index cd8d3455..2651a98d 100644
--- a/src/layer/internal/mod.rs
+++ b/src/layer/internal/mod.rs
@@ -524,10 +524,7 @@ impl InternalLayer {
     }
 
     pub fn is_rollup(&self) -> bool {
-        match self {
-            Rollup(_) => true,
-            _ => false,
-        }
+        matches!(self, Rollup(_))
     }
 }
 
@@ -635,7 +632,7 @@ impl Layer for InternalLayer {
                 parent_count = parent_count
                     - current_layer.node_dict_len() as u64
                     - current_layer.value_dict_len() as u64;
-                if corrected_id > parent_count as u64 {
+                if corrected_id > parent_count {
                     // subject, if it exists, is in this layer
                     corrected_id -= parent_count;
                 } else {
@@ -666,7 +663,7 @@ impl Layer for InternalLayer {
             let mut corrected_id = id;
             if let Some(parent) = current_layer.immediate_parent() {
                 parent_count -= current_layer.predicate_dict_len() as u64;
-                if corrected_id > parent_count as u64 {
+                if corrected_id > parent_count {
                     // subject, if it exists, is in this layer
                     corrected_id -= parent_count;
                 } else {
diff --git a/src/layer/internal/object_iterator.rs b/src/layer/internal/object_iterator.rs
index aa2faf9e..e130cfa5 100644
--- a/src/layer/internal/object_iterator.rs
+++ b/src/layer/internal/object_iterator.rs
@@ -22,10 +22,10 @@ impl InternalLayerTripleObjectIterator {
         s_p_adjacency_list: AdjacencyList,
     ) -> Self {
         Self {
-            subjects: subjects,
-            objects: objects,
-            o_ps_adjacency_list: o_ps_adjacency_list,
-            s_p_adjacency_list: s_p_adjacency_list,
+            subjects,
+            objects,
+            o_ps_adjacency_list,
+            s_p_adjacency_list,
             o_position: 0,
             o_ps_position: 0,
             peeked: None,
diff --git a/src/layer/internal/subject_iterator.rs b/src/layer/internal/subject_iterator.rs
index 7321d349..1c8b1cdd 100644
--- a/src/layer/internal/subject_iterator.rs
+++ b/src/layer/internal/subject_iterator.rs
@@ -22,9 +22,9 @@ impl InternalLayerTripleSubjectIterator {
         sp_o_adjacency_list: AdjacencyList,
     ) -> Self {
         Self {
-            subjects: subjects,
-            s_p_adjacency_list: s_p_adjacency_list,
-            sp_o_adjacency_list: sp_o_adjacency_list,
+            subjects,
+            s_p_adjacency_list,
+            sp_o_adjacency_list,
             s_position: 0,
             s_p_position: 0,
             sp_o_position: 0,
@@ -422,7 +422,7 @@ impl Iterator for InternalTripleStackIterator {
                 (Some(lowest_pos_index), Some(lowest_neg_index)) => {
                     let lowest_pos = self.positives[lowest_pos_index].peek().unwrap();
                     let lowest_neg = self.negatives[lowest_neg_index].peek().unwrap();
-                    match lowest_pos.cmp(&lowest_neg) {
+                    match lowest_pos.cmp(lowest_neg) {
                         Ordering::Less => {
                             // next change is an addition, and there's no matching removal
                             return Some((
@@ -479,7 +479,7 @@ mod tests {
 
     #[tokio::test]
     async fn base_triple_removal_iterator() {
-        let base_layer: InternalLayer = example_base_layer().await.into();
+        let base_layer: InternalLayer = example_base_layer().await;
 
         let triples: Vec<_> = base_layer.internal_triple_removals().collect();
         assert!(triples.is_empty());
@@ -811,7 +811,7 @@ mod tests {
 
     async fn child_layer() -> InternalLayer {
         let base_layer = example_base_layer().await;
-        let parent: Arc<InternalLayer> = Arc::new(base_layer.into());
+        let parent: Arc<InternalLayer> = Arc::new(base_layer);
 
         let child_files = child_layer_files();
 
@@ -830,7 +830,6 @@ mod tests {
         ChildLayer::load_from_files([5, 4, 3, 2, 1], parent, &child_files)
             .await
             .unwrap()
-            .into()
     }
 
     #[tokio::test]
@@ -1032,7 +1031,7 @@ mod tests {
     async fn iterate_partial_stack() {
         let (parent_id, layer) = create_stack_for_partial_tests().await;
 
-        let iterator = InternalTripleStackIterator::from_layer_stack(&*layer, parent_id).unwrap();
+        let iterator = InternalTripleStackIterator::from_layer_stack(&layer, parent_id).unwrap();
         let changes: Vec<_> = iterator
             .map(|t| (t.0, layer.id_triple_to_string(&t.1).unwrap()))
             .collect();
diff --git a/src/layer/layer.rs b/src/layer/layer.rs
index 51652384..7b4ed487 100644
--- a/src/layer/layer.rs
+++ b/src/layer/layer.rs
@@ -98,8 +98,8 @@ pub trait Layer: Send + Sync {
         self.subject_id(&triple.subject).and_then(|subject| {
             self.predicate_id(&triple.predicate).and_then(|predicate| {
                 match &triple.object {
-                    ObjectType::Node(node) => self.object_node_id(&node),
-                    ObjectType::Value(value) => self.object_value_id(&value),
+                    ObjectType::Node(node) => self.object_node_id(node),
+                    ObjectType::Value(value) => self.object_value_id(value),
                 }
                 .map(|object| IdTriple {
                     subject,
@@ -127,11 +127,11 @@ pub trait Layer: Send + Sync {
                 .unwrap_or(PossiblyResolved::Unresolved(triple.predicate)),
             object: match &triple.object {
                 ObjectType::Node(node) => self
-                    .object_node_id(&node)
+                    .object_node_id(node)
                     .map(PossiblyResolved::Resolved)
                     .unwrap_or(PossiblyResolved::Unresolved(triple.object)),
                 ObjectType::Value(value) => self
-                    .object_value_id(&value)
+                    .object_value_id(value)
                     .map(PossiblyResolved::Resolved)
                     .unwrap_or(PossiblyResolved::Unresolved(triple.object)),
             },
@@ -270,7 +270,7 @@ impl<T: Clone + PartialEq + Eq + PartialOrd + Ord + Hash> PossiblyResolved<T> {
     /// Return a PossiblyResolved with the inner value as a reference.
     pub fn as_ref(&self) -> PossiblyResolved<&T> {
         match self {
-            Self::Unresolved(u) => PossiblyResolved::Unresolved(&u),
+            Self::Unresolved(u) => PossiblyResolved::Unresolved(u),
             Self::Resolved(id) => PossiblyResolved::Resolved(*id),
         }
     }
@@ -426,8 +426,7 @@ mod tests {
         let base: Arc<InternalLayer> = Arc::new(
             BaseLayer::load_from_files([1, 2, 3, 4, 5], &files)
                 .await
-                .unwrap()
-                .into(),
+                .unwrap(),
         );
 
         let files = child_layer_files();
@@ -439,8 +438,7 @@ mod tests {
         let child: Arc<InternalLayer> = Arc::new(
             ChildLayer::load_from_files([5, 4, 3, 2, 1], base.clone(), &files)
                 .await
-                .unwrap()
-                .into(),
+                .unwrap(),
         );
 
         // TODO why are we not using these results?
@@ -633,8 +631,7 @@ mod tests {
         let base: Arc<InternalLayer> = Arc::new(
             BaseLayer::load_from_files([1, 2, 3, 4, 5], &files)
                 .await
-                .unwrap()
-                .into(),
+                .unwrap(),
         );
 
         let mut results: Vec<_> = base
diff --git a/src/layer/simple_builder.rs b/src/layer/simple_builder.rs
index 90c4a23e..81c25bb7 100644
--- a/src/layer/simple_builder.rs
+++ b/src/layer/simple_builder.rs
@@ -287,7 +287,7 @@ fn zero_equivalents(
     let mut removals_iter = removals.iter_mut().peekable();
     'outer: for mut addition in additions {
         let mut next = removals_iter.peek();
-        if next == None {
+        if next.is_none() {
             break;
         }
 
@@ -296,7 +296,7 @@ fn zero_equivalents(
                 removals_iter.next().unwrap();
                 next = removals_iter.peek();
 
-                if next == None {
+                if next.is_none() {
                     break 'outer;
                 } else if next >= Some(&addition) {
                     break;
diff --git a/src/storage/archive.rs b/src/storage/archive.rs
index 41af06ac..6a7d146a 100644
--- a/src/storage/archive.rs
+++ b/src/storage/archive.rs
@@ -608,11 +608,7 @@ impl ConstructionFile {
 
     fn is_finalized(&self) -> bool {
         let guard = self.0.read().unwrap();
-        if let ConstructionFileState::Finalized(_) = &*guard {
-            true
-        } else {
-            false
-        }
+        matches!(&*guard, ConstructionFileState::Finalized(_))
     }
 
     fn finalized_buf(self) -> Bytes {
@@ -953,7 +949,7 @@ impl AsyncRead for ArchiveSliceReader {
         }
 
         let read = AsyncRead::poll_read(Pin::new(&mut self.file), cx, buf);
-        if let Poll::Pending = read {
+        if read.is_pending() {
             return Poll::Pending;
         }
 
diff --git a/src/storage/consts.rs b/src/storage/consts.rs
index bae2d668..b6a66766 100644
--- a/src/storage/consts.rs
+++ b/src/storage/consts.rs
@@ -505,7 +505,7 @@ lazy_static! {
     ]);
 }
 
-pub const SHARED_REQUIRED_FILES: [&'static str; 8] = [
+pub const SHARED_REQUIRED_FILES: [&str; 8] = [
     FILENAMES.node_dictionary_blocks,
     FILENAMES.node_dictionary_offsets,
     FILENAMES.predicate_dictionary_blocks,
@@ -516,7 +516,7 @@ pub const SHARED_REQUIRED_FILES: [&'static str; 8] = [
     FILENAMES.value_dictionary_offsets,
 ];
 
-pub const SHARED_OPTIONAL_FILES: [&'static str; 7] = [
+pub const SHARED_OPTIONAL_FILES: [&str; 7] = [
     FILENAMES.node_value_idmap_bits,
     FILENAMES.node_value_idmap_bit_index_blocks,
     FILENAMES.node_value_idmap_bit_index_sblocks,
@@ -526,7 +526,7 @@ pub const SHARED_OPTIONAL_FILES: [&'static str; 7] = [
     FILENAMES.rollup,
 ];
 
-pub const BASE_LAYER_REQUIRED_FILES: [&'static str; 15] = [
+pub const BASE_LAYER_REQUIRED_FILES: [&str; 15] = [
     FILENAMES.base_s_p_adjacency_list_nums,
     FILENAMES.base_s_p_adjacency_list_bits,
     FILENAMES.base_s_p_adjacency_list_bit_index_blocks,
@@ -544,10 +544,9 @@ pub const BASE_LAYER_REQUIRED_FILES: [&'static str; 15] = [
     FILENAMES.base_predicate_wavelet_tree_bit_index_sblocks,
 ];
 
-pub const BASE_LAYER_OPTIONAL_FILES: [&'static str; 2] =
-    [FILENAMES.base_subjects, FILENAMES.base_objects];
+pub const BASE_LAYER_OPTIONAL_FILES: [&str; 2] = [FILENAMES.base_subjects, FILENAMES.base_objects];
 
-pub const CHILD_LAYER_REQUIRED_FILES: [&'static str; 31] = [
+pub const CHILD_LAYER_REQUIRED_FILES: [&str; 31] = [
     FILENAMES.parent,
     FILENAMES.pos_s_p_adjacency_list_nums,
     FILENAMES.pos_s_p_adjacency_list_bits,
@@ -581,7 +580,7 @@ pub const CHILD_LAYER_REQUIRED_FILES: [&'static str; 31] = [
     FILENAMES.neg_predicate_wavelet_tree_bit_index_sblocks,
 ];
 
-pub const CHILD_LAYER_OPTIONAL_FILES: [&'static str; 4] = [
+pub const CHILD_LAYER_OPTIONAL_FILES: [&str; 4] = [
     FILENAMES.pos_subjects,
     FILENAMES.pos_objects,
     FILENAMES.neg_subjects,
diff --git a/src/storage/delta.rs b/src/storage/delta.rs
index fb291899..01b65096 100644
--- a/src/storage/delta.rs
+++ b/src/storage/delta.rs
@@ -19,7 +19,7 @@ async fn safe_upto_bound<S: LayerStore>(
         .retrieve_layer_stack_names_upto(layer.name(), upto)
         .await?;
 
-    let mut l = &*layer;
+    let mut l = layer;
     loop {
         let parent = match l.immediate_parent() {
             None => {
@@ -487,8 +487,7 @@ mod tests {
         let delta_layer: Arc<InternalLayer> = Arc::new(
             BaseLayer::load_from_files([0, 0, 0, 0, 4], &delta_files)
                 .await
-                .unwrap()
-                .into(),
+                .unwrap(),
         );
 
         let expected: Vec<_> = layer
diff --git a/src/storage/directory.rs b/src/storage/directory.rs
index 54702adc..342cffe0 100644
--- a/src/storage/directory.rs
+++ b/src/storage/directory.rs
@@ -193,7 +193,7 @@ impl DirectoryLabelStore {
 }
 
 fn get_label_from_data(name: String, data: &[u8]) -> io::Result<Label> {
-    let s = String::from_utf8_lossy(&data);
+    let s = String::from_utf8_lossy(data);
     let lines: Vec<&str> = s.lines().collect();
     if lines.len() != 2 {
         return Err(io::Error::new(
@@ -208,7 +208,7 @@ fn get_label_from_data(name: String, data: &[u8]) -> io::Result<Label> {
     let version_str = &lines[0];
     let layer_str = &lines[1];
 
-    let version = u64::from_str_radix(version_str, 10);
+    let version = version_str.parse::<u64>();
     if version.is_err() {
         return Err(io::Error::new(
             io::ErrorKind::InvalidData,
@@ -562,7 +562,7 @@ mod tests {
 
         let map = file.map().await.unwrap();
 
-        assert_eq!(&vec![1, 2, 3][..], &map.as_ref()[..]);
+        assert_eq!(&vec![1, 2, 3][..], map.as_ref());
     }
 
     #[tokio::test]
diff --git a/src/storage/file.rs b/src/storage/file.rs
index 78e85dee..c7cefbc0 100644
--- a/src/storage/file.rs
+++ b/src/storage/file.rs
@@ -402,9 +402,9 @@ pub struct BitIndexMaps {
     pub sblocks_map: Bytes,
 }
 
-impl Into<BitIndex> for BitIndexMaps {
-    fn into(self) -> BitIndex {
-        BitIndex::from_maps(self.bits_map, self.blocks_map, self.sblocks_map)
+impl From<BitIndexMaps> for BitIndex {
+    fn from(val: BitIndexMaps) -> Self {
+        BitIndex::from_maps(val.bits_map, val.blocks_map, val.sblocks_map)
     }
 }
 
@@ -443,13 +443,13 @@ pub struct AdjacencyListMaps {
     pub nums_map: Bytes,
 }
 
-impl Into<AdjacencyList> for AdjacencyListMaps {
-    fn into(self) -> AdjacencyList {
+impl From<AdjacencyListMaps> for AdjacencyList {
+    fn from(val: AdjacencyListMaps) -> Self {
         AdjacencyList::parse(
-            self.nums_map,
-            self.bitindex_maps.bits_map,
-            self.bitindex_maps.blocks_map,
-            self.bitindex_maps.sblocks_map,
+            val.nums_map,
+            val.bitindex_maps.bits_map,
+            val.bitindex_maps.blocks_map,
+            val.bitindex_maps.sblocks_map,
         )
     }
 }
diff --git a/src/storage/layer.rs b/src/storage/layer.rs
index 80d01997..896ba6bc 100644
--- a/src/storage/layer.rs
+++ b/src/storage/layer.rs
@@ -1491,12 +1491,11 @@ impl<F: 'static + FileLoad + FileStore + Clone, T: 'static + PersistentLayerStor
                             panic!("infinite rollup loop for layer {:?}", rollup);
                         }
 
-                        let original_parent;
-                        if self.layer_has_parent(current_layer).await? {
-                            original_parent = Some(self.read_parent_file(current_layer).await?);
+                        let original_parent = if self.layer_has_parent(current_layer).await? {
+                            Some(self.read_parent_file(current_layer).await?)
                         } else {
-                            original_parent = None;
-                        }
+                            None
+                        };
 
                         layers_to_load.pop().unwrap(); // we don't want to load this, we want to load the rollup instead!
                         layers_to_load.push((current_layer, Some((rollup, original_parent))));
@@ -1519,12 +1518,12 @@ impl<F: 'static + FileLoad + FileStore + Clone, T: 'static + PersistentLayerStor
                     let files = self.base_layer_files(base_id).await?;
                     let base_layer = BaseLayer::load_from_files(base_id, &files).await?;
 
-                    layer = Arc::new(base_layer.into());
+                    layer = Arc::new(base_layer);
                 }
                 Some((rollup_id, original_parent_id_option)) => {
                     let files = self.base_layer_files(rollup_id).await?;
                     let base_layer: Arc<InternalLayer> =
-                        Arc::new(BaseLayer::load_from_files(rollup_id, &files).await?.into());
+                        Arc::new(BaseLayer::load_from_files(rollup_id, &files).await?);
                     cache.cache_layer(base_layer.clone());
 
                     layer = Arc::new(
@@ -1552,18 +1551,15 @@ impl<F: 'static + FileLoad + FileStore + Clone, T: 'static + PersistentLayerStor
                     let files = self.child_layer_files(layer_id).await?;
                     let child_layer =
                         ChildLayer::load_from_files(layer_id, ancestor, &files).await?;
-                    layer = Arc::new(child_layer.into());
+                    layer = Arc::new(child_layer);
                 }
                 Some((rollup_id, original_parent_id_option)) => {
                     let original_parent_id = original_parent_id_option
                         .expect("child rollup layer should always have original parent id");
 
                     let files = self.child_layer_files(rollup_id).await?;
-                    let child_layer: Arc<InternalLayer> = Arc::new(
-                        ChildLayer::load_from_files(rollup_id, ancestor, &files)
-                            .await?
-                            .into(),
-                    );
+                    let child_layer: Arc<InternalLayer> =
+                        Arc::new(ChildLayer::load_from_files(rollup_id, ancestor, &files).await?);
                     cache.cache_layer(child_layer.clone());
 
                     layer = Arc::new(
diff --git a/src/storage/locking.rs b/src/storage/locking.rs
index d55fe33a..b248836d 100644
--- a/src/storage/locking.rs
+++ b/src/storage/locking.rs
@@ -52,11 +52,9 @@ impl Future for LockedFileLockFuture {
                     if exclusive {
                         file.lock_exclusive()
                             .expect("failed to acquire exclusive lock")
-                    } else {
-                        if !cfg!(feature = "noreadlock") {
-                            file.lock_shared()
-                                .expect("failed to acquire exclusive lock")
-                        }
+                    } else if !cfg!(feature = "noreadlock") {
+                        file.lock_shared()
+                            .expect("failed to acquire exclusive lock")
                     }
                 }));
             }
diff --git a/src/storage/memory.rs b/src/storage/memory.rs
index 26150a5a..3dcbc30a 100644
--- a/src/storage/memory.rs
+++ b/src/storage/memory.rs
@@ -33,6 +33,12 @@ impl MemoryBackedStore {
     }
 }
 
+impl Default for MemoryBackedStore {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 pub struct MemoryBackedStoreWriter {
     file: MemoryBackedStore,
     bytes: BytesMut,
diff --git a/src/storage/pack.rs b/src/storage/pack.rs
index 88002a8e..0826b4c7 100644
--- a/src/storage/pack.rs
+++ b/src/storage/pack.rs
@@ -1,7 +1,7 @@
 use std::collections::{HashMap, HashSet};
 use std::fmt::Display;
 use std::io::{self, Read};
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use async_trait::async_trait;
@@ -138,7 +138,7 @@ async fn tar_append_file<S: PersistentLayerStore, W: io::Write>(
     store: &S,
     tar: &mut tar::Builder<W>,
     layer: [u32; 5],
-    layer_path: &PathBuf,
+    layer_path: &Path,
     file_name: &str,
     mtime: u64,
 ) -> io::Result<()> {
@@ -168,7 +168,7 @@ async fn tar_append_file_if_exists<S: PersistentLayerStore, W: io::Write>(
     store: &S,
     tar: &mut tar::Builder<W>,
     layer: [u32; 5],
-    layer_path: &PathBuf,
+    layer_path: &Path,
     file_name: &str,
     mtime: u64,
 ) -> io::Result<()> {
diff --git a/src/store/mod.rs b/src/store/mod.rs
index 3c776171..6e2dbf04 100644
--- a/src/store/mod.rs
+++ b/src/store/mod.rs
@@ -136,12 +136,10 @@ impl StoreLayerBuilder {
         }
 
         match builder {
-            None => {
-                return Err(io::Error::new(
-                    io::ErrorKind::InvalidData,
-                    "builder has already been committed",
-                ))
-            }
+            None => Err(io::Error::new(
+                io::ErrorKind::InvalidData,
+                "builder has already been committed",
+            )),
             Some(builder) => {
                 let id = builder.name();
                 builder.commit_boxed().await?;
diff --git a/src/structure/adjacencylist.rs b/src/structure/adjacencylist.rs
index 1eb780b8..3529d81b 100644
--- a/src/structure/adjacencylist.rs
+++ b/src/structure/adjacencylist.rs
@@ -52,7 +52,7 @@ impl AdjacencyList {
     }
 
     pub fn left_count(&self) -> usize {
-        if self.bits.len() == 0 {
+        if self.bits.is_empty() {
             0
         } else {
             self.bits.rank1((self.bits.len() as u64) - 1) as usize
diff --git a/src/structure/bitindex.rs b/src/structure/bitindex.rs
index 76b4c117..25c78284 100644
--- a/src/structure/bitindex.rs
+++ b/src/structure/bitindex.rs
@@ -66,6 +66,10 @@ impl BitIndex {
         self.array.len()
     }
 
+    pub fn is_empty(&self) -> bool {
+        self.array.is_empty()
+    }
+
     /// Returns the bit at the given index.
     pub fn get(&self, index: u64) -> bool {
         self.array.get(index as usize)
@@ -243,7 +247,7 @@ impl BitIndex {
                 subrank -= 1;
 
                 if subrank == 0 {
-                    return Some(i as u64);
+                    return Some(i);
                 }
             }
         }
@@ -450,8 +454,7 @@ pub fn build_bitindex_from_block_iter<'a, I: Iterator<Item = u64>, B1: BufMut, B
     // we chunk block_stream into blocks of SBLOCK size for further processing
     let mut sblock_rank = 0;
     let chunks = blocks_iter.chunks(SBLOCK_SIZE);
-    let mut iter = chunks.into_iter();
-    while let Some(chunk) = iter.next() {
+    for chunk in chunks.into_iter() {
         let chunk: Vec<_> = chunk.collect();
         let mut block_ranks = Vec::with_capacity(chunk.len());
         for num in chunk {
diff --git a/src/structure/logarray.rs b/src/structure/logarray.rs
index 02ea0f87..55b434c5 100644
--- a/src/structure/logarray.rs
+++ b/src/structure/logarray.rs
@@ -244,10 +244,8 @@ fn read_control_word_trailing(
 
 fn logarray_length_from_len_width(len: u32, width: u8) -> usize {
     let num_bits = width as usize * len as usize;
-    let num_u64 = num_bits / 64 + (if num_bits % 64 == 0 { 0 } else { 1 });
-    let num_bytes = num_u64 * 8;
-
-    num_bytes
+    let num_u64 = num_bits / 64 + (usize::from(num_bits % 64 != 0));
+    num_u64 * 8
 }
 
 pub fn logarray_length_from_control_word(buf: &[u8]) -> usize {
@@ -434,7 +432,7 @@ impl<'a, B: BufMut> LogArrayBufBuilder<'a, B> {
         let leading_zeros = u64::BITS - self.width as u32;
 
         // If `val` does not fit in the `width`, return an error.
-        if val.leading_zeros() < u32::from(leading_zeros) {
+        if val.leading_zeros() < leading_zeros {
             panic!("expected value ({}) to fit in {} bits", val, self.width);
         }
 
@@ -975,7 +973,7 @@ mod tests {
 
     #[test]
     fn validate_input_buf_size() {
-        let val = |buf_size| LogArrayError::validate_input_buf_size(buf_size);
+        let val = LogArrayError::validate_input_buf_size;
         let err = |buf_size| Err(LogArrayError::InputBufferTooSmall(buf_size));
         assert_eq!(err(7), val(7));
         assert_eq!(Ok(()), val(8));
@@ -985,8 +983,7 @@ mod tests {
 
     #[test]
     fn validate_len_and_width() {
-        let val =
-            |buf_size, len, width| LogArrayError::validate_len_and_width(buf_size, len, width);
+        let val = LogArrayError::validate_len_and_width;
 
         let err = |width| Err(LogArrayError::WidthTooLarge(width));
 
@@ -1080,24 +1077,18 @@ mod tests {
     }
 
     const TEST0_DATA: [u8; 8] = [
-        0b00000000,
-        0b00000000,
-        0b1_0000000,
-        0b00000000,
-        0b10_000000,
-        0b00000000,
-        0b011_00000,
+        0b00000000, 0b00000000, 0b10000000, 0b00000000, 0b10000000, 0b00000000, 0b01100000,
         0b00000000,
     ];
     const TEST0_CONTROL: [u8; 8] = [0, 0, 0, 3, 17, 0, 0, 0];
     const TEST1_DATA: [u8; 8] = [
         0b0100_0000,
         0b00000000,
-        0b00101_000,
+        0b00101000,
         0b00000000,
         0b000110_00,
         0b00000000,
-        0b0000111_0,
+        0b00001110,
         0b00000000,
     ];
 
diff --git a/src/structure/smallbitarray.rs b/src/structure/smallbitarray.rs
index b7108c43..23cd9646 100644
--- a/src/structure/smallbitarray.rs
+++ b/src/structure/smallbitarray.rs
@@ -62,7 +62,7 @@ impl Iterator for SmallBitArrayIter {
             return None;
         }
 
-        let result = (self.val & 0x80000000_00000000) != 0;
+        let result = (self.val & 0x8000_0000_0000_0000) != 0;
 
         self.val <<= 1;
         self.ix += 1;
@@ -79,13 +79,15 @@ mod tests {
         expected = "lsb set for a small bit array. this is reserved for future expansion"
     )]
     fn panic_with_set_lsb() {
-        let val: u64 = 0b01101011_10111001_10010010_00000111_10010001_01100101_00000000_11111111;
+        let val: u64 =
+            0b0110_1011_1011_1001_1001_0010_0000_0111_1001_0001_0110_0101_0000_0000_1111_1111;
 
         let _x = SmallBitArray::new(val);
     }
     #[test]
     fn get_from_small_bit_array() {
-        let val: u64 = 0b01101011_10111001_10010010_00000111_10010001_01100101_00000000_11111110;
+        let val: u64 =
+            0b0110_1011_1011_1001_1001_0010_0000_0111_1001_0001_0110_0101_0000_0000_1111_1110;
 
         let arr = SmallBitArray::new(val);
 
@@ -108,7 +110,8 @@ mod tests {
     #[test]
 
     fn iterate_small_bit_array() {
-        let val: u64 = 0b01101011_10111001_10010010_00000111_10010001_01100101_00000000_11111110;
+        let val: u64 =
+            0b0110_1011_1011_1001_1001_0010_0000_0111_1001_0001_0110_0101_0000_0000_1111_1110;
 
         let arr = SmallBitArray::new(val);
 
@@ -133,7 +136,8 @@ mod tests {
 
     #[test]
     fn small_bit_array_rank() {
-        let val: u64 = 0b01101011_10111001_10010010_00000111_10010001_01100101_00000000_11111110;
+        let val: u64 =
+            0b0110_1011_1011_1001_1001_0010_0000_0111_1001_0001_0110_0101_0000_0000_1111_1110;
 
         let arr = SmallBitArray::new(val);
 
diff --git a/src/structure/tfc/block.rs b/src/structure/tfc/block.rs
index 95e061f7..35282712 100644
--- a/src/structure/tfc/block.rs
+++ b/src/structure/tfc/block.rs
@@ -49,11 +49,10 @@ impl SizedBlockHeader {
 
         for i in 0..(num_entries - 1) as usize {
             let (shared, _) = vbyte::decode_buf(buf)?;
-            let size = if record_size == None {
-                let (size, _) = vbyte::decode_buf(buf)?;
-                size
+            let size = if let Some(record_size) = record_size {
+                record_size as u64 - shared
             } else {
-                record_size.unwrap() as u64 - shared
+                vbyte::decode_buf(buf)?.0
             };
             sizes[i] = size as usize;
             shareds[i] = shared as usize;
@@ -163,6 +162,10 @@ impl SizedDictEntry {
         self.chunks().map(|s| s.len()).sum()
     }
 
+    pub fn is_empty(&self) -> bool {
+        self.chunks().next().is_none()
+    }
+
     fn rope_len(&self) -> usize {
         match self {
             Self::Single(_) => 1,
@@ -191,7 +194,7 @@ impl SizedDictEntry {
     pub fn buf_eq<B: Buf>(&self, mut b: B) -> bool {
         if self.len() != b.remaining() {
             false
-        } else if self.len() == 0 {
+        } else if self.is_empty() {
             true
         } else {
             let mut it = self.chunks();
@@ -249,7 +252,7 @@ impl Hash for SizedDictEntry {
 impl Ord for SizedDictEntry {
     fn cmp(&self, other: &Self) -> Ordering {
         // both are empty, so equal
-        if self.len() == 0 && other.len() == 0 {
+        if self.is_empty() && other.is_empty() {
             return Ordering::Equal;
         }
 
@@ -335,7 +338,7 @@ pub struct SizedDictEntryBuf<'a> {
 impl<'a> SizedDictEntryBuf<'a> {
     fn current_slice(&self) -> &Bytes {
         match self.entry.as_ref() {
-            SizedDictEntry::Single(b) => &b,
+            SizedDictEntry::Single(b) => b,
             SizedDictEntry::Rope(v) => &v[self.slice_ix],
         }
     }
@@ -485,13 +488,12 @@ impl SizedDictBlock {
                 continue;
             }
 
-            let slice;
-            if ix == 0 && start == 0 {
+            let slice = if ix == 0 && start == 0 {
                 // the slice has to come out of the header
-                slice = self.header.head.slice(..have_to_take);
+                self.header.head.slice(..have_to_take)
             } else {
-                slice = self.data.slice(cur_offset..cur_offset + have_to_take);
-            }
+                self.data.slice(cur_offset..cur_offset + have_to_take)
+            };
             slices.push(slice);
             taken += have_to_take;
         }
@@ -502,7 +504,7 @@ impl SizedDictBlock {
         SizedDictEntry::new_optimized(slices)
     }
 
-    fn suffixes<'a>(&'a self) -> impl Iterator<Item = Bytes> + 'a {
+    fn suffixes(&self) -> impl Iterator<Item = Bytes> + '_ {
         let head = Some(self.header.head.clone());
         let mut offset = 0;
         let tail = self.header.sizes.iter().map(move |s| {
@@ -531,11 +533,17 @@ impl SizedDictBlock {
             .zip(self.suffixes().skip(1))
             .enumerate()
         {
+            match (*shared).cmp(&common_prefix) {
+                Ordering::Less => return IdLookupResult::Closest(ix as u64),
+                Ordering::Equal => (),
+                Ordering::Greater => continue,
+            };
+            /*
             if *shared < common_prefix {
                 return IdLookupResult::Closest(ix as u64);
             } else if *shared > common_prefix {
                 continue;
-            }
+            }*/
 
             let (new_common_prefix, ordering) =
                 find_common_prefix_ord(&slice[common_prefix..], &suffix[..]);
@@ -551,7 +559,7 @@ impl SizedDictBlock {
         IdLookupResult::Closest(self.header.num_entries as u64 - 1)
     }
 
-    pub fn iter<'a>(&'a self) -> SizedBlockIterator<'a> {
+    pub fn iter(&self) -> SizedBlockIterator {
         SizedBlockIterator {
             header: Cow::Borrowed(&self.header),
             data: self.data.clone(),
@@ -563,7 +571,7 @@ impl SizedDictBlock {
     pub fn into_iter(self) -> OwnedSizedBlockIterator {
         SizedBlockIterator {
             header: Cow::Owned(self.header),
-            data: self.data.clone(),
+            data: self.data,
             ix: 0,
             last: None,
         }
@@ -698,7 +706,7 @@ pub(crate) fn build_block_unchecked<B: BufMut>(
     let slices_len = slices.len();
     debug_assert!(slices_len <= BLOCK_SIZE && slices_len != 0);
     let cw = create_block_control_word(record_size, slices_len as u8);
-    buf.put_u8(cw as u8);
+    buf.put_u8(cw);
     size += 1;
 
     let first = slices[0];
@@ -712,14 +720,13 @@ pub(crate) fn build_block_unchecked<B: BufMut>(
     let mut last = first;
 
     let mut suffixes: Vec<&[u8]> = Vec::with_capacity(slices.len());
-    for i in 1..slices.len() {
-        let cur = slices[i];
+    for cur in slices.iter().skip(1) {
         let common_prefix = find_common_prefix(last, cur);
         let (vbyte, vbyte_len) = encode_array(common_prefix as u64);
         buf.put_slice(&vbyte[..vbyte_len]);
         size += vbyte_len;
 
-        if record_size == None {
+        if record_size.is_none() {
             let suffix_len = cur.len() - common_prefix;
             let (vbyte, vbyte_len) = encode_array(suffix_len as u64);
             buf.put_slice(&vbyte[..vbyte_len]);
diff --git a/src/structure/tfc/decimal.rs b/src/structure/tfc/decimal.rs
index efdae823..fd4ed845 100644
--- a/src/structure/tfc/decimal.rs
+++ b/src/structure/tfc/decimal.rs
@@ -144,8 +144,8 @@ pub fn integer_and_fraction_to_storage(
     };
     let suffix = if is_neg {
         let mut suffix = encode_fraction(fraction);
-        for i in 0..suffix.len() {
-            suffix[i] = !suffix[i]
+        for item in &mut suffix {
+            *item = !*item
         }
         suffix
     } else {
diff --git a/src/structure/tfc/dict.rs b/src/structure/tfc/dict.rs
index ce4deee1..ed035265 100644
--- a/src/structure/tfc/dict.rs
+++ b/src/structure/tfc/dict.rs
@@ -66,7 +66,7 @@ impl<B1: BufMut, B2: BufMut> SizedDictBufBuilder<B1, B2> {
     }
 
     pub fn finalize(mut self) -> (LateLogArrayBufBuilder<B1>, B2, u64, u64) {
-        if self.current_block.len() > 0 {
+        if !self.current_block.is_empty() {
             let current_block: Vec<&[u8]> = self.current_block.iter().map(|e| e.as_ref()).collect();
             let size = build_block_unchecked(self.record_size, &mut self.data_buf, &current_block);
             self.block_offset += size as u64;
@@ -116,12 +116,11 @@ impl SizedDict {
     }
 
     fn block_offset(&self, block_index: usize) -> usize {
-        let offset: usize;
-        if block_index == 0 {
-            offset = 0;
+        let offset: usize = if block_index == 0 {
+            0
         } else {
-            offset = (self.offsets.entry(block_index - 1) - self.dict_offset) as usize;
-        }
+            (self.offsets.entry(block_index - 1) - self.dict_offset) as usize
+        };
 
         offset
     }
@@ -131,10 +130,7 @@ impl SizedDict {
             panic!("empty dictionary has no block");
         }
         let offset = self.block_offset(block_index);
-        let block_bytes;
-        block_bytes = self.data.slice(offset..);
-
-        block_bytes
+        self.data.slice(offset..)
     }
 
     pub fn block(&self, block_index: usize) -> SizedDictBlock {
@@ -168,8 +164,8 @@ impl SizedDict {
         if index > self.num_entries() {
             return None;
         }
-        let block = self.block(((index - 1) / 8) as usize);
-        Some(block.entry(((index - 1) % 8) as usize))
+        let block = self.block((index - 1) / 8);
+        Some(block.entry((index - 1) % 8))
     }
 
     pub fn id(&self, slice: &[u8]) -> IdLookupResult {
@@ -204,23 +200,10 @@ impl SizedDict {
         let block = self.block(found);
         let block_id = block.id(slice);
         let offset = (found * BLOCK_SIZE) as u64 + 1;
-        let result = block_id.offset(offset).default(offset - 1);
-        /*
-        if found != 0 {
-            // the default value will fill in the last index of the
-            // previous block if the entry was not found in the
-            // current block. This is only possible if the block as
-            // not the very first one.
-            result.default(self.block_num_elements(found - 1) as u64 + offset - 1)
-        } else {
-            result
-        }
-         */
-
-        result
+        block_id.offset(offset).default(offset - 1)
     }
 
-    pub fn block_iter<'a>(&'a self) -> SizedDictBlockIterator<'a> {
+    pub fn block_iter(&self) -> SizedDictBlockIterator {
         SizedDictBlockIterator {
             dict: Cow::Borrowed(self),
             index: 0,
@@ -234,7 +217,7 @@ impl SizedDict {
         }
     }
 
-    pub fn iter<'a>(&'a self) -> impl Iterator<Item = SizedDictEntry> + 'a + Clone {
+    pub fn iter(&self) -> impl Iterator<Item = SizedDictEntry> + '_ + Clone {
         self.block_iter().flat_map(|b| b.into_iter())
     }
 
@@ -356,7 +339,7 @@ mod tests {
         build_dict_and_offsets(
             &mut array_buf,
             &mut data_buf,
-            strings.clone().into_iter().map(|s| Bytes::from(s)),
+            strings.clone().into_iter().map(Bytes::from),
         );
 
         let array_bytes = array_buf.freeze();
diff --git a/src/structure/tfc/typed.rs b/src/structure/tfc/typed.rs
index 0a8d7455..5c7c78d0 100644
--- a/src/structure/tfc/typed.rs
+++ b/src/structure/tfc/typed.rs
@@ -141,7 +141,7 @@ impl TypedDict {
         } else {
             type_offset = self.type_offsets.entry(i - 1) as usize;
             id_offset = self.type_id_offsets[i - 1];
-            block_offset = self.block_offsets.entry(type_offset as usize) as usize;
+            block_offset = self.block_offsets.entry(type_offset) as usize;
         }
 
         let len;
@@ -173,16 +173,14 @@ impl TypedDict {
 
         (
             SizedDict::from_parts(logarray_slice, data_slice, block_offset as u64),
-            id_offset as u64,
+            id_offset,
         )
     }
 
     pub fn type_segment(&self, dt: Datatype) -> Option<(SizedDict, u64)> {
-        if let Some(i) = self.types_present.index_of(dt as u64) {
-            Some(self.inner_type_segment(i))
-        } else {
-            None
-        }
+        self.types_present
+            .index_of(dt as u64)
+            .map(|i| self.inner_type_segment(i))
     }
 
     // TOOD: would be nice if this worked on a buf instead of a slice
@@ -230,9 +228,9 @@ impl TypedDict {
         self.num_entries
     }
 
-    pub fn segment_iter<'a>(&'a self) -> DictSegmentIterator<'a> {
+    pub fn segment_iter(&self) -> DictSegmentIterator<'_> {
         DictSegmentIterator {
-            dict: Cow::Borrowed(&self),
+            dict: Cow::Borrowed(self),
             type_index: 0,
         }
     }
@@ -244,9 +242,7 @@ impl TypedDict {
         }
     }
 
-    pub fn block_iter<'a>(
-        &'a self,
-    ) -> impl Iterator<Item = (Datatype, SizedDictBlock)> + 'a + Clone {
+    pub fn block_iter(&self) -> impl Iterator<Item = (Datatype, SizedDictBlock)> + '_ + Clone {
         self.segment_iter().flat_map(|(datatype, segment)| {
             segment
                 .into_block_iter()
@@ -262,7 +258,7 @@ impl TypedDict {
         })
     }
 
-    pub fn iter<'a>(&'a self) -> impl Iterator<Item = TypedDictEntry> + 'a + Clone {
+    pub fn iter(&self) -> impl Iterator<Item = TypedDictEntry> + '_ + Clone {
         self.block_iter().flat_map(|(datatype, segment)| {
             segment
                 .into_iter()
@@ -332,7 +328,7 @@ impl<T: TdbDataType> TypedDictSegment<T> {
         self.dict.num_entries()
     }
 
-    pub fn iter<'a>(&'a self) -> impl Iterator<Item = SizedDictEntry> + 'a + Clone {
+    pub fn iter(&self) -> impl Iterator<Item = SizedDictEntry> + '_ + Clone {
         self.dict.iter()
     }
 
@@ -365,7 +361,7 @@ impl StringDict {
         self.0.num_entries()
     }
 
-    pub fn iter<'a>(&'a self) -> impl Iterator<Item = SizedDictEntry> + 'a + Clone {
+    pub fn iter(&self) -> impl Iterator<Item = SizedDictEntry> + '_ + Clone {
         self.0.iter()
     }
 
@@ -443,9 +439,9 @@ impl<B1: BufMut, B2: BufMut, B3: BufMut, B4: BufMut> TypedDictBufBuilder<B1, B2,
         if self.current_datatype.is_none() {
             self.current_datatype = Some(value.datatype);
             self.types_present_builder.push(value.datatype as u64);
-            self.sized_dict_buf_builder
-                .as_mut()
-                .map(|b| b.record_size = value.datatype.record_size());
+            if let Some(b) = self.sized_dict_buf_builder.as_mut() {
+                b.record_size = value.datatype.record_size()
+            }
         }
 
         if self.current_datatype != Some(value.datatype) {
@@ -657,8 +653,8 @@ mod tests {
         cycle(-23423423_f32);
         cycle(0_f32);
         cycle(324323_f32);
-        cycle(324323.2343_f32);
-        cycle(-324323.2343_f32);
+        cycle(324323.23_f32);
+        cycle(-324323.23_f32);
         cycle(f32::MAX);
         cycle(f32::MIN);
         cycle(f32::NEG_INFINITY);
diff --git a/src/structure/util.rs b/src/structure/util.rs
index f349bb91..06ca6b31 100644
--- a/src/structure/util.rs
+++ b/src/structure/util.rs
@@ -37,7 +37,7 @@ pub async fn write_nul_terminated_bytes<W: AsyncWrite + Unpin>(
     w: &mut W,
     bytes: &[u8],
 ) -> Result<usize> {
-    w.write_all(&bytes).await?;
+    w.write_all(bytes).await?;
     w.write_all(&[0]).await?;
 
     let count = bytes.len() + 1;
diff --git a/src/structure/wavelettree.rs b/src/structure/wavelettree.rs
index 0cef8957..7a3c9430 100644
--- a/src/structure/wavelettree.rs
+++ b/src/structure/wavelettree.rs
@@ -118,7 +118,7 @@ impl WaveletTree {
         let len = self.len() as u64;
         let mut offset = index as u64;
         let mut alphabet_start = 0;
-        let mut alphabet_end = 2_u64.pow(self.num_layers as u32) as u64;
+        let mut alphabet_end = 2_u64.pow(self.num_layers as u32);
         let mut range_start = 0;
         let mut range_end = len;
         for i in 0..self.num_layers as u64 {
@@ -164,7 +164,7 @@ impl WaveletTree {
         let width = self.len() as u64;
         let mut slices = Vec::with_capacity(self.num_layers as usize);
         let mut alphabet_start = 0;
-        let mut alphabet_end = 2_u64.pow(self.num_layers as u32) as u64;
+        let mut alphabet_end = 2_u64.pow(self.num_layers as u32);
 
         if entry >= alphabet_end {
             return None;
@@ -259,7 +259,7 @@ fn create_fragments(width: u8) -> Vec<FragmentBuilder> {
     result
 }
 
-fn push_to_fragments(num: u64, width: u8, fragments: &mut Vec<FragmentBuilder>) {
+fn push_to_fragments(num: u64, width: u8, fragments: &mut [FragmentBuilder]) {
     let mut num_it: usize = num.try_into().unwrap(); // this will ensure that we get some sort of error on 32 bit for large nums
     for i in 0..width {
         num_it >>= 1;