Infinite Slides, Finite Patience

At 400× magnification, a glass slide becomes a continent. The paramecium I’m tracking occupies maybe 200 micrometres — a speck on a speck — and yet finding it again after bumping the stage takes genuine effort. You can’t look at everything. You look at the one field of view the objective allows, move the stage a fraction of a millimetre, look again.

Lazy evaluation works the same way. A lazy sequence doesn’t compute its elements until something actually needs them. You can define an infinite list of all prime numbers, all Fibonacci values, all magnification levels — and the runtime shrugs, computes nothing, waits for you to take the slice you need.

Clojure’s range with no arguments produces every integer from zero to infinity:

(def specimens (map #(str "slide-" % ".tif") (range)))

;; Nothing computed yet — specimens is a lazy seq
;; Only realize what we need:
(take 5 specimens)
;; => ("slide-0.tif" "slide-1.tif" "slide-2.tif" "slide-3.tif" "slide-4.tif")

(nth specimens 1000000)
;; => "slide-1000000.tif" — computed on demand, no list of a million strings in memory

Ada doesn’t have lazy sequences built in, but you can fake the mechanism with a generator that yields values one at a time. The iterator pattern predates functional laziness and serves the same purpose: don’t allocate what you won’t use.

with Ada.Text_IO; use Ada.Text_IO;
procedure Slide_Generator is
   function Next_Slide (N : Natural) return String is
   begin
      return "slide-" & Natural'Image(N)(2..Natural'Image(N)'Last) & ".tif";
   end Next_Slide;
begin
   for I in 0 .. 4 loop
      Put_Line(Next_Slide(I));
   end loop;
end Slide_Generator;

Output:

slide-0.tif
slide-1.tif
slide-2.tif
slide-3.tif
slide-4.tif

The difference is philosophical. Clojure’s version defines the infinite collection upfront and trusts the runtime to be lazy about realization. Ada’s version never pretends infinity exists — you call the function when you need a value, and that’s that. One is declarative (describe what exists, access it later); the other is imperative (compute when commanded).

Both keep memory bounded. Both process specimens one at a time. Whether you frame it as “I have all the slides” or “I can generate any slide” depends on how you think about data structures — as things that exist, or things that happen.

I spent twenty minutes this afternoon hunting for a rotifer I’d spotted at the edge of the coverslip. By the time I manoeuvred back, it had drifted out of the field. Lazy evaluation wouldn’t have helped. Some things you just have to realize in time.