119 lines
2.7 KiB
Rust
119 lines
2.7 KiB
Rust
//! Simplest sync [Monad].
|
|
//!
|
|
//! For async, see [`super::future`].
|
|
|
|
use crate::func::*;
|
|
|
|
#[derive(SharedFunctor, CovariantFunctor)]
|
|
pub struct SoloInstance;
|
|
|
|
impl WeakFunctor for SoloInstance {
|
|
type F<'a, A: 'a> = A;
|
|
}
|
|
|
|
impl Functor for SoloInstance {
|
|
fn fmap<'a, A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<'a, A>) -> Self::F<'a, B> {
|
|
f(fa)
|
|
}
|
|
|
|
fn replace<'a, A: 'a, B: 'a>(fa: Self::F<'a, A>, b: B) -> Self::F<'a, B> {
|
|
drop(fa);
|
|
b
|
|
}
|
|
|
|
fn void<'a, A: 'a>(fa: Self::F<'a, A>) -> Self::F<'a, ()> {
|
|
drop(fa);
|
|
}
|
|
}
|
|
|
|
impl<'a> Pure<'a> for SoloInstance {
|
|
fn pure<A: 'a>(a: A) -> Self::F<'a, A> {
|
|
a
|
|
}
|
|
}
|
|
|
|
impl<'a> ApplicativeSeq<'a> for SoloInstance {
|
|
fn seq<A: 'a, B: 'a>(
|
|
ff: Self::F<'a, impl 'a + FnOnce(A) -> B>,
|
|
fa: Self::F<'a, A>,
|
|
) -> Self::F<'a, B> {
|
|
ff(fa)
|
|
}
|
|
}
|
|
|
|
impl<'a> ApplicativeLA2<'a> for SoloInstance {
|
|
fn la2<A: 'a, B: 'a, C: 'a>(
|
|
f: impl 'a + FnOnce(A, B) -> C,
|
|
fa: Self::F<'a, A>,
|
|
fb: Self::F<'a, B>,
|
|
) -> Self::F<'a, C> {
|
|
f(fa, fb)
|
|
}
|
|
}
|
|
|
|
impl<'a> ApplicativeTuple<'a> for SoloInstance {
|
|
fn tuple<A: 'a, B: 'a>((fa, fb): (Self::F<'a, A>, Self::F<'a, B>)) -> Self::F<'a, (A, B)> {
|
|
(fa, fb)
|
|
}
|
|
}
|
|
|
|
impl<'a> ApplicativeSelect<'a> for SoloInstance {}
|
|
|
|
impl<'a> Applicative<'a> for SoloInstance {
|
|
fn discard_first<A: 'a, B: 'a>(fa: Self::F<'a, A>, fb: Self::F<'a, B>) -> Self::F<'a, B> {
|
|
drop(fa);
|
|
fb
|
|
}
|
|
|
|
fn discard_second<A: 'a, B: 'a>(fa: Self::F<'a, A>, fb: Self::F<'a, B>) -> Self::F<'a, A> {
|
|
drop(fb);
|
|
fa
|
|
}
|
|
}
|
|
|
|
impl<'a> Monad<'a> for SoloInstance {
|
|
fn bind<A: 'a, B: 'a>(
|
|
fa: Self::F<'a, A>,
|
|
f: impl 'a + FnOnce(A) -> Self::F<'a, B>,
|
|
) -> Self::F<'a, B> {
|
|
f(fa)
|
|
}
|
|
|
|
fn iterate<B: 'a>(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::F<'a, B> {
|
|
loop {
|
|
match f.next() {
|
|
ControlFlow::Continue(next_f) => f = next_f,
|
|
ControlFlow::Break(b) => return b,
|
|
}
|
|
}
|
|
}
|
|
|
|
fn join<A: 'a>(ffa: Self::F<'a, Self::F<'a, A>>) -> Self::F<'a, A> {
|
|
ffa
|
|
}
|
|
}
|
|
|
|
impl LocalFunctor for SoloInstance {
|
|
fn unstuff<'a, A: 'a, B: 'a>(
|
|
state: Self::F<'a, ControlFlow<B, A>>,
|
|
) -> ControlFlow<Self::F<'a, B>, A>
|
|
where
|
|
Self: 'a,
|
|
{
|
|
state
|
|
}
|
|
|
|
fn stuff<'a, A: 'a, T: Pure<'a>>(fa: Self::F<'a, T::F<'a, A>>) -> T::F<'a, Self::F<'a, A>>
|
|
where
|
|
Self: 'a,
|
|
{
|
|
fa
|
|
}
|
|
}
|
|
|
|
impl<'a> Fail<'a, std::convert::Infallible> for SoloInstance {
|
|
fn fail<A: 'a>(e: std::convert::Infallible) -> Self::F<'a, A> {
|
|
match e {}
|
|
}
|
|
}
|