157 lines
3.4 KiB
Rust
157 lines
3.4 KiB
Rust
//! Simplest sync [Monad].
|
|
//!
|
|
//! For async, see [`super::future`].
|
|
|
|
use crate::func::*;
|
|
|
|
#[derive(SharedFunctor, CovariantFunctor)]
|
|
pub struct SoloClass;
|
|
|
|
impl WeakFunctor for SoloClass {
|
|
type F<'a, A: 'a> = A;
|
|
}
|
|
|
|
impl Functor for SoloClass {
|
|
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 Pure for SoloClass {
|
|
fn pure<'a, A: 'a>(a: A) -> Self::F<'a, A> {
|
|
a
|
|
}
|
|
}
|
|
|
|
impl ApplicativeSeq for SoloClass {
|
|
fn seq<'a, 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 ApplicativeLA2 for SoloClass {
|
|
fn la2<'a, 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 ApplicativeTuple for SoloClass {
|
|
fn tuple<'a, A: 'a, B: 'a>((fa, fb): (Self::F<'a, A>, Self::F<'a, B>)) -> Self::F<'a, (A, B)>
|
|
where
|
|
Self: 'a,
|
|
{
|
|
(fa, fb)
|
|
}
|
|
}
|
|
|
|
impl Applicative for SoloClass {
|
|
fn discard_first<'a, 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: 'a, B: 'a>(fa: Self::F<'a, A>, fb: Self::F<'a, B>) -> Self::F<'a, A> {
|
|
drop(fb);
|
|
fa
|
|
}
|
|
}
|
|
|
|
impl Monad for SoloClass {
|
|
fn bind<'a, 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_mut<'a, A: 'a, B: 'a>(
|
|
mut a: A,
|
|
mut f: impl 'a + FnMut(A) -> Self::F<'a, ControlFlow<B, A>>,
|
|
) -> Self::F<'a, B>
|
|
where
|
|
Self: 'a,
|
|
{
|
|
loop {
|
|
match f(a) {
|
|
ControlFlow::Continue(next_a) => a = next_a,
|
|
ControlFlow::Break(b) => return b,
|
|
};
|
|
}
|
|
}
|
|
|
|
fn iterate_argument<'a, A: 'a, B: 'a>(
|
|
mut a: A,
|
|
mut f: impl AIterative<'a, T = Self, A = A, B = B>,
|
|
) -> Self::F<'a, B>
|
|
where
|
|
Self: 'a,
|
|
{
|
|
loop {
|
|
match f.next(a) {
|
|
ControlFlow::Continue((new_a, new_f)) => (a, f) = (new_a, new_f),
|
|
ControlFlow::Break(b) => return b,
|
|
}
|
|
}
|
|
}
|
|
|
|
fn iterate<'a, B: 'a>(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::F<'a, B>
|
|
where
|
|
Self: 'a,
|
|
{
|
|
loop {
|
|
match f.next() {
|
|
ControlFlow::Continue(next_f) => f = next_f,
|
|
ControlFlow::Break(b) => return b,
|
|
}
|
|
}
|
|
}
|
|
|
|
fn join<'a, A: 'a>(ffa: Self::F<'a, Self::F<'a, A>>) -> Self::F<'a, A> {
|
|
ffa
|
|
}
|
|
}
|
|
|
|
impl LocalFunctor for SoloClass {
|
|
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: 'a + Pure>(fa: Self::F<'a, T::F<'a, A>>) -> T::F<'a, Self::F<'a, A>>
|
|
where
|
|
Self: 'a,
|
|
{
|
|
fa
|
|
}
|
|
}
|
|
|
|
impl Fail<std::convert::Infallible> for SoloClass {
|
|
fn fail<'a, A: 'a>(e: std::convert::Infallible) -> Self::F<'a, A>
|
|
where
|
|
Self: 'a,
|
|
std::convert::Infallible: 'a,
|
|
{
|
|
match e {}
|
|
}
|
|
}
|