PTV/radn-rs
1
1
Fork 0
Code Issues 3 Pull Requests Packages Projects Releases Wiki Activity

remove non-FnOnce classes

Browse Source
This commit is contained in:
AF 2023-06-17 18:48:22 +00:00
parent c1f48b1c08
commit eeb1e9e886
3 changed files with 0 additions and 193 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/func.rs
View File

@ -8,10 +8,8 @@
//! * <https://hackage.haskell.org/package/base-4.18.0.0/docs/Control-Monad.html>
mod applicative_select;
pub mod clone_func;
pub mod context;
mod controlflow;
pub mod copy_func;
pub mod derivations;
mod extensions;
pub mod instances;

105
src/func/clone_func.rs
View File

@ -1,105 +0,0 @@
//! Equivalent of [`crate::func`] for [`Clone`]/[`Fn`] Category.
//! Similar to what you'd encounter in Haskell.
//! Not well maintained due to not being used in the main RADN code base.
//!
//! See also: [`super::copy_func`]
pub trait CloneWeakFunctor {
type ClF<'a, A: Clone>: Clone;
}
pub trait CloneFunctor: CloneWeakFunctor {
fn clone_fmap<'a, A: 'a + Clone, B: 'a + Clone>(
f: impl 'a + Fn(A) -> B,
fa: Self::ClF<'a, A>,
) -> Self::ClF<'a, B>;
fn clone_replace<'a, A: 'a + Clone, B: 'a + Clone>(
fa: Self::ClF<'a, A>,
b: B,
) -> Self::ClF<'a, B> {
Self::clone_fmap(move |_| b.clone(), fa)
}
fn clone_void<'a, A: 'a + Clone>(fa: Self::ClF<'a, A>) -> Self::ClF<'a, ()> {
Self::clone_replace(fa, ())
}
}
pub trait CloneApplicativeSeq: CloneFunctor {
fn clone_seq<'a, A: 'a + Clone, B: 'a + Clone, F: 'a + Clone + Fn(A) -> B>(
ff: Self::ClF<'a, F>,
fa: Self::ClF<'a, A>,
) -> Self::ClF<'a, B>;
fn _clone_la2<
'a,
A: 'a + Clone,
B: 'a + Clone,
C: 'a + Clone,
F: 'a + Clone + Fn(A, B) -> C,
>(
f: F,
fa: Self::ClF<'a, A>,
fb: Self::ClF<'a, B>,
) -> Self::ClF<'a, C> {
Self::clone_seq(
Self::clone_fmap(
move |a| {
let cf = f.clone();
move |b: B| cf(a.clone(), b)
},
fa,
),
fb,
)
}
}
pub trait CloneApplicativeLA2: CloneFunctor {
fn clone_la2<'a, A: 'a + Clone, B: 'a + Clone, C: 'a + Clone, F: 'a + Clone + Fn(A, B) -> C>(
f: F,
fa: Self::ClF<'a, A>,
fb: Self::ClF<'a, B>,
) -> Self::ClF<'a, C>;
fn _clone_seq<'a, A: 'a + Clone, B: 'a + Clone, F: 'a + Clone + Fn(A) -> B>(
ff: Self::ClF<'a, F>,
fa: Self::ClF<'a, A>,
) -> Self::ClF<'a, B> {
Self::clone_la2(|f, a| f(a), ff, fa)
}
}
pub trait CloneApplicative: CloneFunctor + CloneApplicativeSeq + CloneApplicativeLA2 {
fn clone_pure<'a, A: 'a + Clone>(a: A) -> Self::ClF<'a, A>;
fn clone_discard_first<'a, A: 'a + Clone, B: 'a + Clone>(
fa: Self::ClF<'a, A>,
fb: Self::ClF<'a, B>,
) -> Self::ClF<'a, B> {
Self::clone_seq(Self::clone_replace(fa, |b| b), fb)
}
fn clone_discard_second<'a, A: 'a + Clone, B: 'a + Clone>(
fa: Self::ClF<'a, A>,
fb: Self::ClF<'a, B>,
) -> Self::ClF<'a, A> {
Self::clone_la2(|a, _| a, fa, fb)
}
}
pub trait CloneMonad: CloneApplicative {
fn clone_bind<'a, A: 'a + Clone, B: 'a + Clone, F: 'a + Clone + Fn(A) -> Self::ClF<'a, B>>(
fa: Self::ClF<'a, A>,
f: F,
) -> Self::ClF<'a, B>;
fn clone_join<'a, A: 'a + Clone>(ffa: Self::ClF<'a, Self::ClF<'a, A>>) -> Self::ClF<'a, A>
where
Self::ClF<'a, A>: 'a,
{
// ugly
Self::clone_bind(ffa, |fa| fa)
}
}

86
src/func/copy_func.rs
View File

@ -1,86 +0,0 @@
//! Equivalent of [`crate::func`] for [`Copy`]/[`Fn`] Category.
//! Not well maintained due to not being used in the main RADN code base.
//!
//! See also: [`super::clone_func`]
pub trait CopyWeakFunctor {
type CF<'a, A: Copy>: 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, ())
}
}
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)
}
}
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)
}
}
pub trait CopyApplicative: CopyFunctor + CopyApplicativeSeq + CopyApplicativeLA2 {
fn copy_pure<'a, A: 'a + Copy>(a: A) -> Self::CF<'a, A>;
fn copy_discard_first<'a, A: 'a + Copy, B: 'a + Copy>(
fa: Self::CF<'a, A>,
fb: Self::CF<'a, B>,
) -> Self::CF<'a, B> {
Self::copy_seq(Self::copy_replace(fa, |b| b), fb)
}
fn copy_discard_second<'a, A: 'a + Copy, B: 'a + Copy>(
fa: Self::CF<'a, A>,
fb: Self::CF<'a, B>,
) -> Self::CF<'a, A> {
Self::copy_la2(|a, _| a, fa, fb)
}
}
pub trait CopyMonad: CopyApplicative {
fn copy_bind<'a, A: 'a + Copy, B: 'a + Copy, F: 'a + Copy + Fn(A) -> Self::CF<'a, B>>(
fa: Self::CF<'a, A>,
f: F,
) -> Self::CF<'a, B>;
fn copy_join<'a, A: 'a + Copy>(ffa: Self::CF<'a, Self::CF<'a, A>>) -> Self::CF<'a, A>
where
Self::CF<'a, A>: 'a,
{
// ugly
Self::copy_bind(ffa, |fa| fa)
}
}