pub struct Bind<F, A, B, IOA>(_, _, _);
Expand description
A function from A
to an IOLike<B>
waiting to be applied to
a lazy value, transforming it from IOLike<A>
to IOLike<B>
.
This is the result of calling [MonadSurrogate.bind_
] on an IOLike
.
Implementations§
Trait Implementations§
source§impl<F, A, B, IOA> Equiv for Bind<F, A, B, IOA>where
F: F1Once<A>,
F::Ret: Equiv<To = IO<B>>,
IOA: Equiv<To = IO<A>>,
impl<F, A, B, IOA> Equiv for Bind<F, A, B, IOA>where F: F1Once<A>, F::Ret: Equiv<To = IO<B>>, IOA: Equiv<To = IO<A>>,
source§impl<F, A, B, IOA> IOLike<B> for Bind<F, A, B, IOA>where
F: F1Once<A>,
F::Ret: Equiv<To = IO<B>> + IOLike<B>,
IOA: IOLike<A>,
impl<F, A, B, IOA> IOLike<B> for Bind<F, A, B, IOA>where F: F1Once<A>, F::Ret: Equiv<To = IO<B>> + IOLike<B>, IOA: IOLike<A>,
impl<F, A, B, IOA> Copy for Bind<F, A, B, IOA>where F: Copy, IOA: Copy,
Auto Trait Implementations§
impl<F, A, B, IOA> RefUnwindSafe for Bind<F, A, B, IOA>where A: RefUnwindSafe, B: RefUnwindSafe, F: RefUnwindSafe, IOA: RefUnwindSafe,
impl<F, A, B, IOA> Send for Bind<F, A, B, IOA>where A: Send, B: Send, F: Send, IOA: Send,
impl<F, A, B, IOA> Sync for Bind<F, A, B, IOA>where A: Sync, B: Sync, F: Sync, IOA: Sync,
impl<F, A, B, IOA> Unpin for Bind<F, A, B, IOA>where A: Unpin, B: Unpin, F: Unpin, IOA: Unpin,
impl<F, A, B, IOA> UnwindSafe for Bind<F, A, B, IOA>where A: UnwindSafe, B: UnwindSafe, F: UnwindSafe, IOA: 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