pub struct Apply<A, B, AB, IOA, IOAB>(_, _, _);
Expand description
Implementations§
Trait Implementations§
Auto Trait Implementations§
impl<A, B, AB, IOA, IOAB> RefUnwindSafe for Apply<A, B, AB, IOA, IOAB>where A: RefUnwindSafe, AB: RefUnwindSafe, B: RefUnwindSafe, IOA: RefUnwindSafe, IOAB: RefUnwindSafe,
impl<A, B, AB, IOA, IOAB> Send for Apply<A, B, AB, IOA, IOAB>where A: Send, AB: Send, B: Send, IOA: Send, IOAB: Send,
impl<A, B, AB, IOA, IOAB> Sync for Apply<A, B, AB, IOA, IOAB>where A: Sync, AB: Sync, B: Sync, IOA: Sync, IOAB: Sync,
impl<A, B, AB, IOA, IOAB> Unpin for Apply<A, B, AB, IOA, IOAB>where A: Unpin, AB: Unpin, B: Unpin, IOA: Unpin, IOAB: Unpin,
impl<A, B, AB, IOA, IOAB> UnwindSafe for Apply<A, B, AB, IOA, IOAB>where A: UnwindSafe, AB: UnwindSafe, B: UnwindSafe, IOA: UnwindSafe, IOAB: UnwindSafe,
Blanket Implementations§
source§impl<I, AB, TofA> ApplySurrogate<IO, AB, TofA> for Iwhere
I: Equiv<To = IO<AB>> + IOLike<AB>,
impl<I, AB, TofA> ApplySurrogate<IO, AB, TofA> for Iwhere I: Equiv<To = IO<AB>> + IOLike<AB>,
§type ApplyOutput = Apply<A, B, AB, TofA, I>
type ApplyOutput = Apply<A, B, AB, TofA, I>
source§impl<I, A> MonadSurrogate<IO, A> for Iwhere
I: Equiv<To = IO<A>> + IOLike<A>,
impl<I, A> MonadSurrogate<IO, A> for Iwhere I: Equiv<To = IO<A>> + IOLike<A>,
§type BindOutput = Bind<AMB, A, B, I>
type BindOutput = Bind<AMB, A, B, I>
source§fn bind_<B, AMB>(
self,
f: AMB
) -> <I as MonadSurrogate<IO, A>>::BindOutput<B, AMB>where
AMB: F1<A, Ret = <IO as HKT1>::T<B>>,
fn bind_<B, AMB>( self, f: AMB ) -> <I as MonadSurrogate<IO, A>>::BindOutput<B, AMB>where AMB: F1<A, Ret = <IO as HKT1>::T<B>>,
Use a function from
A -> M<B>
to transform something
akin to M<A>
to something akin to M<B>
.source§impl<F, A, TF, T> Sequence<F, A, TF> for T
impl<F, A, TF, T> Sequence<F, A, TF> for T
source§fn sequence<Ap>(self) -> Ap::T<F::T<A>>where
Self: Sized + Traversable<F, Ap::T<A>, A, TF> + Foldable<F, Ap::T<A>>,
Ap: HKT1,
Ap::T<A>: Applicative<Ap, A> + ApplyOnce<Ap, A>,
Ap::T<TF>: Applicative<Ap, TF> + ApplyOnce<Ap, TF>,
Ap::T<F::T<A>>: Applicative<Ap, F::T<A>> + ApplyOnce<Ap, F::T<A>>,
F: HKT1<T<Ap::T<A>> = Self>,
fn sequence<Ap>(self) -> Ap::T<F::T<A>>where Self: Sized + Traversable<F, Ap::T<A>, A, TF> + Foldable<F, Ap::T<A>>, Ap: HKT1, Ap::T<A>: Applicative<Ap, A> + ApplyOnce<Ap, A>, Ap::T<TF>: Applicative<Ap, TF> + ApplyOnce<Ap, TF>, Ap::T<F::T<A>>: Applicative<Ap, F::T<A>> + ApplyOnce<Ap, F::T<A>>, F: HKT1<T<Ap::T<A>> = Self>,
See
Sequence