Probing One Skate-Length Ahead with Lazy Streams

Out on the lake you don’t survey the whole route before you push off. You read the next few metres — colour, cracks, the difference between black core ice and the rotten white stuff — and every so often you drive the ispik, the steel-tipped probe pole, into the ice one skate-length ahead. One strike. If it doesn’t punch through, you glide onto that patch and probe again. You never test the far shore from here; the far shore isn’t your problem yet.

That habit has a name in programming: lazy evaluation. Don’t compute a value until something actually needs it. A lazy stream is a list that may run the whole length of the lake but only ever exists as far as you’ve looked.

Scheme made this idiomatic with delay and force, the machinery behind the stream chapters of SICP:

;; Ice thickness (cm) at each 10 m mark along the intended line
(define (ice-at m) (vector-ref #(6 7 5 6 3 8) (quotient m 10)))
(define (holds? cm) (>= (* 5 (* cm cm)) 90))   ; Gold's rule: 5·h² kg ≥ 90 kg load

;; Probe one mark ahead; stop at the first spot that won't hold
(define (glide m)
  (delay (if (holds? (ice-at m))
             (cons m (glide (+ m 10)))
             '())))

(define (walk s)
  (let ((p (force s)))
    (if (null? p) '() (cons (car p) (walk (cdr p))))))

(walk (glide 0))   ; => (0 10 20 30), then stops at the 3 cm hole

The stream is written all the way down the lake, but glide only ever forces the next probe. The 8 cm patch at 50 m sits in the definition and never gets evaluated — I turned back at the 3 cm hole at 40 m before I reached it. Gold’s rule does the deciding: clear blue ice carries roughly 5·h² kilograms, so 3 cm holds about 45 kg, not enough for me and a pack.

Java grew the same trick into its Stream API:

import java.util.Arrays;
import java.util.stream.IntStream;

public class Glide {
    static int[] ice = {6, 7, 5, 6, 3, 8};                 // thickness (cm) every 10 m
    static boolean holds(int cm) { return 5 * cm * cm >= 90; }

    public static void main(String[] args) {
        int[] safe = IntStream.range(0, ice.length)        // lazy pipeline
            .takeWhile(i -> holds(ice[i]))                 // short-circuits at the hole
            .map(i -> i * 10)
            .toArray();
        System.out.println(Arrays.toString(safe));          // [0, 10, 20, 30]
    }
}

takeWhile short-circuits: the moment holds returns false it stops pulling from the pipeline, so the strong ice past the hole never gets checked. Same discipline as the pole — probe forward, commit only to what held, and let the rest of the lake stay a promise until you skate up to it.