deprecating dyadic Either#flatMap in favor of match

jnape · jnape · commit f978218ab8fc · 2018-09-02T15:06:10.000-05:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -25,6 +25,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
 ### Deprecated
 - `AddAll` semigroup, in favor of the monoid that no longer mutates any argument 
+- Dyadic `Either#flatMap()`, in favor of `Either#match` 
 
 ## [3.1.0] - 2018-07-16
 ### Added
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/Either.java b/src/main/java/com/jnape/palatable/lambda/adt/Either.java
@@ -123,7 +123,7 @@ public final Either<L, R> filter(Function<? super R, ? extends Boolean> pred,
      */
     @Override
     public <R2> Either<L, R2> flatMap(Function<? super R, ? extends Monad<R2, Either<L, ?>>> rightFn) {
-        return flatMap(Either::left, rightFn.andThen(Applicative::coerce));
+        return match(Either::left, rightFn.andThen(Applicative::coerce));
     }
 
     /**
@@ -136,15 +136,17 @@ public <R2> Either<L, R2> flatMap(Function<? super R, ? extends Monad<R2, Either
      * @param <L2>    the new left parameter type
      * @param <R2>    the new right parameter type
      * @return the result of either rightFn or leftFn, depending on whether this is a right or a left
+     * @deprecated in favor of {@link Either#match(Function, Function)}
      */
+    @Deprecated
     public final <L2, R2> Either<L2, R2> flatMap(Function<? super L, ? extends Either<L2, R2>> leftFn,
                                                  Function<? super R, ? extends Either<L2, R2>> rightFn) {
         return match(leftFn, rightFn);
     }
 
     @Override
     public final Either<R, L> invert() {
-        return flatMap(Either::right, Either::left);
+        return match(Either::right, Either::left);
     }
 
     /**
diff --git a/src/main/java/com/jnape/palatable/lambda/semigroup/builtin/LeftAll.java b/src/main/java/com/jnape/palatable/lambda/semigroup/builtin/LeftAll.java
@@ -37,7 +37,7 @@ private LeftAll() {
 
     @Override
     public Semigroup<Either<L, R>> apply(Semigroup<L> lSemigroup) {
-        return (x, y) -> x.flatMap(xL -> y.flatMap(yL -> left(lSemigroup.apply(xL, yL)), Either::right), Either::right);
+        return (x, y) -> x.match(xL -> y.match(yL -> left(lSemigroup.apply(xL, yL)), Either::right), Either::right);
     }
 
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/com/jnape/palatable/lambda/semigroup/builtin/LeftAny.java b/src/main/java/com/jnape/palatable/lambda/semigroup/builtin/LeftAny.java
@@ -36,9 +36,9 @@ private LeftAny() {
 
     @Override
     public Semigroup<Either<L, R>> apply(Semigroup<L> lSemigroup) {
-        return (x, y) -> x.flatMap(xL -> y.flatMap(yL -> left(lSemigroup.apply(xL, yL)),
-                                                   yR -> left(xL)),
-                                   xR -> y);
+        return (x, y) -> x.match(xL -> y.match(yL -> left(lSemigroup.apply(xL, yL)),
+                                               yR -> left(xL)),
+                                 xR -> y);
     }
 
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/com/jnape/palatable/lambda/semigroup/builtin/RightAny.java b/src/main/java/com/jnape/palatable/lambda/semigroup/builtin/RightAny.java
@@ -37,9 +37,9 @@ private RightAny() {
 
     @Override
     public Semigroup<Either<L, R>> apply(Semigroup<R> rSemigroup) {
-        return (x, y) -> x.flatMap(constantly(y),
-                                   xR -> y.flatMap(constantly(right(xR)),
-                                                   rSemigroup.apply(xR).andThen(Either::right)));
+        return (x, y) -> x.match(constantly(y),
+                                 xR -> y.match(constantly(right(xR)),
+                                               rSemigroup.apply(xR).andThen(Either::right)));
     }
 
     @SuppressWarnings("unchecked")
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/EitherTest.java b/src/test/java/com/jnape/palatable/lambda/adt/EitherTest.java
@@ -110,15 +110,6 @@ public void monadicFlatMapLiftsRightAndFlattensBackToEither() {
         assertThat(right.flatMap(r -> right(r + 1)), is(right(2)));
     }
 
-    @Test
-    public void dyadicFlatMapDuallyLiftsAndFlattensBackToEither() {
-        Either<String, Integer> left = left("foo");
-        Either<String, Integer> right = right(1);
-
-        assertThat(left.flatMap(l -> left(l + "bar"), r -> right(r + 1)), is(left("foobar")));
-        assertThat(right.flatMap(l -> left(l + "bar"), r -> right(r + 1)), is(right(2)));
-    }
-
     @Test
     public void mergeDuallyLiftsAndCombinesBiasingLeft() {
         Either<String, Integer> left1 = left("foo");

Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ private LeftAll() {`
`37`	`37`
`38`	`38`	`@Override`
`39`	`39`	`public Semigroup<Either<L, R>> apply(Semigroup<L> lSemigroup) {`
`40`		`- return (x, y) -> x.flatMap(xL -> y.flatMap(yL -> left(lSemigroup.apply(xL, yL)), Either::right), Either::right);`
	`40`	`+ return (x, y) -> x.match(xL -> y.match(yL -> left(lSemigroup.apply(xL, yL)), Either::right), Either::right);`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`@SuppressWarnings("unchecked")`