make Drain and DrainFilter independent of ArrayTable

Author: Luro02

src/array_map.rs

@@ -639,7 +639,7 @@ where
     ///
     /// assert_eq!(drained, [None, None, None, Some(("rust", "rost")),]);
     /// ```
-    pub fn drain_filter<F>(&mut self, f: F) -> DrainFilter<'_, K, V, F, B, N>
+    pub fn drain_filter<F>(&mut self, f: F) -> DrainFilter<'_, K, V, F, ArrayTable<(K, V), N>, B>
     where
         F: FnMut(&K, &mut V) -> bool,
     {
@@ -672,7 +672,7 @@ where
     ///     ]
     /// );
     /// ```
-    pub fn drain(&mut self) -> Drain<'_, K, V, B, N> {
+    pub fn drain(&mut self) -> Drain<'_, K, V, ArrayTable<(K, V), N>, B> {
         Drain::new(&mut self.table, &self.build_hasher)
     }
 

src/iter/drain.rs

@@ -1,35 +1,41 @@
 use core::hash::{BuildHasher, Hash};
 
 use super::DrainFilter;
-use crate::raw::ArrayTable;
+use crate::raw::RawTable;
 
 /// A draining iterator over entries of an `ArrayMap`.
 ///
 /// This struct is created by [`ArrayMap::drain`]. See its documentation for
 /// more.
 ///
 /// [`ArrayMap::drain`]: crate::ArrayMap::drain
-pub struct Drain<'a, K, V, B: BuildHasher, const N: usize>
+pub struct Drain<'a, K, V, R, B>
 where
     K: Hash + Eq,
+    R: RawTable<(K, V)>,
+    B: BuildHasher,
 {
-    inner: DrainFilter<'a, K, V, fn(&K, &mut V) -> bool, B, N>,
+    inner: DrainFilter<'a, K, V, fn(&K, &mut V) -> bool, R, B>,
 }
 
-impl<'a, K, V, B: BuildHasher, const N: usize> Drain<'a, K, V, B, N>
+impl<'a, K, V, R, B> Drain<'a, K, V, R, B>
 where
     K: Hash + Eq,
+    R: RawTable<(K, V)>,
+    B: BuildHasher,
 {
-    pub(crate) fn new(table: &'a mut ArrayTable<(K, V), N>, build_hasher: &'a B) -> Self {
+    pub(crate) fn new(table: &'a mut R, build_hasher: &'a B) -> Self {
         Self {
             inner: DrainFilter::new(|_, _| true, table, build_hasher),
         }
     }
 }
 
-impl<'a, K, V, B: BuildHasher, const N: usize> Iterator for Drain<'a, K, V, B, N>
+impl<'a, K, V, R, B> Iterator for Drain<'a, K, V, R, B>
 where
     K: Eq + Hash,
+    R: RawTable<(K, V)>,
+    B: BuildHasher,
 {
     type Item = (K, V);
 

src/iter/drain_filter.rs

@@ -1,7 +1,7 @@
 use core::hash::{BuildHasher, Hash};
 use core::mem;
 
-use crate::raw::{ArrayTable, RawTable};
+use crate::raw::RawTable;
 use crate::utils;
 
 /// A draining iterator over entries of an `ArrayMap` which do not satisfy the
@@ -11,23 +11,27 @@ use crate::utils;
 /// for more.
 ///
 /// [`ArrayMap::drain_filter`]: crate::ArrayMap::drain_filter
-pub struct DrainFilter<'a, K, V, F, B: BuildHasher, const N: usize>
+pub struct DrainFilter<'a, K, V, F, R, B>
 where
+    B: BuildHasher,
     F: FnMut(&K, &mut V) -> bool,
     K: Hash + Eq,
+    R: RawTable<(K, V)>,
 {
     f: F,
-    iter: <ArrayTable<(K, V), N> as RawTable<(K, V)>>::RawIter,
-    table: &'a mut ArrayTable<(K, V), N>,
+    iter: R::RawIter,
+    table: &'a mut R,
     build_hasher: &'a B,
 }
 
-impl<'a, K, V, F, B: BuildHasher, const N: usize> DrainFilter<'a, K, V, F, B, N>
+impl<'a, K, V, F, R, B> DrainFilter<'a, K, V, F, R, B>
 where
+    B: BuildHasher,
     F: FnMut(&K, &mut V) -> bool,
     K: Hash + Eq,
+    R: RawTable<(K, V)>,
 {
-    pub(crate) fn new(f: F, table: &'a mut ArrayTable<(K, V), N>, build_hasher: &'a B) -> Self {
+    pub(crate) fn new(f: F, table: &'a mut R, build_hasher: &'a B) -> Self {
         Self {
             f,
             iter: table.iter(),
@@ -37,10 +41,12 @@ where
     }
 }
 
-impl<'a, K, V, F, B: BuildHasher, const N: usize> Iterator for DrainFilter<'a, K, V, F, B, N>
+impl<'a, K, V, F, R, B> Iterator for DrainFilter<'a, K, V, F, R, B>
 where
+    B: BuildHasher,
     F: FnMut(&K, &mut V) -> bool,
     K: Eq + Hash,
+    R: RawTable<(K, V)>,
 {
     type Item = (K, V);
 
@@ -60,11 +66,12 @@ where
     }
 }
 
-impl<'a, K, V, F, B, const N: usize> Drop for DrainFilter<'a, K, V, F, B, N>
+impl<'a, K, V, F, R, B> Drop for DrainFilter<'a, K, V, F, R, B>
 where
     B: BuildHasher,
     F: FnMut(&K, &mut V) -> bool,
     K: Eq + Hash,
+    R: RawTable<(K, V)>,
 {
     fn drop(&mut self) {
         self.for_each(mem::drop);