Implement Validation.cond (#3062)

Inspiration:

https://github.com/typelevel/cats/blob/ff6827df94bdd3e6d45de1336658af44cbe493b1/core/src/main/scala/cats/data/Validated.scala#L1160

Author: adamkopec

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

@@ -189,6 +189,50 @@ static <E, T> Validation<E, T> narrow(Validation<? extends E, ? extends T> valid
         return (Validation<E, T>) validation;
     }
 
+    /**
+     * Decides which {@code Validation<E, T>} to return, depending on the test value -
+     * if it's true, the result will be a {@link Validation.Valid},
+     * if it's false - the result will be a {@link Validation.Invalid}
+     *
+     * @param test   A {@code boolean} value to evaluate
+     * @param valid  A {@code Supplier<? extends T>} supplier of valid value, called if test is true
+     * @param error  A {@code Supplier<? extends E>} supplier of error, called if test is false
+     * @param <E>    Type of error
+     * @param <T>    Type of valid value
+     *
+     * @return {@code Validation<E, T>} with valid value or error, depending on the test condition evaluation
+     *
+     * @throws NullPointerException if any of the arguments is null
+     */
+    static <E, T> Validation<E, T> cond(boolean test, Supplier<? extends T> valid, Supplier<? extends E> error) {
+        Objects.requireNonNull(valid, "valid is null");
+        Objects.requireNonNull(error, "error is null");
+
+        return test ? valid(valid.get()) : invalid(error.get());
+    }
+
+    /**
+     * Decides which {@code Validation<E, T>} to return, depending on the test value -
+     * if it's true, the result will be a {@link Validation.Valid},
+     * if it's false - the result will be a {@link Validation.Invalid}
+     *
+     * @param test   A {@code boolean} value to evaluate
+     * @param valid  A {@code T} valid value, called if test is true
+     * @param error  An {@code E} error value, called if test is false
+     * @param <E>    Type of error
+     * @param <T>    Type of valid value
+     *
+     * @return {@code Validation<E, T>} with valid value or error, depending on the test condition evaluation
+     *
+     * @throws NullPointerException if any of the arguments is null
+     */
+    static <E, T> Validation<E, T> cond(boolean test, T valid, E error) {
+        Objects.requireNonNull(valid, "valid is null");
+        Objects.requireNonNull(error, "error is null");
+
+        return test ? valid(valid) : invalid(error);
+    }
+
     /**
      * Combines two {@code Validation}s into a {@link Builder}.
      *

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

@@ -26,9 +26,11 @@
 import java.util.ArrayList;
 import java.util.Objects;
 import java.util.Spliterator;
+import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 
 import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.fail;
 
 public class ValidationTest extends AbstractValueTest {
 
@@ -127,6 +129,103 @@ public void shouldNarrowInvalid() {
         assertThat(narrow.getError()).isEqualTo("vavr");
     }
 
+    @Nested
+    public class CondTests {
+
+        @Test
+        public void shouldReturnValidIfTestTrue() {
+            Validation<String, Integer> validation = Validation.cond(true, () -> 21, () -> "vavr");
+            assertThat(validation).isEqualTo(Validation.valid(21));
+        }
+
+        @Test
+        public void shouldReturnInvalidIfTestFalse() {
+            Validation<String, Integer> validation = Validation.cond(false, () -> 21, () -> "vavr");
+            assertThat(validation).isEqualTo(Validation.invalid("vavr"));
+        }
+
+        @Test
+        public void shouldNotEvaluateValidSupplierOnFalse() {
+            Validation<String, Integer> validation = Validation.cond(false, () -> {
+                fail("Should not be called");
+                return 21;
+            }, () -> "vavr");
+            assertThat(validation).isEqualTo(Validation.invalid("vavr"));
+        }
+
+        @Test
+        public void shouldNotEvaluateErrorSupplierOnTrue() {
+            Validation<String, Integer> validation = Validation.cond(true, () -> 21, () -> {
+                fail("Should not be called");
+                return "vavr";
+            });
+            assertThat(validation).isEqualTo(Validation.valid(21));
+        }
+
+        private class Car {
+            String name;
+
+            Car(String name) {
+                this.name = name;
+            }
+
+            @Override
+            public boolean equals(Object o) {
+                if (this == o) return true;
+                if (!(o instanceof Car)) return false;
+                Car other = (Car) o;
+                return name.equals(other.name);
+            }
+
+            @Override
+            public int hashCode() {
+                return name.hashCode();
+            }
+        }
+
+        private class Hatchback extends Car {
+            Hatchback(String name) {
+                super(name);
+            }
+        }
+
+        private class Sedan extends Car {
+            Sedan(String name) {
+                super(name);
+            }
+        }
+
+        @Test
+        public void shouldBeFineWithCovariantError() {
+            Validation<Car, Integer> validation = Validation.cond(false, () -> 21, () -> new Hatchback("vavr"));
+            assertThat(validation).isEqualTo(Validation.invalid(new Hatchback("vavr")));
+        }
+
+        @Test
+        public void shouldBeFineWithCovariantValid() {
+            Validation<String, Car> validation = Validation.cond(true, () -> new Sedan("vavr"), () -> "vavr");
+            assertThat(validation).isEqualTo(Validation.valid(new Sedan("vavr")));
+        }
+
+        @Test
+        public void shouldMakeTheSameDecisionNoMatterHowItsCalled() {
+            Validation<String, Integer> v1 = Validation.cond(true, () -> 21, () -> "vavr");
+            Validation<String, Integer> v2 = Validation.cond(true, 21, "vavr");
+
+            Validation<String, Integer> v3 = Validation.cond(false, () -> 21, () -> "vavr");
+            Validation<String, Integer> v4 = Validation.cond(false, 21, "vavr");
+
+            assertThat(List.of(v1, v2)).allMatch(e -> e.equals(Validation.valid(21)));
+            assertThat(List.of(v3, v4)).allMatch(e -> e.equals(Validation.invalid("vavr")));
+        }
+
+        @Test
+        public void shouldThrowWhenProvidedWithNull() {
+            assertThrows(NullPointerException.class, () -> Validation.cond(false, 1, null));
+            assertThrows(NullPointerException.class, () -> Validation.cond(false, null, 2));
+        }
+    }
+
     // -- Validation.sequence
 
     @Test