Use curry/uncurry functions

src/core/functions.rs

@@ -4,5 +4,19 @@
  * Copyright (c) 2023 Didier Plaindoux
  */
 
-pub type Fun<A, B> = Box<dyn Fn(A) -> B>;
-pub type FunOnce<'a, A, B> = Box<dyn FnOnce(A) -> B + 'a>;
+pub fn uncurry<'a, A, B, C, CURRY>(f: CURRY) -> Box<dyn Fn(A, B) -> C + 'a>
+where
+    CURRY: Fn(A) -> Box<dyn Fn(B) -> C> + 'a,
+{
+    Box::new(move |a, b| f(a)(b))
+}
+
+pub fn curry<'a, A, B, C, UNCURRY>(
+    f: UNCURRY,
+) -> Box<dyn FnOnce(A) -> Box<dyn FnOnce(B) -> C + 'a> + 'a>
+where
+    A: 'a,
+    UNCURRY: FnOnce(A, B) -> C + 'a,
+{
+    Box::new(move |a| Box::new(move |b| f(a, b)))
+}

src/core/mod.rs

@@ -7,3 +7,4 @@
 pub mod functions;
 pub mod hkp;
 pub mod transform;
+pub mod types;

src/core/types.rs

@@ -0,0 +1,10 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2023 Didier Plaindoux
+ */
+
+pub type Fun<A, B> = Box<dyn Fn(A) -> B>;
+pub type FunLT<'a, A, B> = Box<dyn Fn(A) -> B + 'a>;
+pub type FunOnce<A, B> = Box<dyn FnOnce(A) -> B>;
+pub type FunOnceLT<'a, A, B> = Box<dyn FnOnce(A) -> B + 'a>;

src/specs/applicative.rs

@@ -4,7 +4,7 @@
  * Copyright (c) 2023 Didier Plaindoux
  */
 
-use crate::core::functions::Fun;
+use crate::core::types::Fun;
 use crate::specs::functor::Functor;
 
 pub trait Applicative<'a>: Functor<'a> {
@@ -29,11 +29,11 @@ pub trait Applicative<'a>: Functor<'a> {
 }
 
 pub mod curry {
-    use crate::core::functions::{Fun, FunOnce};
+    use crate::core::types::{Fun, FunOnceLT};
     use crate::specs::applicative::Applicative as Api;
 
     pub trait Applicative<'a>: Api<'a> {
-        fn apply<A, B, MAP>(mf: Self::T<MAP>) -> FunOnce<'a, Self::T<A>, Self::T<B>>
+        fn apply<A, B, MAP>(mf: Self::T<MAP>) -> FunOnceLT<'a, Self::T<A>, Self::T<B>>
         where
             Self: 'a,
             A: Clone,
@@ -42,13 +42,13 @@ pub mod curry {
             Box::new(move |ma| <Self as Api<'a>>::apply(mf, ma))
         }
 
-        fn lift1<A, B>(f: Fun<A, B>) -> FunOnce<'a, Self::T<A>, Self::T<B>> {
+        fn lift1<A, B>(f: Fun<A, B>) -> FunOnceLT<'a, Self::T<A>, Self::T<B>> {
             Box::new(move |ma| <Self as Api<'a>>::lift1(f, ma))
         }
 
         fn lift2<A, B, C>(
             f: Fun<A, Fun<B, C>>,
-        ) -> FunOnce<'a, Self::T<A>, FunOnce<'a, Self::T<B>, Self::T<C>>>
+        ) -> FunOnceLT<'a, Self::T<A>, FunOnceLT<'a, Self::T<B>, Self::T<C>>>
         where
             Self: 'a,
             A: Clone,

src/specs/bind.rs

@@ -17,11 +17,11 @@ pub trait Bind<'a>: Applicative<'a> {
 }
 
 pub mod curry {
-    use crate::core::functions::FunOnce;
+    use crate::core::types::FunOnceLT;
     use crate::specs::bind::Bind as Api;
 
     pub trait Bind<'a>: Api<'a> {
-        fn bind<A, B, BIND>(ma: Self::T<A>) -> FunOnce<'a, BIND, Self::T<B>>
+        fn bind<A, B, BIND>(ma: Self::T<A>) -> FunOnceLT<'a, BIND, Self::T<B>>
         where
             Self: 'a,
             BIND: Fn(A) -> Self::T<B> + 'a,

src/specs/functor.rs

@@ -13,14 +13,17 @@ pub trait Functor<'a>: HKP<'a> {
 }
 
 pub mod curry {
+    use crate::core::functions::curry;
     use crate::specs::functor::Functor as Api;
 
     pub trait Functor<'a>: Api<'a> {
         fn map<A, B, MAP>(f: MAP) -> Box<dyn FnOnce(Self::T<A>) -> Self::T<B> + 'a>
         where
+            Self: 'a,
+            A: Copy,
             MAP: Fn(A) -> B + 'a,
         {
-            Box::new(move |a| <Self as Api<'a>>::map(f, a))
+            curry(<Self as Api<'a>>::map)(f)
         }
     }
 }

src/standard/reader.rs

@@ -4,15 +4,15 @@
  * Copyright (c) 2023 Didier Plaindoux
  */
 
-use crate::core::functions::FunOnce;
 use crate::core::hkp::HKP;
+use crate::core::types::FunOnceLT;
 use crate::specs::applicative::Applicative;
 use crate::specs::bind::Bind;
 use crate::specs::functor::Functor;
 use crate::specs::monad::Monad;
 use std::marker::PhantomData;
 
-pub struct Reader<'a, E, F: HKP<'a>, A: 'a>(FunOnce<'a, E, F::T<A>>, PhantomData<F>);
+pub struct Reader<'a, E, F: HKP<'a>, A: 'a>(FunOnceLT<'a, E, F::T<A>>, PhantomData<F>);
 
 pub struct ReaderK<'a, E, F: HKP<'a>>(PhantomData<&'a E>, PhantomData<F>);