Trait MapExt

pub trait MapExt: Iterator + Sized {
    // Provided methods
    fn map_deref<'a, R, U>(self) -> MapFn<Self, &'a U>
       where Self::Item: ThisRef<'a, Out = R>,
             R: ?Sized + Deref<Target = U> + 'a,
             U: ?Sized + 'a { ... }
    fn map_deref_mut<'a, R, U>(self) -> MapFn<Self, &'a mut U>
       where Self::Item: ThisMut<'a, Out = R>,
             R: ?Sized + DerefMut<Target = U> + 'a,
             U: ?Sized + 'a { ... }
    fn map_unpack<U>(self) -> MapFn<Self, U>
       where Self::Item: Unpack<Output = U> { ... }
    fn map_into<U>(self) -> MapFn<Self, U>
       where Self::Item: Into<U> { ... }
    fn map_try_into<U>(
        self,
    ) -> MapFn<Self, Result<U, <Self::Item as TryInto<U>>::Error>>
       where Self::Item: TryInto<U> { ... }
    fn map_parse<U>(self) -> MapFn<Self, Result<U, U::Err>>
       where Self::Item: AsRef<str>,
             U: FromStr { ... }
    fn map_as_ref<'a, U>(self) -> MapFn<Self, &'a U>
       where Self::Item: ThisRef<'a>,
             U: ?Sized + 'a,
             <Self::Item as ThisRef<'a>>::Out: AsRef<U> + 'a { ... }
    fn map_as_mut<'a, U>(self) -> MapFn<Self, &'a mut U>
       where Self::Item: ThisMut<'a>,
             U: ?Sized + 'a,
             <Self::Item as ThisRef<'a>>::Out: AsMut<U> + 'a { ... }
    fn map_borrow<'a, U>(self) -> MapFn<Self, &'a U>
       where Self::Item: ThisRef<'a>,
             U: ?Sized + 'a,
             <Self::Item as ThisRef<'a>>::Out: Borrow<U> + 'a { ... }
    fn map_borrow_mut<'a, U>(self) -> MapFn<Self, &'a mut U>
       where Self::Item: ThisMut<'a>,
             U: ?Sized + 'a,
             <Self::Item as ThisRef<'a>>::Out: BorrowMut<U> + 'a { ... }
    fn map_into_iter<I>(self) -> MapFn<Self, I>
       where Self::Item: IntoIterator<IntoIter = I> { ... }
    fn map_collect<A, C>(self) -> MapFn<Self, C>
       where Self::Item: Iterator<Item = A>,
             C: FromIterator<A> { ... }
    fn map_to_owned<R, U>(self) -> MapFn<Self, U>
       where Self::Item: Deref<Target = R>,
             R: ?Sized + ToOwned<Owned = U> { ... }
    fn map_to_string<R>(self) -> MapFn<Self, String>
       where Self::Item: Deref<Target = R>,
             R: ?Sized + ToString { ... }
    fn map_index<'a, R, I, U>(self, index: I) -> MapIndex<'a, Self, I> 
       where Self::Item: ThisRef<'a, Out = R>,
             R: ?Sized + Index<I, Output = U>,
             U: ?Sized + 'a,
             I: Clone { ... }
    fn map_index_mut<'a, R, I, U>(self, index: I) -> MapIndexMut<'a, Self, I> 
       where Self::Item: ThisMut<'a, Out = R>,
             R: ?Sized + IndexMut<I, Output = U>,
             U: ?Sized + 'a,
             I: Clone { ... }
}

Implement commonly used combinations of Iterator::map

Provided Methods

fn map_deref<'a, R, U>(self) -> MapFn<Self, &'a U>

where Self::Item: ThisRef<'a, Out = R>, R: ?Sized + Deref<Target = U> + 'a, U: ?Sized + 'a,

like iter.map(Deref::deref)

fn map_deref_mut<'a, R, U>(self) -> MapFn<Self, &'a mut U>

where Self::Item: ThisMut<'a, Out = R>, R: ?Sized + DerefMut<Target = U> + 'a, U: ?Sized + 'a,

like iter.map(DerefMut::deref_mut)

fn map_unpack<U>(self) -> MapFn<Self, U>

where Self::Item: Unpack<Output = U>,

like iter.map(Unpack::unpack)

fn map_into<U>(self) -> MapFn<Self, U>

where Self::Item: Into<U>,

like iter.map(Into::into)

fn map_try_into<U>( self, ) -> MapFn<Self, Result<U, <Self::Item as TryInto<U>>::Error>>

where Self::Item: TryInto<U>,

like iter.map(TryInto::try_into)

fn map_parse<U>(self) -> MapFn<Self, Result<U, U::Err>>

where Self::Item: AsRef<str>, U: FromStr,

like iter.map(str::parse::<U>)

fn map_as_ref<'a, U>(self) -> MapFn<Self, &'a U>

where Self::Item: ThisRef<'a>, U: ?Sized + 'a, <Self::Item as ThisRef<'a>>::Out: AsRef<U> + 'a,

like iter.map(AsRef::as_ref::<U>)

fn map_as_mut<'a, U>(self) -> MapFn<Self, &'a mut U>

where Self::Item: ThisMut<'a>, U: ?Sized + 'a, <Self::Item as ThisRef<'a>>::Out: AsMut<U> + 'a,

like iter.map(AsMut::as_mut::<U>)

fn map_borrow<'a, U>(self) -> MapFn<Self, &'a U>

where Self::Item: ThisRef<'a>, U: ?Sized + 'a, <Self::Item as ThisRef<'a>>::Out: Borrow<U> + 'a,

like iter.map(Borrow::borrow::<U>)

fn map_borrow_mut<'a, U>(self) -> MapFn<Self, &'a mut U>

where Self::Item: ThisMut<'a>, U: ?Sized + 'a, <Self::Item as ThisRef<'a>>::Out: BorrowMut<U> + 'a,

like iter.map(BorrowMut::borrow_mut::<U>)

fn map_into_iter<I>(self) -> MapFn<Self, I>

where Self::Item: IntoIterator<IntoIter = I>,

like iter.map(IntoIterator::into_iter)

fn map_collect<A, C>(self) -> MapFn<Self, C>

where Self::Item: Iterator<Item = A>, C: FromIterator<A>,

like iter.map(FromIterator::from_iter)

fn map_to_owned<R, U>(self) -> MapFn<Self, U>

where Self::Item: Deref<Target = R>, R: ?Sized + ToOwned<Owned = U>,

like iter.map(ToOwned::to_owned)

fn map_to_string<R>(self) -> MapFn<Self, String>

where Self::Item: Deref<Target = R>, R: ?Sized + ToString,

like iter.map(ToString::to_string)

fn map_index<'a, R, I, U>(self, index: I) -> MapIndex<'a, Self, I>

where Self::Item: ThisRef<'a, Out = R>, R: ?Sized + Index<I, Output = U>, U: ?Sized + 'a, I: Clone,

like iter.map(|v| &v[index])

fn map_index_mut<'a, R, I, U>(self, index: I) -> MapIndexMut<'a, Self, I>

where Self::Item: ThisMut<'a, Out = R>, R: ?Sized + IndexMut<I, Output = U>, U: ?Sized + 'a, I: Clone,

like iter.map(|v| &mut v[index])

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<I: Iterator> MapExt for I