Lazy evaluation and memoization

Some facts are expensive and conditional: a historical-benefit lookup that only one rule in the policy needs, a document OCR call that manual review might never reach. Lazy<T> wraps a supplier, defers it until get(), and memoizes the result — the functional-programming name for this is call-by-need.

The implementation

1
public final class Lazy<T> {
2

3
    private Supplier<T> supplier;
4
    private T value;
5
    private boolean evaluated;
6

7
    private Lazy(Supplier<T> supplier) {
8
        this.supplier = supplier;
9
    }
10

11
    public static <T> Lazy<T> of(Supplier<T> supplier) {
12
        return new Lazy<>(Objects.requireNonNull(supplier, "supplier must not be null"));
13
    }
14

15
    public synchronized T get() {
16
        if (!evaluated) {
17
            value = supplier.get();
18
            evaluated = true;
19
            supplier = null;
20
        }
21
        return value;
22
    }
23

24
    public <R> Lazy<R> map(Fn1<? super T, ? extends R> mapper) {
25
        return Lazy.of(() -> mapper.apply(get()));
26
    }
27

28
    public <R> Lazy<R> flatMap(Fn1<? super T, Lazy<R>> mapper) {
29
        return Lazy.of(() -> mapper.apply(get()).get());
30
    }
31
}

Three details matter. synchronized makes the evaluate-once guarantee hold under concurrent readers — the first caller pays the cost, everyone else gets the memoized value. supplier = null releases the captured closure (and whatever it referenced) after evaluation. And map/flatMap build new lazy computations without running anything — laziness composes.

The memoization test

1
@Test
2
void evaluatesTheSupplierAtMostOnce() {
3
    AtomicInteger calls = new AtomicInteger();
4
    Lazy<Integer> lazy = Lazy.of(calls::incrementAndGet);
5

6
    assertThat(lazy.get()).isEqualTo(1);
7
    assertThat(lazy.get()).isEqualTo(1);
8
    assertThat(calls).hasValue(1);
9
}
10

11
@Test
12
void mapDefersEvaluationUntilGet() {
13
    AtomicInteger calls = new AtomicInteger();
14
    Lazy<Integer> lazy = Lazy.of(calls::incrementAndGet).map(x -> x * 10);
15

16
    assertThat(calls).hasValue(0);   // nothing ran yet
17
    assertThat(lazy.get()).isEqualTo(10);
18
}

Scheme example: deferred evidence enrichment

1
Lazy<Result<IncomeRecord, RegistryError>> incomeHistory =
2
        Lazy.of(() -> incomeRegistry.load(citizenId));   // expensive historical lookup
3

4
// the policy only needs history on the manual-review path — for a clean
5
// Eligible the registry call never happens
6
EligibilityOutcome outcome = needsManualReview
7
        ? incomeHistory.get().fold(
8
                error -> new ManualReview(scheme.value(), citizenId, "history unavailable"),
9
                record -> evaluateWithHistory(facts, record))   // policy variant, defined by the rules
10
        : FarmerSupportPolicy.evaluate(facts, scheme);

If the rule never asks, the lookup never happens — the “skip work you don’t need” optimization becomes part of the value’s type rather than an if guarding a field.

Trade-off worth stating: Lazy memoizes successfully, meaning exceptions are not cached — a throwing supplier is retried on the next get(). That is usually what you want for transient failures, but a permanently-failing lookup will be re-attempted every time. If you need to remember failure, wrap the computation in Lazy.of(() -> resultOrThrow()) so the memoized value is itself a Result.

JavaFunctional Programming