Struct Map

pub struct Map<I, F> { /* private fields */ }

Implementations

impl<I, F> Map<I, F>

pub fn new(inner: I, func: F) -> Map<I, F>

Trait Implementations

impl<I: AsyncIterator, F, B> AsyncIterator for Map<I, F>

where F: FnMut(I::Item) -> B,

type Item = B

async fn next(&mut self) -> Option<Self::Item>

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the iterator.

fn awaited(self) -> Awaited<Self>

where Self: Sized, Self::Item: Future,

fn map<F, B>(self, f: F) -> Map<Self, F>

where F: FnMut(Self::Item) -> B, Self: Sized,

fn amap<F, B, O>(self, f: F) -> AsyncMap<Self, F>

where F: FnMut(Self::Item) -> O, O: Future<Output = B>, Self: Sized,

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

fn peekable(self) -> Peekable<Self>

where Self: Sized,

fn filter<P>(self, predicate: P) -> Filter<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

fn afilter<P, F>(self, predicate: P) -> AsyncFilter<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> F, F: Future<Output = bool>,

Note:

fn filter_map<F, B>(self, operation: F) -> FilterMap<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

fn afilter_map<F, B, O>(self, operation: F) -> AsyncFilterMap<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> O, O: Future<Output = Option<B>>,

fn copied<'a, T>(self) -> Copied<Self>

where T: 'a + Copy, Self: Sized + AsyncIterator<Item = &'a T>,

fn cloned<'a, T>(self) -> Cloned<Self>

where T: 'a + Clone, Self: Sized + AsyncIterator<Item = &'a T>,

fn inspect<P>(self, op: P) -> Inspect<Self, P>

where Self: Sized, P: FnMut(&Self::Item),

fn fuse(self) -> Fuse<Self>

where Self: Sized,

fn flatten(self) -> Flatten<Self, Self::Item>

where Self: Sized, Self::Item: IntoAsyncIterator,

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>

where Self: Sized, U: IntoAsyncIterator, F: FnMut(Self::Item) -> U,

fn aflat_map<U, F, B>(self, f: F) -> AsyncFlatMap<Self, U, F, B>

where Self: Sized, U: IntoAsyncIterator, F: FnMut(Self::Item) -> B, B: Future<Output = U>,

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoAsyncIterator>::AsyncIter>

where Self: Sized, U: IntoAsyncIterator,

fn intersperse(self, separator: Self::Item) -> Intersperse<Self>

where Self: Sized, Self::Item: Clone,

fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>

where Self: Sized, G: FnMut() -> Self::Item,

fn aintersperse_with<G, F>(self, separator: G) -> AsyncIntersperseWith<Self, G>

where Self: Sized, G: FnMut() -> F, F: Future<Output = Self::Item>,

fn cycle(self) -> Cycle<Self>

where Self: Sized + Clone,

fn take(self, n: usize) -> Take<Self>

where Self: Sized,

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

fn atake_while<P, F>(self, predicate: P) -> AsyncTakeWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> F, F: Future<Output = bool>,

Note:

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>

where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,

fn ascan<St, B, F, O>(self, initial_state: St, f: F) -> AsyncScan<Self, St, F>

where Self: Sized, F: FnMut(&mut St, Self::Item) -> O, O: Future<Output = Option<B>>,

Note:

fn find<P>(&mut self, predicate: P) -> impl Future<Output = Option<Self::Item>>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

fn afind<P, F>( &mut self, predicate: P, ) -> impl Future<Output = Option<Self::Item>>

where Self: Sized, P: FnMut(&Self::Item) -> F, F: Future<Output = bool>,

fn find_map<P, B>(&mut self, operation: P) -> impl Future<Output = Option<B>>

where Self: Sized, P: FnMut(Self::Item) -> Option<B>,

fn afind_map<P, F, B>( &mut self, operation: P, ) -> impl Future<Output = Option<B>>

where Self: Sized, P: FnMut(Self::Item) -> F, F: Future<Output = Option<B>>,

fn collect<B>(self) -> impl Future<Output = B>

where B: FromAsyncIterator<Self::Item>, Self: Sized,

fn fold<B>( self, init: B, f: impl FnMut(B, Self::Item) -> B, ) -> impl Future<Output = B>

where Self: Sized,

fn afold<B, F>( self, init: B, f: impl FnMut(B, Self::Item) -> F, ) -> impl Future<Output = B>

where Self: Sized, F: Future<Output = B>,

fn for_each(self, f: impl FnMut(Self::Item)) -> impl Future<Output = ()>

where Self: Sized,

fn afor_each<F>( self, f: impl FnMut(Self::Item) -> F, ) -> impl Future<Output = ()>

where Self: Sized, F: Future<Output = ()>,

fn reduce( self, f: impl FnMut(Self::Item, Self::Item) -> Self::Item, ) -> impl Future<Output = Option<Self::Item>>

where Self: Sized,

fn areduce<F>( self, f: impl FnMut(Self::Item, Self::Item) -> F, ) -> impl Future<Output = Option<Self::Item>>

where Self: Sized, F: Future<Output = Self::Item>,

fn count(self) -> impl Future<Output = usize>

where Self: Sized,

fn all(self, f: impl FnMut(Self::Item) -> bool) -> impl Future<Output = bool>

where Self: Sized,

fn aall<F>(self, f: impl FnMut(Self::Item) -> F) -> impl Future<Output = bool>

where Self: Sized, F: Future<Output = bool>,

fn any(self, f: impl FnMut(Self::Item) -> bool) -> impl Future<Output = bool>

where Self: Sized,

fn aany<F>(self, f: impl FnMut(Self::Item) -> F) -> impl Future<Output = bool>

where Self: Sized, F: Future<Output = bool>,

impl<I: Clone, F: Clone> Clone for Map<I, F>

fn clone(&self) -> Map<I, F>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<I: AsyncIterator + Debug, F> Debug for Map<I, F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.