avoid creating a new Either where not necessary, add filterLeft

Author: h908714124

src/main/java/io/jbock/util/Either.java

@@ -87,10 +87,10 @@ public static <L, R> Either<L, R> right(R value) {
      * @param <R2> the new RHS type
      * @return an equivalent instance if this is a Left, otherwise a Right containing
      *         the result of applying {@code mapper} to the RHS value
+     * @throws NullPointerException if the {@code mapper} returns a {@code null} result
      */
-    public final <R2> Either<L, R2> map(Function<? super R, ? extends R2> mapper) {
-        return fold(Either::left, r -> right(mapper.apply(r)));
-    }
+    public abstract <R2> Either<L, R2> map(
+            Function<? super R, ? extends R2> mapper);
 
     /**
      * If this is a Right, returns the result of applying the mapper function to the RHS value.
@@ -101,22 +101,21 @@ public final <R2> Either<L, R2> map(Function<? super R, ? extends R2> mapper) {
      * @return an equivalent instance if this is a Left, otherwise the result of
      *         applying {@code mapper} to the RHS value
      */
-    public final <R2> Either<L, R2> flatMap(
-            Function<? super R, ? extends Either<? extends L, ? extends R2>> mapper) {
-        return fold(Either::left, r -> narrow(mapper.apply(r)));
-    }
+    public abstract <R2> Either<L, R2> flatMap(
+            Function<? super R, ? extends Either<? extends L, ? extends R2>> mapper);
 
     /**
      * If this is a Left, returns a Left containing the LHS value.
      * If this is a Right, applies the predicate function to the RHS value.
      * If the predicate function returns an empty result,
      * returns a Right containing the RHS value.
-     * If the result is not empty, returns a Left containing that result.
+     * If the result is not empty, returns a Left containing the result.
      *
      * @param predicate a function that acts as a filter predicate
      * @return filter result
      */
-    public abstract Either<L, R> filter(Function<? super R, LeftOptional<? extends L>> predicate);
+    public abstract Either<L, R> filter(
+            Function<? super R, LeftOptional<? extends L>> predicate);
 
     /**
      * If this is a Left, returns a Left containing the result of applying the mapper function to the LHS value.
@@ -126,8 +125,10 @@ public final <R2> Either<L, R2> flatMap(
      * @param <L2> the new LHS type
      * @return an equivalent instance if this is a Right, otherwise a Left containing
      *         the result of applying {@code mapper} to the LHS value
+     * @throws NullPointerException if the {@code mapper} returns a {@code null} result
      */
-    public abstract <L2> Either<L2, R> mapLeft(Function<? super L, ? extends L2> mapper);
+    public abstract <L2> Either<L2, R> mapLeft(
+            Function<? super L, ? extends L2> mapper);
 
     /**
      * If this is a Left, returns the result of applying the mapper function to the LHS value.
@@ -141,6 +142,19 @@ public final <R2> Either<L, R2> flatMap(
     public abstract <L2> Either<L2, R> flatMapLeft(
             Function<? super L, ? extends Either<? extends L2, ? extends R>> mapper);
 
+    /**
+     * If this is a Right, returns a Right containing the RHS value.
+     * If this is a Left, applies the predicate function to the LHS value.
+     * If the predicate function returns an empty result,
+     * returns a Left containing the LHS value.
+     * If the result is not empty, returns a Right containing the result.
+     *
+     * @param predicate a function that acts as a filter predicate
+     * @return filter result
+     */
+    public abstract Either<L, R> filterLeft(
+            Function<? super L, Optional<? extends R>> predicate);
+
     /**
      * If this is a Right, returns the RHS value.
      * Otherwise throws an exception produced by the exception supplying function.
@@ -150,7 +164,8 @@ public abstract <L2> Either<L2, R> flatMapLeft(
      * @return the RHS value, if this is a Right
      * @throws X the result of applying {@code exceptionSupplier} to the LHS value, if this is a Left
      */
-    public abstract <X extends Throwable> R orElseThrow(Function<? super L, ? extends X> exceptionSupplier) throws X;
+    public abstract <X extends Throwable> R orElseThrow(
+            Function<? super L, ? extends X> exceptionSupplier) throws X;
 
     /**
      * If this is a Left, returns the result of applying the {@code leftMapper} to the LHS value.
@@ -165,15 +180,16 @@ public abstract <U> U fold(
             Function<? super L, ? extends U> leftMapper,
             Function<? super R, ? extends U> rightMapper);
 
-
     /**
      * If this is a Left, performs the {@code leftAction} with the LHS value.
      * Otherwise performs the {@code rightAction} with the RHS value.
      *
      * @param leftAction action to run if this is a Left
      * @param rightAction action to run if this is a Right
      */
-    public abstract void ifPresentOrElse(Consumer<? super L> leftAction, Consumer<? super R> rightAction);
+    public abstract void ifPresentOrElse(
+            Consumer<? super L> leftAction,
+            Consumer<? super R> rightAction);
 
     /**
      * Returns {@code true} if this is a Left, otherwise {@code false}.

src/main/java/io/jbock/util/Left.java

@@ -32,6 +32,16 @@ public Optional<R> getRight() {
         return Optional.empty();
     }
 
+    @Override
+    public <R2> Either<L, R2> map(Function<? super R, ? extends R2> mapper) {
+        return same();
+    }
+
+    @Override
+    public <R2> Either<L, R2> flatMap(Function<? super R, ? extends Either<? extends L, ? extends R2>> mapper) {
+        return same();
+    }
+
     @Override
     public Either<L, R> filter(Function<? super R, LeftOptional<? extends L>> predicate) {
         return same();
@@ -47,6 +57,15 @@ public <L2> Either<L2, R> flatMapLeft(Function<? super L, ? extends Either<? ext
         return narrow(mapper.apply(value));
     }
 
+    @Override
+    public Either<L, R> filterLeft(Function<? super L, Optional<? extends R>> predicate) {
+        Optional<? extends R> test = predicate.apply(value);
+        if (test.isEmpty()) {
+            return same();
+        }
+        return Right.create(test.orElseThrow());
+    }
+
     @Override
     public <X extends Throwable> R orElseThrow(Function<? super L, ? extends X> exceptionSupplier) throws X {
         throw exceptionSupplier.apply(value);
@@ -90,7 +109,7 @@ public int hashCode() {
 
     @SuppressWarnings("unchecked")
     private <R2> Either<L, R2> same() {
-        // return new Left<>(value);
+        // equivalently: return new Left<>(value);
         return (Either<L, R2>) this;
     }
 }

src/main/java/io/jbock/util/Right.java

@@ -32,6 +32,16 @@ public Optional<R> getRight() {
         return Optional.of(value);
     }
 
+    @Override
+    public <R2> Either<L, R2> map(Function<? super R, ? extends R2> mapper) {
+        return create(mapper.apply(value));
+    }
+
+    @Override
+    public <R2> Either<L, R2> flatMap(Function<? super R, ? extends Either<? extends L, ? extends R2>> mapper) {
+        return narrow(mapper.apply(value));
+    }
+
     @Override
     public Either<L, R> filter(Function<? super R, LeftOptional<? extends L>> predicate) {
         LeftOptional<? extends L> test = predicate.apply(value);
@@ -51,6 +61,11 @@ public <L2> Either<L2, R> flatMapLeft(Function<? super L, ? extends Either<? ext
         return same();
     }
 
+    @Override
+    public Either<L, R> filterLeft(Function<? super L, Optional<? extends R>> predicate) {
+        return same();
+    }
+
     @Override
     public <X extends Throwable> R orElseThrow(Function<? super L, ? extends X> exceptionSupplier) throws X {
         return value;
@@ -94,7 +109,7 @@ public int hashCode() {
 
     @SuppressWarnings("unchecked")
     private <L2> Either<L2, R> same() {
-        // return new Right<>(value);
+        // equivalently: return new Right<>(value);
         return (Either<L2, R>) this;
     }
 }

src/test/java/io/jbock/util/EitherTest.java

@@ -9,6 +9,7 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertSame;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
@@ -53,16 +54,16 @@ void testGetRight() {
     @Test
     void testMap() {
         Either<String, String> left = Either.left("1");
-        assertEquals(left, left.map(s -> "A")); // Left is unchanged
+        assertSame(left, left.map(s -> "A")); // Left is unchanged
         Either<?, String> right = Either.right("1");
         assertEquals(Either.right(1), right.map(Integer::parseInt));
     }
 
     @Test
     void testFlatMap() {
         Either<Integer, String> left = Either.left(2);
-        assertEquals(left, left.flatMap(s -> Either.right("1"))); // Left is unchanged
-        assertEquals(left, left.flatMap(s -> Either.left(1))); // Left is unchanged
+        assertSame(left, left.flatMap(s -> Either.right("1"))); // Left is unchanged
+        assertSame(left, left.flatMap(s -> Either.left(1))); // Left is unchanged
         Either<Integer, String> right = Either.right("1");
         assertEquals(Either.right(11), right.flatMap(s -> Either.right(11)));
         assertEquals(Either.left(11), right.flatMap(s -> Either.left(11)));
@@ -73,7 +74,7 @@ void testMapLeft() {
         Either<String, ?> left = Either.left("1");
         assertEquals(Either.left(1), left.mapLeft(Integer::parseInt));
         Either<String, String> right = Either.right("1");
-        assertEquals(right, right.mapLeft(s -> "A")); // Right is unchanged
+        assertSame(right, right.mapLeft(s -> "A")); // Right is unchanged
     }
 
     @Test
@@ -82,20 +83,30 @@ void testFlatMapLeft() {
         assertEquals(Either.left(11), left.flatMapLeft(s -> Either.left(11)));
         assertEquals(Either.right(11), left.flatMapLeft(s -> Either.right(11)));
         Either<String, Integer> right = Either.right(2);
-        assertEquals(right, right.flatMapLeft(s -> Either.left("1"))); // Right is unchanged
-        assertEquals(right, right.flatMapLeft(s -> Either.right(1))); // Right is unchanged
+        assertSame(right, right.flatMapLeft(s -> Either.left("1"))); // Right is unchanged
+        assertSame(right, right.flatMapLeft(s -> Either.right(1))); // Right is unchanged
     }
 
     @Test
     void testFilter() {
         Either<String, ?> left = Either.left("1");
-        assertEquals(left, left.filter(r -> LeftOptional.of("2"))); // Left is unchanged
-        assertEquals(left, left.filter(r -> LeftOptional.empty())); // Left is unchanged
+        assertSame(left, left.filter(r -> LeftOptional.of("2"))); // Left is unchanged
+        assertSame(left, left.filter(r -> LeftOptional.empty())); // Left is unchanged
         Either<String, String> right = Either.right("1");
         assertEquals(Either.left("2"), right.filter(r -> LeftOptional.of("2")));
         assertEquals(right, right.filter(r -> LeftOptional.empty()));
     }
 
+    @Test
+    void testFilterLeft() {
+        Either<?, String> right = Either.right("1");
+        assertSame(right, right.filterLeft(r -> Optional.of("2"))); // Right is unchanged
+        assertSame(right, right.filterLeft(r -> Optional.empty())); // Right is unchanged
+        Either<String, String> left = Either.left("1");
+        assertEquals(Either.right("2"), left.filterLeft(r -> Optional.of("2")));
+        assertEquals(left, left.filterLeft(r -> Optional.empty()));
+    }
+
     @Test
     void testOrElseThrow() {
         Either<String, ?> left = Either.left("1");