Documentation

Whether loop state is exploded in this process (the argument side: explosions, specialise): on unless UNISON_OPTIMIZATIONS says -explode_args.

Whether product results are exploded (the return side: returns, returnWorker): on unless UNISON_OPTIMIZATIONS says -explode_returns.

Whether a product or sum built and matched in the same body is matched where it is built, and a match on the value of a match moved into its tails (knownCons, splitJoins): on unless UNISON_OPTIMIZATIONS says -known_constructor.

Whether any rewrite of the ANF is on: with none, every lambda is emitted as its unoptimized form and no section gets a deoptimization table (the emitter checks this).

The combinator index of a group's k-th specialisation (k from 1): in the high bits like a local function's, with a bit no let index reaches (the lets of a combinator are numbered from 1 in its low sixteen bits) and no local function has. The JIT treats a worker like the entry point it stands for (Compile's isEntry).

The combinator index of a group's product-return worker (returns): the specialisation slot no call pattern takes, since those are numbered from 1.

The combinator index of the k-th join point (k from 1) of the lambda at an index of the group (splitJoins): the lambda's index with k in the bits above any a local function's or a specialisation's number uses, so that the low fifteen bits are the owner's and the JIT compiles it as it does a worker (Compile's isEntry), and the lets of the join point are numbered under it like any combinator's.

How an argument position is taken apart: left as one slot, or a product, a data constructor or a record (Fields, its fields in the schema's order, which is the field names' order), whose fields are taken apart in turn.

A call pattern: a shape per argument.

The values a shape is taken apart into: one for a plain position, the leaves of its fields for a product.

What the rewrites know about the batch, each by a function's reference and Nothing for a function outside the batch or without one: the call patterns it has a specialisation for, in worker order (explosions), the product it returns on every path (returns), and its arity. The analyses run with the parts not yet known empty.

The specialisations of each function of a batch, by its reference: the patterns, in the order their workers are numbered (specIndex).

The specialisations of a batch of groups: for each group's entry point, the patterns its callers in the batch build, each narrowed to what its body consumes, and then the patterns each worker's own body builds, until there are no new ones.

The product each function of a batch returns on every path, by its reference: the shape every tail of its body builds (a constructor application or a record literal, or a variable bound to one, its fields taken apart in turn where they are built for it), met over the tails, where the other tails are saturated calls of functions of the batch that return the same product. A closure from the shapes the tails build: a callee's shape narrows its callers' until nothing changes, and a function with a tail that returns anything else, or calls a function that does, is dropped. Products of one leaf are left to the wide convention and products of none are nothing to return; a function of no arguments is a value evaluated once when it loads, so it keeps its entry.

A lambda as the emitter sees it (prepareBody on its body). Applied to every lambda of a batch, so that the sites the analyses saw are the sites emitted; the analyses pass no setting and get no join points.

The worker of a lambda for a pattern: its parameters are the plain arguments and the fields of the exploded ones, each a fresh name, and its body is the lambda's with the exploded arguments rewritten to their fields, prepared again afterwards, since a record update the rewrite turned into a literal is a product built for whatever it is passed to. The join points are made by the second pass, from the sites of the unoptimized body.

The product-return worker of a lambda that returns a product of the shape on every path: the lambda with its tails yielding the leaves. It gets no join points: its tails are what yield the leaves.

A lambda as the emitter sees it, with what its rewrite changed: the sources of the unoptimized body's variables, the binders of each let the rewrite changed, mapped to the binders of the unoptimized let it stands for (a let of a result's leaves, to the let of the result), and the variables the rewrite found dead wherever a frame could hold them (the let of a site splitJoins rewrote, used only by the match that is gone), and its join points, the k-th at joinIndex k of the lambda's index.

A join point of a lambda (splitJoins): an arm of a match on the value of a match, as a combinator of the group whose parameters are the arm's variables and then the variables the arm uses; the binders of the unoptimized let whose binding the match was in, if any, which is where the unoptimized frames of a continuation captured inside the join point stop (the emitter's deoptOf); and the source of the match's variable, the constructor this arm is for over the arm's variables (none for the default arm, whose frames never read it).

Where a lambda's join points go: the lambda's index in its group, the group's reference, and the names of the group's local functions, which a body refers to as variables but which no frame holds.

Where a variable of the unoptimized body went, for the frames of a continuation captured in the optimized code to be written out as the unoptimized code's (design.md, "Continuations across processes"; FrameLayout): renamed to another variable (a match arm's field variable to the leaf or product that stands for it, a field read's let to the parameter it reads), or replaced by a product the optimized body no longer names, given as the product with the names of its fields in the optimized body (an exploded parameter, a result the leaves replace, a product of either that a match took apart in turn). A variable with no entry has the same name in both.

A product a let built: which one, and its field variables, in the shape's field order.

The body with a name of its own for every binder and an index of its own for every indirect let. Normalization reuses a name under shadowing (the blank variables), and freshen gives a name back once the binder's scope is over, while everything here maps variables by name. Only a binder already bound elsewhere in the body is renamed, so that a body whose binders are already unique comes back as it is: the unoptimized body is renamed the same way, and the names are what pairs its lets with the optimized body's (Prepared). The let indices number the sections of the emitted combinator, and the ones normalization assigned repeat once the ANF optimizer has inlined a body whose lets carry their own (uniqueLets), which is also why the renaming is applied with every rewrite off.

A term and every term inside it. | Every subterm, the term first; built with an accumulator, since the analyses walk it once per let of a body and the nested appends of a concatMap cost the body's size times its depth per walk (a doc literal of a few thousand lets took minutes, 2026-11-03).