Lift the *.Uncurried run wrappers to direct n-ary calls (#198) - #226

Closes #198.

The forks declare uncurried FFI throughout (zipWithImpl is Fn3, pushImpl is STFn2, indexImpl is Fn4), but until now a saturated runSTFn2(pushImpl)(x)(arr)() still compiled to the curried runtime fallback: two closure allocations plus a thunk per call, exactly what curried FFI costs. On the Lua target the ecosystem's uncurried discipline bought nothing.

This lifts the run half of the *.Uncurried wrappers through the foreign lifter (#178) into the AppN node (#179), so a saturated call site collapses to a single direct Lua call.

Changes

1. Lift the run wrappers (ForeignLift). runFn2…runFn10, runSTFn1…runSTFn10, and runEffectFn1…runEffectFn10 join the allowlist. Two shapes were added to the lifter: a saturated call fn(a, b, …) lifts to AppN, and the zero-parameter effect thunk function() … end lifts to an Abs with an unused parameter. So runFn3 becomes \fn a b c -> AppN fn [a, b, c] and runSTFn2 becomes \fn a b -> Abs _ (AppN fn [a, b]). These are inline-always like every lifted accessor, so a saturated site beta-reduces to a direct AppN impl [x, y, z], and a partial application keeps the wrapper's curried fallback. The mk* counterparts need an n-ary AbsN (#227) and stay opaque; runFn0 (a nullary call, no AppN) and runFn1 (PureScript id, no FFI) are not lifted. A literal-lambda call head (an inlined header local, or a parenthesized function literal — Lua legally calls either at any argument count) must be applied at exactly its own arity: a mismatch declines rather than build an ill-formed AppN (the WellApplied invariant), keeping the designed failure mode — decline or NotLiftable, never malformed IR.

2. Fuse the effect run at codegen (Lua backend). The issue expected magic-do to fuse the lifted effect thunk "for free", but it did not: a lifted effect action is a literal thunk \_ -> fn(a, …), and running it ((\_ -> fn(a, …)) EffectRunArg) was lowered to (function() return fn(a, …) end)(), leaving one residual closure. The fix lowers that shape straight to the call fn(a, …).

This has to happen at code generation, not in the IR: the EffectRunArg marker is what tells dead-code elimination to keep a result-unused effect statement (local _ = m()), so stripping it in the optimizer drops the effect entirely. The marker stays in the IR through the whole pipeline; only the Lua backend, downstream of DCE, drops the redundant force. The fusion is restricted to an AppN body, which always lowers to an expression, so it never inlines a Let chunk (which would merge locals past magic-do's chunk boundaries).

Before / after

For an Effect/ST statement (Golden.UncurriedLift):

-- before: runEffectFn2(logTwice)("hello")("world")()  (3 closures, 4 calls)
-- after:
local _ = M.Golden_UncurriedLift_Test_logTwice("hello", "world")

For a pure runFn3 site, saturated and partial:

-- runFn3 add3 1 2 3        ->  add3(1, 2, 3)
-- runFn3 add3 1 2 (partial) -> function(c) return add3(1, 2, c) end

The runFn* / runEffectFn* accessors disappear from the emitted FFI tables entirely.

Testing

• Unit tests (ForeignLift.Spec) for the new lift shapes (runFn3, runSTFn2, runEffectFn1), the declines (mkFn2, nullary runFn0, a literal-lambda call at a mismatched arity), and allowlist membership.
• A runnable golden (Golden.UncurriedLift) exercising pure runFn2/runFn3, a partial application, an effectful runEffectFn2, and a runSTFn2 site that links the real purescript-lua-st fork FFI through the lifter — so a fork release reshaping its Uncurried.lua trips the allowlist hard contract in this repo's CI instead of only downstream. The eval oracle checks the runtime output, and golden.lua pins the collapsed calls.
• Full suite green; property specs stable across seeds; hlint/fourmolu clean.

Golden.StringCodePoints shifts by name index only (the structural diff is empty and its eval oracle is unchanged): its dependency closure references a wrapper before DCE, so the lifter now moves it to a binding with named parameters, uniquify renumbers, and DCE then drops the dead wrapper. Same benign churn the #178 lifter produces.

Notes

The #172 STFn-call microbenchmark and the foldl-driver currying (#24) are out of scope here, as the issue notes. The codegen fusion applies in every statement position, tail included, so a lifted effect wrapper leaves no residual closure wherever it appears in a do-block.