loophole.dev — A Japanese-Minimal Codex of Recursion

§I THE PETIOLE

01_I

CONTROL ENTERS HERE

02_I

A program is a leaf. The petiole is the entry; the apex is the return. Between them, every line of code is a vein.

enter(input) → leaf 03_I

Read at the pace of breathing. The codex will wait. Each cell is closed; each chapter folds back upon itself.

// pause is also computation 04_I

§II ITERATION AS BAMBOO

01_II

Bamboo grows by node. Iteration grows by step. Each segment is a turn of the loop — identical, repeatable, complete.

02_II

for (let i = 0; i < n; i++) {
  step(i);
}

03_II

A node closes the previous segment and opens the next. The condition is a knot. The increment is the next stalk.

04_II

while (cond) {
  body();
  advance();
}

05_II

SEGMENT BY SEGMENT

06_II

When the stalk hollows, control runs through it cleanly. The body is the work; the head and the tail are merely punctuation.

07_II

for (item of grove) {
  cut(item);
}

08_II

§III THE BRANCHING GINKGO

A ginkgo divides at the petiole. The left half is one truth; the right is another. Both leaves share a stem.

01_III

if (light) {
  drift("left");
}

02_III

The condition is the wind that decides which half lights up. Predicates choose; they do not invent.

03_III

else {
  drift("right");
}

04_III

ONE STEM · TWO LEAVES

05_III

Branches are not opposites; they are siblings. The same petiole, the same leaf, two destinations.

06_III

§IV THE RECURSIVE FERN

01_IV

function factorial(n) {
  if (n <= 1) return 1;
  return n * factorial(n - 1);
}

02_IV

A fern remembers its own shape at every scale. Recursion is the same shape, met again, smaller, until the smallest version returns the answer.

03_IV

SELF AT EVERY SCALE

04_IV

The base case is the smallest pinna — the leaflet that does not divide. Without it, the frond unrolls forever.

if (n <= 1) return 1; 05_IV

§V THE PINE-NEEDLE PAIR

async threadA() {
  await draw(needle);
}

01_VA

Two needles share one fascicle. They run in parallel, brushed by the same wind, but they do not become each other.

02_VA

PAIRED · NEVER FUSED

03_VA

async threadB() {
  await draw(needle);
}

04_VB

A lock is the small enso that embraces a needle — for the duration of one breath, only one thread passes through it.

05_VB

await Promise.all([
  threadA(), threadB()
]);

06_VB

§VI THE LOTUS OF PURITY

f₁

f₂

f₃

f₄

f₅

f₆

f₇

f₈

const f = (x) => x;
// no global state

center_VI

A pure function is a lotus — the same input always produces the same output. There is no mud at the petal's edge.

§VII THE LOOPHOLE

01_VII

function tail(n, acc) {
  if (n === 0) return acc;
  return tail(n - 1, acc * n);
}

02_VII

EXIT VIA LOOPHOLE

03_VII

The tea-leaf curls so its tip rejoins its own petiole. The loop is closed; the hole is the way out. Tail-call — a circle with a single opening.

04_VII