[no description]
Diffstat (limited to 'src/iterator.rs')
| -rw-r--r-- | src/iterator.rs | 204 |
1 files changed, 171 insertions, 33 deletions
diff --git a/src/iterator.rs b/src/iterator.rs index 3d3dd26..c32c516 100644 --- a/src/iterator.rs +++ b/src/iterator.rs @@ -1,64 +1,202 @@ -use crate::{Pick, RePick, Tupl}; -/// may add more later -pub trait IteratorOfTuples: Iterator<Item: Tupl> { +#![allow(nonstandard_style)] +use crate::{MapAllMut, Pick, RePick, RefIze, Tupl}; +pub trait IteratorOfTuplesWithF<retval>: + Iterator<Item: Tupl> + Sized +{ /// Map the item at: (|(x, y)| (f(x), y)) - fn map_at<const N: usize, U>( + fn map_at<const N: usize>( self, - f: impl FnMut(<Self::Item as Pick<N>>::At) -> U, - ) -> impl Iterator<Item = <Self::Item as RePick<N, U>>::New> + mut f: impl FnMut(<Self::Item as Pick<N>>::At) -> retval, + ) -> core::iter::Map< + Self, + impl FnMut(<Self>::Item) -> <<Self>::Item as RePick<N, retval>>::New, + > where - Self::Item: RePick<N, U>; - /// make it just one: (|x| x.0) - fn just<const N: usize>( + Self::Item: RePick<N, retval>, + { + self.map(move |x| { + let (l, at, r) = x.depict(); + let at = f(at); + Self::Item::unpick(l, at, r) + }) + } + /// filter map the item at: (|(x, y)| f(x).zip(Some(y)) + fn filter_map_at<const N: usize>( self, - ) -> impl Iterator<Item = <Self::Item as Pick<N>>::At> + mut f: impl FnMut(<Self::Item as Pick<N>>::At) -> Option<retval>, + ) -> core::iter::FilterMap< + Self, + impl FnMut( + <Self as Iterator>::Item, + ) -> Option< + <<Self as Iterator>::Item as RePick<N, retval>>::New, + >, + > where - Self::Item: Pick<N>; + Self::Item: RePick<N, retval>, + { + self.filter_map(move |x| { + let (l, at, r) = x.depict(); + f(at).map(|x| Self::Item::unpick(l, x, r)) + }) + } /// map the item to just one, then map that one: (|x| f(x.0)) - fn map_just<const N: usize, U>( + fn map_on<const N: usize>( self, - f: impl FnMut(<Self::Item as Pick<N>>::At) -> U, + f: impl FnMut(<Self::Item as Pick<N>>::At) -> retval, ) -> core::iter::Map< impl Iterator<Item = <Self::Item as Pick<N>>::At>, - impl FnMut(<Self::Item as Pick<N>>::At) -> U, + impl FnMut(<Self::Item as Pick<N>>::At) -> retval, > where Self: Iterator<Item: Pick<N>> + Sized, { - self.just().map(f) + self.on().map(f) + } + fn fmap_on<const N: usize>( + self, + f: impl FnMut(<Self::Item as Pick<N>>::At) -> retval, + ) -> core::iter::FlatMap< + core::iter::Map< + Self, + impl FnMut( + <Self as Iterator>::Item, + ) + -> <<Self as Iterator>::Item as Pick<N>>::At, + >, + retval, + impl FnMut(<<Self as Iterator>::Item as Pick<N>>::At) -> retval, + > + where + Self::Item: Pick<N>, + retval: IntoIterator, + { + self.on().flat_map(f) } } -impl<I: Iterator<Item: Tupl>> IteratorOfTuples for I { - #[expect(refining_impl_trait)] - fn map_at<const N: usize, U>( +pub trait IteratorOfReferencesToTupleWithF< + 'a, + T: Tupl + RefIze + 'a, + retval, +>: Iterator<Item = &'a T> + Sized +{ + /// Map the item at: (|(x, y)| (f(x), y)) + fn map_at<const N: usize>( self, - mut f: impl FnMut(<Self::Item as Pick<N>>::At) -> U, + f: impl FnMut(<T::AsRef<'a> as Pick<N>>::At) -> retval + 'a, + ) -> impl Iterator<Item = <T::AsRef<'a> as RePick<N, retval>>::New> + where + T::AsRef<'a>: RePick<N, retval>, + { + self.as_ref().map_at(f) + } + /// map the item to just one, then map that one: (|x| f(x.0)) + fn map_on<const N: usize, U>( + self, + f: impl FnMut(<T::AsRef<'a> as Pick<N>>::At) -> U, ) -> core::iter::Map< - I, - impl FnMut( - <I as Iterator>::Item, - ) -> <<I as Iterator>::Item as RePick<N, U>>::New, + impl Iterator<Item = <T::AsRef<'a> as Pick<N>>::At>, + impl FnMut(<T::AsRef<'a> as Pick<N>>::At) -> U, > where - Self::Item: RePick<N, U>, + T::AsRef<'a>: Pick<N>, { - self.map(move |x| { - let (l, at, r) = x.depict(); - let at = f(at); - Self::Item::unpick(l, at, r) - }) + self.on().map(f) } +} - #[expect(refining_impl_trait)] - fn just<const N: usize>( +/// may add more later +pub trait IteratorOfTuples: Iterator<Item: Tupl> + Sized { + /// make it just one: (|x| x.0) + fn on<const N: usize>( self, ) -> core::iter::Map< - I, - impl FnMut(<I>::Item) -> <<I>::Item as Pick<N>>::At, + Self, + impl FnMut( + <Self as Iterator>::Item, + ) -> <<Self as Iterator>::Item as Pick<N>>::At, > where Self::Item: Pick<N>, { self.map(|x| x.pick()) } + fn flatten_on<const N: usize>( + self, + ) -> core::iter::Flatten< + core::iter::Map< + Self, + impl FnMut( + <Self as Iterator>::Item, + ) + -> <<Self as Iterator>::Item as Pick<N>>::At, + >, + > + where + Self::Item: Pick<N, At: IntoIterator>, + { + self.on().flatten() + } + fn map_all<retval: Tupl, functions: Tupl>( + self, + mut fns: functions, + ) -> impl Iterator<Item = retval> + where + Self::Item: MapAllMut<retval, functions>, + { + self.map(move |x| x.map_all_mut(&mut fns)) + } +} + +/// may add more later +pub trait IteratorOfReferencesToTuple<'a, T: Tupl + RefIze + 'a>: + Iterator<Item = &'a T> + Sized +{ + fn as_ref( + self, + ) -> core::iter::Map<Self, fn(&T) -> <T as RefIze>::AsRef<'_>> { + self.map(T::as_ref) + } + + /// make it just one: (|x| x.0) + fn on<const N: usize>( + self, + ) -> impl Iterator<Item = <T::AsRef<'a> as Pick<N>>::At> + where + T::AsRef<'a>: Pick<N>, + { + self.as_ref().on() + } + fn map_all<retval: Tupl, functions: Tupl>( + self, + mut fns: functions, + ) -> impl Iterator<Item = retval> + where + T::AsRef<'a>: MapAllMut<retval, functions>, + { + self.map(move |x| x.as_ref().map_all_mut(&mut fns)) + } +} + +impl<I: Iterator<Item: Tupl>> IteratorOfTuples for I {} + +impl<U, I: Iterator<Item: Tupl>> IteratorOfTuplesWithF<U> for I {} + +impl<'a, T: Tupl + RefIze + 'a, I: Iterator<Item = &'a T>> + IteratorOfReferencesToTuple<'a, T> for I +{ +} + +impl<'a, U, T: Tupl + RefIze + 'a, I: Iterator<Item = &'a T>> + IteratorOfReferencesToTupleWithF<'a, T, U> for I +{ +} +#[test] +fn x() { + let x = [(1, 2), (3, 4)].iter().map_at::<0>(|x| x + 2); + let y = [(1, "a"), (2, "b")] + .iter() + .map_all((|x| x + 1, |x| x.to_uppercase())) + .next_chunk::<2>() + .unwrap(); } |