● Green — 32 exercises now. Both pieces are in: #5

Merged

navicore merged 1 commit from choosing into main

2026-06-10 15:21:13 +00:00

navicore commented

2026-06-10 15:20:06 +00:00

Owner

The "binds vs tests" grid

The 2×2 is the spine of it:

┌─────────────┬──────────────────┬──────────────────────────┐
│ │ doesn't evaluate │ evaluates arithmetic │
├─────────────┼──────────────────┼──────────────────────────┤
│ binds a var │ = (unify) │ is (eval, then bind) │
├─────────────┼──────────────────┼──────────────────────────┤
│ just tests │ == (identity) │ =:= (eval, then compare) │
└─────────────┴──────────────────┴──────────────────────────┘

Seed in 01-arithmetic/01 — a light forward-glance naming the two axes and flagging is as the corner that does
both, so the learner meets is already knowing two siblings are coming. No table yet (they haven't seen =/=:=).
Full grid in 05-comparison/04 — the payoff, where all three are finally in hand, with the empty fourth corner
(==) explicitly forward-referenced to ch 07. That's the through-line into the expansion plan.

The capstone: 05-comparison/06-choosing

A triptych where nobody tells you which operator to use, and each slot admits exactly one:

double(N, D) — produce a computed value → must evaluate + bind → only is
balanced(L, R) — equal as numbers, either side an expression → evaluate, bind nothing → only =:=
boxed(X, B) — assemble box(X) → bind, don't evaluate → only =

I verified on plgc that every wrong pick genuinely breaks — instantiation error, silent false, or
type_error(evaluable, ...) — so the exercise actually bites rather than quietly tolerating a near-miss. The hint
nudges via the grid without naming an operator, per convention.

This lands right where ch 07 picks up: that chapter adds ==/== to the very same grid, so the foundation is now
solid for it.

The "binds vs tests" grid The 2×2 is the spine of it: ┌─────────────┬──────────────────┬──────────────────────────┐ │ │ doesn't evaluate │ evaluates arithmetic │ ├─────────────┼──────────────────┼──────────────────────────┤ │ binds a var │ = (unify) │ is (eval, then bind) │ ├─────────────┼──────────────────┼──────────────────────────┤ │ just tests │ == (identity) │ =:= (eval, then compare) │ └─────────────┴──────────────────┴──────────────────────────┘ - Seed in 01-arithmetic/01 — a light forward-glance naming the two axes and flagging is as the corner that does both, so the learner meets is already knowing two siblings are coming. No table yet (they haven't seen =/=:=). - Full grid in 05-comparison/04 — the payoff, where all three are finally in hand, with the empty fourth corner (==) explicitly forward-referenced to ch 07. That's the through-line into the expansion plan. The capstone: 05-comparison/06-choosing A triptych where nobody tells you which operator to use, and each slot admits exactly one: - double(N, D) — produce a computed value → must evaluate + bind → only is - balanced(L, R) — equal as numbers, either side an expression → evaluate, bind nothing → only =:= - boxed(X, B) — assemble box(X) → bind, don't evaluate → only = I verified on plgc that every wrong pick genuinely breaks — instantiation error, silent false, or type_error(evaluable, ...) — so the exercise actually bites rather than quietly tolerating a near-miss. The hint nudges via the grid without naming an operator, per convention. This lands right where ch 07 picks up: that chapter adds ==/\== to the very same grid, so the foundation is now solid for it.

navicore added 1 commit

2026-06-10 15:20:06 +00:00

● Green — 32 exercises now. Both pieces are in:

CI - Linux / CI - Linux x86_64 (pull_request) Successful in 44s

Details

60791bd213

The "binds vs tests" grid

  The 2×2 is the spine of it:

  ┌─────────────┬──────────────────┬──────────────────────────┐
  │             │ doesn't evaluate │   evaluates arithmetic   │
  ├─────────────┼──────────────────┼──────────────────────────┤
  │ binds a var │ = (unify)        │ is (eval, then bind)     │
  ├─────────────┼──────────────────┼──────────────────────────┤
  │ just tests  │ == (identity)    │ =:= (eval, then compare) │
  └─────────────┴──────────────────┴──────────────────────────┘

  - Seed in 01-arithmetic/01 — a light forward-glance naming the two axes and flagging is as the corner that does
  both, so the learner meets is already knowing two siblings are coming. No table yet (they haven't seen =/=:=).
  - Full grid in 05-comparison/04 — the payoff, where all three are finally in hand, with the empty fourth corner
  (==) explicitly forward-referenced to ch 07. That's the through-line into the expansion plan.

  The capstone: 05-comparison/06-choosing

  A triptych where nobody tells you which operator to use, and each slot admits exactly one:
  - double(N, D) — produce a computed value → must evaluate + bind → only is
  - balanced(L, R) — equal as numbers, either side an expression → evaluate, bind nothing → only =:=
  - boxed(X, B) — assemble box(X) → bind, don't evaluate → only =

  I verified on plgc that every wrong pick genuinely breaks — instantiation error, silent false, or
  type_error(evaluable, ...) — so the exercise actually bites rather than quietly tolerating a near-miss. The hint
  nudges via the grid without naming an operator, per convention.

  This lands right where ch 07 picks up: that chapter adds ==/\== to the very same grid, so the foundation is now
  solid for it.

navicore merged commit a8e8e0bc57 into main

2026-06-10 15:21:13 +00:00

navicore deleted branch choosing

2026-06-10 15:21:13 +00:00

navicore referenced this pull request from a commit

2026-06-10 15:21:13 +00:00

Merge pull request '● Green — 32 exercises now. Both pieces are in:' (#5) from choosing into main