added KleisliTest

DanielGronau · DanielGronau · commit a2b4d3857069 · 2018-01-25T23:01:02.000+01:00
diff --git a/src/main/java/org/highj/control/arrow/kleisli/KleisliProfunctor.java b/src/main/java/org/highj/control/arrow/kleisli/KleisliProfunctor.java
@@ -1,8 +1,6 @@
 package org.highj.control.arrow.kleisli;
 
 import org.derive4j.hkt.__;
-import org.derive4j.hkt.__2;
-import org.highj.Hkt;
 import org.highj.control.arrow.Kleisli;
 import org.highj.typeclass1.monad.Monad;
 import org.highj.typeclass2.profunctor.Profunctor;
@@ -15,11 +13,6 @@ public interface KleisliProfunctor<M> extends Profunctor<__<Kleisli.µ, M>> {
 
     Monad<M> getM();
 
-    @Override
-    default <A, B, C, D> Kleisli<M, A, D> dimap(Function<A, B> f, Function<C, D> g, __<__<__<Kleisli.µ, M>, B>, C> p) {
-        return rmap(g, lmap(f, p));
-    }
-
     @Override
     default <A, B, C> Kleisli<M, A, C> lmap(Function<A, B> f, __<__<__<Kleisli.µ, M>, B>, C> p) {
         return asKleisli(p).lmap(f);
diff --git a/src/main/java/org/highj/typeclass2/profunctor/Profunctor.java b/src/main/java/org/highj/typeclass2/profunctor/Profunctor.java
@@ -9,11 +9,15 @@
 /**
  * A profunctor can be thought of as a bifunctor where the first argument is contravariant and the second argument is covariant.
  *
+ * Minimal definition: dimap OR (lmap AND rmap)
+ *
  * @param <P> the profunctor type class
  */
 public interface Profunctor<P> {
 
-    <A, B, C, D> __2<P, A, D> dimap(Function<A, B> f, Function<C, D> g, __<__<P, B>, C> p);
+    default <A, B, C, D> __2<P, A, D> dimap(Function<A, B> f, Function<C, D> g, __<__<P, B>, C> p) {
+        return rmap(g, lmap(f, p));
+    }
 
     default <A, B, C> __2<P, A, C> lmap(Function<A, B> f, __<__<P, B>, C> p) {
         return dimap(f, Function.identity(), p);
diff --git a/src/test/java/org/highj/control/arrow/KleisliTest.java b/src/test/java/org/highj/control/arrow/KleisliTest.java
@@ -0,0 +1,50 @@
+package org.highj.control.arrow;
+
+import org.derive4j.hkt.__;
+import org.derive4j.hkt.__2;
+import org.highj.Hkt;
+import org.highj.data.Maybe;
+import org.highj.data.eq.Eq;
+import org.highj.typeclass2.arrow.ArrowLaw;
+import org.junit.Test;
+
+import java.util.function.Function;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.highj.data.Maybe.*;
+
+public class KleisliTest {
+
+    @Test
+    public void apply() {
+        Function<String, __<Maybe.µ, Integer>> fn = s -> JustWhenTrue(s.contains("x"), () -> s.indexOf('x'));
+        assertThat(new Kleisli<>(fn).apply("Max")).isEqualTo(Just(2));
+        assertThat(new Kleisli<>(fn).apply("Moritz")).isEqualTo(Nothing());
+    }
+
+    @Test
+    public void lmap() {
+        Function<String, __<Maybe.µ, Integer>> fn = s -> JustWhenTrue(s.contains("x"), () -> s.indexOf('x'));
+        Kleisli<Maybe.µ, String, Integer> kleisli = new Kleisli<>(fn).lmap(s -> new StringBuilder(s).reverse().toString());
+        assertThat(kleisli.apply("Max")).isEqualTo(Just(0));
+        assertThat(kleisli.apply("Moritz")).isEqualTo(Nothing());
+    }
+
+    @Test
+    public void arrowLaw() {
+        new ArrowLaw<__<Kleisli.µ, Maybe.µ>>(Kleisli.arrow(Maybe.monad)) {
+            @Override
+            public <B, C> boolean areEqual(__2<__<Kleisli.µ, Maybe.µ>, B, C> one, __2<__<Kleisli.µ, Maybe.µ>, B, C> two, B b, Eq<C> eq) {
+                Kleisli<Maybe.µ, B, C> kleisliOne = Hkt.asKleisli(one);
+                Kleisli<Maybe.µ, B, C> kleisliTwo = Hkt.asKleisli(two);
+                Maybe<C> maybeOne = Hkt.asMaybe(kleisliOne.apply(b));
+                Maybe<C> maybeTwo = Hkt.asMaybe(kleisliTwo.apply(b));
+                return Maybe.eq(eq).eq(maybeOne, maybeTwo);
+            }
+        }.test();
+    }
+
+    @Test
+    public void profunctor() {
+    }
+}
