GENERICS

  Records, unions, and free functions declare ordered type or integer

  parameters between `⟨` and `⟩`:

      union Maybe⟨T⟩ { None, Some(T) }

      record Buffer⟨const N: u32⟩ { data: [u8; N] }

      fn first⟨T⟩(left: T, right: T) -> T { return left; }

  Concrete data and function applications use the same syntax.

  Every concrete application reachable at run time must be covered by an

  explicit package-level monomorphization root and its dependency closure:

      instantiate Maybe⟨u32⟩, first⟨u32⟩;

  Rooted generic functions add generic callees and nested data applications to

  the specialization closure. For declarations with only type parameters,

  calls may omit the generic argument list when local parameter and result

  evidence selects one already-rooted specialization; inference never creates

  a root. Integer arguments are compile-time expressions. The compiler checks

  each argument against its parameter's declared type. A declaration with

  an integer parameter requires a complete argument list.

  Type parameters may have trait bounds. Calls through those bounds use

  static instance dispatch:

      trait Less { fn (&Less) less(other: &Self) -> bool; }

      fn minimum⟨T: Less⟩(a: T, b: T) -> T {

          if a.less(&b) { return a; }

          return b;

      }

  `Self` is the concrete instance type in trait signatures. Opaque trait

  objects remain dynamic. The compiler rejects traits whose `Self` usage is

  not object-safe. `instance` declares a trait implementation. `instantiate`

  requests generic monomorphization.

  Generic symbols follow ordinary module visibility. A root may reference an

  exported template in another module by its qualified name:

      use containers;

      instantiate containers::Maybe⟨u32⟩;

  Duplicate roots share one package-wide specialization.

  Unsupported by design: generic traits, instances, or methods; associated

  types; overlapping instances; user-defined specialization; arbitrary

  compile-time execution; inferred roots; and higher-kinded types. The compiler

  diagnoses wrong arity or argument kind, unsatisfied or ambiguous bounds,

  missing roots, incomplete or conflicting inference, recursive layout,

  expanding dependency chains, and implementation-limit overflow.