Exercise 6 - Lazy

What is Lazy<T>

Lazy<T> is a class that implements lazy evaluation in Java. Lazy evaluation means a value is computed only when it's actually needed, not when it's defined.

Motivation:

• Improves performance by avoiding unnecessary calculations

• Handles potentially expensive operations only when required

• Supports operations on values that don't exist yet

---

As we have seen in the lecture, Lazy has two ways

1. Use Lambda as Delayed Data

2. Memoization

And the Lazy<T> we build today combines these two ways!

Example

// Without lazy evaluation - calculates immediately even if never used
int result = expensiveCalculation(); 

// With lazy evaluation - calculation happens only when get() is called
Lazy<Integer> lazyResult = Lazy.of(() -> expensiveCalculation());
// ...later in code...
int value = lazyResult.get(); // calculation happens here

Main methods explanation

Before delving into deeper details, this is the field and constructor for our Lazy<T>

public class Lazy<T> {
  private Producer<? extends T> producer;
  private Maybe<T> value;

  private Lazy(Maybe<T> v, Producer<? extends T> s) {
    this.value = v;
    this.producer = s;
  }
}

1

of()

The of() is Lazy<T>'s factory method, it support two ways to create a Lazy.

1. of(T v): Creates a Lazy with an already-computed value

2. of(Producer<? extends T> s): Creates a Lazy with a producer for delayed computation

Implementation

of(T v)

public static <T> Lazy<T> of(T v) {
  return new Lazy<>(Maybe.some(v), null);
}

of(Producer<? extends T> s)

Example

of(T v)

Lazy<String> greeting = Lazy.of("Hello");
System.out.println(greeting.get()); // "Hello" (no computation needed)

of(Producer<? extends T> s)

2

get()

This method is the core of lazy evaluation. It checks if the value is already computed (present in the Maybe container). If available, it returns it; otherwise, it calls the producer to compute the value, stores it for future requests, and returns it. This ensures the computation happens exactly once, the first time it's needed.

Implementation

public T get() {
  return this.value.orElseGet(
      () -> {
        T compute = this.producer.produce();
        this.value = Maybe.some(compute);
        return compute;
      });
}

Example

Lazy<Double> calculation = Lazy.of(() -> Math.sqrt(1024));
// First call computes the value
double value1 = calculation.get(); // 32.0
// Second call reuses the computed value
double value2 = calculation.get(); // 32.0 (no recomputation)

This get() method beautifully combines memoization and lazy evaluation using a lambda expression. And all the following methods that called get() will inherit this laziness!

3

map(Transformer<? super T, ? extends U> t)

The map method allows transformation of a Lazy value into another type without triggering immediate computation. It creates a new Lazy that, when evaluated, will first get this Lazy's value and then apply the transformation function to it. This maintains laziness throughout the chain of operations.

Implementation

public <U> Lazy<U> map(Transformer<? super T, ? extends U> t) {
  return Lazy.of(() -> t.transform(this.get()));
}

Example

Lazy<Integer> number = Lazy.of(() -> 10);
Lazy<String> text = number.map(n -> "Number is: " + n);
// Transformation only happens when get() is called
System.out.println(text.get()); // "Number is: 10"

4

flatMap(Transformer<? super T, ? extends Lazy<? extends U>> t)

The flatMap method is similar to map but works with transformations that themselves return Lazy values. It prevents ending up with nested Lazy structures (like Lazy<Lazy>). When the resulting Lazy is evaluated, it gets this Lazy's value (this.get()), applies the transformation to get another Lazy (t.transform()), and then gets the value from that second Lazy (the second .get()).

Implementation

public <U> Lazy<U> flatMap(Transformer<? super T, ? extends Lazy<? extends U>> t) {
  return Lazy.of(() -> t.transform(this.get()).get());
}

Example

Lazy<Integer> number = Lazy.of(() -> 4);
Lazy<Integer> squareRoot = number.flatMap(n -> Lazy.of(() -> (int)Math.sqrt(n)));
System.out.println(squareRoot.get()); // 2

5

filter(BooleanCondition<? super T> c)

The filter method returns a new Lazy that, when evaluated, will test the original value against the provided condition. Unlike filters in collections that remove elements, this filter converts the value into a boolean result indicating whether the condition passed. The evaluation of both the original value and the condition is deferred until get() is called.

Implementation

public Lazy<Boolean> filter(BooleanCondition<? super T> c) {
  return Lazy.of(() -> c.test(this.get()));
}

Example

Lazy<Integer> number = Lazy.of(() -> 15);
Lazy<Boolean> isEven = number.filter(n -> n % 2 == 0);
System.out.println(isEven.get()); // false

The meaning of Lazy<Boolean> is that this Lazy wrapper wraps a Boolean value, and only when we call its .get(), we can know whether the value wrapped is true or false.

6

combine(Lazy<? extends S> src, Combiner<? super T, ? super S, ? extends R> c)

The combine method allows two Lazy values to be combined into a new Lazy result using a combining function. When evaluated, it will get both values and then apply the combiner function to produce the result. This is useful for operations that require multiple inputs, like addition, concatenation, or any binary operation, while preserving lazy evaluation for all components.

Implementation

public <S, R> Lazy<R> combine(
    Lazy<? extends S> src, Combiner<? super T, ? super S, ? extends R> c) {
  return Lazy.of(() -> c.combine(this.get(), src.get()));
}

Example

Lazy<Integer> first = Lazy.of(() -> 10);
Lazy<Integer> second = Lazy.of(() -> 20);
Lazy<Integer> sum = first.combine(second, (a, b) -> a + b);
System.out.println(sum.get()); // 30

7

equals()

Compares Lazy objects based on their computed values.

Implementation

@Override
public boolean equals(Object obj) {
  if (obj instanceof Lazy<?>) {
    Lazy<?> lazyObj = (Lazy<?>) obj;
    if (this.get().equals(lazyObj.get())) {
      return true;
    }
  }
  return false;
}

Example

Lazy<Integer> a = Lazy.of(() -> 5 + 5);
Lazy<Integer> b = Lazy.of(10);
System.out.println(a.equals(b)); // true

Refer back to the Keys of being lazy, this is concise and important!

Lazy List

Use the above Lazy<T> to build a list that supports:

1. Delayed evaluation when needed

2. Memoization

We have come up with the following LazyList.java

public static <T> LazyList<T> generate(int n, T seed, Transformer<? super T, ? extends T> f) {
    LazyList<T> lazyList = new LazyList<>(new ArrayList<Lazy<T>>(n));
    Lazy<T> curr = Lazy.of(seed); // Initialise an element with the seed.
    for (int i = 0; i < n; i++) {
        lazyList.list.add(curr); // Just append to the end of the list.
        curr = curr.map(f);      // Map the current element to its successor.
    }
    return lazyList;
}

In our LazyList, there is no need to keep track of current index or retrieve/insert by index etc.

public int indexOf(T value) {
    return this.list.indexOf(Lazy.of(value));
}

List::indexOf(T arg): returns the index of the first element whose value equals the argument, determined by the equals method.

No need to perform linear search manually because our Lazy::equals method checks equality by value. This is elegant!