Generic Programming

A placeholder introduced on the type is chosen once when an instance is created and every member of that instance shares it. A placeholder introduced on one operation is chosen afresh for each call and is scoped to that call.

The compiler solves the placeholder from evidence at the call site: the static types of the arguments, the type the result is expected to have where the call sits, and any bound or default declared on the parameter itself.

A key type and a payload type vary independently, so each needs its own placeholder. A placeholder takes one type argument per use, so a single placeholder would force every route key and its payload to be the same type.

A type parameter moves the wrong-kind failure from collection time to the deposit call, and from run time to compile time. Callers also get items back already typed, so no downcast on retrieval can fail.

Only a placeholder introduced on the declaration is one name that all members mean the same thing by. Give each operation its own and nothing ties them together: a value put in and a value taken out need never match, and the stored buffer agrees with neither.

Only what every type supports: hold it, pass it on, return it. With no limit written, the placeholder is implicitly pinned at the widest type available, so no pay-component operation such as reading an amount is callable on it.

Listing two requirements on one placeholder admits any type that already orders and already renders, unchanged. A combined supertype forces every candidate to be redeclared under it, which is impossible for types you do not own, and welds two unrelated capabilities together.

A self-referential limit types each entrant's comparison against its own type, so comparing two unrelated kinds of entrant fails to compile. A plain comparable supertype only promises comparison with some entrant, leaving the mismatch to surface at run time.

Naming a supertype demands that the add-in team edit their type's declaration and take a build dependency on your published artifact. Requiring a shape demands only that the members exist, so a type written before your host can qualify unchanged.

What the body does with the value. If it calls that type's own operations, pin the placeholder at or below the type; if it only hands values of that type in somewhere, pin it at or above.

The array's real element type is still premium-only, so the store plants a value the original holder's type promises can never be there, and the next read of that slot returns something the reader believes is impossible.

A placeholder is a producer when every member that mentions it hands a value of it back: it appears only as output — a return type or a readable property — and never as a parameter the caller supplies.

Not automatically. A subtype relation between two element types says nothing on its own about the containers over them; the container type decides. Three answers are possible - covariant, contravariant, invariant - and invariance is the usual default.

Declaration-site states the direction once, so every use gets the subtyping free - but only for a type whose parameter sits in one direction. Use-site keeps the type invariant and lets each signature narrow its own view, repeatedly.

Each store is tested at run time against the element type the array was actually created with, and a value that does not fit is rejected right there, at the write - not at the call that let the widened array through.

A run-time test can only read what the value still carries, and the discarded argument is not there. Every stack of edits shares one run-time shape, so the test cannot be decided, and the compiler rejects it instead of guessing.

The type argument is the evidence the run time no longer carries: the loader uses it to choose how to convert the stored text and to check the converted value before returning it, so a mismatch fails at the read.

Nothing you can ask the value for. The argument is spent during compilation, and what runs is an ordinary container over the erased element shape. Only a declaration, never the object it points at, may keep a written description of it.

Discarding keeps the compiled shape identical to the pre-parameterized one: one body serves every instantiation, the existing run-time system needs no change, and code compiled before the feature can still call, and be called by, parameterized code.

Construction has to name a concrete type at the point it happens: what to allocate and how to initialise it. A placeholder names none of that once the argument is discarded, and nothing promises the argument can be built at all.

A toolchain can generate a separate copy of the body for each type argument, with every operation resolved to a direct call, or compile one shared copy that receives the type's operations as a passed-in table and calls them indirectly.

The most specific matching definition wins. Where the type argument becomes known, every candidate whose pattern that argument satisfies is gathered, and the narrowest is selected; the general body is the fallback for arguments nothing narrower claims.

A shared container body is compiled once against one uniform slot shape — a reference — so an unboxed point cannot sit in the buffer directly. Each point becomes a separate heap object and the slot holds that object's address.

Per-argument body generation costs build time (a fresh compile per distinct argument), artifact size (every generated body ships), and instruction-cache pressure (more distinct code competing for the same cache). The gain is a direct, inlinable call with no run-time indirection.

Because which body runs is decided by what each call site statically knew about the type, not by the value. A site that fixed the argument takes the drifted body; a site still holding it generically can keep running the general one.

Only the value it was handed. A body that can neither inspect nor construct a value of an unknown type has no other value of that type in scope, so the one body that returns a result returns its argument.

Because the signature promised the same behaviour for every type a caller may name, and behaviour that depends on the choice makes that promise false for the rest. An unconstrained placeholder also declares no capability, so there is usually nothing to branch on.

The caller fixes it, independently at every call site. A universally quantified signature promises the same behaviour for every type a caller may name, so the implementation is written once and has to hold for all of them.

Its type parameter must itself take a type argument: it stands for a wrapper, not for a finished type. Such a parameter is higher-kinded, and its kind records how many arguments it still expects before it names a type.

They normalise every stage result onto one chosen wrapper at the boundary, encode the wrapper as a marker type with lift and lower conversions, or generate the per-wrapper copies from a single source. Each trades the missing abstraction for a different cost.