121 lines
3.2 KiB
Rust
121 lines
3.2 KiB
Rust
//! Async [Monad] based on [`Pin<Box<dyn Future>>`] (see: [`Pin`], [`Box::pin`], [`Future`]).
|
|
//! This generally allows just using `.await` on wrapped instances.
|
|
//!
|
|
//! For sync, see [`super::solo`].
|
|
|
|
use std::{future::Future, pin::Pin};
|
|
|
|
use futures::{
|
|
future::{select, Either, Shared},
|
|
join, FutureExt,
|
|
};
|
|
|
|
use crate::func::*;
|
|
|
|
pub struct FutureInstance;
|
|
|
|
impl WeakFunctor for FutureInstance {
|
|
type F<'a, A: 'a> = Pin<Box<dyn 'a + Future<Output = A>>>;
|
|
}
|
|
|
|
impl<'a> Functor<'a> for FutureInstance {
|
|
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::Fa<A>) -> Self::Fa<B> {
|
|
Box::pin(async { f(fa.await) })
|
|
}
|
|
|
|
fn replace<A: 'a, B: 'a>(fa: Self::Fa<A>, b: B) -> Self::Fa<B> {
|
|
Box::pin(async {
|
|
fa.await;
|
|
b
|
|
})
|
|
}
|
|
}
|
|
|
|
impl<'a> Pure<'a> for FutureInstance {
|
|
fn pure<A: 'a>(a: A) -> Self::Fa<A> {
|
|
Box::pin(async { a })
|
|
}
|
|
}
|
|
|
|
impl<'a> ApplicativeSeq<'a> for FutureInstance {
|
|
fn seq<A: 'a, B: 'a>(ff: Self::Fa<impl 'a + FnOnce(A) -> B>, fa: Self::Fa<A>) -> Self::Fa<B> {
|
|
Box::pin(async {
|
|
let (f, a) = join!(ff, fa);
|
|
f(a)
|
|
})
|
|
}
|
|
}
|
|
|
|
impl<'a> ApplicativeLA2<'a> for FutureInstance {
|
|
fn la2<A: 'a, B: 'a, C: 'a>(
|
|
f: impl 'a + FnOnce(A, B) -> C,
|
|
fa: Self::Fa<A>,
|
|
fb: Self::Fa<B>,
|
|
) -> Self::Fa<C> {
|
|
Box::pin(async {
|
|
let (a, b) = join!(fa, fb);
|
|
f(a, b)
|
|
})
|
|
}
|
|
}
|
|
|
|
impl<'a> ApplicativeTuple<'a> for FutureInstance {
|
|
fn tuple<A: 'a, B: 'a>((fa, fb): (Self::Fa<A>, Self::Fa<B>)) -> Self::Fa<(A, B)> {
|
|
Box::pin(async { join!(fa, fb) })
|
|
}
|
|
}
|
|
|
|
impl<'a> ApplicativeSelect<'a> for FutureInstance {
|
|
fn select<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> SelectedWrapped<'a, A, B, Self> {
|
|
Box::pin(async {
|
|
match select(fa, fb).await {
|
|
Either::Left((a, fb)) => Selected::A(a, fb),
|
|
Either::Right((b, fa)) => Selected::B(fa, b),
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
impl<'a> Applicative<'a> for FutureInstance {
|
|
fn discard_first<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> Self::Fa<B> {
|
|
Box::pin(async { join!(fa, fb).1 })
|
|
}
|
|
|
|
fn discard_second<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> Self::Fa<A> {
|
|
Box::pin(async { join!(fa, fb).0 })
|
|
}
|
|
}
|
|
|
|
impl<'a> Monad<'a> for FutureInstance {
|
|
fn bind<A: 'a, B: 'a>(fa: Self::Fa<A>, f: impl 'a + FnOnce(A) -> Self::Fa<B>) -> Self::Fa<B> {
|
|
Box::pin(async { f(fa.await).await })
|
|
}
|
|
|
|
fn iterate<B: 'a>(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::Fa<B> {
|
|
Box::pin(async move {
|
|
loop {
|
|
match f.next().await {
|
|
ControlFlow::Continue(next_f) => f = next_f,
|
|
ControlFlow::Break(b) => return b,
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
fn join<A: 'a>(ffa: Self::Fa<Self::Fa<A>>) -> Self::Fa<A> {
|
|
Box::pin(async { ffa.await.await })
|
|
}
|
|
}
|
|
|
|
impl<'a> SharedFunctor<'a> for FutureInstance {
|
|
type Shared<A: 'a + Clone> = Shared<Pin<Box<dyn 'a + Future<Output = A>>>>;
|
|
|
|
fn share<A: 'a + Clone>(fa: Self::Fa<A>) -> Self::Shared<A> {
|
|
fa.shared()
|
|
}
|
|
|
|
fn unshare<A: 'a + Clone>(sa: Self::Shared<A>) -> Self::Fa<A> {
|
|
Box::pin(sa)
|
|
}
|
|
}
|