From 1c87e639d4369a43cdea7f5467e7d94e35f81c73 Mon Sep 17 00:00:00 2001 From: timofey Date: Fri, 26 May 2023 11:16:34 +0000 Subject: [PATCH] `WeakFunctorAny` --- radn-derive/src/lib.rs | 6 +- src/flow/traversible/algorithms/contains.rs | 6 +- src/flow/traversible/algorithms/subset.rs | 14 ++-- src/func.rs | 74 ++++++++++----------- src/func/applicative_select.rs | 14 ++-- src/func/controlflow.rs | 14 ++-- src/func/derivations.rs | 16 ++--- src/func/instances/composition.rs | 44 ++++++------ src/func/instances/effect.rs | 32 ++++----- src/func/instances/future.rs | 36 +++++----- src/func/instances/lazy.rs | 36 +++++----- src/func/instances/option.rs | 44 ++++++------ src/func/instances/overload.rs | 42 ++++++------ src/func/instances/result.rs | 38 +++++------ src/func/instances/solo.rs | 38 +++++------ src/func/instances/stackless.rs | 36 +++++----- src/func/instances/tryfuture.rs | 38 +++++------ src/func/test_suite.rs | 4 +- src/func/tests.rs | 44 ++++++------ src/rcore.rs | 6 +- src/testing.rs | 6 +- 21 files changed, 293 insertions(+), 295 deletions(-) diff --git a/radn-derive/src/lib.rs b/radn-derive/src/lib.rs index 83e3ba4..a04d8ad 100644 --- a/radn-derive/src/lib.rs +++ b/radn-derive/src/lib.rs @@ -9,18 +9,18 @@ pub fn derive_shared_functor(input: proc_macro::TokenStream) -> proc_macro::Toke let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); let expanded = quote! { impl #impl_generics SharedFunctorAny for #name #ty_generics #where_clause { - type SharedAny<'a, A: 'a + Clone> = Self::F<'a, A> + type SharedAny<'a, A: 'a + Clone> = Self::FAny<'a, A> where Self: 'a; - fn share<'a, A: 'a + Clone>(fa: Self::F<'a, A>) -> Self::SharedAny<'a, A> + fn share<'a, A: 'a + Clone>(fa: Self::FAny<'a, A>) -> Self::SharedAny<'a, A> where Self: 'a, { fa } - fn unshare<'a, A: 'a + Clone>(sa: Self::SharedAny<'a, A>) -> Self::F<'a, A> + fn unshare<'a, A: 'a + Clone>(sa: Self::SharedAny<'a, A>) -> Self::FAny<'a, A> where Self: 'a, { diff --git a/src/flow/traversible/algorithms/contains.rs b/src/flow/traversible/algorithms/contains.rs index e045286..55d5068 100644 --- a/src/flow/traversible/algorithms/contains.rs +++ b/src/flow/traversible/algorithms/contains.rs @@ -4,7 +4,7 @@ pub fn n_contains<'a, T: MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq>( comparator: &'a dyn Comparator, n_set: Rc>, key: Rc, -) -> T::Fa<()> { +) -> T::F<()> { let (t_setl, t_setr, k_set) = n_set.split(); match comparator.pick_smaller(key.as_ref(), k_set.as_ref()) { Comparison::L => t_contains(comparator, t_setl, key), @@ -17,7 +17,7 @@ pub fn r_contains<'a, T: MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq>( comparator: &'a dyn Comparator, r_set: Rc>, key: Rc, -) -> T::Fa<()> { +) -> T::F<()> { T::bind(r_set.resolve(), |n_set| n_contains(comparator, n_set, key)) } @@ -25,7 +25,7 @@ pub fn t_contains<'a, T: MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq>( comparator: &'a dyn Comparator, t_set: Rc>, key: Rc, -) -> T::Fa<()> { +) -> T::F<()> { match t_set.refer() { Some(r_set) => r_contains(comparator, r_set, key), None => T::fail(()), diff --git a/src/flow/traversible/algorithms/subset.rs b/src/flow/traversible/algorithms/subset.rs index 273304d..76d9e81 100644 --- a/src/flow/traversible/algorithms/subset.rs +++ b/src/flow/traversible/algorithms/subset.rs @@ -12,7 +12,7 @@ struct SubsetContext<'a, T: MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq> { } impl<'a, T: 'a + MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq> SubsetContext<'a, T, A, D> { - fn on_l(self, (t_subl, t_subr, k_sub): Split<'a, T, A, D>) -> T::Fa<()> { + fn on_l(self, (t_subl, t_subr, k_sub): Split<'a, T, A, D>) -> T::F<()> { T::la2( and, algorithms::contains::t_contains(self.comparator, self.t_superl.clone(), k_sub.clone()), @@ -36,7 +36,7 @@ impl<'a, T: 'a + MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq> SubsetContext<'a, ) } - fn on_e(self, (t_subl, t_subr, k_sub): Split<'a, T, A, D>) -> T::Fa<()> { + fn on_e(self, (t_subl, t_subr, k_sub): Split<'a, T, A, D>) -> T::F<()> { T::la2( and, t_subset_of_t( @@ -56,7 +56,7 @@ impl<'a, T: 'a + MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq> SubsetContext<'a, ) } - fn on_r(self, (t_subl, t_subr, k_sub): Split<'a, T, A, D>) -> T::Fa<()> { + fn on_r(self, (t_subl, t_subr, k_sub): Split<'a, T, A, D>) -> T::F<()> { T::la2( and, algorithms::contains::t_contains(self.comparator, self.t_superr.clone(), k_sub.clone()), @@ -80,7 +80,7 @@ impl<'a, T: 'a + MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq> SubsetContext<'a, ) } - fn test(self) -> T::Fa<()> { + fn test(self) -> T::F<()> { let split = self.n_subset.split(); match self .comparator @@ -99,7 +99,7 @@ pub fn n_subset_of_n<'a, T: MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq>( n_superset: Rc>, k_l: Option>, k_r: Option>, -) -> T::Fa<()> { +) -> T::F<()> { let (t_superl, t_superr, k_super) = n_superset.split(); if let Some(ref a_l) = k_l { if let Comparison::R = comparator.pick_smaller(a_l.as_ref(), k_super.as_ref()) { @@ -130,7 +130,7 @@ pub fn r_subset_of_r<'a, T: MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq>( r_superset: Rc>, k_l: Option>, k_r: Option>, -) -> T::Fa<()> { +) -> T::F<()> { T::join(T::la2( move |n_subset, n_superset| n_subset_of_n(comparator, n_subset, n_superset, k_l, k_r), r_subset.resolve(), @@ -144,7 +144,7 @@ pub fn t_subset_of_t<'a, T: MonadFail<'a, ()>, A, D: 'a + PartialEq>( t_superset: Rc>, k_l: Option>, k_r: Option>, -) -> T::Fa<()> { +) -> T::F<()> { match (t_subset.refer(), t_superset.refer()) { (None, _) => T::pure(()), (Some(_), None) => T::fail(()), diff --git a/src/func.rs b/src/func.rs index 95213b3..7f78849 100644 --- a/src/func.rs +++ b/src/func.rs @@ -31,9 +31,9 @@ pub use self::controlflow::{Iterative, IterativeWrapped}; #[cfg(doc)] use self::instances::stackless::StacklessInstance; -pub trait WeakFunctor { +pub trait WeakFunctorAny { /// Type of the wrapped value. - type F<'a, A: 'a>: 'a + type FAny<'a, A: 'a>: 'a where Self: 'a; } @@ -41,32 +41,32 @@ pub trait WeakFunctor { /// Part of Haskell's `Functor f` responsible for having `f a`. /// /// -pub trait WeakFunctorA<'a>: 'a { - type Fa: 'a; +pub trait WeakFunctor<'a>: 'a { + type F: 'a; } -impl<'a, T: ?Sized + 'a + WeakFunctor> WeakFunctorA<'a> for T { - type Fa = T::F<'a, A>; +impl<'a, T: ?Sized + 'a + WeakFunctorAny> WeakFunctor<'a> for T { + type F = T::FAny<'a, A>; } -pub type Wrap<'a, A, T> = >::Fa; +pub type Wrap<'a, A, T> = >::F; /// Rust-specific implementation of [`Functor`], respecting `move` semantics. /// /// -pub trait Functor<'a>: WeakFunctorA<'a> { +pub trait Functor<'a>: WeakFunctor<'a> { /// Equivalent or Haskell's `fmap`. /// Due to Rust limitations, it's not a `function->function` conversion. /// For that see [`derivations::fmap`]. - fn fmap(f: impl 'a + FnOnce(A) -> B, fa: Self::Fa) -> Self::Fa; + fn fmap(f: impl 'a + FnOnce(A) -> B, fa: Self::F) -> Self::F; /// Equivalent of Haskell's `$>`/`<$`. - fn replace(fa: Self::Fa, b: B) -> Self::Fa { + fn replace(fa: Self::F, b: B) -> Self::F { Self::fmap(|_| b, fa) } /// Equivalent of Haskell's `void`. - fn void(fa: Self::Fa) -> Self::Fa<()> { + fn void(fa: Self::F) -> Self::F<()> { Self::replace(fa, ()) } } @@ -74,13 +74,13 @@ pub trait Functor<'a>: WeakFunctorA<'a> { /// Part of [`Applicative`] responsible for Haskell's value lifting, `pure`. pub trait Pure<'a>: Functor<'a> { /// Equivalent of Haskell's `pure`/`return`. - fn pure(a: A) -> Self::Fa; + fn pure(a: A) -> Self::F; } /// Part of [`Applicative`] responsible for Haskell's sequential application `<*>`. pub trait ApplicativeSeq<'a>: Functor<'a> { /// Equivalent of Haskell's `<*>`. - fn seq(ff: Self::Fa B>, fa: Self::Fa) -> Self::Fa; + fn seq(ff: Self::F B>, fa: Self::F) -> Self::F; } /// Part of [`Applicative`] responsible for Haskell's result combination `listA2`. @@ -88,15 +88,15 @@ pub trait ApplicativeLA2<'a>: Functor<'a> { /// Equivalent of Haskell's `listA2`. fn la2( f: impl 'a + FnOnce(A, B) -> C, - fa: Self::Fa, - fb: Self::Fa, - ) -> Self::Fa; + fa: Self::F, + fb: Self::F, + ) -> Self::F; } /// Part of [`Applicative`] responsible for Rust-style result combination, specifically for tuples. pub trait ApplicativeTuple<'a>: Functor<'a> { /// Similar to Haskell's `listA2` but with [Iterator::collect]-ish semantics. - fn tuple(fab: (Self::Fa, Self::Fa)) -> Self::Fa<(A, B)>; + fn tuple(fab: (Self::F, Self::F)) -> Self::F<(A, B)>; } /// Equivalent of Haskell's `Applicative`. @@ -107,12 +107,12 @@ pub trait Applicative<'a>: Pure<'a> + ApplicativeSeq<'a> + ApplicativeLA2<'a> + ApplicativeTuple<'a> + ApplicativeSelect<'a> { /// Equivalent of Haskell's `*>`/`>>`. - fn discard_first(fa: Self::Fa, fb: Self::Fa) -> Self::Fa { + fn discard_first(fa: Self::F, fb: Self::F) -> Self::F { Self::seq(Self::replace(fa, |b| b), fb) } /// Equivalent of Haskell's `<*`. - fn discard_second(fa: Self::Fa, fb: Self::Fa) -> Self::Fa { + fn discard_second(fa: Self::F, fb: Self::F) -> Self::F { Self::la2(|a, _| a, fa, fb) } } @@ -124,16 +124,16 @@ pub trait Monad<'a>: Applicative<'a> { /// Equivalent of Haskell's `>==`. /// Due to Rust limitations, it's not a `function->function` conversion. /// For that see [`derivations::bind`]. - fn bind(fa: Self::Fa, f: impl 'a + FnOnce(A) -> Self::Fa) -> Self::Fa; + fn bind(fa: Self::F, f: impl 'a + FnOnce(A) -> Self::F) -> Self::F; /// Included for optimisation and clarity. /// Generally, [`Monad::bind`] should be enough implement it. /// See [`StacklessInstance::iterate`] for a generic, though less-than ideal, blanket implementation. /// On practice, you generally shouldn't be using [`Monad::bind`]/[`Pure::pure`]/[`Functor::fmap`] here. - fn iterate(f: impl Iterative<'a, T = Self, B = B>) -> Self::Fa; + fn iterate(f: impl Iterative<'a, T = Self, B = B>) -> Self::F; /// Equivalent of Haskell's `join`. - fn join(ffa: Self::Fa>) -> Self::Fa { + fn join(ffa: Self::F>) -> Self::F { Self::bind(ffa, |fa| fa) } } @@ -145,8 +145,8 @@ pub trait MonadExt<'a>: Monad<'a> { /// rather than some dedicated state type. fn iterate_mut( a: A, - f: impl 'a + FnMut(A) -> Self::Fa>, - ) -> Self::Fa { + f: impl 'a + FnMut(A) -> Self::F>, + ) -> Self::F { Self::iterate(BindableMut::new(a, f)) } } @@ -154,9 +154,9 @@ pub trait MonadExt<'a>: Monad<'a> { impl<'a, T: Monad<'a>> MonadExt<'a> for T {} /// Part of [`MonadFail`] responsible for Haskell's `fail`. -pub trait Fail<'a, E: 'a>: WeakFunctorA<'a> { +pub trait Fail<'a, E: 'a>: WeakFunctor<'a> { /// Equivalent of Haskell's `fail`. - fn fail(e: E) -> Self::Fa; + fn fail(e: E) -> Self::F; } /// Equivalent of Haskell's `MonadFail`. Auto-implemented for all [`Fail`]`+`[`Monad`]. @@ -167,14 +167,14 @@ pub trait MonadFail<'a, E: 'a>: Monad<'a> + Fail<'a, E> {} impl<'a, E: 'a, T: Monad<'a> + Fail<'a, E>> MonadFail<'a, E> for T {} /// Represents wrapped results which are instantly available. -pub trait LocalFunctor<'a>: WeakFunctorA<'a> { +pub trait LocalFunctor<'a>: WeakFunctor<'a> { /// Extract iteration state, if successful. - fn unstuff(state: Self::Fa>) -> ControlFlow, A> { + fn unstuff(state: Self::F>) -> ControlFlow, A> { Self::stuff::<_, ControlFlowInstance>(state) } /// Stuff wrapped result into another functor. - fn stuff>(fa: Self::Fa>) -> T::Fa>; + fn stuff>(fa: Self::F>) -> T::F>; } /// Represents a (collection of) [Monad]\(s) that can hold any type of error. @@ -268,36 +268,36 @@ pub trait MonadFailAnyExt<'a>: MonadFailAny<'a> { impl<'a, Fallible: ?Sized + MonadFailAny<'a>> MonadFailAnyExt<'a> for Fallible {} -pub trait SharedFunctorAny: WeakFunctor { +pub trait SharedFunctorAny: WeakFunctorAny { type SharedAny<'a, A: 'a + Clone>: 'a + Clone where Self: 'a; - fn share<'a, A: 'a + Clone>(fa: Self::F<'a, A>) -> Self::SharedAny<'a, A> + fn share<'a, A: 'a + Clone>(fa: Self::FAny<'a, A>) -> Self::SharedAny<'a, A> where Self: 'a; - fn unshare<'a, A: 'a + Clone>(sa: Self::SharedAny<'a, A>) -> Self::F<'a, A> + fn unshare<'a, A: 'a + Clone>(sa: Self::SharedAny<'a, A>) -> Self::FAny<'a, A> where Self: 'a; } -pub trait SharedFunctor<'a>: WeakFunctorA<'a> { +pub trait SharedFunctor<'a>: WeakFunctor<'a> { type Shared: 'a + Clone; - fn share(fa: Self::Fa) -> Self::Shared; + fn share(fa: Self::F) -> Self::Shared; - fn unshare(sa: Self::Shared) -> Self::Fa; + fn unshare(sa: Self::Shared) -> Self::F; } impl<'a, T: 'a + SharedFunctorAny> SharedFunctor<'a> for T { type Shared = T::SharedAny<'a, A>; - fn share(fa: Self::Fa) -> Self::Shared { + fn share(fa: Self::F) -> Self::Shared { T::share(fa) } - fn unshare(sa: Self::Shared) -> Self::Fa { + fn unshare(sa: Self::Shared) -> Self::F { T::unshare(sa) } } diff --git a/src/func/applicative_select.rs b/src/func/applicative_select.rs index 3e986ba..0f636ad 100644 --- a/src/func/applicative_select.rs +++ b/src/func/applicative_select.rs @@ -1,14 +1,14 @@ use super::*; -pub enum Selected<'a, A: 'a, B: 'a, T: ?Sized + WeakFunctorA<'a>> { - A(A, T::Fa), - B(T::Fa, B), +pub enum Selected<'a, A: 'a, B: 'a, T: ?Sized + WeakFunctor<'a>> { + A(A, T::F), + B(T::F, B), } pub type SelectedWrapped<'a, A, B, T> = Wrap<'a, Selected<'a, A, B, T>, T>; pub trait ApplicativeSelect<'a>: Functor<'a> { - fn select(fa: Self::Fa, fb: Self::Fa) -> SelectedWrapped<'a, A, B, Self> { + fn select(fa: Self::F, fb: Self::F) -> SelectedWrapped<'a, A, B, Self> { Self::fmap(|a| Selected::A(a, fb), fa) } } @@ -16,9 +16,9 @@ pub trait ApplicativeSelect<'a>: Functor<'a> { pub trait ApplicativeSelectExt<'a>: ApplicativeSelect<'a> { fn select_map( f: impl 'a + FnOnce(Selected<'a, A, B, Self>) -> C, - fa: Self::Fa, - fb: Self::Fa, - ) -> Self::Fa { + fa: Self::F, + fb: Self::F, + ) -> Self::F { Self::fmap(f, Self::select(fa, fb)) } } diff --git a/src/func/controlflow.rs b/src/func/controlflow.rs index d001ac4..8acff0a 100644 --- a/src/func/controlflow.rs +++ b/src/func/controlflow.rs @@ -4,14 +4,14 @@ use super::*; pub struct ControlFlowInstance(ControlFlow<(), C>); -impl WeakFunctor for ControlFlowInstance { - type F<'a, A: 'a> = ControlFlow +impl WeakFunctorAny for ControlFlowInstance { + type FAny<'a, A: 'a> = ControlFlow where Self: 'a; } impl<'a, C: 'a> Functor<'a> for ControlFlowInstance { - fn fmap(f: impl 'a + FnOnce(A) -> B, fa: Self::Fa) -> Self::Fa { + fn fmap(f: impl 'a + FnOnce(A) -> B, fa: Self::F) -> Self::F { match fa { ControlFlow::Continue(c) => ControlFlow::Continue(c), ControlFlow::Break(a) => ControlFlow::Break(f(a)), @@ -20,14 +20,14 @@ impl<'a, C: 'a> Functor<'a> for ControlFlowInstance { } impl<'a, C: 'a> Pure<'a> for ControlFlowInstance { - fn pure(a: A) -> Self::Fa { + fn pure(a: A) -> Self::F { ControlFlow::Break(a) } } pub struct BindableMut(A, F, PhantomData, PhantomData); -impl<'a, T: ?Sized + Functor<'a>, A: 'a, B: 'a, F: 'a + FnMut(A) -> T::Fa>> +impl<'a, T: ?Sized + Functor<'a>, A: 'a, B: 'a, F: 'a + FnMut(A) -> T::F>> BindableMut { pub fn new(a: A, f: F) -> Self { @@ -35,7 +35,7 @@ impl<'a, T: ?Sized + Functor<'a>, A: 'a, B: 'a, F: 'a + FnMut(A) -> T::Fa, A: 'a, B: 'a, F: 'a + FnMut(A) -> T::Fa>> +impl<'a, T: ?Sized + Functor<'a>, A: 'a, B: 'a, F: 'a + FnMut(A) -> T::F>> Iterative<'a> for BindableMut { type B = B; @@ -64,7 +64,7 @@ pub trait Iterative<'a>: 'a + Sized { /// [`ControlFlow::Break`]. type B: 'a; /// Corresponding [`WeakFunctor`]. - type T: ?Sized + WeakFunctorA<'a>; + type T: ?Sized + WeakFunctor<'a>; /// Get next state. fn next(self) -> IterativeWrapped<'a, Self>; } diff --git a/src/func/derivations.rs b/src/func/derivations.rs index 7e879d8..58724ec 100644 --- a/src/func/derivations.rs +++ b/src/func/derivations.rs @@ -11,7 +11,7 @@ pub fn fmap<'a, T: Functor<'a>, A: 'a, B: 'a>( /// Equivalent of Haskell's `fmap`. `function-function` equivalent of [Monad::bind]. pub fn bind<'a, T: Monad<'a>, A: 'a, B: 'a>( - f: impl 'a + FnOnce(A) -> T::Fa, + f: impl 'a + FnOnce(A) -> T::F, ) -> impl FnOnce(Wrap<'a, A, T>) -> Wrap<'a, B, T> { move |fa| T::bind(fa, f) } @@ -19,9 +19,9 @@ pub fn bind<'a, T: Monad<'a>, A: 'a, B: 'a>( pub trait ApplicativeLA2ViaSeq<'a>: ApplicativeSeq<'a> { fn _la2_via_seq( f: impl 'a + FnOnce(A, B) -> C, - fa: Self::Fa, - fb: Self::Fa, - ) -> Self::Fa { + fa: Self::F, + fb: Self::F, + ) -> Self::F { Self::seq(Self::fmap(|a| |b| f(a, b), fa), fb) } } @@ -30,9 +30,9 @@ impl<'a, T: ApplicativeSeq<'a>> ApplicativeLA2ViaSeq<'a> for T {} pub trait ApplicativeSeqViaLA2<'a>: ApplicativeLA2<'a> { fn _seq_via_la2( - ff: Self::Fa B>, - fa: Self::Fa, - ) -> Self::Fa { + ff: Self::F B>, + fa: Self::F, + ) -> Self::F { Self::la2(|f, a| f(a), ff, fa) } } @@ -40,7 +40,7 @@ pub trait ApplicativeSeqViaLA2<'a>: ApplicativeLA2<'a> { impl<'a, T: ApplicativeLA2<'a>> ApplicativeSeqViaLA2<'a> for T {} pub trait ApplicativeTupleViaLA2<'a>: ApplicativeLA2<'a> { - fn _tuple_via_la2((fa, fb): (Self::Fa, Self::Fa)) -> Self::Fa<(A, B)> { + fn _tuple_via_la2((fa, fb): (Self::F, Self::F)) -> Self::F<(A, B)> { Self::la2(|a, b| (a, b), fa, fb) } } diff --git a/src/func/instances/composition.rs b/src/func/instances/composition.rs index 494ce52..e19384a 100644 --- a/src/func/instances/composition.rs +++ b/src/func/instances/composition.rs @@ -2,26 +2,26 @@ use crate::func::*; pub struct CompositionInstance(U, V); -impl<'a, U: WeakFunctorA<'a>, V: WeakFunctorA<'a>> WeakFunctorA<'a> for CompositionInstance { - type Fa = U::Fa>; +impl<'a, U: WeakFunctor<'a>, V: WeakFunctor<'a>> WeakFunctor<'a> for CompositionInstance { + type F = U::F>; } impl<'a, U: Functor<'a>, V: Functor<'a>> Functor<'a> for CompositionInstance { - fn fmap(f: impl 'a + FnOnce(A) -> B, fa: Self::Fa) -> Self::Fa { + fn fmap(f: impl 'a + FnOnce(A) -> B, fa: Self::F) -> Self::F { U::fmap(|ua| V::fmap(f, ua), fa) } - fn replace(fa: Self::Fa, b: B) -> Self::Fa { + fn replace(fa: Self::F, b: B) -> Self::F { U::fmap(|ua| V::replace(ua, b), fa) } - fn void(fa: Self::Fa) -> Self::Fa<()> { + fn void(fa: Self::F) -> Self::F<()> { U::fmap(|ua| V::void(ua), fa) } } impl<'a, U: Pure<'a>, V: Pure<'a>> Pure<'a> for CompositionInstance { - fn pure(a: A) -> Self::Fa { + fn pure(a: A) -> Self::F { U::pure(V::pure(a)) } } @@ -29,7 +29,7 @@ impl<'a, U: Pure<'a>, V: Pure<'a>> Pure<'a> for CompositionInstance { impl<'a, U: ApplicativeLA2<'a>, V: ApplicativeSeq<'a>> ApplicativeSeq<'a> for CompositionInstance { - fn seq(ff: Self::Fa B>, fa: Self::Fa) -> Self::Fa { + fn seq(ff: Self::F B>, fa: Self::F) -> Self::F { U::la2(|uf, ua| V::seq(uf, ua), ff, fa) } } @@ -39,9 +39,9 @@ impl<'a, U: ApplicativeLA2<'a>, V: ApplicativeLA2<'a>> ApplicativeLA2<'a> { fn la2( f: impl 'a + FnOnce(A, B) -> C, - fa: Self::Fa, - fb: Self::Fa, - ) -> Self::Fa { + fa: Self::F, + fb: Self::F, + ) -> Self::F { U::la2(|ua, ub| V::la2(f, ua, ub), fa, fb) } } @@ -49,7 +49,7 @@ impl<'a, U: ApplicativeLA2<'a>, V: ApplicativeLA2<'a>> ApplicativeLA2<'a> impl<'a, U: ApplicativeTuple<'a>, V: ApplicativeTuple<'a>> ApplicativeTuple<'a> for CompositionInstance { - fn tuple(fab: (Self::Fa, Self::Fa)) -> Self::Fa<(A, B)> { + fn tuple(fab: (Self::F, Self::F)) -> Self::F<(A, B)> { U::fmap(V::tuple, U::tuple(fab)) } } @@ -57,7 +57,7 @@ impl<'a, U: ApplicativeTuple<'a>, V: ApplicativeTuple<'a>> ApplicativeTuple<'a> impl<'a, U: ApplicativeSelect<'a>, V: Functor<'a>> ApplicativeSelect<'a> for CompositionInstance { - fn select(fa: Self::Fa, fb: Self::Fa) -> SelectedWrapped<'a, A, B, Self> { + fn select(fa: Self::F, fb: Self::F) -> SelectedWrapped<'a, A, B, Self> { U::fmap( |selected| match selected { Selected::A(ua, fb) => V::fmap(|a| Selected::A(a, fb), ua), @@ -69,25 +69,25 @@ impl<'a, U: ApplicativeSelect<'a>, V: Functor<'a>> ApplicativeSelect<'a> } impl<'a, U: Applicative<'a>, V: Applicative<'a>> Applicative<'a> for CompositionInstance { - fn discard_first(fa: Self::Fa, fb: Self::Fa) -> Self::Fa { + fn discard_first(fa: Self::F, fb: Self::F) -> Self::F { U::la2(|ua, ub| V::discard_first(ua, ub), fa, fb) } - fn discard_second(fa: Self::Fa, fb: Self::Fa) -> Self::Fa { + fn discard_second(fa: Self::F, fb: Self::F) -> Self::F { U::la2(|ua, ub| V::discard_second(ua, ub), fa, fb) } } impl<'a, U: Monad<'a>, V: Monad<'a> + LocalFunctor<'a>> Monad<'a> for CompositionInstance { - fn bind(fa: Self::Fa, f: impl 'a + FnOnce(A) -> Self::Fa) -> Self::Fa { + fn bind(fa: Self::F, f: impl 'a + FnOnce(A) -> Self::F) -> Self::F { U::bind(fa, |ua| U::fmap(V::join, V::stuff::<_, U>(V::fmap(f, ua)))) } - fn iterate(f: impl Iterative<'a, T = Self, B = B>) -> Self::Fa { + fn iterate(f: impl Iterative<'a, T = Self, B = B>) -> Self::F { U::iterate(ComposedIterative(f)) } - fn join(ffa: Self::Fa>) -> Self::Fa { + fn join(ffa: Self::F>) -> Self::F { U::join(U::fmap(|ufa| U::fmap(V::join, V::stuff::<_, U>(ufa)), ffa)) } } @@ -119,7 +119,7 @@ impl< impl<'a, E: 'a, U: Monad<'a>, V: Fail<'a, E> + LocalFunctor<'a>> Fail<'a, E> for CompositionInstance { - fn fail(e: E) -> Self::Fa { + fn fail(e: E) -> Self::F { U::pure(V::fail(e)) } } @@ -127,11 +127,11 @@ impl<'a, E: 'a, U: Monad<'a>, V: Fail<'a, E> + LocalFunctor<'a>> Fail<'a, E> impl<'a, U: LocalFunctor<'a> + Functor<'a>, V: LocalFunctor<'a>> LocalFunctor<'a> for CompositionInstance { - fn unstuff(state: Self::Fa>) -> ControlFlow, A> { + fn unstuff(state: Self::F>) -> ControlFlow, A> { U::unstuff(U::fmap(V::unstuff, state)) } - fn stuff>(fa: Self::Fa>) -> T::Fa> { + fn stuff>(fa: Self::F>) -> T::F> { U::stuff::<_, T>(U::fmap(V::stuff::<_, T>, fa)) } } @@ -141,11 +141,11 @@ impl<'a, U: SharedFunctor<'a> + Functor<'a>, V: SharedFunctor<'a>> SharedFunctor { type Shared = U::Shared>; - fn share(fa: Self::Fa) -> Self::Shared { + fn share(fa: Self::F) -> Self::Shared { U::share(U::fmap(V::share, fa)) } - fn unshare(sa: Self::Shared) -> Self::Fa { + fn unshare(sa: Self::Shared) -> Self::F { U::fmap(V::unshare, U::unshare(sa)) } } diff --git a/src/func/instances/effect.rs b/src/func/instances/effect.rs index 3e47f5e..38dc146 100644 --- a/src/func/instances/effect.rs +++ b/src/func/instances/effect.rs @@ -26,21 +26,21 @@ impl WithEffect { #[derive(SharedFunctorAny)] pub struct EffectInstance(E); -impl WeakFunctor for EffectInstance { - type F<'a, A: 'a> = WithEffect +impl WeakFunctorAny for EffectInstance { + type FAny<'a, A: 'a> = WithEffect where Self: 'a; } impl<'a, E: 'a> Functor<'a> for EffectInstance { - fn fmap(f: impl 'a + FnOnce(A) -> B, fa: Self::Fa) -> Self::Fa { + fn fmap(f: impl 'a + FnOnce(A) -> B, fa: Self::F) -> Self::F { WithEffect { value: f(fa.value), effect: fa.effect, } } - fn replace(fa: Self::Fa, b: B) -> Self::Fa { + fn replace(fa: Self::F, b: B) -> Self::F { drop(fa.value); WithEffect { value: b, @@ -50,7 +50,7 @@ impl<'a, E: 'a> Functor<'a> for EffectInstance { } impl<'a, E: 'a + Effect> Pure<'a> for EffectInstance { - fn pure(a: A) -> Self::Fa { + fn pure(a: A) -> Self::F { WithEffect { value: a, effect: E::e_pure(), @@ -59,7 +59,7 @@ impl<'a, E: 'a + Effect> Pure<'a> for EffectInstance { } impl<'a, E: 'a + Effect> ApplicativeSeq<'a> for EffectInstance { - fn seq(ff: Self::Fa B>, fa: Self::Fa) -> Self::Fa { + fn seq(ff: Self::F B>, fa: Self::F) -> Self::F { WithEffect { value: (ff.value)(fa.value), effect: E::e_seq(ff.effect, fa.effect), @@ -70,9 +70,9 @@ impl<'a, E: 'a + Effect> ApplicativeSeq<'a> for EffectInstance { impl<'a, E: 'a + Effect> ApplicativeLA2<'a> for EffectInstance { fn la2( f: impl 'a + FnOnce(A, B) -> C, - fa: Self::Fa, - fb: Self::Fa, - ) -> Self::Fa { + fa: Self::F, + fb: Self::F, + ) -> Self::F { WithEffect { value: f(fa.value, fb.value), effect: E::e_seq(fa.effect, fb.effect), @@ -81,7 +81,7 @@ impl<'a, E: 'a + Effect> ApplicativeLA2<'a> for EffectInstance { } impl<'a, E: 'a + Effect> ApplicativeTuple<'a> for EffectInstance { - fn tuple((fa, fb): (Self::Fa, Self::Fa)) -> Self::Fa<(A, B)> { + fn tuple((fa, fb): (Self::F, Self::F)) -> Self::F<(A, B)> { WithEffect { value: (fa.value, fb.value), effect: E::e_seq(fa.effect, fb.effect), @@ -92,7 +92,7 @@ impl<'a, E: 'a + Effect> ApplicativeTuple<'a> for EffectInstance { impl<'a, E: 'a + Effect> ApplicativeSelect<'a> for EffectInstance {} impl<'a, E: 'a + Effect> Applicative<'a> for EffectInstance { - fn discard_first(fa: Self::Fa, fb: Self::Fa) -> Self::Fa { + fn discard_first(fa: Self::F, fb: Self::F) -> Self::F { drop(fa.value); WithEffect { value: fb.value, @@ -100,7 +100,7 @@ impl<'a, E: 'a + Effect> Applicative<'a> for EffectInstance { } } - fn discard_second(fa: Self::Fa, fb: Self::Fa) -> Self::Fa { + fn discard_second(fa: Self::F, fb: Self::F) -> Self::F { drop(fb.value); WithEffect { value: fa.value, @@ -110,11 +110,11 @@ impl<'a, E: 'a + Effect> Applicative<'a> for EffectInstance { } impl<'a, E: 'a + Effect> Monad<'a> for EffectInstance { - fn bind(fa: Self::Fa, f: impl 'a + FnOnce(A) -> Self::Fa) -> Self::Fa { + fn bind(fa: Self::F, f: impl 'a + FnOnce(A) -> Self::F) -> Self::F { f(fa.value).e_after(fa.effect) } - fn iterate(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::Fa { + fn iterate(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::F { let mut effect = E::e_pure(); loop { let fa = f.next(); @@ -126,13 +126,13 @@ impl<'a, E: 'a + Effect> Monad<'a> for EffectInstance { } } - fn join(ffa: Self::Fa>) -> Self::Fa { + fn join(ffa: Self::F>) -> Self::F { ffa.value.e_after(ffa.effect) } } impl<'a, E: 'a> LocalFunctor<'a> for EffectInstance { - fn stuff>(fa: Self::Fa>) -> T::Fa> { + fn stuff>(fa: Self::F>) -> T::F> { T::fmap( |a| WithEffect { value: a, diff --git a/src/func/instances/future.rs b/src/func/instances/future.rs index 4f9fdae..2397702 100644 --- a/src/func/instances/future.rs +++ b/src/func/instances/future.rs @@ -14,16 +14,16 @@ use crate::func::*; pub struct FutureInstance; -impl WeakFunctor for FutureInstance { - type F<'a, A: 'a> = Pin>>; +impl WeakFunctorAny for FutureInstance { + type FAny<'a, A: 'a> = Pin>>; } impl<'a> Functor<'a> for FutureInstance { - fn fmap(f: impl 'a + FnOnce(A) -> B, fa: Self::Fa) -> Self::Fa { + fn fmap(f: impl 'a + FnOnce(A) -> B, fa: Self::F) -> Self::F { Box::pin(async { f(fa.await) }) } - fn replace(fa: Self::Fa, b: B) -> Self::Fa { + fn replace(fa: Self::F, b: B) -> Self::F { Box::pin(async { fa.await; b @@ -32,13 +32,13 @@ impl<'a> Functor<'a> for FutureInstance { } impl<'a> Pure<'a> for FutureInstance { - fn pure(a: A) -> Self::Fa { + fn pure(a: A) -> Self::F { Box::pin(async { a }) } } impl<'a> ApplicativeSeq<'a> for FutureInstance { - fn seq(ff: Self::Fa B>, fa: Self::Fa) -> Self::Fa { + fn seq(ff: Self::F B>, fa: Self::F) -> Self::F { Box::pin(async { let (f, a) = join!(ff, fa); f(a) @@ -49,9 +49,9 @@ impl<'a> ApplicativeSeq<'a> for FutureInstance { impl<'a> ApplicativeLA2<'a> for FutureInstance { fn la2( f: impl 'a + FnOnce(A, B) -> C, - fa: Self::Fa, - fb: Self::Fa, - ) -> Self::Fa { + fa: Self::F, + fb: Self::F, + ) -> Self::F { Box::pin(async { let (a, b) = join!(fa, fb); f(a, b) @@ -60,13 +60,13 @@ impl<'a> ApplicativeLA2<'a> for FutureInstance { } impl<'a> ApplicativeTuple<'a> for FutureInstance { - fn tuple((fa, fb): (Self::Fa, Self::Fa)) -> Self::Fa<(A, B)> { + fn tuple((fa, fb): (Self::F, Self::F)) -> Self::F<(A, B)> { Box::pin(async { join!(fa, fb) }) } } impl<'a> ApplicativeSelect<'a> for FutureInstance { - fn select(fa: Self::Fa, fb: Self::Fa) -> SelectedWrapped<'a, A, B, Self> { + fn select(fa: Self::F, fb: Self::F) -> SelectedWrapped<'a, A, B, Self> { Box::pin(async { match select(fa, fb).await { Either::Left((a, fb)) => Selected::A(a, fb), @@ -77,21 +77,21 @@ impl<'a> ApplicativeSelect<'a> for FutureInstance { } impl<'a> Applicative<'a> for FutureInstance { - fn discard_first(fa: Self::Fa, fb: Self::Fa) -> Self::Fa { + fn discard_first(fa: Self::F, fb: Self::F) -> Self::F { Box::pin(async { join!(fa, fb).1 }) } - fn discard_second(fa: Self::Fa, fb: Self::Fa) -> Self::Fa { + fn discard_second(fa: Self::F, fb: Self::F) -> Self::F { Box::pin(async { join!(fa, fb).0 }) } } impl<'a> Monad<'a> for FutureInstance { - fn bind(fa: Self::Fa, f: impl 'a + FnOnce(A) -> Self::Fa) -> Self::Fa { + fn bind(fa: Self::F, f: impl 'a + FnOnce(A) -> Self::F) -> Self::F { Box::pin(async { f(fa.await).await }) } - fn iterate(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::Fa { + fn iterate(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::F { Box::pin(async move { loop { match f.next().await { @@ -102,7 +102,7 @@ impl<'a> Monad<'a> for FutureInstance { }) } - fn join(ffa: Self::Fa>) -> Self::Fa { + fn join(ffa: Self::F>) -> Self::F { Box::pin(async { ffa.await.await }) } } @@ -110,11 +110,11 @@ impl<'a> Monad<'a> for FutureInstance { impl<'a> SharedFunctor<'a> for FutureInstance { type Shared = Shared>>>; - fn share(fa: Self::Fa) -> Self::Shared { + fn share(fa: Self::F) -> Self::Shared { fa.shared() } - fn unshare(sa: Self::Shared) -> Self::Fa { + fn unshare(sa: Self::Shared) -> Self::F { Box::pin(sa) } } diff --git a/src/func/instances/lazy.rs b/src/func/instances/lazy.rs index 840fcbf..35b7cc1 100644 --- a/src/func/instances/lazy.rs +++ b/src/func/instances/lazy.rs @@ -13,34 +13,34 @@ use crate::func::*; pub struct LazyInstance; -impl WeakFunctor for LazyInstance { - type F<'a, A: 'a> = Box A>; +impl WeakFunctorAny for LazyInstance { + type FAny<'a, A: 'a> = Box A>; } impl<'a> Functor<'a> for LazyInstance { - fn fmap(f: impl 'a + FnOnce(A) -> B, fa: Self::Fa) -> Self::Fa { + fn fmap(f: impl 'a + FnOnce(A) -> B, fa: Self::F) -> Self::F { Box::new(|| f(fa())) } - fn replace(fa: Self::Fa, b: B) -> Self::Fa { + fn replace(fa: Self::F, b: B) -> Self::F { drop(fa); Box::new(|| b) } - fn void(fa: Self::Fa) -> Self::Fa<()> { + fn void(fa: Self::F) -> Self::F<()> { drop(fa); Box::new(|| ()) } } impl<'a> Pure<'a> for LazyInstance { - fn pure(a: A) -> Self::Fa { + fn pure(a: A) -> Self::F { Box::new(|| a) } } impl<'a> ApplicativeSeq<'a> for LazyInstance { - fn seq(ff: Self::Fa B>, fa: Self::Fa) -> Self::Fa { + fn seq(ff: Self::F B>, fa: Self::F) -> Self::F { Box::new(|| ff()(fa())) } } @@ -48,15 +48,15 @@ impl<'a> ApplicativeSeq<'a> for LazyInstance { impl<'a> ApplicativeLA2<'a> for LazyInstance { fn la2( f: impl 'a + FnOnce(A, B) -> C, - fa: Self::Fa, - fb: Self::Fa, - ) -> Self::Fa { + fa: Self::F, + fb: Self::F, + ) -> Self::F { Box::new(|| f(fa(), fb())) } } impl<'a> ApplicativeTuple<'a> for LazyInstance { - fn tuple((fa, fb): (Self::Fa, Self::Fa)) -> Self::Fa<(A, B)> { + fn tuple((fa, fb): (Self::F, Self::F)) -> Self::F<(A, B)> { Box::new(|| (fa(), fb())) } } @@ -64,23 +64,23 @@ impl<'a> ApplicativeTuple<'a> for LazyInstance { impl<'a> ApplicativeSelect<'a> for LazyInstance {} impl<'a> Applicative<'a> for LazyInstance { - fn discard_first(fa: Self::Fa, fb: Self::Fa) -> Self::Fa { + fn discard_first(fa: Self::F, fb: Self::F) -> Self::F { drop(fa); fb } - fn discard_second(fa: Self::Fa, fb: Self::Fa) -> Self::Fa { + fn discard_second(fa: Self::F, fb: Self::F) -> Self::F { drop(fb); fa } } impl<'a> Monad<'a> for LazyInstance { - fn bind(fa: Self::Fa, f: impl 'a + FnOnce(A) -> Self::Fa) -> Self::Fa { + fn bind(fa: Self::F, f: impl 'a + FnOnce(A) -> Self::F) -> Self::F { Box::new(|| f(fa())()) } - fn iterate(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::Fa { + fn iterate(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::F { loop { match f.next()() { ControlFlow::Continue(next_f) => f = next_f, @@ -89,7 +89,7 @@ impl<'a> Monad<'a> for LazyInstance { } } - fn join(ffa: Self::Fa>) -> Self::Fa { + fn join(ffa: Self::F>) -> Self::F { Box::new(|| ffa()()) } } @@ -106,11 +106,11 @@ fn unshare<'a, A: 'a + Clone>(shared: &mut Option A>>) impl<'a> SharedFunctor<'a> for LazyInstance { type Shared = Rc A>>>>; - fn share(fa: Self::Fa) -> Self::Shared { + fn share(fa: Self::F) -> Self::Shared { Rc::new(RefCell::new(Some(fa))) } - fn unshare(sa: Self::Shared) -> Self::Fa { + fn unshare(sa: Self::Shared) -> Self::F { Box::new(move || unshare(&mut *sa.borrow_mut())) } } diff --git a/src/func/instances/option.rs b/src/func/instances/option.rs index a3d9c7b..cc8d5ba 100644 --- a/src/func/instances/option.rs +++ b/src/func/instances/option.rs @@ -12,34 +12,34 @@ use crate::func::*; #[derive(SharedFunctorAny)] pub struct OptionInstance; -impl WeakFunctor for OptionInstance { - type F<'a, A: 'a> = Option; +impl WeakFunctorAny for OptionInstance { + type FAny<'a, A: 'a> = Option; } impl<'a> Functor<'a> for OptionInstance { - fn fmap(f: impl 'a + FnOnce(A) -> B, fa: Self::Fa) -> Self::Fa { + fn fmap(f: impl 'a + FnOnce(A) -> B, fa: Self::F) -> Self::F { fa.map(f) } - fn replace(fa: Self::Fa, b: B) -> Self::Fa { + fn replace(fa: Self::F, b: B) -> Self::F { fa?; Self::pure(b) } - fn void(fa: Self::Fa) -> Self::Fa<()> { + fn void(fa: Self::F) -> Self::F<()> { fa?; Self::pure(()) } } impl<'a> Pure<'a> for OptionInstance { - fn pure(a: A) -> Self::Fa { + fn pure(a: A) -> Self::F { Some(a) } } impl<'a> ApplicativeSeq<'a> for OptionInstance { - fn seq(ff: Self::Fa B>, fa: Self::Fa) -> Self::Fa { + fn seq(ff: Self::F B>, fa: Self::F) -> Self::F { Self::pure(ff?(fa?)) } } @@ -47,15 +47,15 @@ impl<'a> ApplicativeSeq<'a> for OptionInstance { impl<'a> ApplicativeLA2<'a> for OptionInstance { fn la2( f: impl 'a + FnOnce(A, B) -> C, - fa: Self::Fa, - fb: Self::Fa, - ) -> Self::Fa { + fa: Self::F, + fb: Self::F, + ) -> Self::F { Self::pure(f(fa?, fb?)) } } impl<'a> ApplicativeTuple<'a> for OptionInstance { - fn tuple((fa, fb): (Self::Fa, Self::Fa)) -> Self::Fa<(A, B)> { + fn tuple((fa, fb): (Self::F, Self::F)) -> Self::F<(A, B)> { Self::pure((fa?, fb?)) } } @@ -63,23 +63,23 @@ impl<'a> ApplicativeTuple<'a> for OptionInstance { impl<'a> ApplicativeSelect<'a> for OptionInstance {} impl<'a> Applicative<'a> for OptionInstance { - fn discard_first(fa: Self::Fa, fb: Self::Fa) -> Self::Fa { + fn discard_first(fa: Self::F, fb: Self::F) -> Self::F { fa?; fb } - fn discard_second(fa: Self::Fa, fb: Self::Fa) -> Self::Fa { + fn discard_second(fa: Self::F, fb: Self::F) -> Self::F { fb?; fa } } impl<'a> Monad<'a> for OptionInstance { - fn bind(fa: Self::Fa, f: impl 'a + FnOnce(A) -> Self::Fa) -> Self::Fa { + fn bind(fa: Self::F, f: impl 'a + FnOnce(A) -> Self::F) -> Self::F { f(fa?) } - fn iterate(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::Fa { + fn iterate(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::F { loop { match f.next()? { ControlFlow::Continue(next_f) => f = next_f, @@ -88,13 +88,13 @@ impl<'a> Monad<'a> for OptionInstance { } } - fn join(ffa: Self::Fa>) -> Self::Fa { + fn join(ffa: Self::F>) -> Self::F { ffa? } } impl<'a> LocalFunctor<'a> for OptionInstance { - fn unstuff(state: Self::Fa>) -> ControlFlow, A> { + fn unstuff(state: Self::F>) -> ControlFlow, A> { match state { Some(ControlFlow::Continue(a)) => ControlFlow::Continue(a), Some(ControlFlow::Break(b)) => ControlFlow::Break(Some(b)), @@ -102,7 +102,7 @@ impl<'a> LocalFunctor<'a> for OptionInstance { } } - fn stuff>(fa: Self::Fa>) -> T::Fa> { + fn stuff>(fa: Self::F>) -> T::F> { match fa { Some(ua) => T::fmap(Some, ua), None => T::pure(None), @@ -111,7 +111,7 @@ impl<'a> LocalFunctor<'a> for OptionInstance { } impl<'a> Fail<'a, ()> for OptionInstance { - fn fail(_e: ()) -> Self::Fa { + fn fail(_e: ()) -> Self::F { None } } @@ -125,15 +125,15 @@ mod option_tests { impl<'a> tests::Eqr<'a> for T { fn eqr( name: &'a str, - left: Self::Fa, - right: Self::Fa, + left: Self::F, + right: Self::F, ) -> tests::R { tests::eqr(name, left, right) } } impl<'a> test_suite::FunctorTestSuite<'a> for T { - fn sample Self::Fa)>(mut f: F) { + fn sample Self::F)>(mut f: F) { f(&|_| None); f(&|a| Some(a)); } diff --git a/src/func/instances/overload.rs b/src/func/instances/overload.rs index 599541f..1545067 100644 --- a/src/func/instances/overload.rs +++ b/src/func/instances/overload.rs @@ -12,28 +12,26 @@ pub trait DeriveApplicative {} impl DeriveApplicative for O {} pub trait DeriveMonad {} -impl<'a, T: WeakFunctorA<'a>, O: 'a + DeriveWeakFunctor> WeakFunctorA<'a> - for OverloadInstance -{ - type Fa = T::Fa; +impl<'a, T: WeakFunctor<'a>, O: 'a + DeriveWeakFunctor> WeakFunctor<'a> for OverloadInstance { + type F = T::F; } impl<'a, T: Functor<'a>, O: 'a + DeriveFunctor> Functor<'a> for OverloadInstance { - fn fmap(f: impl 'a + FnOnce(A) -> B, fa: Self::Fa) -> Self::Fa { + fn fmap(f: impl 'a + FnOnce(A) -> B, fa: Self::F) -> Self::F { T::fmap(f, fa) } - fn replace(fa: Self::Fa, b: B) -> Self::Fa { + fn replace(fa: Self::F, b: B) -> Self::F { T::replace(fa, b) } - fn void(fa: Self::Fa) -> Self::Fa<()> { + fn void(fa: Self::F) -> Self::F<()> { T::void(fa) } } impl<'a, T: Pure<'a>, O: 'a + DeriveApplicative> Pure<'a> for OverloadInstance { - fn pure(a: A) -> Self::Fa { + fn pure(a: A) -> Self::F { T::pure(a) } } @@ -41,7 +39,7 @@ impl<'a, T: Pure<'a>, O: 'a + DeriveApplicative> Pure<'a> for OverloadInstance, O: 'a + DeriveApplicative> ApplicativeSeq<'a> for OverloadInstance { - fn seq(ff: Self::Fa B>, fa: Self::Fa) -> Self::Fa { + fn seq(ff: Self::F B>, fa: Self::F) -> Self::F { T::seq(ff, fa) } } @@ -51,9 +49,9 @@ impl<'a, T: ApplicativeLA2<'a>, O: 'a + DeriveApplicative> ApplicativeLA2<'a> { fn la2( f: impl 'a + FnOnce(A, B) -> C, - fa: Self::Fa, - fb: Self::Fa, - ) -> Self::Fa { + fa: Self::F, + fb: Self::F, + ) -> Self::F { T::la2(f, fa, fb) } } @@ -61,7 +59,7 @@ impl<'a, T: ApplicativeLA2<'a>, O: 'a + DeriveApplicative> ApplicativeLA2<'a> impl<'a, T: ApplicativeTuple<'a>, O: 'a + DeriveApplicative> ApplicativeTuple<'a> for OverloadInstance { - fn tuple(fab: (Self::Fa, Self::Fa)) -> Self::Fa<(A, B)> { + fn tuple(fab: (Self::F, Self::F)) -> Self::F<(A, B)> { T::tuple(fab) } } @@ -69,7 +67,7 @@ impl<'a, T: ApplicativeTuple<'a>, O: 'a + DeriveApplicative> ApplicativeTuple<'a impl<'a, T: ApplicativeSelect<'a>, O: 'a + DeriveApplicative> ApplicativeSelect<'a> for OverloadInstance { - fn select(fa: Self::Fa, fb: Self::Fa) -> SelectedWrapped<'a, A, B, Self> { + fn select(fa: Self::F, fb: Self::F) -> SelectedWrapped<'a, A, B, Self> { T::select_map( |selected| match selected { Selected::A(a, fb) => Selected::A(a, fb), @@ -82,11 +80,11 @@ impl<'a, T: ApplicativeSelect<'a>, O: 'a + DeriveApplicative> ApplicativeSelect< } impl<'a, T: Applicative<'a>, O: 'a + DeriveApplicative> Applicative<'a> for OverloadInstance { - fn discard_first(fa: Self::Fa, fb: Self::Fa) -> Self::Fa { + fn discard_first(fa: Self::F, fb: Self::F) -> Self::F { T::discard_first(fa, fb) } - fn discard_second(fa: Self::Fa, fb: Self::Fa) -> Self::Fa { + fn discard_second(fa: Self::F, fb: Self::F) -> Self::F { T::discard_second(fa, fb) } } @@ -118,15 +116,15 @@ impl<'a, T: Monad<'a>, O: 'a + DeriveMonad, F: Iterative<'a, T = OverloadInstanc } impl<'a, T: Monad<'a>, O: 'a + DeriveMonad> Monad<'a> for OverloadInstance { - fn bind(fa: Self::Fa, f: impl 'a + FnOnce(A) -> Self::Fa) -> Self::Fa { + fn bind(fa: Self::F, f: impl 'a + FnOnce(A) -> Self::F) -> Self::F { T::bind(fa, f) } - fn iterate(f: impl Iterative<'a, T = Self, B = B>) -> Self::Fa { + fn iterate(f: impl Iterative<'a, T = Self, B = B>) -> Self::F { T::iterate(OverloadIterative::new(f)) } - fn join(ffa: Self::Fa>) -> Self::Fa { + fn join(ffa: Self::F>) -> Self::F { T::join(ffa) } } @@ -138,7 +136,7 @@ impl DeriveMonad for DeriveFail {} impl<'a, E: 'a, Ex: 'a, T: MonadFail<'a, Result>> Fail<'a, E> for OverloadInstance> { - fn fail(e: E) -> Self::Fa { + fn fail(e: E) -> Self::F { T::fail(Ok(e)) } } @@ -199,11 +197,11 @@ impl<'a, T: SharedFunctor<'a>, O: 'a + DeriveWeakFunctor> SharedFunctor<'a> { type Shared = T::Shared; - fn share(fa: Self::Fa) -> Self::Shared { + fn share(fa: Self::F) -> Self::Shared { T::share(fa) } - fn unshare(sa: Self::Shared) -> Self::Fa { + fn unshare(sa: Self::Shared) -> Self::F { T::unshare(sa) } } diff --git a/src/func/instances/result.rs b/src/func/instances/result.rs index 3af93aa..e8a45a9 100644 --- a/src/func/instances/result.rs +++ b/src/func/instances/result.rs @@ -12,34 +12,34 @@ use crate::func::*; #[derive(SharedFunctorAny)] pub struct ResultInstance(E); -impl WeakFunctor for ResultInstance { - type F<'a, A: 'a> = Result where Self: 'a; +impl WeakFunctorAny for ResultInstance { + type FAny<'a, A: 'a> = Result where Self: 'a; } impl<'a, E: 'a> Functor<'a> for ResultInstance { - fn fmap(f: impl 'a + FnOnce(A) -> B, fa: Self::Fa) -> Self::Fa { + fn fmap(f: impl 'a + FnOnce(A) -> B, fa: Self::F) -> Self::F { fa.map(f) } - fn replace(fa: Self::Fa, b: B) -> Self::Fa { + fn replace(fa: Self::F, b: B) -> Self::F { fa?; Self::pure(b) } - fn void(fa: Self::Fa) -> Self::Fa<()> { + fn void(fa: Self::F) -> Self::F<()> { fa?; Self::pure(()) } } impl<'a, E: 'a> Pure<'a> for ResultInstance { - fn pure(a: A) -> Self::Fa { + fn pure(a: A) -> Self::F { Ok(a) } } impl<'a, E: 'a> ApplicativeSeq<'a> for ResultInstance { - fn seq(ff: Self::Fa B>, fa: Self::Fa) -> Self::Fa { + fn seq(ff: Self::F B>, fa: Self::F) -> Self::F { Self::pure(ff?(fa?)) } } @@ -47,15 +47,15 @@ impl<'a, E: 'a> ApplicativeSeq<'a> for ResultInstance { impl<'a, E: 'a> ApplicativeLA2<'a> for ResultInstance { fn la2( f: impl 'a + FnOnce(A, B) -> C, - fa: Self::Fa, - fb: Self::Fa, - ) -> Self::Fa { + fa: Self::F, + fb: Self::F, + ) -> Self::F { Self::pure(f(fa?, fb?)) } } impl<'a, E: 'a> ApplicativeTuple<'a> for ResultInstance { - fn tuple((fa, fb): (Self::Fa, Self::Fa)) -> Self::Fa<(A, B)> { + fn tuple((fa, fb): (Self::F, Self::F)) -> Self::F<(A, B)> { Self::pure((fa?, fb?)) } } @@ -63,23 +63,23 @@ impl<'a, E: 'a> ApplicativeTuple<'a> for ResultInstance { impl<'a, E: 'a> ApplicativeSelect<'a> for ResultInstance {} impl<'a, E: 'a> Applicative<'a> for ResultInstance { - fn discard_first(fa: Self::Fa, fb: Self::Fa) -> Self::Fa { + fn discard_first(fa: Self::F, fb: Self::F) -> Self::F { fa?; fb } - fn discard_second(fa: Self::Fa, fb: Self::Fa) -> Self::Fa { + fn discard_second(fa: Self::F, fb: Self::F) -> Self::F { fb?; fa } } impl<'a, E: 'a> Monad<'a> for ResultInstance { - fn bind(fa: Self::Fa, f: impl 'a + FnOnce(A) -> Self::Fa) -> Self::Fa { + fn bind(fa: Self::F, f: impl 'a + FnOnce(A) -> Self::F) -> Self::F { f(fa?) } - fn iterate(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::Fa { + fn iterate(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::F { loop { match f.next()? { ControlFlow::Continue(next_f) => f = next_f, @@ -88,13 +88,13 @@ impl<'a, E: 'a> Monad<'a> for ResultInstance { } } - fn join(ffa: Self::Fa>) -> Self::Fa { + fn join(ffa: Self::F>) -> Self::F { ffa? } } impl<'a, E: 'a> LocalFunctor<'a> for ResultInstance { - fn unstuff(state: Self::Fa>) -> ControlFlow, A> { + fn unstuff(state: Self::F>) -> ControlFlow, A> { match state { Ok(ControlFlow::Continue(a)) => ControlFlow::Continue(a), Ok(ControlFlow::Break(b)) => ControlFlow::Break(Ok(b)), @@ -102,7 +102,7 @@ impl<'a, E: 'a> LocalFunctor<'a> for ResultInstance { } } - fn stuff>(fa: Self::Fa>) -> T::Fa> { + fn stuff>(fa: Self::F>) -> T::F> { match fa { Ok(ua) => T::fmap(Ok, ua), Err(e) => T::pure(Err(e)), @@ -111,7 +111,7 @@ impl<'a, E: 'a> LocalFunctor<'a> for ResultInstance { } impl<'a, E: 'a> Fail<'a, E> for ResultInstance { - fn fail(e: E) -> Self::Fa { + fn fail(e: E) -> Self::F { Err(e) } } diff --git a/src/func/instances/solo.rs b/src/func/instances/solo.rs index 2f19cc9..185d19a 100644 --- a/src/func/instances/solo.rs +++ b/src/func/instances/solo.rs @@ -7,33 +7,33 @@ use crate::func::*; #[derive(SharedFunctorAny)] pub struct SoloInstance; -impl WeakFunctor for SoloInstance { - type F<'a, A: 'a> = A; +impl WeakFunctorAny for SoloInstance { + type FAny<'a, A: 'a> = A; } impl<'a> Functor<'a> for SoloInstance { - fn fmap(f: impl 'a + FnOnce(A) -> B, fa: Self::Fa) -> Self::Fa { + fn fmap(f: impl 'a + FnOnce(A) -> B, fa: Self::F) -> Self::F { f(fa) } - fn replace(fa: Self::Fa, b: B) -> Self::Fa { + fn replace(fa: Self::F, b: B) -> Self::F { drop(fa); b } - fn void(fa: Self::Fa) -> Self::Fa<()> { + fn void(fa: Self::F) -> Self::F<()> { drop(fa); } } impl<'a> Pure<'a> for SoloInstance { - fn pure(a: A) -> Self::Fa { + fn pure(a: A) -> Self::F { a } } impl<'a> ApplicativeSeq<'a> for SoloInstance { - fn seq(ff: Self::Fa B>, fa: Self::Fa) -> Self::Fa { + fn seq(ff: Self::F B>, fa: Self::F) -> Self::F { ff(fa) } } @@ -41,15 +41,15 @@ impl<'a> ApplicativeSeq<'a> for SoloInstance { impl<'a> ApplicativeLA2<'a> for SoloInstance { fn la2( f: impl 'a + FnOnce(A, B) -> C, - fa: Self::Fa, - fb: Self::Fa, - ) -> Self::Fa { + fa: Self::F, + fb: Self::F, + ) -> Self::F { f(fa, fb) } } impl<'a> ApplicativeTuple<'a> for SoloInstance { - fn tuple((fa, fb): (Self::Fa, Self::Fa)) -> Self::Fa<(A, B)> { + fn tuple((fa, fb): (Self::F, Self::F)) -> Self::F<(A, B)> { (fa, fb) } } @@ -57,23 +57,23 @@ impl<'a> ApplicativeTuple<'a> for SoloInstance { impl<'a> ApplicativeSelect<'a> for SoloInstance {} impl<'a> Applicative<'a> for SoloInstance { - fn discard_first(fa: Self::Fa, fb: Self::Fa) -> Self::Fa { + fn discard_first(fa: Self::F, fb: Self::F) -> Self::F { drop(fa); fb } - fn discard_second(fa: Self::Fa, fb: Self::Fa) -> Self::Fa { + fn discard_second(fa: Self::F, fb: Self::F) -> Self::F { drop(fb); fa } } impl<'a> Monad<'a> for SoloInstance { - fn bind(fa: Self::Fa, f: impl 'a + FnOnce(A) -> Self::Fa) -> Self::Fa { + fn bind(fa: Self::F, f: impl 'a + FnOnce(A) -> Self::F) -> Self::F { f(fa) } - fn iterate(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::Fa { + fn iterate(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::F { loop { match f.next() { ControlFlow::Continue(next_f) => f = next_f, @@ -82,23 +82,23 @@ impl<'a> Monad<'a> for SoloInstance { } } - fn join(ffa: Self::Fa>) -> Self::Fa { + fn join(ffa: Self::F>) -> Self::F { ffa } } impl<'a> LocalFunctor<'a> for SoloInstance { - fn unstuff(state: Self::Fa>) -> ControlFlow, A> { + fn unstuff(state: Self::F>) -> ControlFlow, A> { state } - fn stuff>(fa: Self::Fa>) -> T::Fa> { + fn stuff>(fa: Self::F>) -> T::F> { fa } } impl<'a> Fail<'a, std::convert::Infallible> for SoloInstance { - fn fail(e: std::convert::Infallible) -> Self::Fa { + fn fail(e: std::convert::Infallible) -> Self::F { match e {} } } diff --git a/src/func/instances/stackless.rs b/src/func/instances/stackless.rs index 4690d7e..d8127ca 100644 --- a/src/func/instances/stackless.rs +++ b/src/func/instances/stackless.rs @@ -119,16 +119,16 @@ impl<'a, A: 'a> From for Stackless<'a, A> { pub struct StacklessInstance; -impl WeakFunctor for StacklessInstance { - type F<'a, A: 'a> = Stackless<'a, A>; +impl WeakFunctorAny for StacklessInstance { + type FAny<'a, A: 'a> = Stackless<'a, A>; } impl<'a> Functor<'a> for StacklessInstance { - fn fmap(f: impl 'a + FnOnce(A) -> B, fa: Self::Fa) -> Self::Fa { + fn fmap(f: impl 'a + FnOnce(A) -> B, fa: Self::F) -> Self::F { fa.map(f) } - fn replace(fa: Self::Fa, b: B) -> Self::Fa { + fn replace(fa: Self::F, b: B) -> Self::F { Stackless(Box::new(|takesb| { Some(EvalTree::Composite( Box::new(EvalTree::Atom(Box::new(move || fa.call(drop)))), @@ -142,13 +142,13 @@ impl<'a> Functor<'a> for StacklessInstance { } impl<'a> Pure<'a> for StacklessInstance { - fn pure(a: A) -> Self::Fa { + fn pure(a: A) -> Self::F { Stackless::from(a) } } impl<'a> ApplicativeSeq<'a> for StacklessInstance { - fn seq(ff: Self::Fa B>, fa: Self::Fa) -> Self::Fa { + fn seq(ff: Self::F B>, fa: Self::F) -> Self::F { ff.bind(|f| fa.map(f)) } } @@ -156,15 +156,15 @@ impl<'a> ApplicativeSeq<'a> for StacklessInstance { impl<'a> ApplicativeLA2<'a> for StacklessInstance { fn la2( f: impl 'a + FnOnce(A, B) -> C, - fa: Self::Fa, - fb: Self::Fa, - ) -> Self::Fa { + fa: Self::F, + fb: Self::F, + ) -> Self::F { Self::_la2_via_seq(f, fa, fb) } } impl<'a> ApplicativeTuple<'a> for StacklessInstance { - fn tuple((fa, fb): (Self::Fa, Self::Fa)) -> Self::Fa<(A, B)> { + fn tuple((fa, fb): (Self::F, Self::F)) -> Self::F<(A, B)> { Self::_tuple_via_la2((fa, fb)) } } @@ -172,7 +172,7 @@ impl<'a> ApplicativeTuple<'a> for StacklessInstance { impl<'a> ApplicativeSelect<'a> for StacklessInstance {} impl<'a> Applicative<'a> for StacklessInstance { - fn discard_first(fa: Self::Fa, fb: Self::Fa) -> Self::Fa { + fn discard_first(fa: Self::F, fb: Self::F) -> Self::F { Stackless(Box::new(|takesb| { Some(EvalTree::Composite( Box::new(EvalTree::Atom(Box::new(|| fa.call(drop)))), @@ -181,7 +181,7 @@ impl<'a> Applicative<'a> for StacklessInstance { })) } - fn discard_second(fa: Self::Fa, fb: Self::Fa) -> Self::Fa { + fn discard_second(fa: Self::F, fb: Self::F) -> Self::F { Stackless(Box::new(|takesa| { Some(EvalTree::Composite( Box::new(EvalTree::Atom(Box::new(|| fa.0(takesa)))), @@ -192,11 +192,11 @@ impl<'a> Applicative<'a> for StacklessInstance { } impl<'a> Monad<'a> for StacklessInstance { - fn bind(fa: Self::Fa, f: impl 'a + FnOnce(A) -> Self::Fa) -> Self::Fa { + fn bind(fa: Self::F, f: impl 'a + FnOnce(A) -> Self::F) -> Self::F { fa.bind(f) } - fn iterate(f: impl Iterative<'a, T = Self, B = B>) -> Self::Fa { + fn iterate(f: impl Iterative<'a, T = Self, B = B>) -> Self::F { Self::pure(()).bind(move |_| { f.next().bind(|state| match state { ControlFlow::Continue(next_f) => Self::iterate(next_f), @@ -205,7 +205,7 @@ impl<'a> Monad<'a> for StacklessInstance { }) } - fn join(ffa: Self::Fa>) -> Self::Fa { + fn join(ffa: Self::F>) -> Self::F { Stackless(Box::new(|takesa| { let lcell = Rc::new(Cell::new(None)); let rcell = lcell.clone(); @@ -231,15 +231,15 @@ mod stackless_test { impl<'a> tests::Eqr<'a> for T { fn eqr( name: &'a str, - left: Self::Fa, - right: Self::Fa, + left: Self::F, + right: Self::F, ) -> tests::R { tests::eqr(name, left.evaluate(), right.evaluate()) } } impl<'a> test_suite::FunctorTestSuite<'a> for T { - fn sample Self::Fa)>(mut f: F) { + fn sample Self::F)>(mut f: F) { f(&|a| a.into()); } } diff --git a/src/func/instances/tryfuture.rs b/src/func/instances/tryfuture.rs index 30dac46..7662582 100644 --- a/src/func/instances/tryfuture.rs +++ b/src/func/instances/tryfuture.rs @@ -9,16 +9,16 @@ use crate::func::*; pub struct TryFutureInstance(E); -impl WeakFunctor for TryFutureInstance { - type F<'a, A: 'a> = Pin>>> where Self: 'a; +impl WeakFunctorAny for TryFutureInstance { + type FAny<'a, A: 'a> = Pin>>> where Self: 'a; } impl<'a, E: 'a> Functor<'a> for TryFutureInstance { - fn fmap(f: impl 'a + FnOnce(A) -> B, fa: Self::Fa) -> Self::Fa { + fn fmap(f: impl 'a + FnOnce(A) -> B, fa: Self::F) -> Self::F { Box::pin(async { Ok(f(fa.await?)) }) } - fn replace(fa: Self::Fa, b: B) -> Self::Fa { + fn replace(fa: Self::F, b: B) -> Self::F { Box::pin(async { fa.await?; Ok(b) @@ -27,13 +27,13 @@ impl<'a, E: 'a> Functor<'a> for TryFutureInstance { } impl<'a, E: 'a> Pure<'a> for TryFutureInstance { - fn pure(a: A) -> Self::Fa { + fn pure(a: A) -> Self::F { Box::pin(async { Ok(a) }) } } impl<'a, E: 'a> ApplicativeSeq<'a> for TryFutureInstance { - fn seq(ff: Self::Fa B>, fa: Self::Fa) -> Self::Fa { + fn seq(ff: Self::F B>, fa: Self::F) -> Self::F { Box::pin(async { let (f, a) = try_join!(ff, fa)?; Ok(f(a)) @@ -44,9 +44,9 @@ impl<'a, E: 'a> ApplicativeSeq<'a> for TryFutureInstance { impl<'a, E: 'a> ApplicativeLA2<'a> for TryFutureInstance { fn la2( f: impl 'a + FnOnce(A, B) -> C, - fa: Self::Fa, - fb: Self::Fa, - ) -> Self::Fa { + fa: Self::F, + fb: Self::F, + ) -> Self::F { Box::pin(async { let (a, b) = try_join!(fa, fb)?; Ok(f(a, b)) @@ -55,13 +55,13 @@ impl<'a, E: 'a> ApplicativeLA2<'a> for TryFutureInstance { } impl<'a, E: 'a> ApplicativeTuple<'a> for TryFutureInstance { - fn tuple((fa, fb): (Self::Fa, Self::Fa)) -> Self::Fa<(A, B)> { + fn tuple((fa, fb): (Self::F, Self::F)) -> Self::F<(A, B)> { Box::pin(async { try_join!(fa, fb) }) } } impl<'a, E: 'a> ApplicativeSelect<'a> for TryFutureInstance { - fn select(fa: Self::Fa, fb: Self::Fa) -> SelectedWrapped<'a, A, B, Self> { + fn select(fa: Self::F, fb: Self::F) -> SelectedWrapped<'a, A, B, Self> { Box::pin(async { match try_select(fa, fb).await { Ok(Either::Left((a, fb))) => Ok(Selected::A(a, fb)), @@ -74,21 +74,21 @@ impl<'a, E: 'a> ApplicativeSelect<'a> for TryFutureInstance { } impl<'a, E: 'a> Applicative<'a> for TryFutureInstance { - fn discard_first(fa: Self::Fa, fb: Self::Fa) -> Self::Fa { + fn discard_first(fa: Self::F, fb: Self::F) -> Self::F { Box::pin(async { Ok(try_join!(fa, fb)?.1) }) } - fn discard_second(fa: Self::Fa, fb: Self::Fa) -> Self::Fa { + fn discard_second(fa: Self::F, fb: Self::F) -> Self::F { Box::pin(async { Ok(try_join!(fa, fb)?.0) }) } } impl<'a, E: 'a> Monad<'a> for TryFutureInstance { - fn bind(fa: Self::Fa, f: impl 'a + FnOnce(A) -> Self::Fa) -> Self::Fa { + fn bind(fa: Self::F, f: impl 'a + FnOnce(A) -> Self::F) -> Self::F { Box::pin(async { f(fa.await?).await }) } - fn iterate(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::Fa { + fn iterate(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::F { Box::pin(async move { loop { match f.next().await? { @@ -99,7 +99,7 @@ impl<'a, E: 'a> Monad<'a> for TryFutureInstance { }) } - fn join(ffa: Self::Fa>) -> Self::Fa { + fn join(ffa: Self::F>) -> Self::F { Box::pin(async { ffa.await?.await }) } } @@ -107,17 +107,17 @@ impl<'a, E: 'a> Monad<'a> for TryFutureInstance { impl<'a, E: 'a + Clone> SharedFunctor<'a> for TryFutureInstance { type Shared = Shared>>>>; - fn share(fa: Self::Fa) -> Self::Shared { + fn share(fa: Self::F) -> Self::Shared { fa.shared() } - fn unshare(sa: Self::Shared) -> Self::Fa { + fn unshare(sa: Self::Shared) -> Self::F { Box::pin(sa) } } impl<'a, E: 'a> Fail<'a, E> for TryFutureInstance { - fn fail(e: E) -> Self::Fa { + fn fail(e: E) -> Self::F { Box::pin(async { Err(e) }) } } diff --git a/src/func/test_suite.rs b/src/func/test_suite.rs index fff1cde..1e43473 100644 --- a/src/func/test_suite.rs +++ b/src/func/test_suite.rs @@ -1,8 +1,8 @@ use super::tests::*; use super::*; -pub trait FunctorTestSuite<'a>: WeakFunctorA<'a> + Eqr<'a> { - fn sample Self::Fa)>(f: F); +pub trait FunctorTestSuite<'a>: WeakFunctor<'a> + Eqr<'a> { + fn sample Self::F)>(f: F); } pub fn functor_follows_laws<'a, T: Functor<'a> + FunctorTestSuite<'a>>() -> R { diff --git a/src/func/tests.rs b/src/func/tests.rs index 0104874..f30e77d 100644 --- a/src/func/tests.rs +++ b/src/func/tests.rs @@ -26,8 +26,8 @@ impl R { } } -pub trait Eqr<'a>: WeakFunctorA<'a> { - fn eqr(name: &'a str, left: Self::Fa, right: Self::Fa) -> R; +pub trait Eqr<'a>: WeakFunctor<'a> { + fn eqr(name: &'a str, left: Self::F, right: Self::F) -> R; } pub fn eqr(name: &str, left: T, right: T) -> R { @@ -88,7 +88,7 @@ impl AddAssign for R { } pub fn fmap_respects_identity<'a, T: Functor<'a> + Eqr<'a>, A: 'a + Debug + PartialEq>( - fa0: impl Fn() -> T::Fa, + fa0: impl Fn() -> T::F, ) -> R { T::eqr("identity: fmap id == id", T::fmap(|a| a, fa0()), fa0()) } @@ -102,7 +102,7 @@ pub fn fmap_respects_composition< >( f: impl 'a + Copy + Fn(B) -> C, g: impl 'a + Copy + Fn(A) -> B, - fa0: impl Fn() -> T::Fa, + fa0: impl Fn() -> T::F, ) -> R { T::eqr( "composition: fmap (f . g) == fmap f . fmap g", @@ -112,7 +112,7 @@ pub fn fmap_respects_composition< } pub fn seq_respects_identity<'a, T: Applicative<'a> + Eqr<'a>, A: 'a + Debug + PartialEq>( - fa0: impl Fn() -> T::Fa, + fa0: impl Fn() -> T::F, ) -> R { T::eqr( "identity: pure id <*> v = v", @@ -130,9 +130,9 @@ pub fn seq_respects_composition< F: 'a + Fn(B) -> C, G: 'a + Fn(A) -> B, >( - ff0: impl Fn() -> T::Fa, - fg0: impl Fn() -> T::Fa, - fa0: impl Fn() -> T::Fa, + ff0: impl Fn() -> T::F, + fg0: impl Fn() -> T::F, + fa0: impl Fn() -> T::F, ) -> R { T::eqr( "composition: pure (.) <*> u <*> v <*> w = u <*> (v <*> w)", @@ -165,7 +165,7 @@ pub fn seq_respects_interchange< B: 'a + Debug + PartialEq, F: 'a + Fn(A) -> B, >( - ff0: impl Fn() -> T::Fa, + ff0: impl Fn() -> T::F, a0: impl 'a + Fn() -> A, ) -> R { T::eqr( @@ -182,8 +182,8 @@ pub fn seq_can_be_expressed_via_la2< B: 'a + Debug + PartialEq, F: 'a + Fn(A) -> B, >( - ff0: impl Fn() -> T::Fa, - fa0: impl Fn() -> T::Fa, + ff0: impl Fn() -> T::F, + fa0: impl Fn() -> T::F, ) -> R { T::eqr( "seq via la2: (<*>) = liftA2 id", @@ -199,7 +199,7 @@ pub fn fmap_can_be_expressed_via_seq< B: 'a + Debug + PartialEq, >( f: impl 'a + Copy + Fn(A) -> B, - fa0: impl Fn() -> T::Fa, + fa0: impl Fn() -> T::F, ) -> R { T::eqr( "fmap via seq: fmap f x = pure f <*> x", @@ -214,8 +214,8 @@ pub fn discard_can_be_expressed_via_seq_or_la2< A: 'a, B: 'a + Debug + PartialEq, >( - fa0: impl 'a + Fn() -> T::Fa, - fb0: impl 'a + Fn() -> T::Fa, + fa0: impl 'a + Fn() -> T::F, + fb0: impl 'a + Fn() -> T::F, ) -> R { T::eqr( "discard via seq: u *> v = (id <$ u) <*> v", @@ -229,7 +229,7 @@ pub fn discard_can_be_expressed_via_seq_or_la2< } pub fn bind_respects_left_identity<'a, T: Monad<'a> + Eqr<'a>, A: 'a, B: 'a + Debug + PartialEq>( - f: impl 'a + Fn(A) -> T::Fa, + f: impl 'a + Fn(A) -> T::F, a0: impl Fn() -> A, ) -> R { T::eqr( @@ -240,7 +240,7 @@ pub fn bind_respects_left_identity<'a, T: Monad<'a> + Eqr<'a>, A: 'a, B: 'a + De } pub fn bind_respects_right_identity<'a, T: Monad<'a> + Eqr<'a>, A: 'a + Debug + PartialEq>( - fa0: impl Fn() -> T::Fa, + fa0: impl Fn() -> T::F, ) -> R { T::eqr( "right identity: m >>= bind = m", @@ -250,9 +250,9 @@ pub fn bind_respects_right_identity<'a, T: Monad<'a> + Eqr<'a>, A: 'a + Debug + } pub fn bind_is_associative<'a, T: Monad<'a> + Eqr<'a>, A: 'a, B: 'a, C: 'a + Debug + PartialEq>( - f: impl 'a + Clone + Fn(B) -> T::Fa, - g: impl 'a + Clone + Fn(A) -> T::Fa, - fa0: impl 'a + Fn() -> T::Fa, + f: impl 'a + Clone + Fn(B) -> T::F, + g: impl 'a + Clone + Fn(A) -> T::F, + fa0: impl 'a + Fn() -> T::F, ) -> R { T::eqr( r"associativity: m >>= (\x -> k x >>= h) = (m >>= k) >>= h", @@ -268,8 +268,8 @@ pub fn seq_can_be_expressed_via_bind< B: 'a + Debug + PartialEq, F: 'a + Fn(A) -> B, >( - ff0: impl Fn() -> T::Fa, - fa0: impl 'a + Fn() -> T::Fa, + ff0: impl Fn() -> T::F, + fa0: impl 'a + Fn() -> T::F, ) -> R { T::eqr( r"seq via bind: m1 <*> m2 = m1 >>= (\x1 -> m2 >>= (\x2 -> pure (x1 x2)))", @@ -285,7 +285,7 @@ pub fn fmap_can_be_expressed_via_bind< B: 'a + Debug + PartialEq, >( f: impl 'a + Copy + Fn(A) -> B, - fa0: impl 'a + Fn() -> T::Fa, + fa0: impl 'a + Fn() -> T::F, ) -> R { T::eqr( "fmap via bind: fmap f xs = xs >>= return . f", diff --git a/src/rcore.rs b/src/rcore.rs index 088466e..e2b22cf 100644 --- a/src/rcore.rs +++ b/src/rcore.rs @@ -28,15 +28,15 @@ pub use self::slice_deserializer::*; /// Basic support for tracing events across the execution. pub trait Diagnostic<'a, T: Monad<'a>> { /// Specify that the evaluation happens after a specific event. - fn after<'b, A: 'a>(fa: T::Fa, event: impl 'b + FnOnce() -> String) -> T::Fa + fn after<'b, A: 'a>(fa: T::F, event: impl 'b + FnOnce() -> String) -> T::F where 'a: 'b; /// Specify that the evaluation happens before a specific event. - fn before<'b, A: 'a>(fa: T::Fa, event: impl 'b + FnOnce() -> String) -> T::Fa + fn before<'b, A: 'a>(fa: T::F, event: impl 'b + FnOnce() -> String) -> T::F where 'a: 'b; /// Label the evaluation step as a specific named action. - fn wrapped<'b, A: 'a>(fa: T::Fa, event: impl 'b + FnOnce() -> String) -> T::Fa + fn wrapped<'b, A: 'a>(fa: T::F, event: impl 'b + FnOnce() -> String) -> T::F where 'a: 'b; } diff --git a/src/testing.rs b/src/testing.rs index 70a9b6b..057bba4 100644 --- a/src/testing.rs +++ b/src/testing.rs @@ -13,15 +13,15 @@ use crate::rstd::typeless::*; pub struct NoDiagnostic; impl<'a, T: Monad<'a>> Diagnostic<'a, T> for NoDiagnostic { - fn after<'b, A>(fa: T::Fa, _event: impl 'b + FnOnce() -> String) -> T::Fa { + fn after<'b, A>(fa: T::F, _event: impl 'b + FnOnce() -> String) -> T::F { fa } - fn before<'b, A>(fa: T::Fa, _event: impl 'b + FnOnce() -> String) -> T::Fa { + fn before<'b, A>(fa: T::F, _event: impl 'b + FnOnce() -> String) -> T::F { fa } - fn wrapped<'b, A>(fa: T::Fa, _event: impl 'b + FnOnce() -> String) -> T::Fa { + fn wrapped<'b, A>(fa: T::F, _event: impl 'b + FnOnce() -> String) -> T::F { fa } }