Kata: curry

A saddler cuts a saddle once its order card gives the tree width, the seat size and the leather.

At the saddler's bench	In the kata
the card goes to the cutting table once its boxes are filled	fn runs once the arity is reached (steps 2, 5)
a rider gives one size today and two next week	f(1)(2, 3) (step 7)
a riding school's card, tree width already filled, photocopied for each rider	a partial reused; each call copies (step 4)
one card on the counter that every rider writes on	the shared array (step 3)
the box count printed on top stops at the first box marked "house default"	fn.length (step 2)
"count the default box too" written in pencil	an explicit arity (step 8)

In real terms: curry is a function that keeps returning new functions, each closing over a new array, until enough arguments have arrived to call fn.

Breaks down when: a saddler sees two riders' sizes crowding one card; a shared array fails silently, or later, in someone else's call.

Contrasting case: a card with a "notes" box after the leather: the saddler still starts at three boxes and keeps the notes, as fn gets extra arguments (step 6).

4.1 ExamHall EXH-3520: one shared array behind every length check

The question editor's first draft of curry kept one array per curry() call (EXH-3520). It passed its author's single check and then mixed up questions. MR !3820 replaced it with the reference and added the test list to the repository. The list also runs on two common mutants: M1 keeps one array per curry() call, and M2 passes fn only fn.length arguments.

4.1 reference.mjs                          11 of 11 pass (9 core, 2 ladder)
4.1 M1, one array per curry() call         5 of 11 pass · red: C2 "f(1, 2)(3) and f(1)(2, 3) return fn's result", C5 "a partial is reusable: add1(2)(3), then add1(10)(20)", C6 "two partials made from one partial stay independent", C7 "two chains from the curried function itself stay independent", L1 "an explicit arity waits for a parameter after a default", L2 "fn gets the caller's this, at once and through a partial"
4.1 M2, fn given only arity arguments      10 of 11 pass · red: C8 "arguments past fn.length reach fn"
4.1 EXH-3520 the M1 draft in the editor, 4 fields checked with one rule(10) partial: 1 right
4.1 MR !3820 the reference in the editor, the same 4 fields: 4 right

M1 collects every caller's arguments in one place (step 3), so after its first result each later call of rule adds to a full array. M2 drops what comes after the arity (step 6), which a function reading arguments or a rest parameter notices.

4.2 Streaming: one partial, three titles

A video player builds its stream requests with the reference as request = curry((quality, title, startAt) => …), and keeps const hd = request('1080p') for every title on the shelf:

4.2 hd('Intro')(0) -> 1080p/Intro@0 · hd('Pilot')(90) -> 1080p/Pilot@90 · hd('Finale', 30) -> 1080p/Finale@30
4.2 hd('Extra')(5) after those three -> 1080p/Extra@5 (hd still holds one argument)

Each call of hd builds a new array from ['1080p'], so the three requests never see each other's titles (step 4), and hd itself still holds one argument after them.