Title: Splice a discarded applied function literal, not only a tail-position one · Issue #359 · purescript-lua/purescript-lua · GitHub
Open Graph Title: Splice a discarded applied function literal, not only a tail-position one · Issue #359 · purescript-lua/purescript-lua
X Title: Splice a discarded applied function literal, not only a tail-position one · Issue #359 · purescript-lua/purescript-lua
Description: Problem pslua represents an Effect/ST action as a nullary Lua thunk, and the magic-do pass lowers a do block into one such thunk holding a flat statement sequence. When the optimizer inlines an action's body at a call site, the result is...
Open Graph Description: Problem pslua represents an Effect/ST action as a nullary Lua thunk, and the magic-do pass lowers a do block into one such thunk holding a flat statement sequence. When the optimizer inlines an act...
X Description: Problem pslua represents an Effect/ST action as a nullary Lua thunk, and the magic-do pass lowers a do block into one such thunk holding a flat statement sequence. When the optimizer inlines an act...
Opengraph URL: https://github.com/purescript-lua/purescript-lua/issues/359
X: @github
Domain: github.com
{"@context":"https://schema.org","@type":"DiscussionForumPosting","headline":"Splice a discarded applied function literal, not only a tail-position one","articleBody":"## Problem\n\n`pslua` represents an `Effect`/`ST` action as a nullary Lua thunk, and the magic-do pass lowers a `do` block into one such thunk holding a flat statement sequence. When the optimizer inlines an action's body at a call site, the result is a *literal* thunk that is built and immediately called — a closure allocation and a call whose only purpose is to run statements that could sit in the parent function directly.\n\nThe Lua-level optimizer already removes this, budgeted, in one position. `collapseTailLiteralApplication` (`Language.PureScript.Backend.Lua.Optimizer`) splices the literal's body into its parent when the merged body still fits the local-variable ceiling — the splice undoes exactly the chunking magic-do uses to keep any one function's locals under Lua 5.1's `LUAI_MAXVARS` of 200 (#19), so it re-checks that budget rather than assuming it:\n\n```haskell\ncollapseTailLiteralApplication ∷ LuaLimits → RewriteRule\ncollapseTailLiteralApplication limits = \\case\n Function params body\n | Just (leading, binding, spliced) ← matchTailLiteralApplication body\n , not (chunkScopeUsesVararg spliced)\n , let merged = leading \u003c> binding \u003c> spliced\n , length params + activationLocalSlots merged\n \u003c= workingLocalCeiling limits →\n```\n\nIts matcher, however, only recognises the literal in *tail* position — a function body whose last statement is a `Return` of the applied literal:\n\n```haskell\n matchTailLiteralApplication body = case reverse body of\n Ann (Return [Ann (FunctionCall (Ann (Function params spliced)) args)])\n : reverseLeading → do\n```\n\nA magic-do effect statement is not in tail position. It is a discarded `local` binding, because the statement's value is unused and only its effect matters, so the inlined action lands as `local _ = (function() … end)()` and the rule never sees it. From `Golden.EffectWorkerThunk`, where the two-statement body of `runWith` was pasted into its one call site:\n\n```lua\n local _ = (function()\n local _ = Golden_EffectWorkerThunk_Test_tally_S_w(\"via\", 3)\n return Effect_Console_log(\"ran\")()\n end)()\n```\n\nTwo locals in the parent's budget would admit the splice with room to spare, yet the closure is allocated and called every time this statement runs. Across the golden corpus there are 84 applied-literal sites in this discarded-binding position, against 153 in the tail position the existing rule covers.\n\n## Approach\n\nExtend the reach of the existing rule (or add a sibling sharing its conditions) to an applied function literal that is the right-hand side of a statement whose value is discarded. Every guard the tail case already checks carries over unchanged and should be reused rather than restated: the vararg guard (`chunkScopeUsesVararg`), the parameter binding built from the call's arguments, and the `length params + activationLocalSlots merged \u003c= workingLocalCeiling limits` budget that keeps the splice from undoing magic-do's chunking.\n\nOne condition is new, and it is what bounds the change. The tail case splices a body whose value becomes the parent's return value, so the body's `return` needs no rewriting. In statement position the value is discarded, so the body's trailing `return e` has to become a discarded statement of `e` — and any *other* `return` in the body, for instance inside an `if` branch, would after splicing return from the *parent* function instead of from the thunk. The rewrite must therefore be restricted to a body whose only `return` is its last statement, which is the shape magic-do itself emits; a body with branching returns keeps its thunk.\n\n## Verification / Measurement\n\nThe `runWith` site in `Golden.EffectWorkerThunk` is the minimal positive case: a two-local body with a single trailing return, whose `local _ = (function() … end)()` should become the two statements spliced into the enclosing block, with `eval/golden.txt` unchanged. A golden whose thunk body returns from inside a branch pins the negative side and is the one shape that must keep its closure. Because the parent of a spliced body can itself be spliced, the fixpoint behaviour the tail rule already documents (it re-applies itself to the merged function) needs the same treatment here.\n\nA wall-clock number needs a benchmark whose hot loop executes such a statement; none of the current `bench/macro` specs does, since an inlined action in a hot loop tends to be in tail position. Whether the win is worth a new spec can be judged from the counter oracles first: each spliced site removes one `FNEW` from a function body, which `bench/tools/fnew_census.lua` counts statically and which aborts LuaJIT trace recording (`NYI: bytecode FNEW`) when it sits in a hot path.\n\n## Prerequisites / Relations\n\nIndependent. #342 widens a *different* guard — the code generator's own shed in `Language.PureScript.Backend.Lua`, which drops a literal thunk applied to the effect-run marker when the thunk's body is a call, and which #342 extends to any body that lowers to an expression. That shed cannot handle a body of statements at all, and explicitly leaves such bodies thunked; this issue is about the Lua-level optimizer that runs afterwards and *can* splice statements, given the budget. The two are complementary and neither blocks the other.\n","author":{"url":"https://github.com/Unisay","@type":"Person","name":"Unisay"},"datePublished":"2026-07-30T10:20:31Z","url":"https://github.com/purescript-lua/purescript-lua/issues/359"}
| react-profiling | 0 |
| react-import-map | react,react-dom,react-dom/client,react-dom/profiling,react-is,react/compiler-runtime,react/jsx-dev-runtime,react/jsx-runtime,scheduler@b8488ee2c322 |
| route-pattern | /_view_fragments/issues/show/:user_id/:repository/:id/issue_layout(.:format) |
| route-controller | voltron_issues_fragments |
| route-action | issue_layout |
| fetch-nonce | v2:019d4655-7dca-4095-a929-2fe6278799d6 |
| current-catalog-service-hash | 81bb79d38c15960b92d99bca9288a9108c7a47b18f2423d0f6438c5b7bcd2114 |
| request-id | E94A:33444D:6CF404:92F946:6B00D93E |
| html-safe-nonce | 76ba1413d8572c0df873de207dc78c731db9a7cb6c182d0c3061a94163afc325 |
| visitor-payload | eyJyZWZlcnJlciI6IiIsInJlcXVlc3RfaWQiOiJFOTRBOjMzNDQ0RDo2Q0Y0MDQ6OTJGOTQ2OjZCMDBEOTNFIiwidmlzaXRvcl9pZCI6IjE1OTc2NDA0NDk0Nzk3MDM2NiIsInJlZ2lvbl9lZGdlIjoiaWFkIiwicmVnaW9uX3JlbmRlciI6ImlhZCJ9 |
| visitor-hmac | c61e85f9b4e5ee1045dce18b7d5bcf0056d477ad58e92d1a5c5d41051c42b383 |
| hovercard-subject-tag | issue:5018706472 |
| github-keyboard-shortcuts | repository,issues,copilot |
| google-site-verification | Apib7-x98H0j5cPqHWwSMm6dNU4GmODRoqxLiDzdx9I |
| octolytics-url | https://collector.github.com/github/collect |
| analytics-location | / |
| fb:app_id | 1401488693436528 |
| apple-itunes-app | app-id=1477376905, app-argument=https://github.com/_view_fragments/issues/show/purescript-lua/purescript-lua/359/issue_layout |
| twitter:image | https://opengraph.githubassets.com/108658b5048066ead8f690a0e8fc49cdc537adb1f18fd85fbbc0e0aa9349f84b/purescript-lua/purescript-lua/issues/359 |
| twitter:card | summary_large_image |
| og:image | https://opengraph.githubassets.com/108658b5048066ead8f690a0e8fc49cdc537adb1f18fd85fbbc0e0aa9349f84b/purescript-lua/purescript-lua/issues/359 |
| og:image:alt | Problem pslua represents an Effect/ST action as a nullary Lua thunk, and the magic-do pass lowers a do block into one such thunk holding a flat statement sequence. When the optimizer inlines an act... |
| og:image:width | 1200 |
| og:image:height | 600 |
| og:site_name | GitHub |
| og:type | object |
| og:author:username | Unisay |
| hostname | github.com |
| expected-hostname | github.com |
| None | a481f62a1e04c9b9bdcb5628230682c66d59006f5b13b080f79cba84a176905b |
| turbo-cache-control | no-preview |
| go-import | github.com/purescript-lua/purescript-lua git https://github.com/purescript-lua/purescript-lua.git |
| octolytics-dimension-user_id | 131581790 |
| octolytics-dimension-user_login | purescript-lua |
| octolytics-dimension-repository_id | 587200487 |
| octolytics-dimension-repository_nwo | purescript-lua/purescript-lua |
| octolytics-dimension-repository_public | true |
| octolytics-dimension-repository_is_fork | false |
| octolytics-dimension-repository_network_root_id | 587200487 |
| octolytics-dimension-repository_network_root_nwo | purescript-lua/purescript-lua |
| turbo-body-classes | logged-out env-production page-responsive |
| disable-turbo | false |
| browser-stats-url | https://api.github.com/_private/browser/stats |
| browser-errors-url | https://api.github.com/_private/browser/errors |
| release | 84c8c5cc25e2fb7f2308428458538436baecc6d2 |
| ui-target | full |
| theme-color | #1e2327 |
| color-scheme | light dark |
| react-app-name | issues |
Links:
Viewport: width=device-width