kopscript 0.11.0 → 0.12.0

package/LLM.md

@@ -133,8 +133,8 @@ Dog d = new Dog("Rex");
   the interface in the base list and provide matching public methods, checked at compile time.
 - No nested classes/functions.
 - No multiple inheritance (at most one class in the base list; the rest must be interfaces).
-- `class Box<T> { ... }` — a single type parameter is allowed; see Generics below for the
-  full (deliberately scoped-down) rules.
+- `class Box<T> { ... }` / `class Pair<K, V> { ... }` — one or more type parameters are
+  allowed; see Generics below for the full (deliberately scoped-down) rules.
 
 ### Interfaces
 
@@ -145,7 +145,7 @@ interface IShape {
 interface INamedShape : IShape { // interfaces can extend other interfaces (not classes)
   string GetName();
 }
-interface IContainer<T> {      // interfaces take a single type parameter too — see Generics
+interface IContainer<T> {      // interfaces take type parameters too — see Generics
   T Get();
 }
 ```
@@ -281,7 +281,7 @@ Not a use of user-declared generics (see below) — `state<T>` is one of exactly
 hardcoded parametrized forms in the type system (the other is `task<T>`), each with only
 ever one built-in meaning, unlike a real generic class/interface.
 
-## Generics — a single type parameter on classes/interfaces
+## Generics — one or more type parameters on classes/interfaces
 
 ```ks
 class Box<T> {
@@ -293,34 +293,46 @@ class Box<T> {
 Box<number> nb = new Box<number>(5);   // type argument required on both the type AND `new`
 Box<string> sb = new Box<string>("hi");
 print(nb.Get());                        // 5
+
+class Pair<K, V> {
+  public K First;
+  public V Second;
+  constructor(K k, V v) { this.First = k; this.Second = v; }
+}
+
+Pair<number, string> p = new Pair<number, string>(1, "a");
 ```
 
-One unconstrained, invariant type parameter per class/interface (real *or* `extern` — see
-the `extern` section below) — the whole feature.
+One or more unconstrained, invariant type parameters per class/interface (real *or*
+`extern` — see the `extern` section below), comma-separated: `<T>`, `<K, V>`, `<A, B, C>`,
+however many the declaration needs.
 Erased at codegen (JS has no generics either; `Box<number>` and `Box<string>` both
 compile to the exact same plain `class Box`), so there's no runtime cost and no way to
-inspect `T` at runtime.
+inspect a type parameter at runtime.
 
 **Rules:**
-- The type argument is **required everywhere** a generic type is named — on the variable
-  type (`Box<number>`) and separately on `new` (`new Box<number>(...)`); a bare `Box` (no
-  argument) is a compile error, not "any"/inferred.
-- **Invariant**: `Box<Dog>` is not assignable to `Box<Animal>` even if `Dog : Animal` —
-  type arguments must match exactly, not just be compatible.
-- Nesting works: `Box<Box<number>>`, `Box<number[]>`, `Box<number>?`, `Box<number>?[]`.
-- Inside the class/interface's own body, `T` is fully abstract — you can store it, return
-  it, pass it around, but (unconstrained) you **cannot call any member on a bare `T`
-  value** (`this.value.Foo()` is a compile error: "Cannot access member 'Foo' on type
-  'T'"). This is correct, not a bug — same as an unconstrained type parameter in
-  C#/Java/TypeScript.
+- The type argument(s) are **required everywhere** a generic type is named — on the
+  variable type (`Box<number>`) and separately on `new` (`new Box<number>(...)`); a bare
+  `Box`/`Pair` (no arguments) is a compile error, not "any"/inferred. The count must match
+  the declaration exactly — `Pair<number>` (too few) and `Pair<number, string, bool>` (too
+  many) are both arity errors, not truncated/padded.
+- **Invariant, per slot**: `Box<Dog>` is not assignable to `Box<Animal>` even if `Dog :
+  Animal`, and `Pair<number, string>` is not assignable to `Pair<string, number>` — every
+  type argument must match exactly, in the same position, not just be compatible.
+- Nesting works: `Box<Box<number>>`, `Box<number[]>`, `Box<number>?`, `Box<number>?[]`,
+  `Pair<number, Pair<string, bool>>`.
+- Inside the class/interface's own body, each type parameter is fully abstract — you can
+  store it, return it, pass it around, but (unconstrained) you **cannot call any member on
+  a bare type-parameter value** (`this.value.Foo()` where `value: T` is a compile error:
+  "Cannot access member 'Foo' on type 'T'"). This is correct, not a bug — same as an
+  unconstrained type parameter in C#/Java/TypeScript.
 
 **Does not exist (v1 scope cuts, each deliberate)**:
 - **Generic functions.** `T Identity<T>(T x)` doesn't parse — only classes and interfaces
-  take a type parameter, not free functions/methods themselves (a method *inside* a
-  generic class can use that class's own `T` freely, same as any other member).
-- **Multiple type parameters.** No `Map<K, V>` — exactly one `<T>` or none.
+  take type parameters, not free functions/methods themselves (a method *inside* a
+  generic class can use that class's own type parameters freely, same as any other member).
 - **Constraints.** No `T : IComparable` — a type parameter is always fully unconstrained,
-  which is why you can't call members on a bare `T` (see above).
+  which is why you can't call members on a bare one (see above).
 - **Generic inheritance.** A class/interface's base list can only name a *non-generic*
   type — `class Foo : Box<number>` and even `class Foo<T> : SomeGenericBase<T>` are both
   compile errors ("cannot extend/implement generic type '...' — not supported in v1"). A
@@ -493,9 +505,9 @@ Locals/params: **camelCase**. This is convention, not enforced by the compiler.
 
 ## Does not exist (don't reach for these)
 
-Generics beyond a single unconstrained type parameter (no `Map<K, V>`, no `T : IFoo`
-constraints, no generic functions, no generic inheritance, no variance — see Generics
-above for what *is* supported) · `any`/`unknown` annotations ·
+Generics beyond one or more unconstrained type parameters (no `T : IFoo` constraints, no
+generic functions, no generic inheritance, no variance — see Generics above for what *is*
+supported) · `any`/`unknown` annotations ·
 a `let`/`var` keyword (locals are just `Type name = value;`) · decorators/annotations ·
 reflection · type inference on declarations · ternary expression · union/tuple types ·
 **object-literal syntax** (`{ key: value }` as a value — this doesn't exist *anywhere* in

package/README.md

@@ -22,9 +22,9 @@ LLM's context, as opposed to this README's narrative explanation.
   explicit `virtual`/`override` dispatch (methods are sealed unless marked `virtual`), and a full
   `public`/`protected`/`private` access model enforced at compile time.
 - **Strongly typed**: every declaration is explicitly typed and checked at compile time.
-- **Generics**: a single, unconstrained, invariant type parameter on classes and
-  interfaces (`class Box<T> { public T Value; }`) — erased at codegen with zero runtime
-  cost, the same way `task<T>`/`state<T>` already are.
+- **Generics**: one or more unconstrained, invariant type parameters on classes and
+  interfaces (`class Box<T> { public T Value; }`, `class Pair<K, V> { ... }`) — erased at
+  codegen with zero runtime cost, the same way `task<T>`/`state<T>` already are.
 - **Nullable types with compiler-enforced null-checking**: `T?` (`string?`, `Dog?`,
   `number[]?`) — a `T?` can't be used where a `T` is expected without an `if (x != null)`
   check first (checked statically, not just at runtime), and comparing a value that can
@@ -221,7 +221,7 @@ void Announce(ISpeaker s) {
 
 ### Generics
 
-Classes and interfaces can take a single type parameter:
+Classes and interfaces can take one or more type parameters:
 
 ```ks
 class Box<T> {
@@ -233,34 +233,45 @@ class Box<T> {
 Box<number> nb = new Box<number>(5);
 Box<string> sb = new Box<string>("hi");
 print(nb.Get());   // 5
+
+class Pair<K, V> {
+  public K First;
+  public V Second;
+  constructor(K k, V v) { this.First = k; this.Second = v; }
+}
+
+Pair<number, string> p = new Pair<number, string>(1, "a");
 ```
 
-The type argument is required everywhere the generic type is named — on the variable's
+The type argument(s) are required everywhere the generic type is named — on the variable's
 declared type *and* separately on `new` (`Box<number> nb = new Box<number>(5);`, not
-just one or the other). Generics are erased at codegen exactly like `task<T>`/`state<T>`
-already are — `Box<number>` and `Box<string>` compile to the identical plain `class Box`,
-so there's no runtime cost.
-
-This is deliberately the smallest useful slice of generics, not a scaled-down promise of
-more later inside v1:
-
-- **One type parameter, invariant, unconstrained.** No `Map<K, V>` (multiple parameters),
-  no `T : ISomething` (constraints) — and because `T` is fully unconstrained, you can't
-  call any member on a bare `T` value inside the generic class's own body (that's correct
-  behavior, the same restriction C#/Java/TypeScript put on an unconstrained parameter, not
-  a bug). Invariant means `Box<Dog>` is **not** assignable to `Box<Animal>` even though
-  `Dog : Animal` — type arguments must match exactly.
+just one or the other) — and the count must match the declaration exactly (`Pair<number>`
+alone, or `Pair<number, string, bool>`, are both arity errors). Generics are erased at
+codegen exactly like `task<T>`/`state<T>` already are — `Box<number>` and `Box<string>`
+compile to the identical plain `class Box`, so there's no runtime cost.
+
+Still a deliberately small slice of generics, not a scaled-down promise of more later
+inside v1:
+
+- **Invariant, unconstrained.** No `T : ISomething` (constraints) — and because a type
+  parameter is fully unconstrained, you can't call any member on a bare `T`/`K`/`V` value
+  inside the generic class's own body (that's correct behavior, the same restriction
+  C#/Java/TypeScript put on an unconstrained parameter, not a bug). Invariant means
+  `Box<Dog>` is **not** assignable to `Box<Animal>` even though `Dog : Animal`, and
+  `Pair<number, string>` is not assignable to `Pair<string, number>` — every slot must
+  match exactly, in order.
 - **No generic functions.** `T Identity<T>(T x)` isn't supported — only classes and
-  interfaces take a type parameter. A method *inside* a generic class can still use that
-  class's own `T` freely; it's just not introducing a type parameter of its own.
+  interfaces take type parameters. A method *inside* a generic class can still use that
+  class's own type parameters freely; it's just not introducing one of its own.
 - **No generic inheritance.** A class or interface's base list can only name a
   *non-generic* type. `class Foo : Box<number>` and `class Foo<T> : SomeBase<T>` are both
   compile errors — a generic class can still extend/implement ordinary non-generic bases
   normally, it just can't be the one on either side of a generic base relationship.
 
 See `LLM.md`'s "Generics" section for the exhaustive rules if you're generating code
-against this — nested generics (`Box<Box<number>>`, `Box<number>?[]`) and generic
-interfaces used as standalone parameter types both work and are covered there.
+against this — nested generics (`Box<Box<number>>`, `Box<number>?[]`, `Pair<number,
+Pair<string, bool>>`) and generic interfaces used as standalone parameter types both work
+and are covered there.
 
 ### Enums
 
@@ -359,11 +370,11 @@ consumes `Component`/`Router` themselves via `extern class ... from "kopular/...
 proving `extern` works as a real cross-*package* boundary, not just for describing DOM
 globals within a single project.
 
-An `extern class` can carry its own type parameter, `extern class Box<T> { ... }` —
-exactly the same single-type-parameter rules as a real generic class (see "Generics"
-above: invariant, unconstrained, erased, can't appear in a base list), so a generic type
-from another package (e.g. Kopular's `FormField<T>`) can be described and instantiated
-generically, not just per concrete type:
+An `extern class` can carry its own type parameter(s), `extern class Box<T> { ... }` or
+`extern class Pair<K, V> { ... }` — exactly the same rules as a real generic class (see
+"Generics" above: invariant, unconstrained, erased, can't appear in a base list), so a
+generic type from another package (e.g. Kopular's `FormField<T>`) can be described and
+instantiated generically, not just per concrete type:
 
 ```ks
 extern class Box<T> {

package/dist/checker.js

@@ -56,11 +56,13 @@ export class Checker {
         this.functions = new Map();
         this.externValues = new Map();
         this.namedTypes = new Map();
-        // className/interfaceName -> its type parameter's name (e.g. "Box" -> "T"),
-        // for every generic class/interface — populated up front, before any type
-        // resolution runs, specifically so a forward reference (class A's field
-        // referencing generic class B, declared later in the same file) still
-        // resolves B's genericity correctly. See resolveType/validateGenericArity.
+        // className/interfaceName -> its type parameters' names, in declared order
+        // (e.g. "Pair" -> ["K", "V"]), for every generic class/interface —
+        // populated up front, before any type resolution runs, specifically so a
+        // forward reference (class A's field referencing generic class B, declared
+        // later in the same file) still resolves B's genericity correctly. Also
+        // doubles as the arity table (its length is how many type arguments a
+        // reference to that name must supply). See resolveType/validateGenericArity.
         this.genericTypeParams = new Map();
         this.importedNames = new Set();
         this.rawContents = new Map();
@@ -73,13 +75,13 @@ export class Checker {
         }
         for (const [name, info] of this.imports.classes) {
             this.classes.set(name, info);
-            if (info.typeParam)
-                this.genericTypeParams.set(name, info.typeParam);
+            if (info.typeParams.length > 0)
+                this.genericTypeParams.set(name, info.typeParams);
         }
         for (const [name, info] of this.imports.interfaces) {
             this.interfaces.set(name, info);
-            if (info.typeParam)
-                this.genericTypeParams.set(name, info.typeParam);
+            if (info.typeParams.length > 0)
+                this.genericTypeParams.set(name, info.typeParams);
         }
         for (const [name, info] of this.imports.enums)
             this.enums.set(name, info);
@@ -109,14 +111,14 @@ export class Checker {
         for (const c of externClassDecls)
             this.namedTypes.set(c.name, "class");
         for (const c of classDecls)
-            if (c.typeParam)
-                this.genericTypeParams.set(c.name, c.typeParam);
+            if (c.typeParams.length > 0)
+                this.genericTypeParams.set(c.name, c.typeParams.map((p) => p.name));
         for (const i of interfaceDecls)
-            if (i.typeParam)
-                this.genericTypeParams.set(i.name, i.typeParam);
+            if (i.typeParams.length > 0)
+                this.genericTypeParams.set(i.name, i.typeParams.map((p) => p.name));
         for (const c of externClassDecls)
-            if (c.typeParam)
-                this.genericTypeParams.set(c.name, c.typeParam);
+            if (c.typeParams.length > 0)
+                this.genericTypeParams.set(c.name, c.typeParams.map((p) => p.name));
         for (const e of enumDecls)
             this.registerEnum(e);
         for (const i of interfaceDecls)
@@ -172,11 +174,11 @@ export class Checker {
         });
     }
     registerExternClass(decl) {
-        // Same withTypeParamInScope treatment registerClass gives a real class's
-        // signature (fields/methods/ctor params) — an extern class's own `T`
-        // needs to resolve the same way while its declared members are being
-        // resolved, e.g. `state<T> Value;` in an `extern class FormField<T>`.
-        const { fields, staticFields, methods, staticMethods, ownCtorParams } = this.withTypeParamInScope(decl.typeParam, () => {
+        // Same withTypeParamsInScope treatment registerClass gives a real class's
+        // signature (fields/methods/ctor params) — an extern class's own type
+        // params need to resolve the same way while its declared members are
+        // being resolved, e.g. `state<T> Value;` in an `extern class FormField<T>`.
+        const { fields, staticFields, methods, staticMethods, ownCtorParams } = this.withTypeParamsInScope(decl.typeParams, () => {
             const fields = new Map();
             const staticFields = new Map();
             for (const p of decl.properties) {
@@ -200,7 +202,7 @@ export class Checker {
         });
         this.classes.set(decl.name, {
             name: decl.name,
-            typeParam: decl.typeParam,
+            typeParams: decl.typeParams.map((p) => p.name),
             superclass: null,
             interfaces: [],
             fields,
@@ -341,8 +343,9 @@ export class Checker {
         });
         if (!resolved) {
             const name = node.kind === "NamedType" ? node.name : "[]";
-            if (name !== "[]" && this.genericTypeParams.has(name) && !node.typeArgs) {
-                this.diagnostics.error("KS4007", `Generic type '${name}' requires a type argument (e.g. '${name}<T>')`, line, col);
+            const declaredParams = this.genericTypeParams.get(name);
+            if (name !== "[]" && declaredParams && !node.typeArgs) {
+                this.diagnostics.error("KS4007", `Generic type '${name}' requires ${this.describeArity(declaredParams)} (e.g. '${name}<${declaredParams.join(", ")}>')`, line, col);
             }
             else {
                 this.diagnostics.error("KS4008", `Unknown type '${name}'`, line, col);
@@ -378,70 +381,80 @@ export class Checker {
                 return;
             case "class":
             case "interface": {
-                const isGeneric = this.genericTypeParams.has(type.name);
-                if (isGeneric && !type.typeArg) {
-                    this.diagnostics.error("KS4009", `Generic type '${type.name}' requires a type argument (e.g. '${type.name}<T>')`, line, col);
+                const declaredParams = this.genericTypeParams.get(type.name);
+                const suppliedCount = type.typeArgs?.length ?? 0;
+                if (declaredParams && suppliedCount === 0) {
+                    this.diagnostics.error("KS4009", `Generic type '${type.name}' requires ${this.describeArity(declaredParams)} (e.g. '${type.name}<${declaredParams.join(", ")}>')`, line, col);
                 }
-                else if (!isGeneric && type.typeArg) {
+                else if (!declaredParams && suppliedCount > 0) {
                     this.diagnostics.error("KS4010", `Type '${type.name}' is not generic — it doesn't take a type argument`, line, col);
                 }
-                if (type.typeArg)
-                    this.validateGenericArity(type.typeArg, line, col);
+                else if (declaredParams && suppliedCount > 0 && suppliedCount !== declaredParams.length) {
+                    this.diagnostics.error("KS4090", `Type '${type.name}' expects ${this.describeArity(declaredParams)}, got ${suppliedCount}`, line, col);
+                }
+                type.typeArgs?.forEach((a) => this.validateGenericArity(a, line, col));
                 return;
             }
             default:
                 return;
         }
     }
-    // Temporarily makes `name` (a class/interface's own type parameter, e.g.
-    // "T") resolve as a TypeParamType, for the duration of `fn` — used only
-    // while registering that class/interface's own declaration (fields,
-    // methods, ctor params), so `T Value;` resolves correctly. Scoped this
-    // narrowly (set, run, delete/restore) rather than left in `namedTypes`
-    // permanently, since it's only ever meaningful inside that one
-    // declaration's own body.
-    withTypeParamInScope(typeParam, fn) {
-        if (!typeParam)
+    describeArity(params) {
+        return params.length === 1 ? "a type argument" : `${params.length} type arguments`;
+    }
+    // Temporarily makes each of `typeParams` (a class/interface/function's own
+    // type parameters, e.g. ["K", "V"]) resolve as a TypeParamType, for the
+    // duration of `fn` — used only while registering that declaration's own
+    // signature (fields, methods, ctor/function params), so `T Value;`/`K
+    // key;` resolve correctly. Scoped this narrowly (set, run, delete/
+    // restore) rather than left in `namedTypes` permanently, since it's only
+    // ever meaningful inside that one declaration's own body.
+    withTypeParamsInScope(typeParams, fn) {
+        if (typeParams.length === 0)
             return fn();
-        const previous = this.namedTypes.get(typeParam);
-        this.namedTypes.set(typeParam, "typeParam");
+        const previous = typeParams.map((p) => this.namedTypes.get(p.name));
+        for (const p of typeParams)
+            this.namedTypes.set(p.name, "typeParam");
         try {
             return fn();
         }
         finally {
-            if (previous === undefined)
-                this.namedTypes.delete(typeParam);
-            else
-                this.namedTypes.set(typeParam, previous);
-        }
-    }
-    // Replaces every occurrence of the class/interface's own type parameter
-    // (by name) inside `type` with `arg` — the substitution step that turns
-    // Box<T>'s abstractly-stored field type `T` into `number` when someone
-    // actually asks about `Box<number>.Value`. A type with no occurrence of
-    // `paramName` anywhere in it is returned unchanged (including every
-    // non-generic type, the overwhelming majority).
-    substituteTypeParam(type, paramName, arg) {
+            typeParams.forEach((p, i) => {
+                const prev = previous[i];
+                if (prev === undefined)
+                    this.namedTypes.delete(p.name);
+                else
+                    this.namedTypes.set(p.name, prev);
+            });
+        }
+    }
+    // Replaces every occurrence of a type parameter named in `bindings`
+    // (mapping name -> concrete Type) inside `type` — the substitution step
+    // that turns Pair<K, V>'s abstractly-stored field type `K` into `number`
+    // when someone actually asks about `Pair<number, string>.First`. A type
+    // with none of `bindings`' names occurring anywhere in it is returned
+    // unchanged (including every non-generic type, the overwhelming majority).
+    substituteTypeParams(type, bindings) {
         switch (type.kind) {
             case "typeParam":
-                return type.name === paramName ? arg : type;
+                return bindings.get(type.name) ?? type;
             case "array":
-                return T.arrayOf(this.substituteTypeParam(type.element, paramName, arg));
+                return T.arrayOf(this.substituteTypeParams(type.element, bindings));
             case "nullable":
-                return T.nullableOf(this.substituteTypeParam(type.inner, paramName, arg));
+                return T.nullableOf(this.substituteTypeParams(type.inner, bindings));
             case "task":
-                return T.taskType(this.substituteTypeParam(type.resultType, paramName, arg));
+                return T.taskType(this.substituteTypeParams(type.resultType, bindings));
             case "state":
-                return T.stateType(this.substituteTypeParam(type.valueType, paramName, arg));
+                return T.stateType(this.substituteTypeParams(type.valueType, bindings));
             case "function":
-                return T.functionType(type.params.map((p) => this.substituteTypeParam(p, paramName, arg)), this.substituteTypeParam(type.returnType, paramName, arg));
-            // A nested generic's own type argument can itself mention the outer
-            // T (`Box<T[]>`'s field being List<T> — a v1 corner case, but cheap
-            // to handle correctly): substitute inside it too.
+                return T.functionType(type.params.map((p) => this.substituteTypeParams(p, bindings)), this.substituteTypeParams(type.returnType, bindings));
+            // A nested generic's own type arguments can themselves mention an
+            // outer type param (`Pair<K, V>`'s field being List<K> — a v1 corner
+            // case, but cheap to handle correctly): substitute inside each.
             case "class":
-                return type.typeArg ? T.classType(type.name, this.substituteTypeParam(type.typeArg, paramName, arg)) : type;
+                return type.typeArgs ? T.classType(type.name, type.typeArgs.map((a) => this.substituteTypeParams(a, bindings))) : type;
             case "interface":
-                return type.typeArg ? T.interfaceType(type.name, this.substituteTypeParam(type.typeArg, paramName, arg)) : type;
+                return type.typeArgs ? T.interfaceType(type.name, type.typeArgs.map((a) => this.substituteTypeParams(a, bindings))) : type;
             default:
                 return type;
         }
@@ -459,7 +472,7 @@ export class Checker {
         this.recordHover(decl.line, decl.col, `enum ${decl.name}`);
     }
     registerInterface(decl) {
-        const methods = this.withTypeParamInScope(decl.typeParam, () => decl.methods.map((m) => {
+        const methods = this.withTypeParamsInScope(decl.typeParams, () => decl.methods.map((m) => {
             const params = m.params.map((p) => this.resolveType(p.type, m.line, m.col));
             const returnType = this.resolveType(m.returnType, m.line, m.col);
             this.recordHover(m.nameLine, m.nameCol, `${m.name}(${params.map(T.typeToString).join(", ")}): ${T.typeToString(returnType)}`);
@@ -480,8 +493,8 @@ export class Checker {
             }
             bases.push(baseName);
         }
-        this.interfaces.set(decl.name, { name: decl.name, typeParam: decl.typeParam, bases, methods });
-        this.recordHover(decl.line, decl.col, decl.typeParam ? `interface ${decl.name}<${decl.typeParam}>` : `interface ${decl.name}`);
+        this.interfaces.set(decl.name, { name: decl.name, typeParams: decl.typeParams.map((p) => p.name), bases, methods });
+        this.recordHover(decl.line, decl.col, decl.typeParams.length > 0 ? `interface ${decl.name}<${decl.typeParams.map((p) => p.name).join(", ")}>` : `interface ${decl.name}`);
     }
     checkInterfaceHierarchy(decl) {
         const info = this.interfaces.get(decl.name);
@@ -524,8 +537,8 @@ export class Checker {
         return info.bases.some((b) => this.interfaceExtends(b, sup));
     }
     registerClass(decl) {
-        this.recordHover(decl.line, decl.col, decl.typeParam ? `class ${decl.name}<${decl.typeParam}>` : `class ${decl.name}`);
-        const { fields, staticFields, methods, staticMethods, ownCtorParams } = this.withTypeParamInScope(decl.typeParam, () => {
+        this.recordHover(decl.line, decl.col, decl.typeParams.length > 0 ? `class ${decl.name}<${decl.typeParams.map((p) => p.name).join(", ")}>` : `class ${decl.name}`);
+        const { fields, staticFields, methods, staticMethods, ownCtorParams } = this.withTypeParamsInScope(decl.typeParams, () => {
             const fields = new Map();
             const staticFields = new Map();
             for (const f of decl.fields) {
@@ -584,7 +597,7 @@ export class Checker {
         }
         this.classes.set(decl.name, {
             name: decl.name,
-            typeParam: decl.typeParam,
+            typeParams: decl.typeParams.map((p) => p.name),
             superclass,
             interfaces,
             fields,
@@ -825,11 +838,11 @@ export class Checker {
     // only ever arises from an arity error already diagnosed at the
     // reference site — see validateGenericArity).
     typeArgsMatch(a, b) {
-        if (!a.typeArg && !b.typeArg)
+        if (!a.typeArgs && !b.typeArgs)
             return true;
-        if (!a.typeArg || !b.typeArg)
+        if (!a.typeArgs || !b.typeArgs || a.typeArgs.length !== b.typeArgs.length)
             return false;
-        return T.typesEqual(a.typeArg, b.typeArg);
+        return a.typeArgs.every((t, i) => T.typesEqual(t, b.typeArgs[i]));
     }
     // ---------- top-level ----------
     // Validates that `isAsync` and the declared return type agree — `async`
@@ -867,12 +880,12 @@ export class Checker {
     }
     checkClassBody(decl) {
         // Constructor/method *bodies* run in this same scope registerClass used
-        // for the *signatures* (see withTypeParamInScope) — without it, `T`
+        // for the *signatures* (see withTypeParamsInScope) — without it, `T`
         // resolves everywhere in a generic class's declared field/param/return
         // types but not inside a method body itself (a local `T x = ...;`, or a
         // lambda parameter typed `T`), which would make the type parameter
         // usable only at the class's boundary and not inside its own logic.
-        this.withTypeParamInScope(decl.typeParam, () => this.checkClassBodyInner(decl));
+        this.withTypeParamsInScope(decl.typeParams, () => this.checkClassBodyInner(decl));
     }
     checkClassBodyInner(decl) {
         const info = this.classes.get(decl.name);
@@ -1461,30 +1474,34 @@ export class Checker {
             expr.args.forEach((a) => this.checkExpression(a, scope, ctx));
             return T.UNKNOWN;
         }
-        let typeArg;
-        if (info.typeParam && !expr.typeArgs) {
-            this.diagnostics.error("KS4069", `Generic class '${expr.className}' requires a type argument (e.g. 'new ${expr.className}<T>(...)')`, expr.line, expr.col);
+        let typeArgs;
+        if (info.typeParams.length > 0 && !expr.typeArgs) {
+            this.diagnostics.error("KS4069", `Generic class '${expr.className}' requires ${this.describeArity(info.typeParams)} (e.g. 'new ${expr.className}<${info.typeParams.join(", ")}>(...)')`, expr.line, expr.col);
             // Abstractly-typed (T-containing) ctor params, un-substitutable
-            // without a real type argument, would otherwise cascade into a
+            // without real type arguments, would otherwise cascade into a
             // confusing "expected 'T'" error on every argument — one clear error
             // beats that pile-on.
             expr.args.forEach((a) => this.checkExpression(a, scope, ctx));
             return T.UNKNOWN;
         }
-        if (!info.typeParam && expr.typeArgs) {
+        if (info.typeParams.length === 0 && expr.typeArgs) {
             this.diagnostics.error("KS4070", `Class '${expr.className}' is not generic — it doesn't take a type argument`, expr.line, expr.col);
             expr.args.forEach((a) => this.checkExpression(a, scope, ctx));
             return T.UNKNOWN;
         }
-        if (info.typeParam && expr.typeArgs) {
-            typeArg = this.resolveType(expr.typeArgs[0], expr.line, expr.col);
+        if (info.typeParams.length > 0 && expr.typeArgs) {
+            if (expr.typeArgs.length !== info.typeParams.length) {
+                this.diagnostics.error("KS4091", `Generic class '${expr.className}' expects ${this.describeArity(info.typeParams)}, got ${expr.typeArgs.length}`, expr.line, expr.col);
+                expr.args.forEach((a) => this.checkExpression(a, scope, ctx));
+                return T.UNKNOWN;
+            }
+            typeArgs = expr.typeArgs.map((a) => this.resolveType(a, expr.line, expr.col));
         }
-        this.recordHover(expr.line, expr.col, typeArg ? `class ${expr.className}<${T.typeToString(typeArg)}>` : `class ${expr.className}`);
+        this.recordHover(expr.line, expr.col, typeArgs ? `class ${expr.className}<${typeArgs.map(T.typeToString).join(", ")}>` : `class ${expr.className}`);
         let ctorParams = this.lookupCtorParams(expr.className);
-        if (info.typeParam && typeArg) {
-            const paramName = info.typeParam;
-            const arg = typeArg;
-            ctorParams = ctorParams.map((p) => this.substituteTypeParam(p, paramName, arg));
+        if (info.typeParams.length > 0 && typeArgs) {
+            const bindings = new Map(info.typeParams.map((name, i) => [name, typeArgs[i]]));
+            ctorParams = ctorParams.map((p) => this.substituteTypeParams(p, bindings));
         }
         if (expr.args.length !== ctorParams.length) {
             this.diagnostics.error("KS4071", `Expected ${ctorParams.length} constructor argument(s), got ${expr.args.length}`, expr.line, expr.col);
@@ -1496,7 +1513,7 @@ export class Checker {
                 this.diagnostics.error("KS4072", `Constructor argument ${i + 1} has type '${T.typeToString(argType)}', expected '${T.typeToString(expected)}'`, arg.line, arg.col);
             }
         });
-        return T.classType(expr.className, typeArg);
+        return T.classType(expr.className, typeArgs);
     }
     lookupCtorParams(className) {
         let current = className;
@@ -1649,9 +1666,10 @@ export class Checker {
             // v1 has no generic inheritance (a generic class's base list can only
             // name non-generic types), so a member found on a generic instance
             // was always declared directly on that same class — substituting by
-            // its own type parameter, not some ancestor's, is always correct.
-            const paramName = objectType.typeArg ? this.genericTypeParams.get(objectType.name) : undefined;
-            const substitute = (type) => (paramName && objectType.typeArg ? this.substituteTypeParam(type, paramName, objectType.typeArg) : type);
+            // its own type parameters, not some ancestor's, is always correct.
+            const declaredParams = objectType.typeArgs ? this.genericTypeParams.get(objectType.name) : undefined;
+            const bindings = declaredParams && objectType.typeArgs ? new Map(declaredParams.map((name, i) => [name, objectType.typeArgs[i]])) : null;
+            const substitute = (type) => (bindings ? this.substituteTypeParams(type, bindings) : type);
             const field = this.lookupField(objectType.name, expr.property);
             if (field) {
                 this.checkAccessibility(field.info.visibility, field.owner, ctx, expr.property, expr.line, expr.col);
@@ -1666,7 +1684,7 @@ export class Checker {
             const method = this.lookupMethod(objectType.name, expr.property);
             if (method) {
                 this.checkAccessibility(method.info.visibility, method.owner, ctx, expr.property, expr.line, expr.col);
-                const info = paramName ? { ...method.info, params: method.info.params.map(substitute), returnType: substitute(method.info.returnType) } : method.info;
+                const info = bindings ? { ...method.info, params: method.info.params.map(substitute), returnType: substitute(method.info.returnType) } : method.info;
                 return { type: info.returnType, methodInfo: info };
             }
             this.diagnostics.error("KS4083", `Class '${objectType.name}' has no member '${expr.property}'`, expr.line, expr.col);
@@ -1678,8 +1696,9 @@ export class Checker {
                 // v1 has no generic interface inheritance either (same restriction
                 // as classes — see registerInterface), so a signature found here
                 // was always declared directly on this same interface.
-                const paramName = objectType.typeArg ? this.genericTypeParams.get(objectType.name) : undefined;
-                const substitute = (type) => (paramName && objectType.typeArg ? this.substituteTypeParam(type, paramName, objectType.typeArg) : type);
+                const declaredParams = objectType.typeArgs ? this.genericTypeParams.get(objectType.name) : undefined;
+                const bindings = declaredParams && objectType.typeArgs ? new Map(declaredParams.map((name, i) => [name, objectType.typeArgs[i]])) : null;
+                const substitute = (type) => (bindings ? this.substituteTypeParams(type, bindings) : type);
                 const params = sig.params.map(substitute);
                 const returnType = substitute(sig.returnType);
                 return { type: returnType, methodInfo: { params, returnType, visibility: "public", isVirtual: false, isOverride: false } };

package/dist/parser.js

@@ -243,20 +243,25 @@ export class Parser {
         this.consume(TokenKind.RParen, "Expected ')' after parameters");
         return params;
     }
-    // `<T>` right after a class/interface name — a single, unconstrained type
-    // parameter (v1 has no `Map<K, V>`, no `T : IFoo` constraints). Null if
-    // absent, the overwhelmingly common case.
-    parseOptionalTypeParam() {
+    // `<K, V>` right after a class/interface name — one or more type
+    // parameters, comma-separated. Empty array if absent, the overwhelmingly
+    // common case. Constraint syntax (`<T : IFoo>`) isn't parsed yet — every
+    // entry's `constraint` is always null for now (see AST.TypeParamDecl).
+    parseTypeParamList() {
         if (!this.match(TokenKind.Lt))
-            return null;
-        const name = this.consume(TokenKind.Identifier, "Expected a type parameter name").lexeme;
-        this.consume(TokenKind.Gt, "Expected '>' after type parameter");
-        return name;
+            return [];
+        const params = [];
+        do {
+            const nameTok = this.consume(TokenKind.Identifier, "Expected a type parameter name");
+            params.push({ name: nameTok.lexeme, constraint: null, line: nameTok.line, col: nameTok.col });
+        } while (this.match(TokenKind.Comma));
+        this.consume(TokenKind.Gt, "Expected '>' after type parameter list");
+        return params;
     }
     parseClassDecl(isExported) {
         const start = this.advance(); // 'class'
         const name = this.consume(TokenKind.Identifier, "Expected class name").lexeme;
-        const typeParam = this.parseOptionalTypeParam();
+        const typeParams = this.parseTypeParamList();
         const baseList = [];
         if (this.match(TokenKind.Colon)) {
             do {
@@ -412,12 +417,12 @@ export class Parser {
             }
         }
         this.consume(TokenKind.RBrace, "Expected '}' after class body");
-        return { kind: "ClassDecl", isExported, name, typeParam, baseList, fields, properties, constructor: ctor, methods, template, line: start.line, col: start.col };
+        return { kind: "ClassDecl", isExported, name, typeParams, baseList, fields, properties, constructor: ctor, methods, template, line: start.line, col: start.col };
     }
     parseInterfaceDecl(isExported) {
         const start = this.advance(); // 'interface'
         const name = this.consume(TokenKind.Identifier, "Expected interface name").lexeme;
-        const typeParam = this.parseOptionalTypeParam();
+        const typeParams = this.parseTypeParamList();
         const baseList = [];
         if (this.match(TokenKind.Colon)) {
             do {
@@ -443,7 +448,7 @@ export class Parser {
             });
         }
         this.consume(TokenKind.RBrace, "Expected '}' after interface body");
-        return { kind: "InterfaceDecl", isExported, name, typeParam, baseList, methods, line: start.line, col: start.col };
+        return { kind: "InterfaceDecl", isExported, name, typeParams, baseList, methods, line: start.line, col: start.col };
     }
     parseEnumDecl(isExported) {
         const start = this.advance(); // 'enum'
@@ -510,7 +515,7 @@ export class Parser {
     }
     parseExternClassBody(start, isExported) {
         const name = this.consume(TokenKind.Identifier, "Expected class name").lexeme;
-        const typeParam = this.parseOptionalTypeParam();
+        const typeParams = this.parseTypeParamList();
         this.consume(TokenKind.LBrace, "Expected '{' before extern class body");
         let hasConstructor = false;
         let ctorParams = [];
@@ -575,7 +580,7 @@ export class Parser {
         this.consume(TokenKind.RBrace, "Expected '}' after extern class body");
         const { modulePath, jsName } = this.parseExternTail(name);
         this.consume(TokenKind.Semicolon, "Expected ';' after extern class declaration");
-        return { kind: "ExternClassDecl", isExported, name, typeParam, jsName, hasConstructor, ctorParams, properties, methods, modulePath, line: start.line, col: start.col };
+        return { kind: "ExternClassDecl", isExported, name, typeParams, jsName, hasConstructor, ctorParams, properties, methods, modulePath, line: start.line, col: start.col };
     }
     parseBlock() {
         const start = this.consume(TokenKind.LBrace, "Expected '{'");
@@ -705,15 +710,18 @@ export class Parser {
         }
         else {
             const nameToken = this.check(TokenKind.Void) ? this.advance() : this.consume(TokenKind.Identifier, "Expected type name");
-            // `Box<number>` — a generic type reference. At most one type argument
-            // in v1 (matching ClassDecl/InterfaceDecl's single type parameter);
-            // whether `name` actually refers to a declared generic type is a
+            // `Pair<number, string>` — a generic type reference, comma-separated
+            // type arguments. Whether `name` actually refers to a declared
+            // generic type (and whether the count matches its arity) is a
             // semantic question the checker answers, not the parser.
             let typeArgs = null;
             if (this.check(TokenKind.Lt)) {
                 this.advance();
                 typeArgs = [this.parseType()];
-                this.consume(TokenKind.Gt, "Expected '>' after type argument");
+                while (this.match(TokenKind.Comma)) {
+                    typeArgs.push(this.parseType());
+                }
+                this.consume(TokenKind.Gt, "Expected '>' after type argument list");
             }
             type = { kind: "NamedType", name: nameToken.lexeme, typeArgs, line: nameToken.line, col: nameToken.col };
         }
@@ -893,14 +901,18 @@ export class Parser {
         if (this.check(TokenKind.New)) {
             this.advance();
             const className = this.consume(TokenKind.Identifier, "Expected class name after 'new'").lexeme;
-            // `new Box<number>(...)` — unambiguous here: `new <Identifier>` is
-            // always followed by `(`, generic type args or not, so seeing `<`
-            // instead can only mean a type argument list, never a comparison.
+            // `new Pair<number, string>(...)` — unambiguous here: `new
+            // <Identifier>` is always followed by `(`, generic type args or not,
+            // so seeing `<` instead can only mean a type argument list, never a
+            // comparison.
             let typeArgs = null;
             if (this.check(TokenKind.Lt)) {
                 this.advance();
                 typeArgs = [this.parseType()];
-                this.consume(TokenKind.Gt, "Expected '>' after type argument");
+                while (this.match(TokenKind.Comma)) {
+                    typeArgs.push(this.parseType());
+                }
+                this.consume(TokenKind.Gt, "Expected '>' after type argument list");
             }
             this.consume(TokenKind.LParen, "Expected '(' after class name");
             const args = [];

package/dist/printer.js

@@ -212,7 +212,7 @@ export class Printer {
     printClass(decl, indent) {
         const pad = indentStr(indent);
         const memberPad = indentStr(indent + 1);
-        const nameWithTypeParam = decl.typeParam ? `${decl.name}<${decl.typeParam}>` : decl.name;
+        const nameWithTypeParam = decl.typeParams.length > 0 ? `${decl.name}<${decl.typeParams.map((p) => p.name).join(", ")}>` : decl.name;
         const header = decl.baseList.length > 0 ? `class ${nameWithTypeParam} : ${decl.baseList.join(", ")} {` : `class ${nameWithTypeParam} {`;
         const prefix = decl.isExported ? "" : "private ";
         const memberParts = [];
@@ -250,7 +250,7 @@ export class Printer {
     printInterface(decl, indent) {
         const pad = indentStr(indent);
         const memberPad = indentStr(indent + 1);
-        const nameWithTypeParam = decl.typeParam ? `${decl.name}<${decl.typeParam}>` : decl.name;
+        const nameWithTypeParam = decl.typeParams.length > 0 ? `${decl.name}<${decl.typeParams.map((p) => p.name).join(", ")}>` : decl.name;
         const header = decl.baseList.length > 0 ? `interface ${nameWithTypeParam} : ${decl.baseList.join(", ")} {` : `interface ${nameWithTypeParam} {`;
         const prefix = decl.isExported ? "" : "private ";
         if (decl.methods.length === 0)
@@ -279,7 +279,7 @@ export class Printer {
         const pad = indentStr(indent);
         const memberPad = indentStr(indent + 1);
         const prefix = decl.isExported ? "" : "private ";
-        const nameWithTypeParam = decl.typeParam ? `${decl.name}<${decl.typeParam}>` : decl.name;
+        const nameWithTypeParam = decl.typeParams.length > 0 ? `${decl.name}<${decl.typeParams.map((p) => p.name).join(", ")}>` : decl.name;
         const lines = [];
         if (decl.hasConstructor)
             lines.push(`${memberPad}constructor(${this.printParams(decl.ctorParams)});`);

package/dist/types.js

@@ -6,11 +6,11 @@ export const UNKNOWN = { kind: "unknown" };
 export function arrayOf(element) {
     return { kind: "array", element };
 }
-export function classType(name, typeArg) {
-    return typeArg ? { kind: "class", name, typeArg } : { kind: "class", name };
+export function classType(name, typeArgs) {
+    return typeArgs && typeArgs.length > 0 ? { kind: "class", name, typeArgs } : { kind: "class", name };
 }
-export function interfaceType(name, typeArg) {
-    return typeArg ? { kind: "interface", name, typeArg } : { kind: "interface", name };
+export function interfaceType(name, typeArgs) {
+    return typeArgs && typeArgs.length > 0 ? { kind: "interface", name, typeArgs } : { kind: "interface", name };
 }
 export function typeParamType(name) {
     return { kind: "typeParam", name };
@@ -44,7 +44,7 @@ export function typeToString(t) {
             return t.name;
         case "class":
         case "interface":
-            return t.typeArg ? `${t.name}<${typeToString(t.typeArg)}>` : t.name;
+            return t.typeArgs && t.typeArgs.length > 0 ? `${t.name}<${t.typeArgs.map(typeToString).join(", ")}>` : t.name;
         case "function":
             return `(${t.params.map(typeToString).join(", ")}) => ${typeToString(t.returnType)}`;
         case "task":
@@ -91,31 +91,36 @@ export function resolveTypeNode(node, namedTypes, onNamedType) {
         const inner = resolveTypeNode(node.inner, namedTypes, onNamedType);
         return inner ? nullableOf(inner) : null;
     }
-    // At most one type argument in v1 — resolve it once, up front; a
-    // primitive/enum/type-param name below never accepts one (arity error,
-    // caught as a plain resolution failure here — a class/interface's own
-    // required-vs-supplied arity mismatch is a separate check the caller
-    // makes, since only it knows which names are actually declared generic).
-    let typeArg = null;
+    // Resolve every type argument given, in order — a primitive/enum/
+    // type-param name below never accepts any (arity error, caught as a plain
+    // resolution failure here). Arity *against a class/interface's own
+    // declared parameter count* is a separate check the caller makes, since
+    // only it knows which names are actually declared generic and with how
+    // many parameters (see Checker.validateGenericArity).
+    let typeArgs = null;
     if (node.typeArgs) {
-        typeArg = resolveTypeNode(node.typeArgs[0], namedTypes, onNamedType);
-        if (!typeArg)
-            return null;
+        typeArgs = [];
+        for (const argNode of node.typeArgs) {
+            const resolvedArg = resolveTypeNode(argNode, namedTypes, onNamedType);
+            if (!resolvedArg)
+                return null;
+            typeArgs.push(resolvedArg);
+        }
     }
     let resolved;
     if (PRIMITIVE_NAMES.has(node.name)) {
-        resolved = typeArg ? null : { kind: node.name };
+        resolved = typeArgs ? null : { kind: node.name };
     }
     else {
         const kind = namedTypes.get(node.name);
         if (kind === "class")
-            resolved = classType(node.name, typeArg ?? undefined);
+            resolved = classType(node.name, typeArgs ?? undefined);
         else if (kind === "interface")
-            resolved = interfaceType(node.name, typeArg ?? undefined);
+            resolved = interfaceType(node.name, typeArgs ?? undefined);
         else if (kind === "enum")
-            resolved = typeArg ? null : enumType(node.name);
+            resolved = typeArgs ? null : enumType(node.name);
         else if (kind === "typeParam")
-            resolved = typeArg ? null : typeParamType(node.name);
+            resolved = typeArgs ? null : typeParamType(node.name);
         else
             resolved = null;
     }
@@ -153,12 +158,12 @@ export function typesEqual(a, b) {
         const other = b;
         if (a.name !== other.name)
             return false;
-        if ("typeArg" in a || "typeArg" in other) {
-            const aArg = a.typeArg;
-            const bArg = other.typeArg;
-            if (!aArg || !bArg)
+        if ("typeArgs" in a || "typeArgs" in other) {
+            const aArgs = a.typeArgs;
+            const bArgs = other.typeArgs;
+            if (!aArgs || !bArgs || aArgs.length !== bArgs.length)
                 return false;
-            return typesEqual(aArg, bArg);
+            return aArgs.every((t, i) => typesEqual(t, bArgs[i]));
         }
         return true;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kopscript",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "KopScript: a small OOP, strongly-typed language that transpiles to JavaScript, with generics and nullable types",
   "type": "module",
   "license": "MIT",