Changed Either.sequence return type (#2072)

Author: danieldietrich

vavr/src/main/java/io/vavr/control/Either.java

@@ -9,7 +9,6 @@
 import io.vavr.Value;
 import io.vavr.collection.Iterator;
 import io.vavr.collection.Seq;
-import io.vavr.collection.Vector;
 
 import java.io.Serializable;
 import java.util.NoSuchElementException;
@@ -166,25 +165,40 @@ default <U> U fold(Function<? super L, ? extends U> leftMapper, Function<? super
 
     /**
      * Reduces many {@code Either}s into a single {@code Either} by transforming an
-     * {@code Iterable<Either<? extends L, ? extends R>>} into a {@code Either<? extends L, Seq<R>>}. If any of
-     * the {@code Either}s are {@link Either.Left}, then this returns a {@link Either.Left}.
+     * {@code Iterable<Either<L, R>>} into a {@code Either<Seq<L>, Seq<R>>}.
+     * <p>
+     * If any of the given {@code Either}s is a {@link Either.Left} then sequence returns a {@link Either.Left}
+     * containing a non-empty {@link Seq} of all left values.
+     * <p>
+     * If none of the given {@code Either}s is a {@link Either.Left} then sequence returns a {@link Either.Right}
+     * containing a (possibly empty) {@link Seq} of all right values.
+     *
+     * <pre>{@code
+     * // = Right(Seq())
+     * Either.sequence(List.empty())
+     *
+     * // = Right(Seq(1, 2))
+     * Either.sequence(List.of(Either.right(1), Either.right(2)))
      *
-     * @param values An {@link Iterable} of {@code Either}s
-     * @param <L>    left type of the Eithers
-     * @param <R>    right type of the Eithers
-     * @return A {@code Either} of a {@link Seq} of results
-     * @throws NullPointerException if {@code values} is null
+     * // = Left(Seq("x"))
+     * Either.sequence(List.of(Either.right(1), Either.left("x")))
+     * }</pre>
+     *
+     * @param eithers An {@link Iterable} of {@code Either}s
+     * @param <L>     closure of all left types of the given {@code Either}s
+     * @param <R>     closure of all right types of the given {@code Either}s
+     * @return An {@code Either} of a {@link Seq} of left or right values
+     * @throws NullPointerException if {@code eithers} is null
      */
-    static <L,R> Either<L, Seq<R>> sequence(Iterable<? extends Either<? extends L, ? extends R>> values) {
-        Objects.requireNonNull(values, "values is null");
-        Vector<R> vector = Vector.empty();
-        for (Either<? extends L, ? extends R> value : values) {
-            if (value.isLeft()) {
-                return Either.left(value.getLeft());
-            }
-            vector = vector.append(value.get());
-        }
-        return Either.right(vector);
+    @SuppressWarnings("unchecked")
+    static <L,R> Either<Seq<L>, Seq<R>> sequence(Iterable<? extends Either<? extends L, ? extends R>> eithers) {
+        Objects.requireNonNull(eithers, "eithers is null");
+        return Iterator.ofAll((Iterable<Either<L, R>>) eithers)
+                .partition(Either::isLeft)
+                .apply((leftPartition, rightPartition) -> leftPartition.hasNext()
+                    ? Either.left(leftPartition.map(Either::getLeft).toVector())
+                    : Either.right(rightPartition.map(Either::get).toVector())
+                );
     }
 
     /**

vavr/src/test/java/io/vavr/control/EitherTest.java

@@ -9,6 +9,7 @@
 import io.vavr.AbstractValueTest;
 import io.vavr.collection.Seq;
 import io.vavr.collection.List;
+import io.vavr.collection.Vector;
 import org.junit.Test;
 
 import java.util.NoSuchElementException;
@@ -17,6 +18,7 @@
 
 import static io.vavr.API.Left;
 import static io.vavr.API.Right;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 public class EitherTest extends AbstractValueTest {
 
@@ -93,26 +95,42 @@ public void shouldFoldRight() {
     // -- sequence
 
     @Test
-    public void shouldConvertListOfRightToEitherOfList() {
-        List<Either<String, String>> tries = List.of(Either.right("a"), Either.right("b"), Either.right("c"));
-        Either<String, Seq<String>> reducedEither = Either.sequence(tries);
-        assertThat(reducedEither instanceof Either.Right).isTrue();
-        assertThat(reducedEither.get().size()).isEqualTo(3);
-        assertThat(reducedEither.get().mkString()).isEqualTo("abc");
+    public void shouldThrowWhenSequencingNull() {
+        assertThatThrownBy(() -> Either.sequence(null))
+                .isInstanceOf(NullPointerException.class)
+                .withFailMessage("eithers is null");
     }
 
     @Test
-    public void shouldConvertListOfLeftToEitherOfList() {
-        List<Either<Integer, String>> tries = List.of(Either.left(1), Either.left(2), Either.left(3));
-        Either<Integer, Seq<String>> reducedEither = Either.sequence(tries);
-        assertThat(reducedEither).isEqualTo(Either.left(1));
+    public void shouldSequenceEmptyIterableOfEither() {
+        final Iterable<Either<Integer, String>> eithers = List.empty();
+        final Either<Seq<Integer>, Seq<String>> actual = Either.sequence(eithers);
+        final Either<Seq<Integer>, Seq<String>> expected = Either.right(Vector.empty());
+        assertThat(actual).isEqualTo(expected);
+    }
+
+    @Test
+    public void shouldSequenceNonEmptyIterableOfRight() {
+        final Iterable<Either<Integer, String>> eithers = List.of(Either.right("a"), Either.right("b"), Either.right("c"));
+        final Either<Seq<Integer>, Seq<String>> actual = Either.sequence(eithers);
+        final Either<Seq<Integer>, Seq<String>> expected = Either.right(Vector.of("a", "b", "c"));
+        assertThat(actual).isEqualTo(expected);
     }
 
     @Test
-    public void shouldConvertListOfMixedEitherToEitherOfList() {
-        List<Either<Integer,String>> tries = List.of(Either.right("a"), Either.left(1), Either.right("c"));
-        Either<Integer, Seq<String>> reducedEither = Either.sequence(tries);
-        assertThat(reducedEither).isEqualTo(Either.left(1));
+    public void shouldSequenceNonEmptyIterableOfLeft() {
+        final Iterable<Either<Integer, String>> eithers = List.of(Either.left(1), Either.left(2), Either.left(3));
+        final Either<Seq<Integer>, Seq<String>> actual = Either.sequence(eithers);
+        final Either<Seq<Integer>, Seq<String>> expected = Either.left(Vector.of(1, 2, 3));
+        assertThat(actual).isEqualTo(expected);
+    }
+
+    @Test
+    public void shouldSequenceNonEmptyIterableOfMixedEither() {
+        final Iterable<Either<Integer,String>> eithers = List.of(Either.right("a"), Either.left(1), Either.right("c"), Either.left(3));
+        final Either<Seq<Integer>, Seq<String>> actual = Either.sequence(eithers);
+        final Either<Seq<Integer>, Seq<String>> expected = Either.left(Vector.of(1, 3));
+        assertThat(actual).isEqualTo(expected);
     }
 
     @Test