edict-lang 1.22.1 → 1.23.2

package/dist/browser-full.bundle.js

@@ -1,4 +1,4 @@
-// edict-lang v1.22.1 — browser-full bundle (phases 1-5, compile, execute, Z3 contracts)
+// edict-lang v1.23.2 — browser-full bundle (phases 1-5, compile, execute, Z3 contracts)
 // https://github.com/Sowiedu/Edict
 
 var __create = Object.create;
@@ -7817,7 +7817,7 @@ function unknownNodeKind(path, received, validKinds, suggestion) {
   return result;
 }
 function missingField(path, nodeId, field, expectedFormat, suggestion) {
-  const result = { error: "missing_field", path, nodeId, field, expectedFormat };
+  const result = { error: "missing_field", path, nodeId, field, expectedFormat, hint: "use edict_explain for repair context" };
   if (suggestion)
     result.suggestion = suggestion;
   return result;
@@ -8286,6 +8286,9 @@ var edict_schema_default = {
             },
             {
               $ref: "#/definitions/FreshnessType"
+            },
+            {
+              $ref: "#/definitions/TypeVarType"
             }
           ]
         },
@@ -8383,6 +8386,9 @@ var edict_schema_default = {
             },
             {
               $ref: "#/definitions/FreshnessType"
+            },
+            {
+              $ref: "#/definitions/TypeVarType"
             }
           ]
         }
@@ -8475,6 +8481,9 @@ var edict_schema_default = {
         },
         {
           $ref: "#/definitions/FreshnessType"
+        },
+        {
+          $ref: "#/definitions/TypeVarType"
         }
       ],
       properties: {
@@ -8493,7 +8502,8 @@ var edict_schema_default = {
             "confidence",
             "provenance",
             "capability",
-            "fresh"
+            "fresh",
+            "type_var"
           ]
         }
       }
@@ -8735,6 +8745,9 @@ var edict_schema_default = {
             },
             {
               $ref: "#/definitions/FreshnessType"
+            },
+            {
+              $ref: "#/definitions/TypeVarType"
             }
           ]
         }
@@ -8934,6 +8947,23 @@ var edict_schema_default = {
         "maxAge"
       ]
     },
+    TypeVarType: {
+      description: "Type variable \u2014 placeholder for a concrete type, resolved at call sites.\nUsed in polymorphic builtin signatures (e.g., array_get: Array<T> \u2192 T).\nCompile-time only \u2014 erased during type checking (unified with concrete types).\nNever appears in user-written ASTs; only in builtin type definitions.",
+      type: "object",
+      properties: {
+        kind: {
+          type: "string",
+          const: "type_var"
+        },
+        name: {
+          type: "string"
+        }
+      },
+      required: [
+        "kind",
+        "name"
+      ]
+    },
     Identifier: {
       type: "object",
       properties: {
@@ -9146,6 +9176,9 @@ var edict_schema_default = {
             },
             {
               $ref: "#/definitions/FreshnessType"
+            },
+            {
+              $ref: "#/definitions/TypeVarType"
             }
           ]
         },
@@ -10518,6 +10551,9 @@ var edict_fragment_schema_default = {
             },
             {
               $ref: "#/definitions/FreshnessType"
+            },
+            {
+              $ref: "#/definitions/TypeVarType"
             }
           ]
         },
@@ -10615,6 +10651,9 @@ var edict_fragment_schema_default = {
             },
             {
               $ref: "#/definitions/FreshnessType"
+            },
+            {
+              $ref: "#/definitions/TypeVarType"
             }
           ]
         }
@@ -10707,6 +10746,9 @@ var edict_fragment_schema_default = {
         },
         {
           $ref: "#/definitions/FreshnessType"
+        },
+        {
+          $ref: "#/definitions/TypeVarType"
         }
       ],
       properties: {
@@ -10725,7 +10767,8 @@ var edict_fragment_schema_default = {
             "confidence",
             "provenance",
             "capability",
-            "fresh"
+            "fresh",
+            "type_var"
           ]
         }
       }
@@ -10967,6 +11010,9 @@ var edict_fragment_schema_default = {
             },
             {
               $ref: "#/definitions/FreshnessType"
+            },
+            {
+              $ref: "#/definitions/TypeVarType"
             }
           ]
         }
@@ -11166,6 +11212,23 @@ var edict_fragment_schema_default = {
         "maxAge"
       ]
     },
+    TypeVarType: {
+      description: "Type variable \u2014 placeholder for a concrete type, resolved at call sites.\nUsed in polymorphic builtin signatures (e.g., array_get: Array<T> \u2192 T).\nCompile-time only \u2014 erased during type checking (unified with concrete types).\nNever appears in user-written ASTs; only in builtin type definitions.",
+      type: "object",
+      properties: {
+        kind: {
+          type: "string",
+          const: "type_var"
+        },
+        name: {
+          type: "string"
+        }
+      },
+      required: [
+        "kind",
+        "name"
+      ]
+    },
     Identifier: {
       type: "object",
       properties: {
@@ -11378,6 +11441,9 @@ var edict_fragment_schema_default = {
             },
             {
               $ref: "#/definitions/FreshnessType"
+            },
+            {
+              $ref: "#/definitions/TypeVarType"
             }
           ]
         },
@@ -13494,10 +13560,13 @@ var FLOAT_TYPE = { kind: "basic", name: "Float" };
 var STRING_TYPE = { kind: "basic", name: "String" };
 var BOOL_TYPE = { kind: "basic", name: "Bool" };
 var UNKNOWN_TYPE = { kind: "named", name: "unknown" };
-var ARRAY_INT_TYPE = { kind: "array", element: INT_TYPE };
-var OPTION_INT_TYPE = { kind: "option", inner: INT_TYPE };
-var RESULT_INT_TYPE = { kind: "result", ok: INT_TYPE, err: INT_TYPE };
 var RESULT_STRING_TYPE = { kind: "result", ok: STRING_TYPE, err: STRING_TYPE };
+var T_TYPE = { kind: "type_var", name: "T" };
+var E_TYPE = { kind: "type_var", name: "E" };
+var U_TYPE = { kind: "type_var", name: "U" };
+var ARRAY_T_TYPE = { kind: "array", element: T_TYPE };
+var OPTION_T_TYPE = { kind: "option", inner: T_TYPE };
+var RESULT_T_E_TYPE = { kind: "result", ok: T_TYPE, err: E_TYPE };
 
 // dist/builtins/host-helpers.js
 var EdictOomError = class extends Error {
@@ -15262,7 +15331,7 @@ function generateArraySort(mod) {
 var HOST_ARRAY_BUILTINS = [
   {
     name: "array_length",
-    type: { kind: "fn_type", params: [ARRAY_INT_TYPE], effects: ["pure"], returnType: INT_TYPE },
+    type: { kind: "fn_type", params: [ARRAY_T_TYPE], effects: ["pure"], returnType: INT_TYPE },
     impl: {
       kind: "host",
       factory: (ctx) => (arrPtr) => {
@@ -15272,7 +15341,7 @@ var HOST_ARRAY_BUILTINS = [
   },
   {
     name: "array_get",
-    type: { kind: "fn_type", params: [ARRAY_INT_TYPE, INT_TYPE], effects: ["pure"], returnType: INT_TYPE },
+    type: { kind: "fn_type", params: [ARRAY_T_TYPE, INT_TYPE], effects: ["pure"], returnType: T_TYPE },
     impl: {
       kind: "host",
       factory: (ctx) => (arrPtr, index) => {
@@ -15286,7 +15355,7 @@ var HOST_ARRAY_BUILTINS = [
   },
   {
     name: "array_set",
-    type: { kind: "fn_type", params: [ARRAY_INT_TYPE, INT_TYPE, INT_TYPE], effects: ["pure"], returnType: ARRAY_INT_TYPE },
+    type: { kind: "fn_type", params: [ARRAY_T_TYPE, INT_TYPE, T_TYPE], effects: ["pure"], returnType: ARRAY_T_TYPE },
     impl: {
       kind: "host",
       factory: (ctx) => (arrPtr, index, value) => {
@@ -15302,7 +15371,7 @@ var HOST_ARRAY_BUILTINS = [
   },
   {
     name: "array_push",
-    type: { kind: "fn_type", params: [ARRAY_INT_TYPE, INT_TYPE], effects: ["pure"], returnType: ARRAY_INT_TYPE },
+    type: { kind: "fn_type", params: [ARRAY_T_TYPE, T_TYPE], effects: ["pure"], returnType: ARRAY_T_TYPE },
     impl: {
       kind: "host",
       factory: (ctx) => (arrPtr, value) => {
@@ -15319,7 +15388,7 @@ var HOST_ARRAY_BUILTINS = [
   },
   {
     name: "array_pop",
-    type: { kind: "fn_type", params: [ARRAY_INT_TYPE], effects: ["pure"], returnType: ARRAY_INT_TYPE },
+    type: { kind: "fn_type", params: [ARRAY_T_TYPE], effects: ["pure"], returnType: ARRAY_T_TYPE },
     impl: {
       kind: "host",
       factory: (ctx) => (arrPtr) => {
@@ -15337,7 +15406,7 @@ var HOST_ARRAY_BUILTINS = [
   },
   {
     name: "array_concat",
-    type: { kind: "fn_type", params: [ARRAY_INT_TYPE, ARRAY_INT_TYPE], effects: ["pure"], returnType: ARRAY_INT_TYPE },
+    type: { kind: "fn_type", params: [ARRAY_T_TYPE, ARRAY_T_TYPE], effects: ["pure"], returnType: ARRAY_T_TYPE },
     impl: {
       kind: "host",
       factory: (ctx) => (aPtr, bPtr) => {
@@ -15357,7 +15426,7 @@ var HOST_ARRAY_BUILTINS = [
   },
   {
     name: "array_slice",
-    type: { kind: "fn_type", params: [ARRAY_INT_TYPE, INT_TYPE, INT_TYPE], effects: ["pure"], returnType: ARRAY_INT_TYPE },
+    type: { kind: "fn_type", params: [ARRAY_T_TYPE, INT_TYPE, INT_TYPE], effects: ["pure"], returnType: ARRAY_T_TYPE },
     impl: {
       kind: "host",
       factory: (ctx) => (arrPtr, start, end) => {
@@ -15375,7 +15444,7 @@ var HOST_ARRAY_BUILTINS = [
   },
   {
     name: "array_isEmpty",
-    type: { kind: "fn_type", params: [ARRAY_INT_TYPE], effects: ["pure"], returnType: BOOL_TYPE },
+    type: { kind: "fn_type", params: [ARRAY_T_TYPE], effects: ["pure"], returnType: BOOL_TYPE },
     impl: {
       kind: "host",
       factory: (ctx) => (arrPtr) => {
@@ -15385,7 +15454,7 @@ var HOST_ARRAY_BUILTINS = [
   },
   {
     name: "array_contains",
-    type: { kind: "fn_type", params: [ARRAY_INT_TYPE, INT_TYPE], effects: ["pure"], returnType: BOOL_TYPE },
+    type: { kind: "fn_type", params: [ARRAY_T_TYPE, T_TYPE], effects: ["pure"], returnType: BOOL_TYPE },
     impl: {
       kind: "host",
       factory: (ctx) => (arrPtr, value) => {
@@ -15401,7 +15470,7 @@ var HOST_ARRAY_BUILTINS = [
   },
   {
     name: "array_reverse",
-    type: { kind: "fn_type", params: [ARRAY_INT_TYPE], effects: ["pure"], returnType: ARRAY_INT_TYPE },
+    type: { kind: "fn_type", params: [ARRAY_T_TYPE], effects: ["pure"], returnType: ARRAY_T_TYPE },
     impl: {
       kind: "host",
       factory: (ctx) => (arrPtr) => {
@@ -15422,11 +15491,11 @@ var WASM_ARRAY_BUILTINS = [
     type: {
       kind: "fn_type",
       params: [
-        ARRAY_INT_TYPE,
-        { kind: "fn_type", params: [INT_TYPE], effects: [], returnType: INT_TYPE }
+        ARRAY_T_TYPE,
+        { kind: "fn_type", params: [T_TYPE], effects: [], returnType: U_TYPE }
       ],
       effects: ["pure"],
-      returnType: ARRAY_INT_TYPE
+      returnType: { kind: "array", element: U_TYPE }
     },
     impl: { kind: "wasm", generator: generateArrayMap }
   },
@@ -15435,11 +15504,11 @@ var WASM_ARRAY_BUILTINS = [
     type: {
       kind: "fn_type",
       params: [
-        ARRAY_INT_TYPE,
-        { kind: "fn_type", params: [INT_TYPE], effects: [], returnType: BOOL_TYPE }
+        ARRAY_T_TYPE,
+        { kind: "fn_type", params: [T_TYPE], effects: [], returnType: BOOL_TYPE }
       ],
       effects: ["pure"],
-      returnType: ARRAY_INT_TYPE
+      returnType: ARRAY_T_TYPE
     },
     impl: { kind: "wasm", generator: generateArrayFilter }
   },
@@ -15448,12 +15517,12 @@ var WASM_ARRAY_BUILTINS = [
     type: {
       kind: "fn_type",
       params: [
-        ARRAY_INT_TYPE,
-        INT_TYPE,
-        { kind: "fn_type", params: [INT_TYPE, INT_TYPE], effects: [], returnType: INT_TYPE }
+        ARRAY_T_TYPE,
+        U_TYPE,
+        { kind: "fn_type", params: [U_TYPE, T_TYPE], effects: [], returnType: U_TYPE }
       ],
       effects: ["pure"],
-      returnType: INT_TYPE
+      returnType: U_TYPE
     },
     impl: { kind: "wasm", generator: generateArrayReduce }
   },
@@ -15462,11 +15531,11 @@ var WASM_ARRAY_BUILTINS = [
     type: {
       kind: "fn_type",
       params: [
-        ARRAY_INT_TYPE,
-        { kind: "fn_type", params: [INT_TYPE], effects: [], returnType: BOOL_TYPE }
+        ARRAY_T_TYPE,
+        { kind: "fn_type", params: [T_TYPE], effects: [], returnType: BOOL_TYPE }
       ],
       effects: ["pure"],
-      returnType: OPTION_INT_TYPE
+      returnType: OPTION_T_TYPE
     },
     impl: { kind: "wasm", generator: generateArrayFind }
   },
@@ -15475,11 +15544,11 @@ var WASM_ARRAY_BUILTINS = [
     type: {
       kind: "fn_type",
       params: [
-        ARRAY_INT_TYPE,
-        { kind: "fn_type", params: [INT_TYPE, INT_TYPE], effects: [], returnType: INT_TYPE }
+        ARRAY_T_TYPE,
+        { kind: "fn_type", params: [T_TYPE, T_TYPE], effects: [], returnType: INT_TYPE }
       ],
       effects: ["pure"],
-      returnType: ARRAY_INT_TYPE
+      returnType: ARRAY_T_TYPE
     },
     impl: { kind: "wasm", generator: generateArraySort }
   }
@@ -15490,7 +15559,7 @@ var ARRAY_BUILTINS = [...HOST_ARRAY_BUILTINS, ...WASM_ARRAY_BUILTINS];
 var OPTION_BUILTINS = [
   {
     name: "isSome",
-    type: { kind: "fn_type", params: [OPTION_INT_TYPE], effects: ["pure"], returnType: BOOL_TYPE },
+    type: { kind: "fn_type", params: [OPTION_T_TYPE], effects: ["pure"], returnType: BOOL_TYPE },
     impl: {
       kind: "host",
       factory: (ctx) => (ptr) => {
@@ -15500,7 +15569,7 @@ var OPTION_BUILTINS = [
   },
   {
     name: "isNone",
-    type: { kind: "fn_type", params: [OPTION_INT_TYPE], effects: ["pure"], returnType: BOOL_TYPE },
+    type: { kind: "fn_type", params: [OPTION_T_TYPE], effects: ["pure"], returnType: BOOL_TYPE },
     impl: {
       kind: "host",
       factory: (ctx) => (ptr) => {
@@ -15510,7 +15579,7 @@ var OPTION_BUILTINS = [
   },
   {
     name: "unwrap",
-    type: { kind: "fn_type", params: [OPTION_INT_TYPE], effects: ["fails"], returnType: INT_TYPE },
+    type: { kind: "fn_type", params: [OPTION_T_TYPE], effects: ["fails"], returnType: T_TYPE },
     impl: {
       kind: "host",
       factory: (ctx) => (ptr) => {
@@ -15524,7 +15593,7 @@ var OPTION_BUILTINS = [
   },
   {
     name: "unwrapOr",
-    type: { kind: "fn_type", params: [OPTION_INT_TYPE, INT_TYPE], effects: ["pure"], returnType: INT_TYPE },
+    type: { kind: "fn_type", params: [OPTION_T_TYPE, T_TYPE], effects: ["pure"], returnType: T_TYPE },
     impl: {
       kind: "host",
       factory: (ctx) => (ptr, defaultVal) => {
@@ -15542,7 +15611,7 @@ var OPTION_BUILTINS = [
 var RESULT_BUILTINS = [
   {
     name: "isOk",
-    type: { kind: "fn_type", params: [RESULT_INT_TYPE], effects: ["pure"], returnType: BOOL_TYPE },
+    type: { kind: "fn_type", params: [RESULT_T_E_TYPE], effects: ["pure"], returnType: BOOL_TYPE },
     impl: {
       kind: "host",
       factory: (ctx) => (ptr) => {
@@ -15552,7 +15621,7 @@ var RESULT_BUILTINS = [
   },
   {
     name: "isErr",
-    type: { kind: "fn_type", params: [RESULT_INT_TYPE], effects: ["pure"], returnType: BOOL_TYPE },
+    type: { kind: "fn_type", params: [RESULT_T_E_TYPE], effects: ["pure"], returnType: BOOL_TYPE },
     impl: {
       kind: "host",
       factory: (ctx) => (ptr) => {
@@ -15562,7 +15631,7 @@ var RESULT_BUILTINS = [
   },
   {
     name: "unwrapOk",
-    type: { kind: "fn_type", params: [RESULT_INT_TYPE], effects: ["fails"], returnType: INT_TYPE },
+    type: { kind: "fn_type", params: [RESULT_T_E_TYPE], effects: ["fails"], returnType: T_TYPE },
     impl: {
       kind: "host",
       factory: (ctx) => (ptr) => {
@@ -15576,7 +15645,7 @@ var RESULT_BUILTINS = [
   },
   {
     name: "unwrapErr",
-    type: { kind: "fn_type", params: [RESULT_INT_TYPE], effects: ["fails"], returnType: INT_TYPE },
+    type: { kind: "fn_type", params: [RESULT_T_E_TYPE], effects: ["fails"], returnType: E_TYPE },
     impl: {
       kind: "host",
       factory: (ctx) => (ptr) => {
@@ -15590,7 +15659,7 @@ var RESULT_BUILTINS = [
   },
   {
     name: "unwrapOkOr",
-    type: { kind: "fn_type", params: [RESULT_INT_TYPE, INT_TYPE], effects: ["pure"], returnType: INT_TYPE },
+    type: { kind: "fn_type", params: [RESULT_T_E_TYPE, T_TYPE], effects: ["pure"], returnType: T_TYPE },
     impl: {
       kind: "host",
       factory: (ctx) => (ptr, defaultVal) => {
@@ -15604,7 +15673,7 @@ var RESULT_BUILTINS = [
   },
   {
     name: "unwrapErrOr",
-    type: { kind: "fn_type", params: [RESULT_INT_TYPE, INT_TYPE], effects: ["pure"], returnType: INT_TYPE },
+    type: { kind: "fn_type", params: [RESULT_T_E_TYPE, E_TYPE], effects: ["pure"], returnType: E_TYPE },
     impl: {
       kind: "host",
       factory: (ctx) => (ptr, defaultVal) => {
@@ -16565,7 +16634,8 @@ var VALID_TYPE_KINDS = [
   "confidence",
   "provenance",
   "capability",
-  "fresh"
+  "fresh",
+  "type_var"
 ];
 var VALID_PATTERN_KINDS = [
   "literal_pattern",
@@ -16769,6 +16839,8 @@ function typesEqual(a, b, env) {
   const rb = resolveType(b, env);
   if (isUnknown(ra) || isUnknown(rb))
     return true;
+  if (ra.kind === "type_var" || rb.kind === "type_var")
+    return true;
   if (ra.kind !== rb.kind)
     return false;
   switch (ra.kind) {
@@ -16840,6 +16912,103 @@ function isUnknown(type) {
   return type.kind === "named" && type.name === "unknown";
 }
 
+// dist/checker/unify.js
+function unifyTypeVars(paramTypes, argTypes) {
+  const bindings = /* @__PURE__ */ new Map();
+  const count = Math.min(paramTypes.length, argTypes.length);
+  for (let i = 0; i < count; i++) {
+    unifyOne(paramTypes[i], argTypes[i], bindings);
+  }
+  return bindings;
+}
+function unifyOne(paramType, argType, bindings) {
+  if (paramType.kind === "type_var") {
+    if (!bindings.has(paramType.name)) {
+      bindings.set(paramType.name, argType);
+    }
+    return;
+  }
+  if (paramType.kind === "array" && argType.kind === "array") {
+    unifyOne(paramType.element, argType.element, bindings);
+  } else if (paramType.kind === "option" && argType.kind === "option") {
+    unifyOne(paramType.inner, argType.inner, bindings);
+  } else if (paramType.kind === "result" && argType.kind === "result") {
+    unifyOne(paramType.ok, argType.ok, bindings);
+    unifyOne(paramType.err, argType.err, bindings);
+  } else if (paramType.kind === "fn_type" && argType.kind === "fn_type") {
+    const count = Math.min(paramType.params.length, argType.params.length);
+    for (let i = 0; i < count; i++) {
+      unifyOne(paramType.params[i], argType.params[i], bindings);
+    }
+    unifyOne(paramType.returnType, argType.returnType, bindings);
+  } else if (paramType.kind === "tuple" && argType.kind === "tuple") {
+    const count = Math.min(paramType.elements.length, argType.elements.length);
+    for (let i = 0; i < count; i++) {
+      unifyOne(paramType.elements[i], argType.elements[i], bindings);
+    }
+  }
+}
+function substituteTypeVars(type, bindings) {
+  if (bindings.size === 0)
+    return type;
+  switch (type.kind) {
+    case "type_var": {
+      const bound = bindings.get(type.name);
+      return bound ?? type;
+    }
+    case "array":
+      return { kind: "array", element: substituteTypeVars(type.element, bindings) };
+    case "option":
+      return { kind: "option", inner: substituteTypeVars(type.inner, bindings) };
+    case "result":
+      return {
+        kind: "result",
+        ok: substituteTypeVars(type.ok, bindings),
+        err: substituteTypeVars(type.err, bindings)
+      };
+    case "fn_type":
+      return {
+        kind: "fn_type",
+        params: type.params.map((p) => substituteTypeVars(p, bindings)),
+        effects: type.effects,
+        returnType: substituteTypeVars(type.returnType, bindings)
+      };
+    case "tuple":
+      return {
+        kind: "tuple",
+        elements: type.elements.map((e) => substituteTypeVars(e, bindings))
+      };
+    // Leaf types — no type_var inside
+    case "basic":
+    case "named":
+    case "unit_type":
+    case "confidence":
+    case "provenance":
+    case "capability":
+    case "fresh":
+    case "refined":
+      return type;
+  }
+}
+function containsTypeVars(type) {
+  switch (type.kind) {
+    case "type_var":
+      return true;
+    case "array":
+      return containsTypeVars(type.element);
+    case "option":
+      return containsTypeVars(type.inner);
+    case "result":
+      return containsTypeVars(type.ok) || containsTypeVars(type.err);
+    case "fn_type":
+      return type.params.some(containsTypeVars) || containsTypeVars(type.returnType);
+    case "tuple":
+      return type.elements.some(containsTypeVars);
+    default:
+      return false;
+  }
+}
+
 // dist/checker/check.js
 function typeCheck(module) {
   const errors = [];
@@ -17161,13 +17330,28 @@ function inferCall(expr, env, errors, typeInfo) {
       typeInfo.resolvedCallSiteEffects.set(expr.id, [...resolvedEffects]);
     }
   }
+  const hasTypeVars = containsTypeVars(resolved.returnType) || resolved.params.some(containsTypeVars);
+  const typeVarBindings = hasTypeVars ? unifyTypeVars(resolved.params, argTypes) : null;
+  if (typeVarBindings && typeVarBindings.size > 0) {
+    for (let i = 0; i < checkCount; i++) {
+      const rawParam = resolved.params[i];
+      if (!containsTypeVars(rawParam))
+        continue;
+      const concreteParam = substituteTypeVars(rawParam, typeVarBindings);
+      const argType = argTypes[i];
+      if (!isUnknown(argType)) {
+        checkExpectedType(argType, concreteParam, expr.args[i].id, env, errors);
+      }
+    }
+  }
+  const concreteReturnType = typeVarBindings && typeVarBindings.size > 0 ? substituteTypeVars(resolved.returnType, typeVarBindings) : resolved.returnType;
   if (expr.fn.kind === "ident") {
     const builtin = BUILTIN_FUNCTIONS.get(expr.fn.name);
     if (builtin?.provenance) {
-      return { kind: "provenance", base: resolved.returnType, sources: [builtin.provenance] };
+      return { kind: "provenance", base: concreteReturnType, sources: [builtin.provenance] };
     }
   }
-  return resolved.returnType;
+  return concreteReturnType;
 }
 function inferIf(expr, env, errors, typeInfo) {
   const condType = inferExpr(expr.condition, env, errors, typeInfo);
@@ -19258,6 +19442,22 @@ function getSupportedContainers() {
   }
   return cachedSupportedContainers;
 }
+function containerMatchesSupported(concrete, supported) {
+  if (supported.kind === "type_var")
+    return true;
+  if (concrete.kind !== supported.kind)
+    return false;
+  switch (concrete.kind) {
+    case "array":
+      return supported.kind === "array" && containerMatchesSupported(concrete.element, supported.element);
+    case "option":
+      return supported.kind === "option" && containerMatchesSupported(concrete.inner, supported.inner);
+    case "result":
+      return supported.kind === "result" && containerMatchesSupported(concrete.ok, supported.ok) && containerMatchesSupported(concrete.err, supported.err);
+    default:
+      return JSON.stringify(concrete) === JSON.stringify(supported);
+  }
+}
 function checkMonomorphicContainers(module, warnings) {
   const supported = getSupportedContainers();
   function checkType(type, nodeId, location) {
@@ -19265,8 +19465,7 @@ function checkMonomorphicContainers(module, warnings) {
       return;
     if (type.kind === "array" || type.kind === "option" || type.kind === "result") {
       const supportedList = supported.get(type.kind) ?? [];
-      const key = JSON.stringify(type);
-      if (!supportedList.some((t) => JSON.stringify(t) === key)) {
+      if (!supportedList.some((t) => containerMatchesSupported(type, t))) {
         const suggestion = supportedList.length > 0 ? { nodeId, field: "type", value: supportedList[0] } : void 0;
         warnings.push(unsupportedContainer(nodeId, location, type.kind, type, supportedList, suggestion));
       }