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

WeakFunctorAny

Browse Source
This commit is contained in:
AF 2023-05-26 11:16:34 +00:00
parent 1012f9be5e
commit 1c87e639d4
21 changed files with 293 additions and 295 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
radn-derive/src/lib.rs
View File

@ -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,
{

6
src/flow/traversible/algorithms/contains.rs
View File

@ -4,7 +4,7 @@ pub fn n_contains<'a, T: MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq>(
comparator: &'a dyn Comparator<A>,
n_set: Rc<dyn TraversibleBinaryNode<'a, T, A, D>>,
key: Rc<A>,
) -> 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<A>,
r_set: Rc<dyn TraversibleBinaryReference<'a, T, A, D>>,
key: Rc<A>,
) -> 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<A>,
t_set: Rc<dyn TraversibleBinaryTree<'a, T, A, D>>,
key: Rc<A>,
) -> T::Fa<()> {
) -> T::F<()> {
match t_set.refer() {
Some(r_set) => r_contains(comparator, r_set, key),
None => T::fail(()),

14
src/flow/traversible/algorithms/subset.rs
View File

@ -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<dyn TraversibleBinaryNode<'a, T, A, D>>,
k_l: Option<Rc<A>>,
k_r: Option<Rc<A>>,
) -> 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<dyn TraversibleBinaryReference<'a, T, A, D>>,
k_l: Option<Rc<A>>,
k_r: Option<Rc<A>>,
) -> 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<dyn TraversibleBinaryTree<'a, T, A, D>>,
k_l: Option<Rc<A>>,
k_r: Option<Rc<A>>,
) -> T::Fa<()> {
) -> T::F<()> {
match (t_subset.refer(), t_superset.refer()) {
(None, _) => T::pure(()),
(Some(_), None) => T::fail(()),

74
src/func.rs
View File

@ -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`.
///
/// <https://hackage.haskell.org/package/base-4.18.0.0/docs/Data-Functor.html>
pub trait WeakFunctorA<'a>: 'a {
type Fa<A: 'a>: 'a;
pub trait WeakFunctor<'a>: 'a {
type F<A: 'a>: 'a;
}
impl<'a, T: ?Sized + 'a + WeakFunctor> WeakFunctorA<'a> for T {
type Fa<A: 'a> = T::F<'a, A>;
impl<'a, T: ?Sized + 'a + WeakFunctorAny> WeakFunctor<'a> for T {
type F<A: 'a> = T::FAny<'a, A>;
}
pub type Wrap<'a, A, T> = <T as WeakFunctorA<'a>>::Fa<A>;
pub type Wrap<'a, A, T> = <T as WeakFunctor<'a>>::F<A>;
/// Rust-specific implementation of [`Functor`], respecting `move` semantics.
///
/// <https://hackage.haskell.org/package/base-4.18.0.0/docs/Data-Functor.html>
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<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::Fa<A>) -> Self::Fa<B>;
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<A>) -> Self::F<B>;
/// Equivalent of Haskell's `$>`/`<$`.
fn replace<A: 'a, B: 'a>(fa: Self::Fa<A>, b: B) -> Self::Fa<B> {
fn replace<A: 'a, B: 'a>(fa: Self::F<A>, b: B) -> Self::F<B> {
Self::fmap(|_| b, fa)
}
/// Equivalent of Haskell's `void`.
fn void<A: 'a>(fa: Self::Fa<A>) -> Self::Fa<()> {
fn void<A: 'a>(fa: Self::F<A>) -> 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>(a: A) -> Self::Fa<A>;
fn pure<A: 'a>(a: A) -> Self::F<A>;
}
/// Part of [`Applicative`] responsible for Haskell's sequential application `<*>`.
pub trait ApplicativeSeq<'a>: Functor<'a> {
/// Equivalent of Haskell's `<*>`.
fn seq<A: 'a, B: 'a>(ff: Self::Fa<impl 'a + FnOnce(A) -> B>, fa: Self::Fa<A>) -> Self::Fa<B>;
fn seq<A: 'a, B: 'a>(ff: Self::F<impl 'a + FnOnce(A) -> B>, fa: Self::F<A>) -> Self::F<B>;
}
/// 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<A: 'a, B: 'a, C: 'a>(
f: impl 'a + FnOnce(A, B) -> C,
fa: Self::Fa<A>,
fb: Self::Fa<B>,
) -> Self::Fa<C>;
fa: Self::F<A>,
fb: Self::F<B>,
) -> Self::F<C>;
}
/// 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<A: 'a, B: 'a>(fab: (Self::Fa<A>, Self::Fa<B>)) -> Self::Fa<(A, B)>;
fn tuple<A: 'a, B: 'a>(fab: (Self::F<A>, Self::F<B>)) -> 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<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> Self::Fa<B> {
fn discard_first<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<B> {
Self::seq(Self::replace(fa, |b| b), fb)
}
/// Equivalent of Haskell's `<*`.
fn discard_second<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> Self::Fa<A> {
fn discard_second<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<A> {
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<A: 'a, B: 'a>(fa: Self::Fa<A>, f: impl 'a + FnOnce(A) -> Self::Fa<B>) -> Self::Fa<B>;
fn bind<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> Self::F<B>) -> Self::F<B>;
/// 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<B: 'a>(f: impl Iterative<'a, T = Self, B = B>) -> Self::Fa<B>;
fn iterate<B: 'a>(f: impl Iterative<'a, T = Self, B = B>) -> Self::F<B>;
/// Equivalent of Haskell's `join`.
fn join<A: 'a>(ffa: Self::Fa<Self::Fa<A>>) -> Self::Fa<A> {
fn join<A: 'a>(ffa: Self::F<Self::F<A>>) -> Self::F<A> {
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, B: 'a>(
a: A,
f: impl 'a + FnMut(A) -> Self::Fa<ControlFlow<B, A>>,
) -> Self::Fa<B> {
f: impl 'a + FnMut(A) -> Self::F<ControlFlow<B, A>>,
) -> Self::F<B> {
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<A: 'a>(e: E) -> Self::Fa<A>;
fn fail<A: 'a>(e: E) -> Self::F<A>;
}
/// 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<A: 'a, B: 'a>(state: Self::Fa<ControlFlow<B, A>>) -> ControlFlow<Self::Fa<B>, A> {
fn unstuff<A: 'a, B: 'a>(state: Self::F<ControlFlow<B, A>>) -> ControlFlow<Self::F<B>, A> {
Self::stuff::<_, ControlFlowInstance<A>>(state)
}
/// Stuff wrapped result into another functor.
fn stuff<A: 'a, T: Pure<'a>>(fa: Self::Fa<T::Fa<A>>) -> T::Fa<Self::Fa<A>>;
fn stuff<A: 'a, T: Pure<'a>>(fa: Self::F<T::F<A>>) -> T::F<Self::F<A>>;
}
/// 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: 'a + Clone>: 'a + Clone;
fn share<A: 'a + Clone>(fa: Self::Fa<A>) -> Self::Shared<A>;
fn share<A: 'a + Clone>(fa: Self::F<A>) -> Self::Shared<A>;
fn unshare<A: 'a + Clone>(sa: Self::Shared<A>) -> Self::Fa<A>;
fn unshare<A: 'a + Clone>(sa: Self::Shared<A>) -> Self::F<A>;
}
impl<'a, T: 'a + SharedFunctorAny> SharedFunctor<'a> for T {
type Shared<A: 'a + Clone> = T::SharedAny<'a, A>;
fn share<A: 'a + Clone>(fa: Self::Fa<A>) -> Self::Shared<A> {
fn share<A: 'a + Clone>(fa: Self::F<A>) -> Self::Shared<A> {
T::share(fa)
}
fn unshare<A: 'a + Clone>(sa: Self::Shared<A>) -> Self::Fa<A> {
fn unshare<A: 'a + Clone>(sa: Self::Shared<A>) -> Self::F<A> {
T::unshare(sa)
}
}

14
src/func/applicative_select.rs
View File

@ -1,14 +1,14 @@
use super::*;
pub enum Selected<'a, A: 'a, B: 'a, T: ?Sized + WeakFunctorA<'a>> {
A(A, T::Fa<B>),
B(T::Fa<A>, B),
pub enum Selected<'a, A: 'a, B: 'a, T: ?Sized + WeakFunctor<'a>> {
A(A, T::F<B>),
B(T::F<A>, B),
}
pub type SelectedWrapped<'a, A, B, T> = Wrap<'a, Selected<'a, A, B, T>, T>;
pub trait ApplicativeSelect<'a>: Functor<'a> {
fn select<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> SelectedWrapped<'a, A, B, Self> {
fn select<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> 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<A: 'a, B: 'a, C: 'a>(
f: impl 'a + FnOnce(Selected<'a, A, B, Self>) -> C,
fa: Self::Fa<A>,
fb: Self::Fa<B>,
) -> Self::Fa<C> {
fa: Self::F<A>,
fb: Self::F<B>,
) -> Self::F<C> {
Self::fmap(f, Self::select(fa, fb))
}
}

14
src/func/controlflow.rs
View File

@ -4,14 +4,14 @@ use super::*;
pub struct ControlFlowInstance<C>(ControlFlow<(), C>);
impl<C> WeakFunctor for ControlFlowInstance<C> {
type F<'a, A: 'a> = ControlFlow<A, C>
impl<C> WeakFunctorAny for ControlFlowInstance<C> {
type FAny<'a, A: 'a> = ControlFlow<A, C>
where
Self: 'a;
}
impl<'a, C: 'a> Functor<'a> for ControlFlowInstance<C> {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::Fa<A>) -> Self::Fa<B> {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<A>) -> Self::F<B> {
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<C> {
}
impl<'a, C: 'a> Pure<'a> for ControlFlowInstance<C> {
fn pure<A: 'a>(a: A) -> Self::Fa<A> {
fn pure<A: 'a>(a: A) -> Self::F<A> {
ControlFlow::Break(a)
}
}
pub struct BindableMut<T: ?Sized, A, B, F>(A, F, PhantomData<B>, PhantomData<T>);
impl<'a, T: ?Sized + Functor<'a>, A: 'a, B: 'a, F: 'a + FnMut(A) -> T::Fa<ControlFlow<B, A>>>
impl<'a, T: ?Sized + Functor<'a>, A: 'a, B: 'a, F: 'a + FnMut(A) -> T::F<ControlFlow<B, A>>>
BindableMut<T, A, B, F>
{
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<Contro
}
}
impl<'a, T: ?Sized + Functor<'a>, A: 'a, B: 'a, F: 'a + FnMut(A) -> T::Fa<ControlFlow<B, A>>>
impl<'a, T: ?Sized + Functor<'a>, A: 'a, B: 'a, F: 'a + FnMut(A) -> T::F<ControlFlow<B, A>>>
Iterative<'a> for BindableMut<T, A, B, F>
{
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>;
}

16
src/func/derivations.rs
View File

@ -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<B>,
f: impl 'a + FnOnce(A) -> T::F<B>,
) -> 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<A: 'a, B: 'a, C: 'a>(
f: impl 'a + FnOnce(A, B) -> C,
fa: Self::Fa<A>,
fb: Self::Fa<B>,
) -> Self::Fa<C> {
fa: Self::F<A>,
fb: Self::F<B>,
) -> Self::F<C> {
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<A: 'a, B: 'a>(
ff: Self::Fa<impl 'a + FnOnce(A) -> B>,
fa: Self::Fa<A>,
) -> Self::Fa<B> {
ff: Self::F<impl 'a + FnOnce(A) -> B>,
fa: Self::F<A>,
) -> Self::F<B> {
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<A: 'a, B: 'a>((fa, fb): (Self::Fa<A>, Self::Fa<B>)) -> Self::Fa<(A, B)> {
fn _tuple_via_la2<A: 'a, B: 'a>((fa, fb): (Self::F<A>, Self::F<B>)) -> Self::F<(A, B)> {
Self::la2(|a, b| (a, b), fa, fb)
}
}

44
src/func/instances/composition.rs
View File

@ -2,26 +2,26 @@ use crate::func::*;
pub struct CompositionInstance<U, V>(U, V);
impl<'a, U: WeakFunctorA<'a>, V: WeakFunctorA<'a>> WeakFunctorA<'a> for CompositionInstance<U, V> {
type Fa<A: 'a> = U::Fa<V::Fa<A>>;
impl<'a, U: WeakFunctor<'a>, V: WeakFunctor<'a>> WeakFunctor<'a> for CompositionInstance<U, V> {
type F<A: 'a> = U::F<V::F<A>>;
}
impl<'a, U: Functor<'a>, V: Functor<'a>> Functor<'a> for CompositionInstance<U, V> {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::Fa<A>) -> Self::Fa<B> {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<A>) -> Self::F<B> {
U::fmap(|ua| V::fmap(f, ua), fa)
}
fn replace<A: 'a, B: 'a>(fa: Self::Fa<A>, b: B) -> Self::Fa<B> {
fn replace<A: 'a, B: 'a>(fa: Self::F<A>, b: B) -> Self::F<B> {
U::fmap(|ua| V::replace(ua, b), fa)
}
fn void<A: 'a>(fa: Self::Fa<A>) -> Self::Fa<()> {
fn void<A: 'a>(fa: Self::F<A>) -> Self::F<()> {
U::fmap(|ua| V::void(ua), fa)
}
}
impl<'a, U: Pure<'a>, V: Pure<'a>> Pure<'a> for CompositionInstance<U, V> {
fn pure<A: 'a>(a: A) -> Self::Fa<A> {
fn pure<A: 'a>(a: A) -> Self::F<A> {
U::pure(V::pure(a))
}
}
@ -29,7 +29,7 @@ impl<'a, U: Pure<'a>, V: Pure<'a>> Pure<'a> for CompositionInstance<U, V> {
impl<'a, U: ApplicativeLA2<'a>, V: ApplicativeSeq<'a>> ApplicativeSeq<'a>
for CompositionInstance<U, V>
{
fn seq<A: 'a, B: 'a>(ff: Self::Fa<impl 'a + FnOnce(A) -> B>, fa: Self::Fa<A>) -> Self::Fa<B> {
fn seq<A: 'a, B: 'a>(ff: Self::F<impl 'a + FnOnce(A) -> B>, fa: Self::F<A>) -> Self::F<B> {
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<A: 'a, B: 'a, C: 'a>(
f: impl 'a + FnOnce(A, B) -> C,
fa: Self::Fa<A>,
fb: Self::Fa<B>,
) -> Self::Fa<C> {
fa: Self::F<A>,
fb: Self::F<B>,
) -> Self::F<C> {
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<U, V>
{
fn tuple<A: 'a, B: 'a>(fab: (Self::Fa<A>, Self::Fa<B>)) -> Self::Fa<(A, B)> {
fn tuple<A: 'a, B: 'a>(fab: (Self::F<A>, Self::F<B>)) -> 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<U, V>
{
fn select<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> SelectedWrapped<'a, A, B, Self> {
fn select<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> 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<U, V> {
fn discard_first<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> Self::Fa<B> {
fn discard_first<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<B> {
U::la2(|ua, ub| V::discard_first(ua, ub), fa, fb)
}
fn discard_second<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> Self::Fa<A> {
fn discard_second<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<A> {
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<U, V> {
fn bind<A: 'a, B: 'a>(fa: Self::Fa<A>, f: impl 'a + FnOnce(A) -> Self::Fa<B>) -> Self::Fa<B> {
fn bind<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> Self::F<B>) -> Self::F<B> {
U::bind(fa, |ua| U::fmap(V::join, V::stuff::<_, U>(V::fmap(f, ua))))
}
fn iterate<B: 'a>(f: impl Iterative<'a, T = Self, B = B>) -> Self::Fa<B> {
fn iterate<B: 'a>(f: impl Iterative<'a, T = Self, B = B>) -> Self::F<B> {
U::iterate(ComposedIterative(f))
}
fn join<A: 'a>(ffa: Self::Fa<Self::Fa<A>>) -> Self::Fa<A> {
fn join<A: 'a>(ffa: Self::F<Self::F<A>>) -> Self::F<A> {
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<U, V>
{
fn fail<A: 'a>(e: E) -> Self::Fa<A> {
fn fail<A: 'a>(e: E) -> Self::F<A> {
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<U, V>
{
fn unstuff<A: 'a, B: 'a>(state: Self::Fa<ControlFlow<B, A>>) -> ControlFlow<Self::Fa<B>, A> {
fn unstuff<A: 'a, B: 'a>(state: Self::F<ControlFlow<B, A>>) -> ControlFlow<Self::F<B>, A> {
U::unstuff(U::fmap(V::unstuff, state))
}
fn stuff<A: 'a, T: Pure<'a>>(fa: Self::Fa<T::Fa<A>>) -> T::Fa<Self::Fa<A>> {
fn stuff<A: 'a, T: Pure<'a>>(fa: Self::F<T::F<A>>) -> T::F<Self::F<A>> {
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<A: 'a + Clone> = U::Shared<V::Shared<A>>;
fn share<A: 'a + Clone>(fa: Self::Fa<A>) -> Self::Shared<A> {
fn share<A: 'a + Clone>(fa: Self::F<A>) -> Self::Shared<A> {
U::share(U::fmap(V::share, fa))
}
fn unshare<A: 'a + Clone>(sa: Self::Shared<A>) -> Self::Fa<A> {
fn unshare<A: 'a + Clone>(sa: Self::Shared<A>) -> Self::F<A> {
U::fmap(V::unshare, U::unshare(sa))
}
}

32
src/func/instances/effect.rs
View File

@ -26,21 +26,21 @@ impl<A, E: Effect> WithEffect<A, E> {
#[derive(SharedFunctorAny)]
pub struct EffectInstance<E>(E);
impl<E> WeakFunctor for EffectInstance<E> {
type F<'a, A: 'a> = WithEffect<A, E>
impl<E> WeakFunctorAny for EffectInstance<E> {
type FAny<'a, A: 'a> = WithEffect<A, E>
where
Self: 'a;
}
impl<'a, E: 'a> Functor<'a> for EffectInstance<E> {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::Fa<A>) -> Self::Fa<B> {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<A>) -> Self::F<B> {
WithEffect {
value: f(fa.value),
effect: fa.effect,
}
}
fn replace<A: 'a, B: 'a>(fa: Self::Fa<A>, b: B) -> Self::Fa<B> {
fn replace<A: 'a, B: 'a>(fa: Self::F<A>, b: B) -> Self::F<B> {
drop(fa.value);
WithEffect {
value: b,
@ -50,7 +50,7 @@ impl<'a, E: 'a> Functor<'a> for EffectInstance<E> {
}
impl<'a, E: 'a + Effect> Pure<'a> for EffectInstance<E> {
fn pure<A: 'a>(a: A) -> Self::Fa<A> {
fn pure<A: 'a>(a: A) -> Self::F<A> {
WithEffect {
value: a,
effect: E::e_pure(),
@ -59,7 +59,7 @@ impl<'a, E: 'a + Effect> Pure<'a> for EffectInstance<E> {
}
impl<'a, E: 'a + Effect> ApplicativeSeq<'a> for EffectInstance<E> {
fn seq<A: 'a, B: 'a>(ff: Self::Fa<impl 'a + FnOnce(A) -> B>, fa: Self::Fa<A>) -> Self::Fa<B> {
fn seq<A: 'a, B: 'a>(ff: Self::F<impl 'a + FnOnce(A) -> B>, fa: Self::F<A>) -> Self::F<B> {
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<E> {
impl<'a, E: 'a + Effect> ApplicativeLA2<'a> for EffectInstance<E> {
fn la2<A: 'a, B: 'a, C: 'a>(
f: impl 'a + FnOnce(A, B) -> C,
fa: Self::Fa<A>,
fb: Self::Fa<B>,
) -> Self::Fa<C> {
fa: Self::F<A>,
fb: Self::F<B>,
) -> Self::F<C> {
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<E> {
}
impl<'a, E: 'a + Effect> ApplicativeTuple<'a> for EffectInstance<E> {
fn tuple<A: 'a, B: 'a>((fa, fb): (Self::Fa<A>, Self::Fa<B>)) -> Self::Fa<(A, B)> {
fn tuple<A: 'a, B: 'a>((fa, fb): (Self::F<A>, Self::F<B>)) -> 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<E> {
impl<'a, E: 'a + Effect> ApplicativeSelect<'a> for EffectInstance<E> {}
impl<'a, E: 'a + Effect> Applicative<'a> for EffectInstance<E> {
fn discard_first<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> Self::Fa<B> {
fn discard_first<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<B> {
drop(fa.value);
WithEffect {
value: fb.value,
@ -100,7 +100,7 @@ impl<'a, E: 'a + Effect> Applicative<'a> for EffectInstance<E> {
}
}
fn discard_second<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> Self::Fa<A> {
fn discard_second<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<A> {
drop(fb.value);
WithEffect {
value: fa.value,
@ -110,11 +110,11 @@ impl<'a, E: 'a + Effect> Applicative<'a> for EffectInstance<E> {
}
impl<'a, E: 'a + Effect> Monad<'a> for EffectInstance<E> {
fn bind<A: 'a, B: 'a>(fa: Self::Fa<A>, f: impl 'a + FnOnce(A) -> Self::Fa<B>) -> Self::Fa<B> {
fn bind<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> Self::F<B>) -> Self::F<B> {
f(fa.value).e_after(fa.effect)
}
fn iterate<B: 'a>(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::Fa<B> {
fn iterate<B: 'a>(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::F<B> {
let mut effect = E::e_pure();
loop {
let fa = f.next();
@ -126,13 +126,13 @@ impl<'a, E: 'a + Effect> Monad<'a> for EffectInstance<E> {
}
}
fn join<A: 'a>(ffa: Self::Fa<Self::Fa<A>>) -> Self::Fa<A> {
fn join<A: 'a>(ffa: Self::F<Self::F<A>>) -> Self::F<A> {
ffa.value.e_after(ffa.effect)
}
}
impl<'a, E: 'a> LocalFunctor<'a> for EffectInstance<E> {
fn stuff<A: 'a, T: Pure<'a>>(fa: Self::Fa<T::Fa<A>>) -> T::Fa<Self::Fa<A>> {
fn stuff<A: 'a, T: Pure<'a>>(fa: Self::F<T::F<A>>) -> T::F<Self::F<A>> {
T::fmap(
|a| WithEffect {
value: a,

36
src/func/instances/future.rs
View File

@ -14,16 +14,16 @@ use crate::func::*;
pub struct FutureInstance;
impl WeakFunctor for FutureInstance {
type F<'a, A: 'a> = Pin<Box<dyn 'a + Future<Output = A>>>;
impl WeakFunctorAny for FutureInstance {
type FAny<'a, A: 'a> = Pin<Box<dyn 'a + Future<Output = A>>>;
}
impl<'a> Functor<'a> for FutureInstance {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::Fa<A>) -> Self::Fa<B> {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<A>) -> Self::F<B> {
Box::pin(async { f(fa.await) })
}
fn replace<A: 'a, B: 'a>(fa: Self::Fa<A>, b: B) -> Self::Fa<B> {
fn replace<A: 'a, B: 'a>(fa: Self::F<A>, b: B) -> Self::F<B> {
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>(a: A) -> Self::Fa<A> {
fn pure<A: 'a>(a: A) -> Self::F<A> {
Box::pin(async { a })
}
}
impl<'a> ApplicativeSeq<'a> for FutureInstance {
fn seq<A: 'a, B: 'a>(ff: Self::Fa<impl 'a + FnOnce(A) -> B>, fa: Self::Fa<A>) -> Self::Fa<B> {
fn seq<A: 'a, B: 'a>(ff: Self::F<impl 'a + FnOnce(A) -> B>, fa: Self::F<A>) -> Self::F<B> {
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<A: 'a, B: 'a, C: 'a>(
f: impl 'a + FnOnce(A, B) -> C,
fa: Self::Fa<A>,
fb: Self::Fa<B>,
) -> Self::Fa<C> {
fa: Self::F<A>,
fb: Self::F<B>,
) -> Self::F<C> {
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<A: 'a, B: 'a>((fa, fb): (Self::Fa<A>, Self::Fa<B>)) -> Self::Fa<(A, B)> {
fn tuple<A: 'a, B: 'a>((fa, fb): (Self::F<A>, Self::F<B>)) -> Self::F<(A, B)> {
Box::pin(async { join!(fa, fb) })
}
}
impl<'a> ApplicativeSelect<'a> for FutureInstance {
fn select<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> SelectedWrapped<'a, A, B, Self> {
fn select<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> 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<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> Self::Fa<B> {
fn discard_first<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<B> {
Box::pin(async { join!(fa, fb).1 })
}
fn discard_second<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> Self::Fa<A> {
fn discard_second<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<A> {
Box::pin(async { join!(fa, fb).0 })
}
}
impl<'a> Monad<'a> for FutureInstance {
fn bind<A: 'a, B: 'a>(fa: Self::Fa<A>, f: impl 'a + FnOnce(A) -> Self::Fa<B>) -> Self::Fa<B> {
fn bind<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> Self::F<B>) -> Self::F<B> {
Box::pin(async { f(fa.await).await })
}
fn iterate<B: 'a>(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::Fa<B> {
fn iterate<B: 'a>(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::F<B> {
Box::pin(async move {
loop {
match f.next().await {
@ -102,7 +102,7 @@ impl<'a> Monad<'a> for FutureInstance {
})
}
fn join<A: 'a>(ffa: Self::Fa<Self::Fa<A>>) -> Self::Fa<A> {
fn join<A: 'a>(ffa: Self::F<Self::F<A>>) -> Self::F<A> {
Box::pin(async { ffa.await.await })
}
}
@ -110,11 +110,11 @@ impl<'a> Monad<'a> for FutureInstance {
impl<'a> SharedFunctor<'a> for FutureInstance {
type Shared<A: 'a + Clone> = Shared<Pin<Box<dyn 'a + Future<Output = A>>>>;
fn share<A: 'a + Clone>(fa: Self::Fa<A>) -> Self::Shared<A> {
fn share<A: 'a + Clone>(fa: Self::F<A>) -> Self::Shared<A> {
fa.shared()
}
fn unshare<A: 'a + Clone>(sa: Self::Shared<A>) -> Self::Fa<A> {
fn unshare<A: 'a + Clone>(sa: Self::Shared<A>) -> Self::F<A> {
Box::pin(sa)
}
}

36
src/func/instances/lazy.rs
View File

@ -13,34 +13,34 @@ use crate::func::*;
pub struct LazyInstance;
impl WeakFunctor for LazyInstance {
type F<'a, A: 'a> = Box<dyn 'a + FnOnce() -> A>;
impl WeakFunctorAny for LazyInstance {
type FAny<'a, A: 'a> = Box<dyn 'a + FnOnce() -> A>;
}
impl<'a> Functor<'a> for LazyInstance {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::Fa<A>) -> Self::Fa<B> {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<A>) -> Self::F<B> {
Box::new(|| f(fa()))
}
fn replace<A: 'a, B: 'a>(fa: Self::Fa<A>, b: B) -> Self::Fa<B> {
fn replace<A: 'a, B: 'a>(fa: Self::F<A>, b: B) -> Self::F<B> {
drop(fa);
Box::new(|| b)
}
fn void<A: 'a>(fa: Self::Fa<A>) -> Self::Fa<()> {
fn void<A: 'a>(fa: Self::F<A>) -> Self::F<()> {
drop(fa);
Box::new(|| ())
}
}
impl<'a> Pure<'a> for LazyInstance {
fn pure<A: 'a>(a: A) -> Self::Fa<A> {
fn pure<A: 'a>(a: A) -> Self::F<A> {
Box::new(|| a)
}
}
impl<'a> ApplicativeSeq<'a> for LazyInstance {
fn seq<A: 'a, B: 'a>(ff: Self::Fa<impl 'a + FnOnce(A) -> B>, fa: Self::Fa<A>) -> Self::Fa<B> {
fn seq<A: 'a, B: 'a>(ff: Self::F<impl 'a + FnOnce(A) -> B>, fa: Self::F<A>) -> Self::F<B> {
Box::new(|| ff()(fa()))
}
}
@ -48,15 +48,15 @@ impl<'a> ApplicativeSeq<'a> for LazyInstance {
impl<'a> ApplicativeLA2<'a> for LazyInstance {
fn la2<A: 'a, B: 'a, C: 'a>(
f: impl 'a + FnOnce(A, B) -> C,
fa: Self::Fa<A>,
fb: Self::Fa<B>,
) -> Self::Fa<C> {
fa: Self::F<A>,
fb: Self::F<B>,
) -> Self::F<C> {
Box::new(|| f(fa(), fb()))
}
}
impl<'a> ApplicativeTuple<'a> for LazyInstance {
fn tuple<A: 'a, B: 'a>((fa, fb): (Self::Fa<A>, Self::Fa<B>)) -> Self::Fa<(A, B)> {
fn tuple<A: 'a, B: 'a>((fa, fb): (Self::F<A>, Self::F<B>)) -> 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<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> Self::Fa<B> {
fn discard_first<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<B> {
drop(fa);
fb
}
fn discard_second<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> Self::Fa<A> {
fn discard_second<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<A> {
drop(fb);
fa
}
}
impl<'a> Monad<'a> for LazyInstance {
fn bind<A: 'a, B: 'a>(fa: Self::Fa<A>, f: impl 'a + FnOnce(A) -> Self::Fa<B>) -> Self::Fa<B> {
fn bind<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> Self::F<B>) -> Self::F<B> {
Box::new(|| f(fa())())
}
fn iterate<B: 'a>(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::Fa<B> {
fn iterate<B: 'a>(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::F<B> {
loop {
match f.next()() {
ControlFlow::Continue(next_f) => f = next_f,
@ -89,7 +89,7 @@ impl<'a> Monad<'a> for LazyInstance {
}
}
fn join<A: 'a>(ffa: Self::Fa<Self::Fa<A>>) -> Self::Fa<A> {
fn join<A: 'a>(ffa: Self::F<Self::F<A>>) -> Self::F<A> {
Box::new(|| ffa()())
}
}
@ -106,11 +106,11 @@ fn unshare<'a, A: 'a + Clone>(shared: &mut Option<Box<dyn 'a + FnOnce() -> A>>)
impl<'a> SharedFunctor<'a> for LazyInstance {
type Shared<A: 'a + Clone> = Rc<RefCell<Option<Box<dyn 'a + FnOnce() -> A>>>>;
fn share<A: 'a + Clone>(fa: Self::Fa<A>) -> Self::Shared<A> {
fn share<A: 'a + Clone>(fa: Self::F<A>) -> Self::Shared<A> {
Rc::new(RefCell::new(Some(fa)))
}
fn unshare<A: 'a + Clone>(sa: Self::Shared<A>) -> Self::Fa<A> {
fn unshare<A: 'a + Clone>(sa: Self::Shared<A>) -> Self::F<A> {
Box::new(move || unshare(&mut *sa.borrow_mut()))
}
}

44
src/func/instances/option.rs
View File

@ -12,34 +12,34 @@ use crate::func::*;
#[derive(SharedFunctorAny)]
pub struct OptionInstance;
impl WeakFunctor for OptionInstance {
type F<'a, A: 'a> = Option<A>;
impl WeakFunctorAny for OptionInstance {
type FAny<'a, A: 'a> = Option<A>;
}
impl<'a> Functor<'a> for OptionInstance {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::Fa<A>) -> Self::Fa<B> {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<A>) -> Self::F<B> {
fa.map(f)
}
fn replace<A: 'a, B: 'a>(fa: Self::Fa<A>, b: B) -> Self::Fa<B> {
fn replace<A: 'a, B: 'a>(fa: Self::F<A>, b: B) -> Self::F<B> {
fa?;
Self::pure(b)
}
fn void<A: 'a>(fa: Self::Fa<A>) -> Self::Fa<()> {
fn void<A: 'a>(fa: Self::F<A>) -> Self::F<()> {
fa?;
Self::pure(())
}
}
impl<'a> Pure<'a> for OptionInstance {
fn pure<A: 'a>(a: A) -> Self::Fa<A> {
fn pure<A: 'a>(a: A) -> Self::F<A> {
Some(a)
}
}
impl<'a> ApplicativeSeq<'a> for OptionInstance {
fn seq<A: 'a, B: 'a>(ff: Self::Fa<impl 'a + FnOnce(A) -> B>, fa: Self::Fa<A>) -> Self::Fa<B> {
fn seq<A: 'a, B: 'a>(ff: Self::F<impl 'a + FnOnce(A) -> B>, fa: Self::F<A>) -> Self::F<B> {
Self::pure(ff?(fa?))
}
}
@ -47,15 +47,15 @@ impl<'a> ApplicativeSeq<'a> for OptionInstance {
impl<'a> ApplicativeLA2<'a> for OptionInstance {
fn la2<A: 'a, B: 'a, C: 'a>(
f: impl 'a + FnOnce(A, B) -> C,
fa: Self::Fa<A>,
fb: Self::Fa<B>,
) -> Self::Fa<C> {
fa: Self::F<A>,
fb: Self::F<B>,
) -> Self::F<C> {
Self::pure(f(fa?, fb?))
}
}
impl<'a> ApplicativeTuple<'a> for OptionInstance {
fn tuple<A: 'a, B: 'a>((fa, fb): (Self::Fa<A>, Self::Fa<B>)) -> Self::Fa<(A, B)> {
fn tuple<A: 'a, B: 'a>((fa, fb): (Self::F<A>, Self::F<B>)) -> 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<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> Self::Fa<B> {
fn discard_first<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<B> {
fa?;
fb
}
fn discard_second<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> Self::Fa<A> {
fn discard_second<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<A> {
fb?;
fa
}
}
impl<'a> Monad<'a> for OptionInstance {
fn bind<A: 'a, B: 'a>(fa: Self::Fa<A>, f: impl 'a + FnOnce(A) -> Self::Fa<B>) -> Self::Fa<B> {
fn bind<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> Self::F<B>) -> Self::F<B> {
f(fa?)
}
fn iterate<B: 'a>(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::Fa<B> {
fn iterate<B: 'a>(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::F<B> {
loop {
match f.next()? {
ControlFlow::Continue(next_f) => f = next_f,
@ -88,13 +88,13 @@ impl<'a> Monad<'a> for OptionInstance {
}
}
fn join<A: 'a>(ffa: Self::Fa<Self::Fa<A>>) -> Self::Fa<A> {
fn join<A: 'a>(ffa: Self::F<Self::F<A>>) -> Self::F<A> {
ffa?
}
}
impl<'a> LocalFunctor<'a> for OptionInstance {
fn unstuff<A: 'a, B: 'a>(state: Self::Fa<ControlFlow<B, A>>) -> ControlFlow<Self::Fa<B>, A> {
fn unstuff<A: 'a, B: 'a>(state: Self::F<ControlFlow<B, A>>) -> ControlFlow<Self::F<B>, 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<A: 'a, T: Pure<'a>>(fa: Self::Fa<T::Fa<A>>) -> T::Fa<Self::Fa<A>> {
fn stuff<A: 'a, T: Pure<'a>>(fa: Self::F<T::F<A>>) -> T::F<Self::F<A>> {
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<A: 'a>(_e: ()) -> Self::Fa<A> {
fn fail<A: 'a>(_e: ()) -> Self::F<A> {
None
}
}
@ -125,15 +125,15 @@ mod option_tests {
impl<'a> tests::Eqr<'a> for T {
fn eqr<A: PartialEq + std::fmt::Debug + 'a>(
name: &'a str,
left: Self::Fa<A>,
right: Self::Fa<A>,
left: Self::F<A>,
right: Self::F<A>,
) -> tests::R {
tests::eqr(name, left, right)
}
}
impl<'a> test_suite::FunctorTestSuite<'a> for T {
fn sample<A: 'a, F: FnMut(&'a dyn Fn(A) -> Self::Fa<A>)>(mut f: F) {
fn sample<A: 'a, F: FnMut(&'a dyn Fn(A) -> Self::F<A>)>(mut f: F) {
f(&|_| None);
f(&|a| Some(a));
}

42
src/func/instances/overload.rs
View File

@ -12,28 +12,26 @@ pub trait DeriveApplicative {}
impl<O: DeriveMonad> DeriveApplicative for O {}
pub trait DeriveMonad {}
impl<'a, T: WeakFunctorA<'a>, O: 'a + DeriveWeakFunctor> WeakFunctorA<'a>
for OverloadInstance<T, O>
{
type Fa<A: 'a> = T::Fa<A>;
impl<'a, T: WeakFunctor<'a>, O: 'a + DeriveWeakFunctor> WeakFunctor<'a> for OverloadInstance<T, O> {
type F<A: 'a> = T::F<A>;
}
impl<'a, T: Functor<'a>, O: 'a + DeriveFunctor> Functor<'a> for OverloadInstance<T, O> {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::Fa<A>) -> Self::Fa<B> {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<A>) -> Self::F<B> {
T::fmap(f, fa)
}
fn replace<A: 'a, B: 'a>(fa: Self::Fa<A>, b: B) -> Self::Fa<B> {
fn replace<A: 'a, B: 'a>(fa: Self::F<A>, b: B) -> Self::F<B> {
T::replace(fa, b)
}
fn void<A: 'a>(fa: Self::Fa<A>) -> Self::Fa<()> {
fn void<A: 'a>(fa: Self::F<A>) -> Self::F<()> {
T::void(fa)
}
}
impl<'a, T: Pure<'a>, O: 'a + DeriveApplicative> Pure<'a> for OverloadInstance<T, O> {
fn pure<A: 'a>(a: A) -> Self::Fa<A> {
fn pure<A: 'a>(a: A) -> Self::F<A> {
T::pure(a)
}
}
@ -41,7 +39,7 @@ impl<'a, T: Pure<'a>, O: 'a + DeriveApplicative> Pure<'a> for OverloadInstance<T
impl<'a, T: ApplicativeSeq<'a>, O: 'a + DeriveApplicative> ApplicativeSeq<'a>
for OverloadInstance<T, O>
{
fn seq<A: 'a, B: 'a>(ff: Self::Fa<impl 'a + FnOnce(A) -> B>, fa: Self::Fa<A>) -> Self::Fa<B> {
fn seq<A: 'a, B: 'a>(ff: Self::F<impl 'a + FnOnce(A) -> B>, fa: Self::F<A>) -> Self::F<B> {
T::seq(ff, fa)
}
}
@ -51,9 +49,9 @@ impl<'a, T: ApplicativeLA2<'a>, O: 'a + DeriveApplicative> ApplicativeLA2<'a>
{
fn la2<A: 'a, B: 'a, C: 'a>(
f: impl 'a + FnOnce(A, B) -> C,
fa: Self::Fa<A>,
fb: Self::Fa<B>,
) -> Self::Fa<C> {
fa: Self::F<A>,
fb: Self::F<B>,
) -> Self::F<C> {
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<T, O>
{
fn tuple<A: 'a, B: 'a>(fab: (Self::Fa<A>, Self::Fa<B>)) -> Self::Fa<(A, B)> {
fn tuple<A: 'a, B: 'a>(fab: (Self::F<A>, Self::F<B>)) -> 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<T, O>
{
fn select<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> SelectedWrapped<'a, A, B, Self> {
fn select<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> 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<T, O> {
fn discard_first<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> Self::Fa<B> {
fn discard_first<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<B> {
T::discard_first(fa, fb)
}
fn discard_second<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> Self::Fa<A> {
fn discard_second<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<A> {
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<T, O> {
fn bind<A: 'a, B: 'a>(fa: Self::Fa<A>, f: impl 'a + FnOnce(A) -> Self::Fa<B>) -> Self::Fa<B> {
fn bind<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> Self::F<B>) -> Self::F<B> {
T::bind(fa, f)
}
fn iterate<B: 'a>(f: impl Iterative<'a, T = Self, B = B>) -> Self::Fa<B> {
fn iterate<B: 'a>(f: impl Iterative<'a, T = Self, B = B>) -> Self::F<B> {
T::iterate(OverloadIterative::new(f))
}
fn join<A: 'a>(ffa: Self::Fa<Self::Fa<A>>) -> Self::Fa<A> {
fn join<A: 'a>(ffa: Self::F<Self::F<A>>) -> Self::F<A> {
T::join(ffa)
}
}
@ -138,7 +136,7 @@ impl<Ex> DeriveMonad for DeriveFail<Ex> {}
impl<'a, E: 'a, Ex: 'a, T: MonadFail<'a, Result<E, Ex>>> Fail<'a, E>
for OverloadInstance<T, DeriveFail<Ex>>
{
fn fail<A: 'a>(e: E) -> Self::Fa<A> {
fn fail<A: 'a>(e: E) -> Self::F<A> {
T::fail(Ok(e))
}
}
@ -199,11 +197,11 @@ impl<'a, T: SharedFunctor<'a>, O: 'a + DeriveWeakFunctor> SharedFunctor<'a>
{
type Shared<A: 'a + Clone> = T::Shared<A>;
fn share<A: 'a + Clone>(fa: Self::Fa<A>) -> Self::Shared<A> {
fn share<A: 'a + Clone>(fa: Self::F<A>) -> Self::Shared<A> {
T::share(fa)
}
fn unshare<A: 'a + Clone>(sa: Self::Shared<A>) -> Self::Fa<A> {
fn unshare<A: 'a + Clone>(sa: Self::Shared<A>) -> Self::F<A> {
T::unshare(sa)
}
}

38
src/func/instances/result.rs
View File

@ -12,34 +12,34 @@ use crate::func::*;
#[derive(SharedFunctorAny)]
pub struct ResultInstance<E>(E);
impl<E> WeakFunctor for ResultInstance<E> {
type F<'a, A: 'a> = Result<A, E> where Self: 'a;
impl<E> WeakFunctorAny for ResultInstance<E> {
type FAny<'a, A: 'a> = Result<A, E> where Self: 'a;
}
impl<'a, E: 'a> Functor<'a> for ResultInstance<E> {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::Fa<A>) -> Self::Fa<B> {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<A>) -> Self::F<B> {
fa.map(f)
}
fn replace<A: 'a, B: 'a>(fa: Self::Fa<A>, b: B) -> Self::Fa<B> {
fn replace<A: 'a, B: 'a>(fa: Self::F<A>, b: B) -> Self::F<B> {
fa?;
Self::pure(b)
}
fn void<A: 'a>(fa: Self::Fa<A>) -> Self::Fa<()> {
fn void<A: 'a>(fa: Self::F<A>) -> Self::F<()> {
fa?;
Self::pure(())
}
}
impl<'a, E: 'a> Pure<'a> for ResultInstance<E> {
fn pure<A: 'a>(a: A) -> Self::Fa<A> {
fn pure<A: 'a>(a: A) -> Self::F<A> {
Ok(a)
}
}
impl<'a, E: 'a> ApplicativeSeq<'a> for ResultInstance<E> {
fn seq<A: 'a, B: 'a>(ff: Self::Fa<impl 'a + FnOnce(A) -> B>, fa: Self::Fa<A>) -> Self::Fa<B> {
fn seq<A: 'a, B: 'a>(ff: Self::F<impl 'a + FnOnce(A) -> B>, fa: Self::F<A>) -> Self::F<B> {
Self::pure(ff?(fa?))
}
}
@ -47,15 +47,15 @@ impl<'a, E: 'a> ApplicativeSeq<'a> for ResultInstance<E> {
impl<'a, E: 'a> ApplicativeLA2<'a> for ResultInstance<E> {
fn la2<A: 'a, B: 'a, C: 'a>(
f: impl 'a + FnOnce(A, B) -> C,
fa: Self::Fa<A>,
fb: Self::Fa<B>,
) -> Self::Fa<C> {
fa: Self::F<A>,
fb: Self::F<B>,
) -> Self::F<C> {
Self::pure(f(fa?, fb?))
}
}
impl<'a, E: 'a> ApplicativeTuple<'a> for ResultInstance<E> {
fn tuple<A: 'a, B: 'a>((fa, fb): (Self::Fa<A>, Self::Fa<B>)) -> Self::Fa<(A, B)> {
fn tuple<A: 'a, B: 'a>((fa, fb): (Self::F<A>, Self::F<B>)) -> Self::F<(A, B)> {
Self::pure((fa?, fb?))
}
}
@ -63,23 +63,23 @@ impl<'a, E: 'a> ApplicativeTuple<'a> for ResultInstance<E> {
impl<'a, E: 'a> ApplicativeSelect<'a> for ResultInstance<E> {}
impl<'a, E: 'a> Applicative<'a> for ResultInstance<E> {
fn discard_first<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> Self::Fa<B> {
fn discard_first<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<B> {
fa?;
fb
}
fn discard_second<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> Self::Fa<A> {
fn discard_second<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<A> {
fb?;
fa
}
}
impl<'a, E: 'a> Monad<'a> for ResultInstance<E> {
fn bind<A: 'a, B: 'a>(fa: Self::Fa<A>, f: impl 'a + FnOnce(A) -> Self::Fa<B>) -> Self::Fa<B> {
fn bind<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> Self::F<B>) -> Self::F<B> {
f(fa?)
}
fn iterate<B: 'a>(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::Fa<B> {
fn iterate<B: 'a>(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::F<B> {
loop {
match f.next()? {
ControlFlow::Continue(next_f) => f = next_f,
@ -88,13 +88,13 @@ impl<'a, E: 'a> Monad<'a> for ResultInstance<E> {
}
}
fn join<A: 'a>(ffa: Self::Fa<Self::Fa<A>>) -> Self::Fa<A> {
fn join<A: 'a>(ffa: Self::F<Self::F<A>>) -> Self::F<A> {
ffa?
}
}
impl<'a, E: 'a> LocalFunctor<'a> for ResultInstance<E> {
fn unstuff<A: 'a, B: 'a>(state: Self::Fa<ControlFlow<B, A>>) -> ControlFlow<Self::Fa<B>, A> {
fn unstuff<A: 'a, B: 'a>(state: Self::F<ControlFlow<B, A>>) -> ControlFlow<Self::F<B>, 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<E> {
}
}
fn stuff<A: 'a, T: Pure<'a>>(fa: Self::Fa<T::Fa<A>>) -> T::Fa<Self::Fa<A>> {
fn stuff<A: 'a, T: Pure<'a>>(fa: Self::F<T::F<A>>) -> T::F<Self::F<A>> {
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<E> {
}
impl<'a, E: 'a> Fail<'a, E> for ResultInstance<E> {
fn fail<A: 'a>(e: E) -> Self::Fa<A> {
fn fail<A: 'a>(e: E) -> Self::F<A> {
Err(e)
}
}

38
src/func/instances/solo.rs
View File

@ -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<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::Fa<A>) -> Self::Fa<B> {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<A>) -> Self::F<B> {
f(fa)
}
fn replace<A: 'a, B: 'a>(fa: Self::Fa<A>, b: B) -> Self::Fa<B> {
fn replace<A: 'a, B: 'a>(fa: Self::F<A>, b: B) -> Self::F<B> {
drop(fa);
b
}
fn void<A: 'a>(fa: Self::Fa<A>) -> Self::Fa<()> {
fn void<A: 'a>(fa: Self::F<A>) -> Self::F<()> {
drop(fa);
}
}
impl<'a> Pure<'a> for SoloInstance {
fn pure<A: 'a>(a: A) -> Self::Fa<A> {
fn pure<A: 'a>(a: A) -> Self::F<A> {
a
}
}
impl<'a> ApplicativeSeq<'a> for SoloInstance {
fn seq<A: 'a, B: 'a>(ff: Self::Fa<impl 'a + FnOnce(A) -> B>, fa: Self::Fa<A>) -> Self::Fa<B> {
fn seq<A: 'a, B: 'a>(ff: Self::F<impl 'a + FnOnce(A) -> B>, fa: Self::F<A>) -> Self::F<B> {
ff(fa)
}
}
@ -41,15 +41,15 @@ impl<'a> ApplicativeSeq<'a> for SoloInstance {
impl<'a> ApplicativeLA2<'a> for SoloInstance {
fn la2<A: 'a, B: 'a, C: 'a>(
f: impl 'a + FnOnce(A, B) -> C,
fa: Self::Fa<A>,
fb: Self::Fa<B>,
) -> Self::Fa<C> {
fa: Self::F<A>,
fb: Self::F<B>,
) -> Self::F<C> {
f(fa, fb)
}
}
impl<'a> ApplicativeTuple<'a> for SoloInstance {
fn tuple<A: 'a, B: 'a>((fa, fb): (Self::Fa<A>, Self::Fa<B>)) -> Self::Fa<(A, B)> {
fn tuple<A: 'a, B: 'a>((fa, fb): (Self::F<A>, Self::F<B>)) -> 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<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> Self::Fa<B> {
fn discard_first<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<B> {
drop(fa);
fb
}
fn discard_second<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> Self::Fa<A> {
fn discard_second<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<A> {
drop(fb);
fa
}
}
impl<'a> Monad<'a> for SoloInstance {
fn bind<A: 'a, B: 'a>(fa: Self::Fa<A>, f: impl 'a + FnOnce(A) -> Self::Fa<B>) -> Self::Fa<B> {
fn bind<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> Self::F<B>) -> Self::F<B> {
f(fa)
}
fn iterate<B: 'a>(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::Fa<B> {
fn iterate<B: 'a>(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::F<B> {
loop {
match f.next() {
ControlFlow::Continue(next_f) => f = next_f,
@ -82,23 +82,23 @@ impl<'a> Monad<'a> for SoloInstance {
}
}
fn join<A: 'a>(ffa: Self::Fa<Self::Fa<A>>) -> Self::Fa<A> {
fn join<A: 'a>(ffa: Self::F<Self::F<A>>) -> Self::F<A> {
ffa
}
}
impl<'a> LocalFunctor<'a> for SoloInstance {
fn unstuff<A: 'a, B: 'a>(state: Self::Fa<ControlFlow<B, A>>) -> ControlFlow<Self::Fa<B>, A> {
fn unstuff<A: 'a, B: 'a>(state: Self::F<ControlFlow<B, A>>) -> ControlFlow<Self::F<B>, A> {
state
}
fn stuff<A: 'a, T: Pure<'a>>(fa: Self::Fa<T::Fa<A>>) -> T::Fa<Self::Fa<A>> {
fn stuff<A: 'a, T: Pure<'a>>(fa: Self::F<T::F<A>>) -> T::F<Self::F<A>> {
fa
}
}
impl<'a> Fail<'a, std::convert::Infallible> for SoloInstance {
fn fail<A: 'a>(e: std::convert::Infallible) -> Self::Fa<A> {
fn fail<A: 'a>(e: std::convert::Infallible) -> Self::F<A> {
match e {}
}
}

36
src/func/instances/stackless.rs
View File

@ -119,16 +119,16 @@ impl<'a, A: 'a> From<A> 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<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::Fa<A>) -> Self::Fa<B> {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<A>) -> Self::F<B> {
fa.map(f)
}
fn replace<A: 'a, B: 'a>(fa: Self::Fa<A>, b: B) -> Self::Fa<B> {
fn replace<A: 'a, B: 'a>(fa: Self::F<A>, b: B) -> Self::F<B> {
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>(a: A) -> Self::Fa<A> {
fn pure<A: 'a>(a: A) -> Self::F<A> {
Stackless::from(a)
}
}
impl<'a> ApplicativeSeq<'a> for StacklessInstance {
fn seq<A: 'a, B: 'a>(ff: Self::Fa<impl 'a + FnOnce(A) -> B>, fa: Self::Fa<A>) -> Self::Fa<B> {
fn seq<A: 'a, B: 'a>(ff: Self::F<impl 'a + FnOnce(A) -> B>, fa: Self::F<A>) -> Self::F<B> {
ff.bind(|f| fa.map(f))
}
}
@ -156,15 +156,15 @@ impl<'a> ApplicativeSeq<'a> for StacklessInstance {
impl<'a> ApplicativeLA2<'a> for StacklessInstance {
fn la2<A: 'a, B: 'a, C: 'a>(
f: impl 'a + FnOnce(A, B) -> C,
fa: Self::Fa<A>,
fb: Self::Fa<B>,
) -> Self::Fa<C> {
fa: Self::F<A>,
fb: Self::F<B>,
) -> Self::F<C> {
Self::_la2_via_seq(f, fa, fb)
}
}
impl<'a> ApplicativeTuple<'a> for StacklessInstance {
fn tuple<A: 'a, B: 'a>((fa, fb): (Self::Fa<A>, Self::Fa<B>)) -> Self::Fa<(A, B)> {
fn tuple<A: 'a, B: 'a>((fa, fb): (Self::F<A>, Self::F<B>)) -> 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<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> Self::Fa<B> {
fn discard_first<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<B> {
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<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> Self::Fa<A> {
fn discard_second<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<A> {
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<A: 'a, B: 'a>(fa: Self::Fa<A>, f: impl 'a + FnOnce(A) -> Self::Fa<B>) -> Self::Fa<B> {
fn bind<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> Self::F<B>) -> Self::F<B> {
fa.bind(f)
}
fn iterate<B: 'a>(f: impl Iterative<'a, T = Self, B = B>) -> Self::Fa<B> {
fn iterate<B: 'a>(f: impl Iterative<'a, T = Self, B = B>) -> Self::F<B> {
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<A: 'a>(ffa: Self::Fa<Self::Fa<A>>) -> Self::Fa<A> {
fn join<A: 'a>(ffa: Self::F<Self::F<A>>) -> Self::F<A> {
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<A: PartialEq + std::fmt::Debug + 'a>(
name: &'a str,
left: Self::Fa<A>,
right: Self::Fa<A>,
left: Self::F<A>,
right: Self::F<A>,
) -> tests::R {
tests::eqr(name, left.evaluate(), right.evaluate())
}
}
impl<'a> test_suite::FunctorTestSuite<'a> for T {
fn sample<A: 'a, F: FnMut(&'a dyn Fn(A) -> Self::Fa<A>)>(mut f: F) {
fn sample<A: 'a, F: FnMut(&'a dyn Fn(A) -> Self::F<A>)>(mut f: F) {
f(&|a| a.into());
}
}

38
src/func/instances/tryfuture.rs
View File

@ -9,16 +9,16 @@ use crate::func::*;
pub struct TryFutureInstance<E>(E);
impl<E> WeakFunctor for TryFutureInstance<E> {
type F<'a, A: 'a> = Pin<Box<dyn 'a + Future<Output = Result<A, E>>>> where Self: 'a;
impl<E> WeakFunctorAny for TryFutureInstance<E> {
type FAny<'a, A: 'a> = Pin<Box<dyn 'a + Future<Output = Result<A, E>>>> where Self: 'a;
}
impl<'a, E: 'a> Functor<'a> for TryFutureInstance<E> {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::Fa<A>) -> Self::Fa<B> {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<A>) -> Self::F<B> {
Box::pin(async { Ok(f(fa.await?)) })
}
fn replace<A: 'a, B: 'a>(fa: Self::Fa<A>, b: B) -> Self::Fa<B> {
fn replace<A: 'a, B: 'a>(fa: Self::F<A>, b: B) -> Self::F<B> {
Box::pin(async {
fa.await?;
Ok(b)
@ -27,13 +27,13 @@ impl<'a, E: 'a> Functor<'a> for TryFutureInstance<E> {
}
impl<'a, E: 'a> Pure<'a> for TryFutureInstance<E> {
fn pure<A: 'a>(a: A) -> Self::Fa<A> {
fn pure<A: 'a>(a: A) -> Self::F<A> {
Box::pin(async { Ok(a) })
}
}
impl<'a, E: 'a> ApplicativeSeq<'a> for TryFutureInstance<E> {
fn seq<A: 'a, B: 'a>(ff: Self::Fa<impl 'a + FnOnce(A) -> B>, fa: Self::Fa<A>) -> Self::Fa<B> {
fn seq<A: 'a, B: 'a>(ff: Self::F<impl 'a + FnOnce(A) -> B>, fa: Self::F<A>) -> Self::F<B> {
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<E> {
impl<'a, E: 'a> ApplicativeLA2<'a> for TryFutureInstance<E> {
fn la2<A: 'a, B: 'a, C: 'a>(
f: impl 'a + FnOnce(A, B) -> C,
fa: Self::Fa<A>,
fb: Self::Fa<B>,
) -> Self::Fa<C> {
fa: Self::F<A>,
fb: Self::F<B>,
) -> Self::F<C> {
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<E> {
}
impl<'a, E: 'a> ApplicativeTuple<'a> for TryFutureInstance<E> {
fn tuple<A: 'a, B: 'a>((fa, fb): (Self::Fa<A>, Self::Fa<B>)) -> Self::Fa<(A, B)> {
fn tuple<A: 'a, B: 'a>((fa, fb): (Self::F<A>, Self::F<B>)) -> Self::F<(A, B)> {
Box::pin(async { try_join!(fa, fb) })
}
}
impl<'a, E: 'a> ApplicativeSelect<'a> for TryFutureInstance<E> {
fn select<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> SelectedWrapped<'a, A, B, Self> {
fn select<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> 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<E> {
}
impl<'a, E: 'a> Applicative<'a> for TryFutureInstance<E> {
fn discard_first<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> Self::Fa<B> {
fn discard_first<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<B> {
Box::pin(async { Ok(try_join!(fa, fb)?.1) })
}
fn discard_second<A: 'a, B: 'a>(fa: Self::Fa<A>, fb: Self::Fa<B>) -> Self::Fa<A> {
fn discard_second<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<A> {
Box::pin(async { Ok(try_join!(fa, fb)?.0) })
}
}
impl<'a, E: 'a> Monad<'a> for TryFutureInstance<E> {
fn bind<A: 'a, B: 'a>(fa: Self::Fa<A>, f: impl 'a + FnOnce(A) -> Self::Fa<B>) -> Self::Fa<B> {
fn bind<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> Self::F<B>) -> Self::F<B> {
Box::pin(async { f(fa.await?).await })
}
fn iterate<B: 'a>(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::Fa<B> {
fn iterate<B: 'a>(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::F<B> {
Box::pin(async move {
loop {
match f.next().await? {
@ -99,7 +99,7 @@ impl<'a, E: 'a> Monad<'a> for TryFutureInstance<E> {
})
}
fn join<A: 'a>(ffa: Self::Fa<Self::Fa<A>>) -> Self::Fa<A> {
fn join<A: 'a>(ffa: Self::F<Self::F<A>>) -> Self::F<A> {
Box::pin(async { ffa.await?.await })
}
}
@ -107,17 +107,17 @@ impl<'a, E: 'a> Monad<'a> for TryFutureInstance<E> {
impl<'a, E: 'a + Clone> SharedFunctor<'a> for TryFutureInstance<E> {
type Shared<A: 'a + Clone> = Shared<Pin<Box<dyn 'a + Future<Output = Result<A, E>>>>>;
fn share<A: 'a + Clone>(fa: Self::Fa<A>) -> Self::Shared<A> {
fn share<A: 'a + Clone>(fa: Self::F<A>) -> Self::Shared<A> {
fa.shared()
}
fn unshare<A: 'a + Clone>(sa: Self::Shared<A>) -> Self::Fa<A> {
fn unshare<A: 'a + Clone>(sa: Self::Shared<A>) -> Self::F<A> {
Box::pin(sa)
}
}
impl<'a, E: 'a> Fail<'a, E> for TryFutureInstance<E> {
fn fail<A: 'a>(e: E) -> Self::Fa<A> {
fn fail<A: 'a>(e: E) -> Self::F<A> {
Box::pin(async { Err(e) })
}
}

4
src/func/test_suite.rs
View File

@ -1,8 +1,8 @@
use super::tests::*;
use super::*;
pub trait FunctorTestSuite<'a>: WeakFunctorA<'a> + Eqr<'a> {
fn sample<A: 'a, F: FnMut(&'a dyn Fn(A) -> Self::Fa<A>)>(f: F);
pub trait FunctorTestSuite<'a>: WeakFunctor<'a> + Eqr<'a> {
fn sample<A: 'a, F: FnMut(&'a dyn Fn(A) -> Self::F<A>)>(f: F);
}
pub fn functor_follows_laws<'a, T: Functor<'a> + FunctorTestSuite<'a>>() -> R {

44
src/func/tests.rs
View File

@ -26,8 +26,8 @@ impl R {
}
}
pub trait Eqr<'a>: WeakFunctorA<'a> {
fn eqr<A: PartialEq + Debug + 'a>(name: &'a str, left: Self::Fa<A>, right: Self::Fa<A>) -> R;
pub trait Eqr<'a>: WeakFunctor<'a> {
fn eqr<A: PartialEq + Debug + 'a>(name: &'a str, left: Self::F<A>, right: Self::F<A>) -> R;
}
pub fn eqr<T: PartialEq + Debug>(name: &str, left: T, right: T) -> R {
@ -88,7 +88,7 @@ impl AddAssign<R> for R {
}
pub fn fmap_respects_identity<'a, T: Functor<'a> + Eqr<'a>, A: 'a + Debug + PartialEq>(
fa0: impl Fn() -> T::Fa<A>,
fa0: impl Fn() -> T::F<A>,
) -> 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<A>,
fa0: impl Fn() -> T::F<A>,
) -> 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<A>,
fa0: impl Fn() -> T::F<A>,
) -> 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<F>,
fg0: impl Fn() -> T::Fa<G>,
fa0: impl Fn() -> T::Fa<A>,
ff0: impl Fn() -> T::F<F>,
fg0: impl Fn() -> T::F<G>,
fa0: impl Fn() -> T::F<A>,
) -> 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<F>,
ff0: impl Fn() -> T::F<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<F>,
fa0: impl Fn() -> T::Fa<A>,
ff0: impl Fn() -> T::F<F>,
fa0: impl Fn() -> T::F<A>,
) -> 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<A>,
fa0: impl Fn() -> T::F<A>,
) -> 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<A>,
fb0: impl 'a + Fn() -> T::Fa<B>,
fa0: impl 'a + Fn() -> T::F<A>,
fb0: impl 'a + Fn() -> T::F<B>,
) -> 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<B>,
f: impl 'a + Fn(A) -> T::F<B>,
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<A>,
fa0: impl Fn() -> T::F<A>,
) -> 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<C>,
g: impl 'a + Clone + Fn(A) -> T::Fa<B>,
fa0: impl 'a + Fn() -> T::Fa<A>,
f: impl 'a + Clone + Fn(B) -> T::F<C>,
g: impl 'a + Clone + Fn(A) -> T::F<B>,
fa0: impl 'a + Fn() -> T::F<A>,
) -> 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<F>,
fa0: impl 'a + Fn() -> T::Fa<A>,
ff0: impl Fn() -> T::F<F>,
fa0: impl 'a + Fn() -> T::F<A>,
) -> 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<A>,
fa0: impl 'a + Fn() -> T::F<A>,
) -> R {
T::eqr(
"fmap via bind: fmap f xs = xs >>= return . f",

6
src/rcore.rs
View File

@ -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<A>, event: impl 'b + FnOnce() -> String) -> T::Fa<A>
fn after<'b, A: 'a>(fa: T::F<A>, event: impl 'b + FnOnce() -> String) -> T::F<A>
where
'a: 'b;
/// Specify that the evaluation happens before a specific event.
fn before<'b, A: 'a>(fa: T::Fa<A>, event: impl 'b + FnOnce() -> String) -> T::Fa<A>
fn before<'b, A: 'a>(fa: T::F<A>, event: impl 'b + FnOnce() -> String) -> T::F<A>
where
'a: 'b;
/// Label the evaluation step as a specific named action.
fn wrapped<'b, A: 'a>(fa: T::Fa<A>, event: impl 'b + FnOnce() -> String) -> T::Fa<A>
fn wrapped<'b, A: 'a>(fa: T::F<A>, event: impl 'b + FnOnce() -> String) -> T::F<A>
where
'a: 'b;
}

6
src/testing.rs
View File

@ -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<A>, _event: impl 'b + FnOnce() -> String) -> T::Fa<A> {
fn after<'b, A>(fa: T::F<A>, _event: impl 'b + FnOnce() -> String) -> T::F<A> {
fa
}
fn before<'b, A>(fa: T::Fa<A>, _event: impl 'b + FnOnce() -> String) -> T::Fa<A> {
fn before<'b, A>(fa: T::F<A>, _event: impl 'b + FnOnce() -> String) -> T::F<A> {
fa
}
fn wrapped<'b, A>(fa: T::Fa<A>, _event: impl 'b + FnOnce() -> String) -> T::Fa<A> {
fn wrapped<'b, A>(fa: T::F<A>, _event: impl 'b + FnOnce() -> String) -> T::F<A> {
fa
}
}