gat_lending_iterator/adapters/
map.rs

1use crate::{LendingIterator, SingleArgFnMut, SingleArgFnOnce};
2use core::fmt;
3
4/// A lending iterator that maps the elements of `iter` with `f`.
5///
6/// This `struct` is created by the [`map`] method on [`LendingIterator`]. See
7/// its documentation for more.
8///
9/// [`LendingIterator`]: crate::LendingIterator
10/// [`map`]: crate::LendingIterator::map
11#[derive(Clone)]
12#[must_use = "iterators are lazy and do nothing unless consumed"]
13pub struct Map<I, F> {
14    iter: I,
15    f: F,
16}
17
18impl<I, F> Map<I, F> {
19    pub(crate) fn new(iter: I, f: F) -> Self {
20        Self { iter, f }
21    }
22}
23
24impl<I: fmt::Debug, F> fmt::Debug for Map<I, F> {
25    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
26        f.debug_struct("Map").field("iter", &self.iter).finish_non_exhaustive()
27    }
28}
29
30impl<I, F> LendingIterator for Map<I, F>
31where
32    I: LendingIterator,
33    F: for<'a> SingleArgFnMut<I::Item<'a>>,
34{
35    type Item<'a> = <F as SingleArgFnOnce<I::Item<'a>>>::Output
36        where
37            Self: 'a;
38
39    #[inline]
40    fn next(&mut self) -> Option<Self::Item<'_>> {
41        self.iter.next().map(&mut self.f)
42    }
43}
44
45/// An iterator that maps the elements of `iter` with `f`.
46///
47/// This `struct` is created when [`IntoIterator::into_iter`] is called on [`Map`].
48pub struct IntoIter<I, F> {
49    iter: I,
50    f: F,
51}
52
53impl<I, F, O> Iterator for IntoIter<I, F>
54where
55    I: LendingIterator,
56    F: FnMut(I::Item<'_>) -> O,
57{
58    type Item = O;
59
60    fn next(&mut self) -> Option<Self::Item> {
61        self.iter.next().map(&mut self.f)
62    }
63}
64
65impl<I, F, O> IntoIterator for Map<I, F>
66where
67    I: LendingIterator,
68    F: FnMut(I::Item<'_>) -> O,
69{
70    type Item = O;
71    type IntoIter = IntoIter<I, F>;
72
73    fn into_iter(self) -> Self::IntoIter {
74        IntoIter {
75            iter: self.iter,
76            f: self.f,
77        }
78    }
79}