75 lines
1.7 KiB
Rust
75 lines
1.7 KiB
Rust
use crate::func::*;
|
|
|
|
pub struct ResultClass<E: 'static>(E);
|
|
|
|
impl<E> WeakFunctor for ResultClass<E> {
|
|
type F<'a, A: 'a> = Result<A, E>;
|
|
}
|
|
|
|
impl<E> Functor for ResultClass<E> {
|
|
fn fmap<'a, A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<'a, A>) -> Self::F<'a, B> {
|
|
fa.map(f)
|
|
}
|
|
|
|
fn replace<'a, A: 'a, B: 'a>(fa: Self::F<'a, A>, b: B) -> Self::F<'a, B> {
|
|
fa.map(|_| b)
|
|
}
|
|
}
|
|
|
|
impl<E> ApplicativeSeq for ResultClass<E> {
|
|
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> {
|
|
Self::pure(ff?(fa?))
|
|
}
|
|
}
|
|
|
|
impl<E> ApplicativeLA2 for ResultClass<E> {
|
|
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> {
|
|
Self::pure(f(fa?, fb?))
|
|
}
|
|
}
|
|
|
|
impl<E> ApplicativeTuple for ResultClass<E> {
|
|
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,
|
|
{
|
|
Self::pure((fa?, fb?))
|
|
}
|
|
}
|
|
|
|
impl<E> Applicative for ResultClass<E> {
|
|
fn pure<'a, A: 'a>(a: A) -> Self::F<'a, A> {
|
|
Ok(a)
|
|
}
|
|
|
|
fn discard_first<'a, A: 'a, B: 'a>(fa: Self::F<'a, A>, fb: Self::F<'a, B>) -> Self::F<'a, B> {
|
|
fa?;
|
|
fb
|
|
}
|
|
|
|
fn discard_second<'a, A: 'a, B: 'a>(fa: Self::F<'a, A>, fb: Self::F<'a, B>) -> Self::F<'a, A> {
|
|
fb?;
|
|
fa
|
|
}
|
|
}
|
|
|
|
impl<E> Monad for ResultClass<E> {
|
|
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 join<'a, A: 'a>(ffa: Self::F<'a, Self::F<'a, A>>) -> Self::F<'a, A> {
|
|
ffa?
|
|
}
|
|
}
|