Adding Kleisli arrows

Author: jnape

CHANGELOG.md

@@ -9,10 +9,12 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - `Try`, a `Monad` representing an expression-like analog of `try/catch/finally`
 - `CheckedRunnable`, the `Runnable` counterpart to `CheckedSupplier` that can throw checked exceptions
 - `Unit`, the lambda analog to `Void`, except actually inhabited by a singleton instance 
+- `Kleisli`, the abstract representation of a `Kleisli` arrow (`Monad#flatMap`) as an `Fn1` 
 
 ### Changed
 - `Bifunctor` is now a `BoundedBifunctor` where both parameter upper bounds are `Object`
 - `Peek2` now accepts the more general `BoundedBifunctor`
+- `Identity`, `Compose`, and `Const` functors all have better `toString` implementations
 
 ### Deprecated
 - `Either#trying` in favor of `Try#trying` 

src/main/java/com/jnape/palatable/lambda/functions/specialized/Kleisli.java

@@ -0,0 +1,90 @@
+package com.jnape.palatable.lambda.functions.specialized;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functor.Applicative;
+import com.jnape.palatable.lambda.monad.Monad;
+
+import java.util.function.Function;
+
+/**
+ * The Kleisli arrow of a {@link Monad}, manifest as simply an <code>{@link Fn1}&lt;A, MB&gt;</code>. This can be
+ * thought of as a fixed, portable {@link Monad#flatMap(Function)}.
+ *
+ * @param <A>  the input argument type
+ * @param <M>  the {@link Monad} unification parameter
+ * @param <MB> the output {@link Monad} type
+ */
+@FunctionalInterface
+public interface Kleisli<A, B, M extends Monad, MB extends Monad<B, M>> extends Fn1<A, MB> {
+
+    /**
+     * Left-to-right composition of two compatible {@link Kleisli} arrows, yielding a new {@link Kleisli} arrow.
+     *
+     * @param after the arrow to execute after this one
+     * @param <C>   the new return parameter type
+     * @param <MC>  the {@link Monad} instance to return
+     * @return the composition of the two arrows as a new {@link Kleisli} arrow
+     */
+    default <C, MC extends Monad<C, M>> Kleisli<A, C, M, MC> andThen(Kleisli<B, C, M, MC> after) {
+        return a -> apply(a).flatMap(after).coerce();
+    }
+
+    /**
+     * Right-to-left composition of two compatible {@link Kleisli} arrows, yielding a new {@link Kleisli} arrow.
+     *
+     * @param before the arrow to execute before this one
+     * @param <Z>    the new input argument type
+     * @param <MA>   the {@link Monad} instance to flatMap with this arrow
+     * @return the composition of the two arrows as a new {@link Kleisli} arrow
+     */
+    default <Z, MA extends Monad<A, M>> Kleisli<Z, B, M, MB> compose(Kleisli<Z, A, M, MA> before) {
+        return z -> before.apply(z).flatMap(this).coerce();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    default <Z> Kleisli<Z, B, M, MB> compose(Function<? super Z, ? extends A> before) {
+        return Fn1.super.compose(before)::apply;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    default <C> Kleisli<A, B, M, MB> discardR(Applicative<C, Fn1<A, ?>> appB) {
+        return Fn1.super.discardR(appB)::apply;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    default <Z> Kleisli<Z, B, M, MB> contraMap(Function<? super Z, ? extends A> fn) {
+        return Fn1.super.contraMap(fn)::apply;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    default <Z> Kleisli<Z, B, M, MB> diMapL(Function<? super Z, ? extends A> fn) {
+        return Fn1.super.diMapL(fn)::apply;
+    }
+
+    /**
+     * Adapt a compatible function into a {@link Kleisli} arrow.
+     *
+     * @param fn   the function
+     * @param <A>  the input argument type
+     * @param <B>  the output parameter type
+     * @param <M>  the {@link Monad} unification parameter
+     * @param <MB> the returned {@link Monad} instance
+     * @return the function adapted as a {@link Kleisli} arrow
+     */
+    static <A, B, M extends Monad, MB extends Monad<B, M>> Kleisli<A, B, M, MB> kleisli(
+            Function<? super A, ? extends MB> fn) {
+        return fn::apply;
+    }
+}

src/main/java/com/jnape/palatable/lambda/functor/builtin/Compose.java

@@ -59,4 +59,11 @@ public boolean equals(Object other) {
     public int hashCode() {
         return Objects.hash(fga);
     }
+
+    @Override
+    public String toString() {
+        return "Compose{" +
+                "fga=" + fga +
+                '}';
+    }
 }

src/main/java/com/jnape/palatable/lambda/functor/builtin/Const.java

@@ -1,8 +1,8 @@
 package com.jnape.palatable.lambda.functor.builtin;
 
-import com.jnape.palatable.lambda.monad.Monad;
 import com.jnape.palatable.lambda.functor.Applicative;
 import com.jnape.palatable.lambda.functor.Bifunctor;
+import com.jnape.palatable.lambda.monad.Monad;
 import com.jnape.palatable.lambda.traversable.Traversable;
 
 import java.util.Objects;
@@ -34,16 +34,6 @@ public A runConst() {
         return a;
     }
 
-    @Override
-    public boolean equals(Object other) {
-        return other instanceof Const && Objects.equals(a, ((Const) other).a);
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(a);
-    }
-
     /**
      * Map over the right parameter. Note that because <code>B</code> is never actually known quantity outside of a type
      * signature, this is effectively a no-op that serves only to alter <code>Const's</code> type signature.
@@ -131,4 +121,21 @@ public <C, D> Const<C, D> biMap(Function<? super A, ? extends C> lFn,
                                     Function<? super B, ? extends D> rFn) {
         return new Const<>(lFn.apply(a));
     }
+
+    @Override
+    public boolean equals(Object other) {
+        return other instanceof Const && Objects.equals(a, ((Const) other).a);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(a);
+    }
+
+    @Override
+    public String toString() {
+        return "Const{" +
+                "a=" + a +
+                '}';
+    }
 }

src/main/java/com/jnape/palatable/lambda/functor/builtin/Identity.java

@@ -81,4 +81,11 @@ public boolean equals(Object other) {
     public int hashCode() {
         return Objects.hash(a);
     }
+
+    @Override
+    public String toString() {
+        return "Identity{" +
+                "a=" + a +
+                '}';
+    }
 }

src/test/java/com/jnape/palatable/lambda/functions/specialized/KleisliTest.java

@@ -0,0 +1,26 @@
+package com.jnape.palatable.lambda.functions.specialized;
+
+import com.jnape.palatable.lambda.functor.builtin.Identity;
+import org.junit.Test;
+
+import static com.jnape.palatable.lambda.functions.specialized.Kleisli.kleisli;
+import static java.lang.Integer.parseInt;
+import static org.junit.Assert.assertEquals;
+
+public class KleisliTest {
+
+    private static final Kleisli<Integer, String, Identity, Identity<String>>  G = kleisli(i -> new Identity<>(i.toString()));
+    private static final Kleisli<String, Integer, Identity, Identity<Integer>> F = kleisli(s -> new Identity<>(parseInt(s)));
+
+    @Test
+    public void leftToRightComposition() {
+        assertEquals(new Identity<>(1), G.andThen(F).apply(1));
+        assertEquals(new Identity<>("1"), F.andThen(G).apply("1"));
+    }
+
+    @Test
+    public void rightToLeftComposition() {
+        assertEquals(new Identity<>("1"), G.compose(F).apply("1"));
+        assertEquals(new Identity<>(1), F.compose(G).apply(1));
+    }
+}