Return concrete types from LiteMap iter methods

This closes #8054.

Considerations
--------------

* Not sure if it's ideal to just shove in map.rs the new iter types
* I considered using derive for the Debug impls, but opted for explicit
  impl because the type parameter is S, while the thing being stored
  is S::KeyValueIter, not S.
* The Clone impl is explicit for the same reasons
* No Copy impl, because that's against API guidelines for Iterators
* I parametrize over S, rather than S::KeyValueIter because I found it
  prettier, it doesn't introduce new types in the signature.
* I use function pointer (fn(In) -> Out) over a type parameter so that
  we don't have to explicit the closure type on output.

I think it might be possible to parametrize over the function, to avoid
using a function pointer, but it might be at the expanse of clarity:

    pub fn values(&'a self) -> ValuesIter<
        'a,
        K,
        V,
        S::KeyValueIter,
        impl Fn((&'a K, &'a V)) -> &'a V + Send + Sync + 'static,
    > {
        ValuesIter {
            iter: self.values.lm_iter().map(|val| val.1),
        }
    }

Author: nicopap

utils/litemap/src/map.rs

@@ -901,7 +901,7 @@ where
     S: StoreIterable<'a, K, V>,
 {
     /// Produce an ordered iterator over key-value pairs
-    pub fn iter(&'a self) -> impl DoubleEndedIterator<Item = (&'a K, &'a V)> {
+    pub fn iter(&'a self) -> S::KeyValueIter {
         self.values.lm_iter()
     }
 
@@ -918,13 +918,17 @@ where
     }
 
     /// Produce an ordered iterator over keys
-    pub fn keys(&'a self) -> impl DoubleEndedIterator<Item = &'a K> {
-        self.values.lm_iter().map(|val| val.0)
+    pub fn keys(&'a self) -> KeysIter<'a, K, V, S> {
+        KeysIter {
+            iter: self.values.lm_iter().map(|val| val.0),
+        }
     }
 
     /// Produce an iterator over values, ordered by their keys
-    pub fn values(&'a self) -> impl DoubleEndedIterator<Item = &'a V> {
-        self.values.lm_iter().map(|val| val.1)
+    pub fn values(&'a self) -> ValuesIter<'a, K, V, S> {
+        ValuesIter {
+            iter: self.values.lm_iter().map(|val| val.1),
+        }
     }
 }
 
@@ -933,7 +937,7 @@ where
     S: StoreIterableMut<'a, K, V>,
 {
     /// Produce an ordered mutable iterator over key-value pairs
-    pub fn iter_mut(&'a mut self) -> impl DoubleEndedIterator<Item = (&'a K, &'a mut V)> {
+    pub fn iter_mut(&'a mut self) -> S::KeyValueIterMut {
         self.values.lm_iter_mut()
     }
 }
@@ -1217,6 +1221,106 @@ impl_const_get_with_index_for_integer!(i64);
 impl_const_get_with_index_for_integer!(i128);
 impl_const_get_with_index_for_integer!(isize);
 
+type MapKv<'a, I, K, V, Out> = core::iter::Map<I, fn((&'a K, &'a V)) -> &'a Out>;
+
+pub struct KeysIter<'a, K, V, S: StoreIterable<'a, K, V>> {
+    iter: MapKv<'a, S::KeyValueIter, K, V, K>,
+}
+
+pub struct ValuesIter<'a, K, V, S: StoreIterable<'a, K, V>> {
+    iter: MapKv<'a, S::KeyValueIter, K, V, V>,
+}
+
+impl<'a, K, V, S: StoreIterable<'a, K, V>> Iterator for KeysIter<'a, K, V, S> {
+    type Item = &'a K;
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.iter.size_hint()
+    }
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter.next()
+    }
+    fn fold<B, F>(self, init: B, f: F) -> B
+    where
+        Self: Sized,
+        F: FnMut(B, Self::Item) -> B,
+    {
+        self.iter.fold(init, f)
+    }
+    fn nth(&mut self, n: usize) -> Option<Self::Item> {
+        self.iter.nth(n)
+    }
+}
+impl<'a, K, V, S: StoreIterable<'a, K, V>> ExactSizeIterator for KeysIter<'a, K, V, S> {}
+impl<'a, K, V, S: StoreIterable<'a, K, V>> DoubleEndedIterator for KeysIter<'a, K, V, S> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.iter.next_back()
+    }
+}
+impl<'a, K, V, S: StoreIterable<'a, K, V>> Clone for KeysIter<'a, K, V, S>
+where
+    S::KeyValueIter: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            iter: self.iter.clone(),
+        }
+    }
+}
+impl<'a, K, V, S: StoreIterable<'a, K, V>> Debug for KeysIter<'a, K, V, S>
+where
+    S::KeyValueIter: Debug,
+{
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_tuple("KeysIter").field(&self.iter).finish()
+    }
+}
+
+impl<'a, K, V, S: StoreIterable<'a, K, V>> Iterator for ValuesIter<'a, K, V, S> {
+    type Item = &'a V;
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.iter.size_hint()
+    }
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter.next()
+    }
+    fn fold<B, F>(self, init: B, f: F) -> B
+    where
+        Self: Sized,
+        F: FnMut(B, Self::Item) -> B,
+    {
+        self.iter.fold(init, f)
+    }
+    fn nth(&mut self, n: usize) -> Option<Self::Item> {
+        self.iter.nth(n)
+    }
+}
+impl<'a, K, V, S: StoreIterable<'a, K, V>> ExactSizeIterator for ValuesIter<'a, K, V, S> {}
+impl<'a, K, V, S: StoreIterable<'a, K, V>> DoubleEndedIterator for ValuesIter<'a, K, V, S> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.iter.next_back()
+    }
+}
+impl<'a, K, V, S: StoreIterable<'a, K, V>> Clone for ValuesIter<'a, K, V, S>
+where
+    S::KeyValueIter: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            iter: self.iter.clone(),
+        }
+    }
+}
+impl<'a, K, V, S: StoreIterable<'a, K, V>> Debug for ValuesIter<'a, K, V, S>
+where
+    S::KeyValueIter: Debug,
+{
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_tuple("ValuesIter").field(&self.iter).finish()
+    }
+}
+
 /// An entry in a `LiteMap`, which may be either occupied or vacant.
 #[allow(clippy::exhaustive_enums)]
 pub enum Entry<'a, K, V, S> {