Fix elided lifetime warnings by explicitly specifying '_ in return types

src/map.rs

@@ -391,7 +391,7 @@ impl<K: Bytes, V> GenericPatriciaMap<K, V> {
     /// assert_eq!(vec![(Vec::from("bar"), &2), ("baz".into(), &3), ("foo".into(), &1)],
     ///            map.iter().collect::<Vec<_>>());
     /// ```
-    pub fn iter(&self) -> Iter<K, V> {
+    pub fn iter(&self) -> Iter<'_, K, V> {
         Iter::new(self.tree.nodes(), Vec::new())
     }
 
@@ -409,7 +409,7 @@ impl<K: Bytes, V> GenericPatriciaMap<K, V> {
     /// }
     /// assert_eq!(map.get("bar"), Some(&12));
     /// ```
-    pub fn iter_mut(&mut self) -> IterMut<K, V> {
+    pub fn iter_mut(&mut self) -> IterMut<'_, K, V> {
         IterMut::new(self.tree.nodes_mut(), Vec::new())
     }
 
@@ -425,7 +425,7 @@ impl<K: Bytes, V> GenericPatriciaMap<K, V> {
     /// assert_eq!(vec![Vec::from("bar"), "baz".into(), "foo".into()],
     ///            map.keys().collect::<Vec<_>>());
     /// ```
-    pub fn keys(&self) -> Keys<K, V> {
+    pub fn keys(&self) -> Keys<'_, K, V> {
         Keys(self.iter())
     }
 
@@ -441,7 +441,7 @@ impl<K: Bytes, V> GenericPatriciaMap<K, V> {
     /// assert_eq!(vec![2, 3, 1],
     ///            map.values().cloned().collect::<Vec<_>>());
     /// ```
-    pub fn values(&self) -> Values<V> {
+    pub fn values(&self) -> Values<'_, V> {
         Values {
             nodes: self.tree.nodes(),
         }
@@ -462,7 +462,7 @@ impl<K: Bytes, V> GenericPatriciaMap<K, V> {
     /// assert_eq!(vec![12, 13, 11],
     ///            map.values().cloned().collect::<Vec<_>>());
     /// ```
-    pub fn values_mut(&mut self) -> ValuesMut<V> {
+    pub fn values_mut(&mut self) -> ValuesMut<'_, V> {
         ValuesMut {
             nodes: self.tree.nodes_mut(),
         }

src/node.rs

@@ -1,6 +1,6 @@
 //! A node which represents a subtree of a patricia tree.
 use crate::BorrowedBytes;
-use alloc::alloc::{alloc, dealloc, handle_alloc_error, Layout};
+use alloc::alloc::{Layout, alloc, dealloc, handle_alloc_error};
 use alloc::vec::Vec;
 use core::marker::PhantomData;
 use core::{mem, ptr, slice};
@@ -370,26 +370,26 @@ impl<V> Node<V> {
     }
 
     /// Gets an iterator which traverses the nodes in this tree, in depth first order.
-    pub fn iter(&self) -> Iter<V> {
+    pub fn iter(&self) -> Iter<'_, V> {
         Iter {
             stack: vec![(0, self)],
         }
     }
 
     /// Gets a mutable iterator which traverses the nodes in this tree, in depth first order.
-    pub fn iter_mut(&mut self) -> IterMut<V> {
+    pub fn iter_mut(&mut self) -> IterMut<'_, V> {
         IterMut {
             stack: vec![(0, self)],
         }
     }
 
-    pub(crate) fn iter_descendant(&self) -> Iter<V> {
+    pub(crate) fn iter_descendant(&self) -> Iter<'_, V> {
         Iter {
             stack: vec![(0, self)],
         }
     }
 
-    pub(crate) fn iter_descendant_mut(&mut self) -> IterMut<V> {
+    pub(crate) fn iter_descendant_mut(&mut self) -> IterMut<'_, V> {
         IterMut {
             stack: vec![(0, self)],
         }

src/set.rs

@@ -1,8 +1,8 @@
 //! A set based on a patricia tree.
+use crate::Bytes;
 use crate::map::{self, GenericPatriciaMap};
 #[cfg(any(feature = "serde", test))]
 use crate::node::Node;
-use crate::Bytes;
 use alloc::string::String;
 use alloc::vec::Vec;
 use core::fmt;
@@ -246,7 +246,7 @@ impl<T: Bytes> GenericPatriciaSet<T> {
     ///
     /// assert_eq!(set.iter().collect::<Vec<_>>(), [Vec::from("bar"), "baz".into(), "foo".into()]);
     /// ```
-    pub fn iter(&self) -> Iter<T> {
+    pub fn iter(&self) -> Iter<'_, T> {
         Iter(self.map.keys())
     }
 }

src/tree.rs

@@ -1,8 +1,8 @@
 use alloc::vec::Vec;
 
 use crate::{
-    node::{self, Node, NodeMut},
     BorrowedBytes,
+    node::{self, Node, NodeMut},
 };
 
 #[derive(Debug, Clone)]
@@ -59,7 +59,10 @@ impl<V> PatriciaTree<V> {
             .get_longest_common_prefix_mut(key, 0)
             .map(|(n, v)| (&key.as_bytes()[..n], v))
     }
-    pub fn iter_prefix<K: ?Sized + BorrowedBytes>(&self, prefix: &K) -> Option<(usize, Nodes<V>)> {
+    pub fn iter_prefix<K: ?Sized + BorrowedBytes>(
+        &self,
+        prefix: &K,
+    ) -> Option<(usize, Nodes<'_, V>)> {
         if let Some((common_prefix_len, node)) = self.root.get_prefix_node(prefix) {
             let nodes = Nodes {
                 nodes: node.iter_descendant(),
@@ -73,7 +76,7 @@ impl<V> PatriciaTree<V> {
     pub fn iter_prefix_mut<K: ?Sized + BorrowedBytes>(
         &mut self,
         prefix: &K,
-    ) -> Option<(usize, NodesMut<V>)> {
+    ) -> Option<(usize, NodesMut<'_, V>)> {
         if let Some((common_prefix_len, node)) = self.root.get_prefix_node_mut(prefix) {
             let nodes = NodesMut {
                 nodes: node.iter_descendant_mut(),
@@ -119,13 +122,13 @@ impl<V> PatriciaTree<V> {
     pub fn len(&self) -> usize {
         self.len
     }
-    pub fn nodes(&self) -> Nodes<V> {
+    pub fn nodes(&self) -> Nodes<'_, V> {
         Nodes {
             nodes: self.root.iter(),
             label_lens: Vec::new(),
         }
     }
-    pub fn nodes_mut(&mut self) -> NodesMut<V> {
+    pub fn nodes_mut(&mut self) -> NodesMut<'_, V> {
         NodesMut {
             nodes: self.root.iter_mut(),
             label_lens: Vec::new(),