Applicatives and validation

An eligibility application fails several checks at once: the applicant is under age, the declared income is over the limit, and no documents were attached. Telling the citizen only about the age failure — then the income failure on resubmission, then the documents — is the UX of a flatMap chain, which short-circuits at the first error. Validation needs the opposite semantics: run every check independently and accumulate all the failures.

That is what applicatives are for. Where a monad sequences dependent steps (Part 9), an applicative combines independent computations. In Java terms: map2 takes two Validated values and a combining function, and when both failed it merges the errors instead of dropping one.

The accumulator: NonEmptyList

Errors accumulate into a list that is guaranteed non-empty — an Invalid with zero errors would be a lie:

1
public record NonEmptyList<T>(T head, List<T> tail) {
2

3
    @SafeVarargs
4
    public static <T> NonEmptyList<T> of(T head, T... rest) {
5
        return new NonEmptyList<>(head, List.of(rest));
6
    }
7

8
    public NonEmptyList<T> append(NonEmptyList<T> other) { /* head + both tails */ }
9

10
    public static <T> Semigroup<NonEmptyList<T>> semigroup() {
11
        return NonEmptyList::append;
12
    }
13
}

The Semigroup is what map2 uses to merge two error collections. A semigroup is just an associative combine operation — Part 12 builds it properly; for now read NonEmptyList.semigroup() as “concatenate both error lists.”

Validated and map2

1
public sealed interface Validated<E, T> {
2

3
    <R> Validated<E, R> map(Fn1<? super T, ? extends R> mapper);
4

5
    static <E, T> Validated<E, T> valid(T value) { return new Valid<>(value); }
6
    static <E, T> Validated<E, T> invalid(E error) { return new Invalid<>(error); }
7

8
    static <E, A, B, C> Validated<E, C> map2(
9
            Validated<E, A> first,
10
            Validated<E, B> second,
11
            Semigroup<E> semigroup,
12
            BiFunction<? super A, ? super B, ? extends C> combine) {
13
        return switch (first) {
14
            case Valid<E, A>(var a) -> switch (second) {
15
                case Valid<E, B>(var b) -> valid(combine.apply(a, b));
16
                case Invalid<E, B>(var error) -> invalid(error);
17
            };
18
            case Invalid<E, A>(var errorA) -> switch (second) {
19
                case Valid<E, B>(var b) -> invalid(errorA);
20
                case Invalid<E, B>(var errorB) -> invalid(semigroup.combine(errorA, errorB));
21
            };
22
        };
23
    }
24

25
    record Valid<E, T>(T value) implements Validated<E, T> { /* map applies the function */ }
26
    record Invalid<E, T>(E error) implements Validated<E, T> { /* map passes the error through */ }
27
}

Read the four cases: both valid → combine the values; one invalid → keep that error; both invalid → merge the errors. That last case is the entire difference from Result.flatMap, which would have kept only errorA.

Scheme example: validating an application

Each check is a pure function from the input to a Validated — either the checked field or a one-element error list:

1
public static Validated<NonEmptyList<String>, Integer> checkAge(
2
        ApplicationInput input, PolicyEnvironment environment) {
3
    return input.age() >= environment.minimumAge()
4
            ? Validated.valid(input.age())
5
            : Validated.invalid(NonEmptyList.of(
6
                    "age " + input.age() + " is below the minimum " + environment.minimumAge()));
7
}

checkIncome and checkDocuments follow the same pattern, and map2 threads them together:

1
public static Validated<NonEmptyList<String>, ApplicationInput> validate(
2
        ApplicationInput input, PolicyEnvironment environment) {
3
    Semigroup<NonEmptyList<String>> errors = NonEmptyList.semigroup();
4
    return Validated.map2(
5
            Validated.map2(
6
                    checkAge(input, environment),
7
                    checkIncome(input, environment),
8
                    errors,
9
                    Tuple2::new),
10
            checkDocuments(input),
11
            errors,
12
            (ageAndIncome, documents) -> new ApplicationInput(
13
                    input.citizenId(), ageAndIncome.first(), ageAndIncome.second(),
14
                    input.resident(), documents));
15
}

An input of age=16, income=900_000, documents=[] returns all three failures in one Invalid:

1
Invalid(["age 16 is below the minimum 18",
2
         "declared income exceeds the limit of 300000",
3
         "no supporting documents supplied"])

The decision rule

Dependent steps, stop at first failure → Result + flatMap (Part 9). Fetching a land record requires the citizen lookup to have succeeded.
Independent checks, report every failure → Validated + map2. Form validation, eligibility pre-checks, document requirements.
Validated is deliberately not a monad — if it had a lawful flatMap it would have to short-circuit, which is exactly the behavior it exists to avoid. Part 10’s laws make that precise.

JavaFunctional Programming