148 lines
4.1 KiB
Rust
148 lines
4.1 KiB
Rust
use super::func::*;
|
|
|
|
pub trait CopyWeakFunctor {
|
|
type CF<'a, A: Copy>;
|
|
}
|
|
|
|
pub trait CopyFunctor: CopyWeakFunctor {
|
|
fn copy_fmap<'a, A: 'a + Copy, B: 'a + Copy, F: 'a + Fn(A) -> B>(
|
|
f: F,
|
|
fa: Self::CF<'a, A>,
|
|
) -> Self::CF<'a, B>;
|
|
|
|
fn copy_replace<'a, A: 'a + Copy, B: 'a + Copy>(fa: Self::CF<'a, A>, b: B) -> Self::CF<'a, B> {
|
|
Self::copy_fmap(move |_| b, fa)
|
|
}
|
|
|
|
fn copy_void<'a, A: 'a + Copy>(fa: Self::CF<'a, A>) -> Self::CF<'a, ()> {
|
|
Self::copy_replace(fa, ())
|
|
}
|
|
}
|
|
|
|
impl<T: WeakFunctor> CopyWeakFunctor for T {
|
|
type CF<'a, A: Copy> = T::F<'a, A>;
|
|
}
|
|
|
|
impl<T: Functor> CopyFunctor for T {
|
|
fn copy_fmap<'a, A: 'a + Copy, B: 'a + Copy, F: 'a + Fn(A) -> B>(
|
|
f: F,
|
|
fa: Self::CF<'a, A>,
|
|
) -> Self::CF<'a, B> {
|
|
Self::fmap(f, fa)
|
|
}
|
|
|
|
fn copy_replace<'a, A: 'a + Copy, B: 'a + Copy>(fa: Self::CF<'a, A>, b: B) -> Self::CF<'a, B> {
|
|
Self::replace(fa, b)
|
|
}
|
|
|
|
fn copy_void<'a, A: 'a + Copy>(fa: Self::CF<'a, A>) -> Self::CF<'a, ()> {
|
|
Self::void(fa)
|
|
}
|
|
}
|
|
|
|
pub trait CopyApplicativeSeq: CopyFunctor {
|
|
fn copy_seq<'a, A: 'a + Copy, B: 'a + Copy, F: 'a + Copy + Fn(A) -> B>(
|
|
ff: Self::CF<'a, F>,
|
|
fa: Self::CF<'a, A>,
|
|
) -> Self::CF<'a, B>;
|
|
|
|
fn _copy_la2<'a, A: 'a + Copy, B: 'a + Copy, C: 'a + Copy, F: 'a + Copy + Fn(A, B) -> C>(
|
|
f: F,
|
|
fa: Self::CF<'a, A>,
|
|
fb: Self::CF<'a, B>,
|
|
) -> Self::CF<'a, C> {
|
|
Self::copy_seq(Self::copy_fmap(move |a| move |b| f(a, b), fa), fb)
|
|
}
|
|
}
|
|
|
|
impl<T: ApplicativeSeq> CopyApplicativeSeq for T {
|
|
fn copy_seq<'a, A: 'a + Copy, B: 'a + Copy, F: 'a + Copy + Fn(A) -> B>(
|
|
ff: Self::CF<'a, F>,
|
|
fa: Self::CF<'a, A>,
|
|
) -> Self::CF<'a, B> {
|
|
Self::seq(ff, fa)
|
|
}
|
|
}
|
|
|
|
pub trait CopyApplicativeLA2: CopyFunctor {
|
|
fn copy_la2<'a, A: 'a + Copy, B: 'a + Copy, C: 'a + Copy, F: 'a + Copy + Fn(A, B) -> C>(
|
|
f: F,
|
|
fa: Self::CF<'a, A>,
|
|
fb: Self::CF<'a, B>,
|
|
) -> Self::CF<'a, C>;
|
|
|
|
fn _copy_seq<'a, A: 'a + Copy, B: 'a + Copy, F: 'a + Copy + Fn(A) -> B>(
|
|
ff: Self::CF<'a, F>,
|
|
fa: Self::CF<'a, A>,
|
|
) -> Self::CF<'a, B> {
|
|
Self::copy_la2(|f, a| f(a), ff, fa)
|
|
}
|
|
}
|
|
|
|
impl<T: ApplicativeLA2> CopyApplicativeLA2 for T {
|
|
fn copy_la2<'a, A: 'a + Copy, B: 'a + Copy, C: 'a + Copy, F: 'a + Copy + Fn(A, B) -> C>(
|
|
f: F,
|
|
fa: Self::CF<'a, A>,
|
|
fb: Self::CF<'a, B>,
|
|
) -> Self::CF<'a, C> {
|
|
Self::la2(f, fa, fb)
|
|
}
|
|
}
|
|
|
|
// pub trait CopyApplicative: CopyFunctor + CopyApplicativeSeq + CopyApplicativeLA2 {
|
|
// fn copy_pure<A: Copy>(a: A) -> Self::CF<A>;
|
|
|
|
// fn copy_discard_first<A: Copy, B: Copy>(fa: Self::CF<A>, fb: Self::CF<B>) -> Self::CF<B> {
|
|
// Self::copy_seq(Self::copy_replace(fa, |b| b), fb)
|
|
// }
|
|
|
|
// fn copy_discard_second<A: Copy, B: Copy>(fa: Self::CF<A>, fb: Self::CF<B>) -> Self::CF<A> {
|
|
// Self::copy_la2(|a, _| a, fa, fb)
|
|
// }
|
|
// }
|
|
|
|
// impl<T: Applicative> CopyApplicative for T {
|
|
// fn copy_pure<A: Copy>(a: A) -> Self::CF<A> {
|
|
// Self::pure(a)
|
|
// }
|
|
|
|
// fn copy_discard_first<A: Copy, B: Copy>(fa: Self::CF<A>, fb: Self::CF<B>) -> Self::CF<B> {
|
|
// Self::discard_first(fa, fb)
|
|
// }
|
|
|
|
// fn copy_discard_second<A: Copy, B: Copy>(fa: Self::CF<A>, fb: Self::CF<B>) -> Self::CF<A> {
|
|
// Self::discard_second(fa, fb)
|
|
// }
|
|
// }
|
|
|
|
// pub trait CopyMonad: CopyApplicative {
|
|
// fn copy_bind<A: Copy, B: Copy, F: Copy + Fn(A) -> Self::CF<B>>(
|
|
// fa: Self::CF<A>,
|
|
// f: F,
|
|
// ) -> Self::CF<B>;
|
|
|
|
// fn copy_join<A: Copy>(ffa: Self::CF<Self::CF<A>>) -> Self::CF<A>
|
|
// where
|
|
// Self::CF<A>: Copy,
|
|
// {
|
|
// // ugly
|
|
// Self::copy_bind(ffa, |fa| fa)
|
|
// }
|
|
// }
|
|
|
|
// impl<T: Monad> CopyMonad for T {
|
|
// fn copy_bind<A: Copy, B: Copy, F: Copy + Fn(A) -> Self::CF<B>>(
|
|
// fa: Self::CF<A>,
|
|
// f: F,
|
|
// ) -> Self::CF<B> {
|
|
// T::bind(fa, f)
|
|
// }
|
|
|
|
// fn copy_join<A: Copy>(ffa: Self::CF<Self::CF<A>>) -> Self::CF<A>
|
|
// where
|
|
// Self::CF<A>: Copy,
|
|
// {
|
|
// T::join(ffa)
|
|
// }
|
|
// }
|