Merge pull request #4 from cuviper/clippy

cuviper · web-flow · commit 2d9e930d80a1 · 2025-01-29T20:39:07.000Z
Fix `clippy::needless_lifetimes` and `clippy::type_complexity`
diff --git a/src/map/core.rs b/src/map/core.rs
@@ -102,23 +102,23 @@ fn update_index(table: &mut Indices, offset: usize, hash: HashValue, old: usize,
     *index = OffsetIndex::new(new, offset);
 }
 
+/// A simple alias to help `clippy::type_complexity`
+type Pair<T> = (T, T);
+
 #[inline]
-fn len_slices<T>((head, tail): (&[T], &[T])) -> usize {
+fn len_slices<T>((head, tail): Pair<&[T]>) -> usize {
     head.len() + tail.len()
 }
 
 #[inline]
-fn iter_slices<'a, T>(
-    (head, tail): (&'a [T], &'a [T]),
-) -> iter::Chain<slice::Iter<'a, T>, slice::Iter<'a, T>> {
+fn iter_slices<T>(
+    (head, tail): Pair<&'_ [T]>,
+) -> iter::Chain<slice::Iter<'_, T>, slice::Iter<'_, T>> {
     head.iter().chain(tail)
 }
 
 #[inline]
-fn split_slices<'a, T>(
-    (head, tail): (&'a [T], &'a [T]),
-    i: usize,
-) -> ((&'a [T], &'a [T]), (&'a [T], &'a [T])) {
+fn split_slices<T>((head, tail): Pair<&'_ [T]>, i: usize) -> Pair<Pair<&'_ [T]>> {
     if i <= head.len() {
         let (head, mid) = head.split_at(i);
         ((head, &[]), (mid, tail))
@@ -129,10 +129,7 @@ fn split_slices<'a, T>(
 }
 
 #[inline]
-fn split_slices_mut<'a, T>(
-    (head, tail): (&'a mut [T], &'a mut [T]),
-    i: usize,
-) -> ((&'a mut [T], &'a mut [T]), (&'a mut [T], &'a mut [T])) {
+fn split_slices_mut<T>((head, tail): Pair<&'_ mut [T]>, i: usize) -> Pair<Pair<&'_ mut [T]>> {
     if i <= head.len() {
         let (head, mid) = head.split_at_mut(i);
         ((head, &mut []), (mid, tail))
@@ -143,11 +140,7 @@ fn split_slices_mut<'a, T>(
 }
 
 #[inline]
-fn sub_slices_mut<'a, T>(
-    slices: (&'a mut [T], &'a mut [T]),
-    start: usize,
-    end: usize,
-) -> (&'a mut [T], &'a mut [T]) {
+fn sub_slices_mut<T>(slices: Pair<&'_ mut [T]>, start: usize, end: usize) -> Pair<&'_ mut [T]> {
     let (slices, _) = split_slices_mut(slices, end);
     split_slices_mut(slices, start).1
 }
@@ -156,11 +149,7 @@ fn sub_slices_mut<'a, T>(
 /// and without regard for duplication.
 ///
 /// ***Panics*** if there is not sufficient capacity already.
-fn insert_bulk_no_grow<K, V>(
-    indices: &mut Indices,
-    offset: usize,
-    entries: (&[Bucket<K, V>], &[Bucket<K, V>]),
-) {
+fn insert_bulk_no_grow<K, V>(indices: &mut Indices, offset: usize, entries: Pair<&[Bucket<K, V>]>) {
     assert!(indices.capacity() - indices.len() >= len_slices(entries));
     for entry in iter_slices(entries) {
         let index = OffsetIndex::new(indices.len(), offset);
diff --git a/src/map/iter.rs b/src/map/iter.rs
@@ -43,15 +43,19 @@ pub(crate) struct Buckets<'a, K, V> {
 
 impl<'a, K, V> Buckets<'a, K, V> {
     pub(crate) fn new(entries: &'a VecDeque<Bucket<K, V>>) -> Self {
-        Self::from_slices(entries.as_slices())
-    }
-
-    pub(crate) fn from_slices((head, tail): (&'a [Bucket<K, V>], &'a [Bucket<K, V>])) -> Self {
+        let (head, tail) = entries.as_slices();
         Self {
             head: head.iter(),
             tail: tail.iter(),
         }
     }
+
+    pub(crate) fn from_slice(slice: &'a [Bucket<K, V>]) -> Self {
+        Self {
+            head: slice.iter(),
+            tail: [].iter(),
+        }
+    }
 }
 
 impl<'a, K, V> Iterator for Buckets<'a, K, V> {
@@ -148,18 +152,25 @@ struct BucketsMut<'a, K, V> {
 
 impl<'a, K, V> BucketsMut<'a, K, V> {
     fn new(entries: &'a mut VecDeque<Bucket<K, V>>) -> Self {
-        Self::from_mut_slices(entries.as_mut_slices())
-    }
-
-    fn from_mut_slices((head, tail): (&'a mut [Bucket<K, V>], &'a mut [Bucket<K, V>])) -> Self {
+        let (head, tail) = entries.as_mut_slices();
         Self {
             head: head.iter_mut(),
             tail: tail.iter_mut(),
         }
     }
 
+    fn from_mut_slice(slice: &'a mut [Bucket<K, V>]) -> Self {
+        Self {
+            head: slice.iter_mut(),
+            tail: [].iter_mut(),
+        }
+    }
+
     fn iter(&self) -> Buckets<'_, K, V> {
-        Buckets::from_slices((self.head.as_slice(), self.tail.as_slice()))
+        Buckets {
+            head: self.head.as_slice().iter(),
+            tail: self.tail.as_slice().iter(),
+        }
     }
 }
 
@@ -255,9 +266,9 @@ impl<'a, K, V> Iter<'a, K, V> {
         }
     }
 
-    pub(super) fn from_slices(slices: (&'a [Bucket<K, V>], &'a [Bucket<K, V>])) -> Self {
+    pub(super) fn from_slice(slice: &'a [Bucket<K, V>]) -> Self {
         Self {
-            iter: Buckets::from_slices(slices),
+            iter: Buckets::from_slice(slice),
         }
     }
 }
@@ -318,11 +329,9 @@ impl<'a, K, V> IterMut<'a, K, V> {
         }
     }
 
-    pub(super) fn from_mut_slices(
-        slices: (&'a mut [Bucket<K, V>], &'a mut [Bucket<K, V>]),
-    ) -> Self {
+    pub(super) fn from_mut_slice(slice: &'a mut [Bucket<K, V>]) -> Self {
         Self {
-            iter: BucketsMut::from_mut_slices(slices),
+            iter: BucketsMut::from_mut_slice(slice),
         }
     }
 }
@@ -517,9 +526,9 @@ impl<'a, K, V> Keys<'a, K, V> {
         }
     }
 
-    pub(super) fn from_slices(slices: (&'a [Bucket<K, V>], &'a [Bucket<K, V>])) -> Self {
+    pub(super) fn from_slice(slice: &'a [Bucket<K, V>]) -> Self {
         Self {
-            iter: Buckets::from_slices(slices),
+            iter: Buckets::from_slice(slice),
         }
     }
 }
@@ -623,7 +632,7 @@ impl<K, V> Default for Keys<'_, K, V> {
 /// map.insert("foo", 1);
 /// println!("{:?}", map.keys()[10]); // panics!
 /// ```
-impl<'a, K, V> Index<usize> for Keys<'a, K, V> {
+impl<K, V> Index<usize> for Keys<'_, K, V> {
     type Output = K;
 
     /// Returns a reference to the key at the supplied `index`.
@@ -705,9 +714,9 @@ impl<'a, K, V> Values<'a, K, V> {
         }
     }
 
-    pub(super) fn from_slices(slices: (&'a [Bucket<K, V>], &'a [Bucket<K, V>])) -> Self {
+    pub(super) fn from_slice(slice: &'a [Bucket<K, V>]) -> Self {
         Self {
-            iter: Buckets::from_slices(slices),
+            iter: Buckets::from_slice(slice),
         }
     }
 }
@@ -768,11 +777,9 @@ impl<'a, K, V> ValuesMut<'a, K, V> {
         }
     }
 
-    pub(super) fn from_mut_slices(
-        slices: (&'a mut [Bucket<K, V>], &'a mut [Bucket<K, V>]),
-    ) -> Self {
+    pub(super) fn from_mut_slice(slice: &'a mut [Bucket<K, V>]) -> Self {
         Self {
-            iter: BucketsMut::from_mut_slices(slices),
+            iter: BucketsMut::from_mut_slice(slice),
         }
     }
 }
@@ -975,7 +982,7 @@ where
 {
 }
 
-impl<'a, I, K, V, S> fmt::Debug for Splice<'a, I, K, V, S>
+impl<I, K, V, S> fmt::Debug for Splice<'_, I, K, V, S>
 where
     I: fmt::Debug + Iterator<Item = (K, V)>,
     K: fmt::Debug + Hash + Eq,
diff --git a/src/map/slice.rs b/src/map/slice.rs
@@ -173,17 +173,17 @@ impl<K, V> Slice<K, V> {
 
     /// Return an iterator over the key-value pairs of the map slice.
     pub fn iter(&self) -> Iter<'_, K, V> {
-        Iter::from_slices((&self.entries, &[]))
+        Iter::from_slice(&self.entries)
     }
 
     /// Return an iterator over the key-value pairs of the map slice.
     pub fn iter_mut(&mut self) -> IterMut<'_, K, V> {
-        IterMut::from_mut_slices((&mut self.entries, &mut []))
+        IterMut::from_mut_slice(&mut self.entries)
     }
 
     /// Return an iterator over the keys of the map slice.
     pub fn keys(&self) -> Keys<'_, K, V> {
-        Keys::from_slices((&self.entries, &[]))
+        Keys::from_slice(&self.entries)
     }
 
     /// Return an owning iterator over the keys of the map slice.
@@ -193,12 +193,12 @@ impl<K, V> Slice<K, V> {
 
     /// Return an iterator over the values of the map slice.
     pub fn values(&self) -> Values<'_, K, V> {
-        Values::from_slices((&self.entries, &[]))
+        Values::from_slice(&self.entries)
     }
 
     /// Return an iterator over mutable references to the the values of the map slice.
     pub fn values_mut(&mut self) -> ValuesMut<'_, K, V> {
-        ValuesMut::from_mut_slices((&mut self.entries, &mut []))
+        ValuesMut::from_mut_slice(&mut self.entries)
     }
 
     /// Return an owning iterator over the values of the map slice.
diff --git a/src/rayon/map.rs b/src/rayon/map.rs
@@ -83,11 +83,15 @@ pub(super) struct ParBuckets<'a, K, V> {
 
 impl<'a, K, V> ParBuckets<'a, K, V> {
     pub(super) fn new(entries: &'a VecDeque<Bucket<K, V>>) -> Self {
-        Self::from_slices(entries.as_slices())
+        let (head, tail) = entries.as_slices();
+        Self { head, tail }
     }
 
-    pub(super) fn from_slices((head, tail): (&'a [Bucket<K, V>], &'a [Bucket<K, V>])) -> Self {
-        Self { head, tail }
+    pub(super) fn from_slice(slice: &'a [Bucket<K, V>]) -> Self {
+        Self {
+            head: slice,
+            tail: &[],
+        }
     }
 
     pub(super) fn iter(&self) -> impl Iterator<Item = &Bucket<K, V>> {
@@ -119,7 +123,7 @@ impl<'a, K: Sync, V: Sync> ParallelIterator for ParBuckets<'a, K, V> {
     }
 }
 
-impl<'a, K: Sync, V: Sync> IndexedParallelIterator for ParBuckets<'a, K, V> {
+impl<K: Sync, V: Sync> IndexedParallelIterator for ParBuckets<'_, K, V> {
     fn drive<C>(self, consumer: C) -> C::Result
     where
         C: Consumer<Self::Item>,
@@ -167,7 +171,7 @@ where
 
     fn into_par_iter(self) -> Self::Iter {
         ParIter {
-            entries: ParBuckets::from_slices((&self.entries, &[])),
+            entries: ParBuckets::from_slice(&self.entries),
         }
     }
 }
@@ -215,11 +219,15 @@ struct ParBucketsMut<'a, K, V> {
 
 impl<'a, K, V> ParBucketsMut<'a, K, V> {
     fn new(entries: &'a mut VecDeque<Bucket<K, V>>) -> Self {
-        Self::from_mut_slices(entries.as_mut_slices())
+        let (head, tail) = entries.as_mut_slices();
+        Self { head, tail }
     }
 
-    fn from_mut_slices((head, tail): (&'a mut [Bucket<K, V>], &'a mut [Bucket<K, V>])) -> Self {
-        Self { head, tail }
+    fn from_mut_slice(slice: &'a mut [Bucket<K, V>]) -> Self {
+        Self {
+            head: slice,
+            tail: &mut [],
+        }
     }
 
     fn iter(&self) -> impl Iterator<Item = &Bucket<K, V>> {
@@ -245,7 +253,7 @@ impl<'a, K: Send, V: Send> ParallelIterator for ParBucketsMut<'a, K, V> {
     }
 }
 
-impl<'a, K: Send, V: Send> IndexedParallelIterator for ParBucketsMut<'a, K, V> {
+impl<K: Send, V: Send> IndexedParallelIterator for ParBucketsMut<'_, K, V> {
     fn drive<C>(self, consumer: C) -> C::Result
     where
         C: Consumer<Self::Item>,
@@ -293,7 +301,7 @@ where
 
     fn into_par_iter(self) -> Self::Iter {
         ParIterMut {
-            entries: ParBucketsMut::from_mut_slices((&mut self.entries, &mut [])),
+            entries: ParBucketsMut::from_mut_slice(&mut self.entries),
         }
     }
 }
@@ -407,7 +415,7 @@ where
     /// in the slice is still preserved for operations like `reduce` and `collect`.
     pub fn par_keys(&self) -> ParKeys<'_, K, V> {
         ParKeys {
-            entries: ParBuckets::from_slices((&self.entries, &[])),
+            entries: ParBuckets::from_slice(&self.entries),
         }
     }
 
@@ -417,7 +425,7 @@ where
     /// in the slice is still preserved for operations like `reduce` and `collect`.
     pub fn par_values(&self) -> ParValues<'_, K, V> {
         ParValues {
-            entries: ParBuckets::from_slices((&self.entries, &[])),
+            entries: ParBuckets::from_slice(&self.entries),
         }
     }
 }
@@ -530,7 +538,7 @@ where
     /// in the slice is still preserved for operations like `reduce` and `collect`.
     pub fn par_values_mut(&mut self) -> ParValuesMut<'_, K, V> {
         ParValuesMut {
-            entries: ParBucketsMut::from_mut_slices((&mut self.entries, &mut [])),
+            entries: ParBucketsMut::from_mut_slice(&mut self.entries),
         }
     }
 }
diff --git a/src/rayon/set.rs b/src/rayon/set.rs
@@ -98,7 +98,7 @@ where
 
     fn into_par_iter(self) -> Self::Iter {
         ParIter {
-            entries: ParBuckets::from_slices((&self.entries, &[])),
+            entries: ParBuckets::from_slice(&self.entries),
         }
     }
 }
diff --git a/src/set/iter.rs b/src/set/iter.rs
@@ -40,9 +40,9 @@ impl<'a, T> Iter<'a, T> {
         }
     }
 
-    pub(super) fn from_slices(slices: (&'a [Bucket<T>], &'a [Bucket<T>])) -> Self {
+    pub(super) fn from_slice(slice: &'a [Bucket<T>]) -> Self {
         Self {
-            iter: Buckets::from_slices(slices),
+            iter: Buckets::from_slice(slice),
         }
     }
 }
@@ -607,7 +607,7 @@ impl<I: Iterator> Iterator for UnitValue<I> {
     }
 }
 
-impl<'a, I, T, S> fmt::Debug for Splice<'a, I, T, S>
+impl<I, T, S> fmt::Debug for Splice<'_, I, T, S>
 where
     I: fmt::Debug + Iterator<Item = T>,
     T: fmt::Debug + Hash + Eq,
diff --git a/src/set/slice.rs b/src/set/slice.rs
@@ -109,7 +109,7 @@ impl<T> Slice<T> {
 
     /// Return an iterator over the values of the set slice.
     pub fn iter(&self) -> Iter<'_, T> {
-        Iter::from_slices((&self.entries, &[]))
+        Iter::from_slice(&self.entries)
     }
 
     /// Search over a sorted set for a value.

Original file line number	Diff line number	Diff line change
`@@ -43,15 +43,19 @@ pub(crate) struct Buckets<'a, K, V> {`
`43`	`43`
`44`	`44`	`impl<'a, K, V> Buckets<'a, K, V> {`
`45`	`45`	`pub(crate) fn new(entries: &'a VecDeque<Bucket<K, V>>) -> Self {`
`46`		`- Self::from_slices(entries.as_slices())`
`47`		`- }`
`48`		`-`
`49`		`- pub(crate) fn from_slices((head, tail): (&'a [Bucket<K, V>], &'a [Bucket<K, V>])) -> Self {`
	`46`	`+ let (head, tail) = entries.as_slices();`
`50`	`47`	`Self {`
`51`	`48`	`head: head.iter(),`
`52`	`49`	`tail: tail.iter(),`
`53`	`50`	`}`
`54`	`51`	`}`
	`52`	`+`
	`53`	`+ pub(crate) fn from_slice(slice: &'a [Bucket<K, V>]) -> Self {`
	`54`	`+ Self {`
	`55`	`+ head: slice.iter(),`
	`56`	`+ tail: [].iter(),`
	`57`	`+ }`
	`58`	`+ }`
`55`	`59`	`}`
`56`	`60`
`57`	`61`	`impl<'a, K, V> Iterator for Buckets<'a, K, V> {`
`@@ -148,18 +152,25 @@ struct BucketsMut<'a, K, V> {`
`148`	`152`
`149`	`153`	`impl<'a, K, V> BucketsMut<'a, K, V> {`
`150`	`154`	`fn new(entries: &'a mut VecDeque<Bucket<K, V>>) -> Self {`
`151`		`- Self::from_mut_slices(entries.as_mut_slices())`
`152`		`- }`
`153`		`-`
`154`		`- fn from_mut_slices((head, tail): (&'a mut [Bucket<K, V>], &'a mut [Bucket<K, V>])) -> Self {`
	`155`	`+ let (head, tail) = entries.as_mut_slices();`
`155`	`156`	`Self {`
`156`	`157`	`head: head.iter_mut(),`
`157`	`158`	`tail: tail.iter_mut(),`
`158`	`159`	`}`
`159`	`160`	`}`
`160`	`161`
	`162`	`+ fn from_mut_slice(slice: &'a mut [Bucket<K, V>]) -> Self {`
	`163`	`+ Self {`
	`164`	`+ head: slice.iter_mut(),`
	`165`	`+ tail: [].iter_mut(),`
	`166`	`+ }`
	`167`	`+ }`
	`168`	`+`
`161`	`169`	`fn iter(&self) -> Buckets<'_, K, V> {`
`162`		`- Buckets::from_slices((self.head.as_slice(), self.tail.as_slice()))`
	`170`	`+ Buckets {`
	`171`	`+ head: self.head.as_slice().iter(),`
	`172`	`+ tail: self.tail.as_slice().iter(),`
	`173`	`+ }`
`163`	`174`	`}`
`164`	`175`	`}`
`165`	`176`
`@@ -255,9 +266,9 @@ impl<'a, K, V> Iter<'a, K, V> {`
`255`	`266`	`}`
`256`	`267`	`}`
`257`	`268`
`258`		`- pub(super) fn from_slices(slices: (&'a [Bucket<K, V>], &'a [Bucket<K, V>])) -> Self {`
	`269`	`+ pub(super) fn from_slice(slice: &'a [Bucket<K, V>]) -> Self {`
`259`	`270`	`Self {`
`260`		`- iter: Buckets::from_slices(slices),`
	`271`	`+ iter: Buckets::from_slice(slice),`
`261`	`272`	`}`
`262`	`273`	`}`
`263`	`274`	`}`
`@@ -318,11 +329,9 @@ impl<'a, K, V> IterMut<'a, K, V> {`
`318`	`329`	`}`
`319`	`330`	`}`
`320`	`331`
`321`		`- pub(super) fn from_mut_slices(`
`322`		`- slices: (&'a mut [Bucket<K, V>], &'a mut [Bucket<K, V>]),`
`323`		`- ) -> Self {`
	`332`	`+ pub(super) fn from_mut_slice(slice: &'a mut [Bucket<K, V>]) -> Self {`
`324`	`333`	`Self {`
`325`		`- iter: BucketsMut::from_mut_slices(slices),`
	`334`	`+ iter: BucketsMut::from_mut_slice(slice),`
`326`	`335`	`}`
`327`	`336`	`}`
`328`	`337`	`}`
`@@ -517,9 +526,9 @@ impl<'a, K, V> Keys<'a, K, V> {`
`517`	`526`	`}`
`518`	`527`	`}`
`519`	`528`
`520`		`- pub(super) fn from_slices(slices: (&'a [Bucket<K, V>], &'a [Bucket<K, V>])) -> Self {`
	`529`	`+ pub(super) fn from_slice(slice: &'a [Bucket<K, V>]) -> Self {`
`521`	`530`	`Self {`
`522`		`- iter: Buckets::from_slices(slices),`
	`531`	`+ iter: Buckets::from_slice(slice),`
`523`	`532`	`}`
`524`	`533`	`}`
`525`	`534`	`}`
`@@ -623,7 +632,7 @@ impl<K, V> Default for Keys<'_, K, V> {`
`623`	`632`	`/// map.insert("foo", 1);`
`624`	`633`	`/// println!("{:?}", map.keys()[10]); // panics!`
`625`	`634`	/// ```
`626`		`-impl<'a, K, V> Index<usize> for Keys<'a, K, V> {`
	`635`	`+impl<K, V> Index<usize> for Keys<'_, K, V> {`
`627`	`636`	`type Output = K;`
`628`	`637`
`629`	`638`	/// Returns a reference to the key at the supplied `index`.
`@@ -705,9 +714,9 @@ impl<'a, K, V> Values<'a, K, V> {`
`705`	`714`	`}`
`706`	`715`	`}`
`707`	`716`
`708`		`- pub(super) fn from_slices(slices: (&'a [Bucket<K, V>], &'a [Bucket<K, V>])) -> Self {`
	`717`	`+ pub(super) fn from_slice(slice: &'a [Bucket<K, V>]) -> Self {`
`709`	`718`	`Self {`
`710`		`- iter: Buckets::from_slices(slices),`
	`719`	`+ iter: Buckets::from_slice(slice),`
`711`	`720`	`}`
`712`	`721`	`}`
`713`	`722`	`}`
`@@ -768,11 +777,9 @@ impl<'a, K, V> ValuesMut<'a, K, V> {`
`768`	`777`	`}`
`769`	`778`	`}`
`770`	`779`
`771`		`- pub(super) fn from_mut_slices(`
`772`		`- slices: (&'a mut [Bucket<K, V>], &'a mut [Bucket<K, V>]),`
`773`		`- ) -> Self {`
	`780`	`+ pub(super) fn from_mut_slice(slice: &'a mut [Bucket<K, V>]) -> Self {`
`774`	`781`	`Self {`
`775`		`- iter: BucketsMut::from_mut_slices(slices),`
	`782`	`+ iter: BucketsMut::from_mut_slice(slice),`
`776`	`783`	`}`
`777`	`784`	`}`
`778`	`785`	`}`
`@@ -975,7 +982,7 @@ where`
`975`	`982`	`{`
`976`	`983`	`}`
`977`	`984`
`978`		`-impl<'a, I, K, V, S> fmt::Debug for Splice<'a, I, K, V, S>`
	`985`	`+impl<I, K, V, S> fmt::Debug for Splice<'_, I, K, V, S>`
`979`	`986`	`where`
`980`	`987`	`I: fmt::Debug + Iterator<Item = (K, V)>,`
`981`	`988`	`K: fmt::Debug + Hash + Eq,`
Original file line number	Diff line number	Diff line change
`@@ -173,17 +173,17 @@ impl<K, V> Slice<K, V> {`
`173`	`173`
`174`	`174`	`/// Return an iterator over the key-value pairs of the map slice.`
`175`	`175`	`pub fn iter(&self) -> Iter<'_, K, V> {`
`176`		`- Iter::from_slices((&self.entries, &[]))`
	`176`	`+ Iter::from_slice(&self.entries)`
`177`	`177`	`}`
`178`	`178`
`179`	`179`	`/// Return an iterator over the key-value pairs of the map slice.`
`180`	`180`	`pub fn iter_mut(&mut self) -> IterMut<'_, K, V> {`
`181`		`- IterMut::from_mut_slices((&mut self.entries, &mut []))`
	`181`	`+ IterMut::from_mut_slice(&mut self.entries)`
`182`	`182`	`}`
`183`	`183`
`184`	`184`	`/// Return an iterator over the keys of the map slice.`
`185`	`185`	`pub fn keys(&self) -> Keys<'_, K, V> {`
`186`		`- Keys::from_slices((&self.entries, &[]))`
	`186`	`+ Keys::from_slice(&self.entries)`
`187`	`187`	`}`
`188`	`188`
`189`	`189`	`/// Return an owning iterator over the keys of the map slice.`
`@@ -193,12 +193,12 @@ impl<K, V> Slice<K, V> {`
`193`	`193`
`194`	`194`	`/// Return an iterator over the values of the map slice.`
`195`	`195`	`pub fn values(&self) -> Values<'_, K, V> {`
`196`		`- Values::from_slices((&self.entries, &[]))`
	`196`	`+ Values::from_slice(&self.entries)`
`197`	`197`	`}`
`198`	`198`
`199`	`199`	`/// Return an iterator over mutable references to the the values of the map slice.`
`200`	`200`	`pub fn values_mut(&mut self) -> ValuesMut<'_, K, V> {`
`201`		`- ValuesMut::from_mut_slices((&mut self.entries, &mut []))`
	`201`	`+ ValuesMut::from_mut_slice(&mut self.entries)`
`202`	`202`	`}`
`203`	`203`
`204`	`204`	`/// Return an owning iterator over the values of the map slice.`
Original file line number	Diff line number	Diff line change
`@@ -83,11 +83,15 @@ pub(super) struct ParBuckets<'a, K, V> {`
`83`	`83`
`84`	`84`	`impl<'a, K, V> ParBuckets<'a, K, V> {`
`85`	`85`	`pub(super) fn new(entries: &'a VecDeque<Bucket<K, V>>) -> Self {`
`86`		`- Self::from_slices(entries.as_slices())`
	`86`	`+ let (head, tail) = entries.as_slices();`
	`87`	`+ Self { head, tail }`
`87`	`88`	`}`
`88`	`89`
`89`		`- pub(super) fn from_slices((head, tail): (&'a [Bucket<K, V>], &'a [Bucket<K, V>])) -> Self {`
`90`		`- Self { head, tail }`
	`90`	`+ pub(super) fn from_slice(slice: &'a [Bucket<K, V>]) -> Self {`
	`91`	`+ Self {`
	`92`	`+ head: slice,`
	`93`	`+ tail: &[],`
	`94`	`+ }`
`91`	`95`	`}`
`92`	`96`
`93`	`97`	`pub(super) fn iter(&self) -> impl Iterator<Item = &Bucket<K, V>> {`
`@@ -119,7 +123,7 @@ impl<'a, K: Sync, V: Sync> ParallelIterator for ParBuckets<'a, K, V> {`
`119`	`123`	`}`
`120`	`124`	`}`
`121`	`125`
`122`		`-impl<'a, K: Sync, V: Sync> IndexedParallelIterator for ParBuckets<'a, K, V> {`
	`126`	`+impl<K: Sync, V: Sync> IndexedParallelIterator for ParBuckets<'_, K, V> {`
`123`	`127`	`fn drive<C>(self, consumer: C) -> C::Result`
`124`	`128`	`where`
`125`	`129`	`C: Consumer<Self::Item>,`
`@@ -167,7 +171,7 @@ where`
`167`	`171`
`168`	`172`	`fn into_par_iter(self) -> Self::Iter {`
`169`	`173`	`ParIter {`
`170`		`- entries: ParBuckets::from_slices((&self.entries, &[])),`
	`174`	`+ entries: ParBuckets::from_slice(&self.entries),`
`171`	`175`	`}`
`172`	`176`	`}`
`173`	`177`	`}`
`@@ -215,11 +219,15 @@ struct ParBucketsMut<'a, K, V> {`
`215`	`219`
`216`	`220`	`impl<'a, K, V> ParBucketsMut<'a, K, V> {`
`217`	`221`	`fn new(entries: &'a mut VecDeque<Bucket<K, V>>) -> Self {`
`218`		`- Self::from_mut_slices(entries.as_mut_slices())`
	`222`	`+ let (head, tail) = entries.as_mut_slices();`
	`223`	`+ Self { head, tail }`
`219`	`224`	`}`
`220`	`225`
`221`		`- fn from_mut_slices((head, tail): (&'a mut [Bucket<K, V>], &'a mut [Bucket<K, V>])) -> Self {`
`222`		`- Self { head, tail }`
	`226`	`+ fn from_mut_slice(slice: &'a mut [Bucket<K, V>]) -> Self {`
	`227`	`+ Self {`
	`228`	`+ head: slice,`
	`229`	`+ tail: &mut [],`
	`230`	`+ }`
`223`	`231`	`}`
`224`	`232`
`225`	`233`	`fn iter(&self) -> impl Iterator<Item = &Bucket<K, V>> {`
`@@ -245,7 +253,7 @@ impl<'a, K: Send, V: Send> ParallelIterator for ParBucketsMut<'a, K, V> {`
`245`	`253`	`}`
`246`	`254`	`}`
`247`	`255`
`248`		`-impl<'a, K: Send, V: Send> IndexedParallelIterator for ParBucketsMut<'a, K, V> {`
	`256`	`+impl<K: Send, V: Send> IndexedParallelIterator for ParBucketsMut<'_, K, V> {`
`249`	`257`	`fn drive<C>(self, consumer: C) -> C::Result`
`250`	`258`	`where`
`251`	`259`	`C: Consumer<Self::Item>,`
`@@ -293,7 +301,7 @@ where`
`293`	`301`
`294`	`302`	`fn into_par_iter(self) -> Self::Iter {`
`295`	`303`	`ParIterMut {`
`296`		`- entries: ParBucketsMut::from_mut_slices((&mut self.entries, &mut [])),`
	`304`	`+ entries: ParBucketsMut::from_mut_slice(&mut self.entries),`
`297`	`305`	`}`
`298`	`306`	`}`
`299`	`307`	`}`
`@@ -407,7 +415,7 @@ where`
`407`	`415`	/// in the slice is still preserved for operations like `reduce` and `collect`.
`408`	`416`	`pub fn par_keys(&self) -> ParKeys<'_, K, V> {`
`409`	`417`	`ParKeys {`
`410`		`- entries: ParBuckets::from_slices((&self.entries, &[])),`
	`418`	`+ entries: ParBuckets::from_slice(&self.entries),`
`411`	`419`	`}`
`412`	`420`	`}`
`413`	`421`
`@@ -417,7 +425,7 @@ where`
`417`	`425`	/// in the slice is still preserved for operations like `reduce` and `collect`.
`418`	`426`	`pub fn par_values(&self) -> ParValues<'_, K, V> {`
`419`	`427`	`ParValues {`
`420`		`- entries: ParBuckets::from_slices((&self.entries, &[])),`
	`428`	`+ entries: ParBuckets::from_slice(&self.entries),`
`421`	`429`	`}`
`422`	`430`	`}`
`423`	`431`	`}`
`@@ -530,7 +538,7 @@ where`
`530`	`538`	/// in the slice is still preserved for operations like `reduce` and `collect`.
`531`	`539`	`pub fn par_values_mut(&mut self) -> ParValuesMut<'_, K, V> {`
`532`	`540`	`ParValuesMut {`
`533`		`- entries: ParBucketsMut::from_mut_slices((&mut self.entries, &mut [])),`
	`541`	`+ entries: ParBucketsMut::from_mut_slice(&mut self.entries),`
`534`	`542`	`}`
`535`	`543`	`}`
`536`	`544`	`}`
Original file line number	Diff line number	Diff line change
`@@ -98,7 +98,7 @@ where`
`98`	`98`
`99`	`99`	`fn into_par_iter(self) -> Self::Iter {`
`100`	`100`	`ParIter {`
`101`		`- entries: ParBuckets::from_slices((&self.entries, &[])),`
	`101`	`+ entries: ParBuckets::from_slice(&self.entries),`
`102`	`102`	`}`
`103`	`103`	`}`
`104`	`104`	`}`
Original file line number	Diff line number	Diff line change
`@@ -40,9 +40,9 @@ impl<'a, T> Iter<'a, T> {`
`40`	`40`	`}`
`41`	`41`	`}`
`42`	`42`
`43`		`- pub(super) fn from_slices(slices: (&'a [Bucket<T>], &'a [Bucket<T>])) -> Self {`
	`43`	`+ pub(super) fn from_slice(slice: &'a [Bucket<T>]) -> Self {`
`44`	`44`	`Self {`
`45`		`- iter: Buckets::from_slices(slices),`
	`45`	`+ iter: Buckets::from_slice(slice),`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`	`}`
`@@ -607,7 +607,7 @@ impl<I: Iterator> Iterator for UnitValue<I> {`
`607`	`607`	`}`
`608`	`608`	`}`
`609`	`609`
`610`		`-impl<'a, I, T, S> fmt::Debug for Splice<'a, I, T, S>`
	`610`	`+impl<I, T, S> fmt::Debug for Splice<'_, I, T, S>`
`611`	`611`	`where`
`612`	`612`	`I: fmt::Debug + Iterator<Item = T>,`
`613`	`613`	`T: fmt::Debug + Hash + Eq,`
Original file line number	Diff line number	Diff line change
`@@ -109,7 +109,7 @@ impl<T> Slice<T> {`
`109`	`109`
`110`	`110`	`/// Return an iterator over the values of the set slice.`
`111`	`111`	`pub fn iter(&self) -> Iter<'_, T> {`
`112`		`- Iter::from_slices((&self.entries, &[]))`
	`112`	`+ Iter::from_slice(&self.entries)`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`/// Search over a sorted set for a value.`