Option: absence as data

A citizen with no land-record entry is not a failure. The record may not exist yet, or the scheme may not need it — but null cannot tell “legitimately absent” apart from “someone forgot to set this field.” Option<T> makes absence a value with a type: Some<T> or None, and the compiler forces callers to handle both.

Yes, Optional exists. We build Option anyway — to see its implementation, to test its laws, and to give the library one consistent API (fold, Fn1-based mappers) across all its types. Part 19 covers when to use which.

The type

1
public sealed interface Option<T> {
2

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

5
    <R> Option<R> flatMap(Fn1<? super T, ? extends Option<R>> mapper);
6

7
    Option<T> filter(Predicate<? super T> predicate);
8

9
    <R> R fold(Supplier<? extends R> whenNone, Fn1<? super T, ? extends R> whenSome);
10

11
    T orElse(T fallback);
12

13
    T orElseGet(Supplier<? extends T> fallback);
14

15
    static <T> Option<T> some(T value) {
16
        return new Some<>(Objects.requireNonNull(value, "value must not be null"));
17
    }
18

19
    static <T> Option<T> none() {
20
        return new None<>();
21
    }
22

23
    static <T> Option<T> ofNullable(T value) {
24
        return value == null ? none() : some(value);
25
    }
26
}

Some and None are records nested in the interface, so the sealed hierarchy closes itself — the permits list is inferred from the same file. some rejects nulls deliberately: an Option containing null recreates the exact ambiguity the type exists to remove.

The two implementations

1
record Some<T>(T value) implements Option<T> {
2

3
    @Override
4
    public <R> Option<R> map(Fn1<? super T, ? extends R> mapper) {
5
        return Option.some(mapper.apply(value));
6
    }
7

8
    @Override
9
    public <R> Option<R> flatMap(Fn1<? super T, ? extends Option<R>> mapper) {
10
        return mapper.apply(value);
11
    }
12

13
    @Override
14
    public Option<T> filter(Predicate<? super T> predicate) {
15
        return predicate.test(value) ? this : Option.none();
16
    }
17

18
    @Override
19
    public <R> R fold(Supplier<? extends R> whenNone, Fn1<? super T, ? extends R> whenSome) {
20
        return whenSome.apply(value);
21
    }
22
    // orElse/orElseGet return value
23
}
24

25
record None<T>() implements Option<T> {
26

27
    @Override
28
    public <R> Option<R> map(Fn1<? super T, ? extends R> mapper) {
29
        return Option.none();
30
    }
31

32
    @Override
33
    public <R> Option<R> flatMap(Fn1<? super T, ? extends Option<R>> mapper) {
34
        return Option.none();
35
    }
36

37
    @Override
38
    public Option<T> filter(Predicate<? super T> predicate) {
39
        return this;
40
    }
41

42
    @Override
43
    public <R> R fold(Supplier<? extends R> whenNone, Fn1<? super T, ? extends R> whenSome) {
44
        return whenNone.get();
45
    }
46
    // orElse/orElseGet return the fallback
47
}

The asymmetry is the lesson: None.map does not call the mapper at all. Mapping over an absent value is a no-op, not an error — that is what makes chains of map safe to write without defensive null checks between steps.

Scheme example: optional land evidence

1
// an existing evidence store returns null when no record exists — wrap at the boundary
2
Option<LandRecord> landRecord = Option.ofNullable(landRecords.get(citizenId));
3

4
Option<LandCategory> category = landRecord.map(LandRecord::landCategory);
5

6
String outcome = landRecord.fold(
7
        () -> "no land record on file",
8
        record -> "land category " + record.landCategory());

fold is the exit door: it collapses both cases to one type at the boundary where you must produce a response. Inside the pipeline you stay in Option; at the edge you fold out.

Choosing between Option, Result, and exceptions

Absent is a normal outcome → Option (no land record yet).
Absent carries a reason callers need → Result (Part 6) — a registry timeout is not the same as “not found,” and the type should say so.
The situation is genuinely unrecoverable — corrupted state, contract violation → an exception. Expected outcomes in disguised as exceptions make control flow invisible.

Law preview: Option obeys the functor and monad laws — map(identity) = identity, and some(a).flatMap(f) = f(a). Parts 7 and 10 test them for real; for now, hold the intuition that map never changes whether a value is present, only what a present value is.

JavaFunctional Programming