pub struct Unfold<T, F, E> { /* private fields */ }Trait Implementations§
Source§impl<T, F, E, Item> Effective for Unfold<T, F, E>
impl<T, F, E, Item> Effective for Unfold<T, F, E>
Source§type Async = <E as Effective>::Async
type Async = <E as Effective>::Async
Models whether this effective type can pause or will block
impl<'__pin, T, F, E> Unpin for Unfold<T, F, E>where
PinnedFieldsOf<__Origin<'__pin, T, F, E>>: Unpin,
Auto Trait Implementations§
impl<T, F, E> Freeze for Unfold<T, F, E>
impl<T, F, E> RefUnwindSafe for Unfold<T, F, E>
impl<T, F, E> Send for Unfold<T, F, E>
impl<T, F, E> Sync for Unfold<T, F, E>
impl<T, F, E> UnwindSafe for Unfold<T, F, E>
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
Source§impl<E> EffectiveExt for Ewhere
E: Effective,
impl<E> EffectiveExt for Ewhere
E: Effective,
Source§fn flat_map<R, F>(self, f: F) -> Flatten<Map<Self, F>>
fn flat_map<R, F>(self, f: F) -> Flatten<Map<Self, F>>
Apply the function over the items, returning a new effective, Flattening the result
into a single effective.
Source§fn flatten_fallible(
self,
) -> Flatten<Map<Self, fn(Self::Item) -> FromFallible<Self::Item>>>where
Self: Sized + Effective<Failure = Infallible>,
Self::Item: Fallible,
Self::Produces: ProducesMultipleWith<Single>,
Self::Async: IsAsyncWith<Blocking>,
fn flatten_fallible(
self,
) -> Flatten<Map<Self, fn(Self::Item) -> FromFallible<Self::Item>>>where
Self: Sized + Effective<Failure = Infallible>,
Self::Item: Fallible,
Self::Produces: ProducesMultipleWith<Single>,
Self::Async: IsAsyncWith<Blocking>,
If the
Item of this effective is fallible, it pulls that flattens into the effective. Read moreSource§fn flatten_future(
self,
) -> Flatten<Map<Self, fn(Self::Item) -> FromFuture<Self::Item>>>where
Self: Sized,
Self::Item: Future,
Self::Async: IsAsyncWith<Async>,
Self::Produces: ProducesMultipleWith<Single>,
Self::Failure: HasFailureWith<Infallible>,
fn flatten_future(
self,
) -> Flatten<Map<Self, fn(Self::Item) -> FromFuture<Self::Item>>>where
Self: Sized,
Self::Item: Future,
Self::Async: IsAsyncWith<Async>,
Self::Produces: ProducesMultipleWith<Single>,
Self::Failure: HasFailureWith<Infallible>,
If the
Item of this effective is a future, it pulls that future into the effective.Source§fn flatten_iterator(
self,
) -> Flatten<Map<Self, fn(Self::Item) -> FromIterator<Self::Item>>>where
Self: Sized,
Self::Item: Iterator,
Self::Async: IsAsyncWith<Blocking>,
Self::Produces: ProducesMultipleWith<Multiple>,
Self::Failure: HasFailureWith<Infallible>,
fn flatten_iterator(
self,
) -> Flatten<Map<Self, fn(Self::Item) -> FromIterator<Self::Item>>>where
Self: Sized,
Self::Item: Iterator,
Self::Async: IsAsyncWith<Blocking>,
Self::Produces: ProducesMultipleWith<Multiple>,
Self::Failure: HasFailureWith<Infallible>,
If the
Item of this effective is an iterator, it pulls that iterator into the effective.Source§fn flatten(self) -> Flatten<Self>
fn flatten(self) -> Flatten<Self>
If this effective item is itself an effective, flatten those items into a single effective.
Source§fn collect<C>(self) -> Collect<Self, C> ⓘ
fn collect<C>(self) -> Collect<Self, C> ⓘ
Collect the items from this iterator into a collection. Read more
Source§fn fold<F, B, C>(self, init: B, func: F) -> Fold<Self, F, B, C> ⓘ
fn fold<F, B, C>(self, init: B, func: F) -> Fold<Self, F, B, C> ⓘ
High level fold function. Takes all the items in the effective and applies the
func to it,
with a running accumulator. Returns the final accumulator value. Read more