What a synthesizer sees when solving C (Stock T): the via-target it is building the instance for (Stock T), the underlying analysed type (T), the newtype-unwrap coercion between them, and T's constructors. Field types are already instantiated at T's actual arguments.

One constructor of the analysed type: its DataCon, field types (instantiated at T's arguments), fixity, and record labels if any.

A Core-building computation that may request sub-instances (emitting wanted constraints) and allocate fresh binders. Structurally this is a reader of the CtLoc over a writer of emitted Cts over TcPluginM, so we derive the monad instances straight from that stack (the representations are coercible).

Run a synthesizer at a constraint location, collecting the wanteds it emitted (to be returned to GHC alongside the solution).

Build a Synth from a location-dependent, wanted-emitting action — the inverse of runSynth. Lets a raw CtLoc -> TcPluginM (EvTerm, [Ct]) synthesizer be presented as a Deriver (see viaSynth in the plugin).

Lift a plugin action.

The continuation: request the dictionary for C ty and resume with its evidence. Emits the wanted so GHC solves it (possibly via this very plugin, enabling recursion into the field's own instance).

A fresh local binder of the given type.

x |> co, skipping the cast entirely when co is reflexive (the not-overridden case) so the generated Core stays byte-identical.

Apply a class's dictionary constructor: C:Cls @ty m1 .. mn.

Build a (recursive) dictionary giving explicit superclass dictionaries and implementations for the listed method indices; every other method is taken from the class's own default (applied to the recursive dictionary). Lets a synthesizer fill a many-method class from a few key methods — e.g. Hashable from just hashWithSalt (its hash has a default), with its Eq superclass supplied as [field eqCls ty].

A class method selected by its source name — order-independent, unlike indexing classMethods positionally (whose order can differ across GHC versions). Panics if the class has no such method (a plugin bug).

The constructor of a product (the sole one). Exported so product synthesizers can feed it to the per-Constructor NP combinators below.

The SOP eliminator (from + case): scrutinise a value of the via-type and dispatch on its constructor. k idx con fields builds the resTy-typed branch body for constructor con (index idx in dtCons) with its bound field expressions. One alternative per constructor — so this is the sum-of-products generalisation of fromProduct.

The SOP introducer (inj + to): build a value of the via-type from a chosen constructor and one expression per its fields.

productTypeFrom + a continuation: the single-constructor case of matchSOP.

productTypeTo: the single-constructor case of injectSOP.

pure_NP / cpure_NP: one result per field, produced from its type (cpure also from its cls dictionary, e.g. k ft d = mempty @ft d).

pureFields that also hands each field its own cls dictionary.

hmap / hcmap: map over the fields positionwise (the basic NP action; cmap also hands each field's cls dictionary to the step).

mapFields that also hands each field its own cls dictionary.

liftA2_NP / cliftA2_NP: combine two field-lists positionwise (czip via each field's cls dictionary, e.g. k ft d x y = (<>) @ft d x y).

zipFields that also hands each field its own cls dictionary.

hfoldl / cfoldl_NP: collapse the fields left-to-right through an accumulator a (any host value — a CoreExpr, a list, …). The step of the unconstrained foldlFields has full Synth access (request anynoseveral dictionaries); cfoldlFields hands it each field's cls dictionary. Needed by accumulating classes, e.g. Hashable's hashWithSalt threading the salt.

foldlFields that also hands each field its own cls dictionary.

htraverse over a list of fields: produce one a per field in Synth. The most general traversal-shaped combinator — used for applicative-effectful work like generating `Gen a` values (for Arbitrary). traverseFields has full Synth access; ctraverseFields hands each field's cls dictionary to the step.

hctraverse: the constrained traverseFields — requests each field's cls dictionary and hands it to the step (alongside the field value). Used by Arbitrary (request `Arbitrary ft` per field, emit `Gen ft`), CoArbitrary (request `CoArbitrary ft`, emit function generator), and Shrink (request `Shrink ft`, emit shrink list).

A class's synthesizer, keyed by the wrapper arity it works through.

Register synthesis of a class cls derived via Stock. The method does not mention cls, so the plugin selects the instance by looking it up in the instance environment rather than by ordinary dispatch.

A Stock1 synthesizer for a (Type -> Type) class: given the class, the constraint location, the via-target Stock1 F and the inner F, build the dictionary — or Nothing if a field shape is unsupported. (Lifted classes need the parameter-variance walk, so they get the raw form rather than the Datatype-based Deriver; the Stock1 TyCon is recoverable as tyConAppTyCon of the via-target.)

Register synthesis of a (Type -> Type) class derived via Stock1 (the lifted counterpart of DeriveStock — e.g. NFData1, Hashable1).

The Stock2 analogue of Deriver1: given the class, the location, the via-target Stock2 P and the inner P, build the dictionary.

Register synthesis of a (Type -> Type -> Type) class derived via Stock2 (e.g. NFData2).