Monad#zip default implementation sequences in reverse (better) order

jnape · jnape · commit e5da83a9d04d · 2018-04-14T17:44:31.000-05:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -7,6 +7,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 ### Changed
 - ***Breaking Change***: `Sequence` now has two more type parameters to aid in inference
 - ***Breaking Change***: `Traversable#traverse` now has three more type parameters to aid in inference
+- ***Breaking Change***: `Monad#zip` now forces `m a -> b` before `m a` in default `Applicative#zip` implementation; this is only breaking for types that are sensitive to computation order (the resulting values are the same)
 - `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
diff --git a/src/main/java/com/jnape/palatable/lambda/functor/Applicative.java b/src/main/java/com/jnape/palatable/lambda/functor/Applicative.java
@@ -61,7 +61,7 @@ default <B> Applicative<B, App> fmap(Function<? super A, ? extends B> fn) {
      * @return appB
      */
     default <B> Applicative<B, App> discardL(Applicative<B, App> appB) {
-        return appB.zip(zip(pure(constantly(id()))));
+        return appB.zip(fmap(constantly(id())));
     }
 
     /**
diff --git a/src/main/java/com/jnape/palatable/lambda/monad/Monad.java b/src/main/java/com/jnape/palatable/lambda/monad/Monad.java
@@ -4,8 +4,6 @@
 
 import java.util.function.Function;
 
-import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
-
 /**
  * Monads are {@link Applicative} functors that support a flattening operation to unwrap <code>M&lt;M&lt;A&gt;&gt;
  * -&gt; M&lt;A&gt;</code>. This flattening operation, coupled with {@link Applicative#zip(Applicative)}, gives rise to
@@ -55,7 +53,7 @@ default <B> Monad<B, M> fmap(Function<? super A, ? extends B> fn) {
      */
     @Override
     default <B> Monad<B, M> zip(Applicative<Function<? super A, ? extends B>, M> appFn) {
-        return fmap(a -> appFn.<Monad<Function<? super A, ? extends B>, M>>coerce().<B>fmap(f -> f.apply(a))).flatMap(id());
+        return appFn.<Monad<Function<? super A, ? extends B>, M>>coerce().flatMap(ab -> fmap(ab::apply));
     }
 
     /**
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple2Test.java b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple2Test.java
@@ -105,7 +105,7 @@ public void staticFactoryMethodFromMapEntry() {
     public void zipPrecedence() {
         Tuple2<String, Integer> a = tuple("foo", 1);
         Tuple2<String, Function<? super Integer, ? extends Integer>> b = tuple("bar", x -> x + 1);
-        assertEquals(tuple("foo", 2), a.zip(b));
+        assertEquals(tuple("bar", 2), a.zip(b));
     }
 
     @Test
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple5Test.java b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple5Test.java
@@ -92,7 +92,7 @@ public void fill() {
     public void zipPrecedence() {
         Tuple5<String, Integer, Integer, Integer, Integer> a = tuple("foo", 1, 2, 3, 4);
         Tuple5<String, Integer, Integer, Integer, Function<? super Integer, ? extends Integer>> b = tuple("bar", 2, 3, 4, x -> x + 1);
-        assertEquals(tuple("foo", 1, 2, 3, 5), a.zip(b));
+        assertEquals(tuple("bar", 2, 3, 4, 5), a.zip(b));
     }
 
     @Test
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple6Test.java b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple6Test.java
@@ -96,7 +96,7 @@ public void fill() {
     public void zipPrecedence() {
         Tuple6<String, Integer, Integer, Integer, Integer, Integer> a = tuple("foo", 1, 2, 3, 4, 5);
         Tuple6<String, Integer, Integer, Integer, Integer, Function<? super Integer, ? extends Integer>> b = tuple("bar", 2, 3, 4, 5, x -> x + 1);
-        assertEquals(tuple("foo", 1, 2, 3, 4, 6), a.zip(b));
+        assertEquals(tuple("bar", 2, 3, 4, 5, 6), a.zip(b));
     }
 
     @Test
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple7Test.java b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple7Test.java
@@ -99,7 +99,7 @@ public void into() {
     public void zipPrecedence() {
         Tuple7<String, Integer, Integer, Integer, Integer, Integer, Integer> a = tuple("foo", 1, 2, 3, 4, 5, 6);
         Tuple7<String, Integer, Integer, Integer, Integer, Integer, Function<? super Integer, ? extends Integer>> b = tuple("bar", 2, 3, 4, 5, 6, x -> x + 1);
-        assertEquals(tuple("foo", 1, 2, 3, 4, 5, 7), a.zip(b));
+        assertEquals(tuple("bar", 2, 3, 4, 5, 6, 7), a.zip(b));
     }
 
     @Test
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple8Test.java b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple8Test.java
@@ -102,7 +102,7 @@ public void into() {
     public void zipPrecedence() {
         Tuple8<String, Integer, Integer, Integer, Integer, Integer, Integer, Integer> a = tuple("foo", 1, 2, 3, 4, 5, 6, 7);
         Tuple8<String, Integer, Integer, Integer, Integer, Integer, Integer, Function<? super Integer, ? extends Integer>> b = tuple("bar", 2, 3, 4, 5, 6, 7, x -> x + 1);
-        assertEquals(tuple("foo", 1, 2, 3, 4, 5, 6, 8), a.zip(b));
+        assertEquals(tuple("bar", 2, 3, 4, 5, 6, 7, 8), a.zip(b));
     }
 
     @Test
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/LiftA2Test.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/LiftA2Test.java
@@ -16,7 +16,7 @@ public class LiftA2Test {
     public void liftsAndAppliesDyadicFunctionToTwoApplicatives() {
         BiFunction<Integer, Integer, Integer> add = (x, y) -> x + y;
         assertEquals(right(3), liftA2(add, right(1), right(2)).coerce());
-        assertEquals(tuple(2, 5), liftA2(add, tuple(1, 2), tuple(2, 3)).coerce());
+        assertEquals(tuple(1, 5), liftA2(add, tuple(1, 2), tuple(2, 3)).coerce());
         assertEquals(new Identity<>(3), liftA2(add, new Identity<>(1), new Identity<>(2)));
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,7 @@ default <B> Applicative<B, App> fmap(Function<? super A, ? extends B> fn) {`
`61`	`61`	`* @return appB`
`62`	`62`	`*/`
`63`	`63`	`default <B> Applicative<B, App> discardL(Applicative<B, App> appB) {`
`64`		`- return appB.zip(zip(pure(constantly(id()))));`
	`64`	`+ return appB.zip(fmap(constantly(id())));`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -105,7 +105,7 @@ public void staticFactoryMethodFromMapEntry() {`
`105`	`105`	`public void zipPrecedence() {`
`106`	`106`	`Tuple2<String, Integer> a = tuple("foo", 1);`
`107`	`107`	`Tuple2<String, Function<? super Integer, ? extends Integer>> b = tuple("bar", x -> x + 1);`
`108`		`- assertEquals(tuple("foo", 2), a.zip(b));`
	`108`	`+ assertEquals(tuple("bar", 2), a.zip(b));`
`109`	`109`	`}`
`110`	`110`
`111`	`111`	`@Test`
Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ public void fill() {`
`92`	`92`	`public void zipPrecedence() {`
`93`	`93`	`Tuple5<String, Integer, Integer, Integer, Integer> a = tuple("foo", 1, 2, 3, 4);`
`94`	`94`	`Tuple5<String, Integer, Integer, Integer, Function<? super Integer, ? extends Integer>> b = tuple("bar", 2, 3, 4, x -> x + 1);`
`95`		`- assertEquals(tuple("foo", 1, 2, 3, 5), a.zip(b));`
	`95`	`+ assertEquals(tuple("bar", 2, 3, 4, 5), a.zip(b));`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`@Test`
Original file line number	Diff line number	Diff line change
`@@ -96,7 +96,7 @@ public void fill() {`
`96`	`96`	`public void zipPrecedence() {`
`97`	`97`	`Tuple6<String, Integer, Integer, Integer, Integer, Integer> a = tuple("foo", 1, 2, 3, 4, 5);`
`98`	`98`	`Tuple6<String, Integer, Integer, Integer, Integer, Function<? super Integer, ? extends Integer>> b = tuple("bar", 2, 3, 4, 5, x -> x + 1);`
`99`		`- assertEquals(tuple("foo", 1, 2, 3, 4, 6), a.zip(b));`
	`99`	`+ assertEquals(tuple("bar", 2, 3, 4, 5, 6), a.zip(b));`
`100`	`100`	`}`
`101`	`101`
`102`	`102`	`@Test`
Original file line number	Diff line number	Diff line change
`@@ -99,7 +99,7 @@ public void into() {`
`99`	`99`	`public void zipPrecedence() {`
`100`	`100`	`Tuple7<String, Integer, Integer, Integer, Integer, Integer, Integer> a = tuple("foo", 1, 2, 3, 4, 5, 6);`
`101`	`101`	`Tuple7<String, Integer, Integer, Integer, Integer, Integer, Function<? super Integer, ? extends Integer>> b = tuple("bar", 2, 3, 4, 5, 6, x -> x + 1);`
`102`		`- assertEquals(tuple("foo", 1, 2, 3, 4, 5, 7), a.zip(b));`
	`102`	`+ assertEquals(tuple("bar", 2, 3, 4, 5, 6, 7), a.zip(b));`
`103`	`103`	`}`
`104`	`104`
`105`	`105`	`@Test`
Original file line number	Diff line number	Diff line change
`@@ -102,7 +102,7 @@ public void into() {`
`102`	`102`	`public void zipPrecedence() {`
`103`	`103`	`Tuple8<String, Integer, Integer, Integer, Integer, Integer, Integer, Integer> a = tuple("foo", 1, 2, 3, 4, 5, 6, 7);`
`104`	`104`	`Tuple8<String, Integer, Integer, Integer, Integer, Integer, Integer, Function<? super Integer, ? extends Integer>> b = tuple("bar", 2, 3, 4, 5, 6, 7, x -> x + 1);`
`105`		`- assertEquals(tuple("foo", 1, 2, 3, 4, 5, 6, 8), a.zip(b));`
	`105`	`+ assertEquals(tuple("bar", 2, 3, 4, 5, 6, 7, 8), a.zip(b));`
`106`	`106`	`}`
`107`	`107`
`108`	`108`	`@Test`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ public class LiftA2Test {`
`16`	`16`	`public void liftsAndAppliesDyadicFunctionToTwoApplicatives() {`
`17`	`17`	`BiFunction<Integer, Integer, Integer> add = (x, y) -> x + y;`
`18`	`18`	`assertEquals(right(3), liftA2(add, right(1), right(2)).coerce());`
`19`		`- assertEquals(tuple(2, 5), liftA2(add, tuple(1, 2), tuple(2, 3)).coerce());`
	`19`	`+ assertEquals(tuple(1, 5), liftA2(add, tuple(1, 2), tuple(2, 3)).coerce());`
`20`	`20`	`assertEquals(new Identity<>(3), liftA2(add, new Identity<>(1), new Identity<>(2)));`
`21`	`21`	`}`
`22`	`22`	`}`