From eeb1e9e886fe49cb9d7fc225dbfcd19ecccb276d Mon Sep 17 00:00:00 2001 From: timofey Date: Sat, 17 Jun 2023 18:48:22 +0000 Subject: [PATCH] remove non-`FnOnce` classes --- src/func.rs | 2 - src/func/clone_func.rs | 105 ----------------------------------------- src/func/copy_func.rs | 86 --------------------------------- 3 files changed, 193 deletions(-) delete mode 100644 src/func/clone_func.rs delete mode 100644 src/func/copy_func.rs diff --git a/src/func.rs b/src/func.rs index e2492cc..5a44bb8 100644 --- a/src/func.rs +++ b/src/func.rs @@ -8,10 +8,8 @@ //! * mod applicative_select; -pub mod clone_func; pub mod context; mod controlflow; -pub mod copy_func; pub mod derivations; mod extensions; pub mod instances; diff --git a/src/func/clone_func.rs b/src/func/clone_func.rs deleted file mode 100644 index 5eb5199..0000000 --- a/src/func/clone_func.rs +++ /dev/null @@ -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) - } -} diff --git a/src/func/copy_func.rs b/src/func/copy_func.rs deleted file mode 100644 index fd4ebc3..0000000 --- a/src/func/copy_func.rs +++ /dev/null @@ -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) - } -}