3 files changed, 110 insertions, 109 deletions

diff --git a/src/main/java/org/pacien/lemonad/validation/Validation.java b/src/main/java/org/pacien/lemonad/validation/Validation.java
index 04c1ed0..98a4496 100644
--- a/src/main/java/org/pacien/lemonad/validation/Validation.java
+++ b/src/main/java/org/pacien/lemonad/validation/Validation.java
@@ -20,17 +20,17 @@ package org.pacien.lemonad.validation;
 
 import org.pacien.lemonad.attempt.Attempt;
 
-import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
-import java.util.Objects;
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 import java.util.function.Function;
-import java.util.stream.Stream;
+import java.util.function.Predicate;
 
 import lombok.NonNull;
 
-import static java.util.stream.Collectors.toUnmodifiableList;
+import static java.util.function.Function.identity;
 import static org.pacien.lemonad.attempt.Attempt.failure;
 import static org.pacien.lemonad.attempt.Attempt.success;
 
@@ -72,58 +72,133 @@ public interface Validation<S, E> {
   }
 
   /**
-   * @param consumer the consumer called with the validation subject and reported errors if the validation is failed.
+   * @param consumer the consumer called with the validation subject and reported errors if the validation has failed.
    * @return the current object.
    */
   default Validation<S, E> ifInvalid(@NonNull BiConsumer<? super S, ? super List<? super E>> consumer) {
-    if (!isValid()) consumer.accept(getSubject(), getErrors());
+    if (isInvalid()) consumer.accept(getSubject(), getErrors());
     return this;
   }
 
   /**
-   * @return an {@link Attempt} with a state corresponding to the one of the validation.
+   * @param predicate the validation predicate testing the validity of a subject.
+   * @param error     the error to return if the subject does not pass the test.
+   * @return an updated {@link Validation}.
    */
-  default Attempt<S, List<E>> toAttempt() {
-    return isValid() ? success(getSubject()) : failure(getErrors());
+  default Validation<S, E> validate(@NonNull Predicate<? super S> predicate, @NonNull E error) {
+    return validate(identity(), predicate, error);
+  }
+
+  /**
+   * @param mapper    the field getter mapping the validation subject.
+   * @param predicate the validation predicate testing the validity of a subject.
+   * @param error     the error to return if the subject does not pass the test.
+   * @return an updated {@link Validation}.
+   */
+  default <F> Validation<S, E> validate(
+    @NonNull Function<? super S, ? extends F> mapper,
+    @NonNull Predicate<? super F> predicate,
+    E error
+  ) {
+    return validate(mapper, field -> predicate.test(field) ? List.of() : List.of(error));
+  }
+
+  /**
+   * @param validator the validating function to use, returning a potentially empty list of errors.
+   * @return an updated {@link Validation}.
+   */
+  default Validation<S, E> validate(@NonNull Function<? super S, ? extends List<? extends E>> validator) {
+    var errors = validator.apply(getSubject());
+    return errors.isEmpty() ? this : merge(errors);
+  }
+
+  /**
+   * @param mapper    the field getter mapping the validation subject.
+   * @param validator the validating function to use, returning a potentially empty list of errors.
+   * @return an updated {@link Validation}.
+   */
+  default <F> Validation<S, E> validate(
+    @NonNull Function<? super S, ? extends F> mapper,
+    @NonNull Function<? super F, ? extends List<? extends E>> validator
+  ) {
+    return validate(validator.compose(mapper));
+  }
+
+  /**
+   * @param validator a subject validating function returning a {@link Validation}.
+   * @return an updated {@link Validation}.
+   */
+  default Validation<S, E> merge(@NonNull Function<? super S, ? extends Validation<?, ? extends E>> validator) {
+    return merge(validator.apply(getSubject()));
+  }
+
+  /**
+   * @param mapper    the field getter mapping the validation subject.
+   * @param validator a subject validating function returning a {@link Validation}.
+   * @return an updated {@link Validation}.
+   */
+  default <F> Validation<S, E> merge(
+    @NonNull Function<? super S, ? extends F> mapper,
+    @NonNull Function<? super F, ? extends Validation<?, ? extends E>> validator
+  ) {
+    return merge(validator.compose(mapper));
+  }
+
+  /**
+   * @param validation another validation to merge into the current one.
+   * @return an updated {@link Validation}.
+   */
+  @SuppressWarnings("unchecked")
+  default Validation<S, E> merge(@NonNull Validation<?, ? extends E> validation) {
+    if (validation.isValid()) return this;
+    if (this.isValid()) return Validation.of(this.getSubject(), (List<E>) validation.getErrors());
+    return merge(validation.getErrors());
+  }
+
+  /**
+   * @param errors a potentially empty list of additional errors to take into account.
+   * @return an updated {@link Validation}.
+   */
+  default Validation<S, E> merge(@NonNull Collection<? extends E> errors) {
+    var combinedErrors = new ArrayList<E>(getErrors().size() + errors.size());
+    combinedErrors.addAll(getErrors());
+    combinedErrors.addAll(errors);
+    return new ValidationContainer<>(getSubject(), combinedErrors);
   }
 
   /**
    * @param mapper a function transforming a {@link Validation}.
    * @return the transformed {@link Validation}.
    */
-  default <SS, EE> Validation<SS, EE> flatMap(@NonNull Function<? super Validation<? super S, ? super E>, ? extends Validation<? extends SS, ? extends EE>> mapper) {
+  default <SS, EE> Validation<SS, EE> flatMap(
+    @NonNull Function<? super Validation<? super S, ? super E>, ? extends Validation<? extends SS, ? extends EE>> mapper
+  ) {
     //noinspection unchecked
     return (Validation<SS, EE>) mapper.apply(this);
   }
 
   /**
-   * @param subject           an overriding subject.
-   * @param validationResults a {@link Stream} of {@link Validation}s to merge.
-   * @return the merged {@link Validation} containing all errors from the supplied ones.
+   * @return an {@link Attempt} with a state corresponding to the one of the validation.
    */
-  static <S, E> Validation<S, E> merge(S subject, @NonNull Stream<? extends Validation<?, ? extends E>> validationResults) {
-    return new ValidationContainer<>(
-      subject,
-      validationResults.flatMap(res -> res.getErrors().stream()).collect(toUnmodifiableList()));
+  default Attempt<S, List<E>> toAttempt() {
+    return isValid() ? success(getSubject()) : failure(getErrors());
   }
 
   /**
-   * @param subject the suject of the validation.
-   * @return a successful {@link Validation}.
+   * @param subject the subject of the validation.
+   * @param errors  some optional validation errors.
+   * @return a {@link Validation}.
    */
-  static <S, E> Validation<S, E> valid(S subject) {
-    return new ValidationContainer<>(subject, List.of());
+  @SafeVarargs static <S, E> Validation<S, E> of(S subject, E... errors) {
+    return Validation.of(subject, List.of(errors));
   }
 
   /**
-   * @param subject the suject of the validation.
-   * @param error   a validation error.
-   * @param errors  additional validation errors.
-   * @return a failed {@link Validation} for the supplied subject.
+   * @param subject the subject of the validation.
+   * @param errors  some optional validation errors.
+   * @return a {@link Validation}.
    */
-  @SafeVarargs static <S, E> Validation<S, E> invalid(S subject, E error, E... errors) {
-    return new ValidationContainer<>(
-      subject,
-      Stream.concat(Stream.of(error), Arrays.stream(errors)).map(Objects::requireNonNull).collect(toUnmodifiableList()));
+  static <S, E> Validation<S, E> of(S subject, @NonNull List<E> errors) {
+    return new ValidationContainer<>(subject, errors);