@calcit/procs 0.12.17 → 0.12.18

package/editing-history/{202604132309-typeslot-enum-compile-safety.md → 2026-0413-2309-typeslot-enum-compile-safety.md}

@@ -7,22 +7,27 @@
 ## 修改的文件
 
 ### `src/calcit/type_annotation.rs`
+
 - `resolve_to_enum_with_ref()`: 新增 `TypeSlot` 分支，通过 `resolve_type_slot()` 解析绑定类型后委托
 - `matches_with_bindings()`: 双向 `Tuple/Enum` 匹配 — 原先只有 `(Tuple, Enum)` 方向，TypeSlot 解析后顺序会翻转，新增 `(Enum, Tuple)` 方向
 
 ### `src/calcit.rs`
+
 - 将 `resolve_type_slot` 加入 `pub use` 导出列表
 
 ### `src/runner/preprocess.rs`
+
 - `resolve_enum_value()`: 在 `as_struct()` 调用前增加 TypeSlot 解析（避免 `&CalcitStruct` 生命周期问题）
 - 新增 `try_rewrite_local_fn_tuple_args_to_enum_tuples()`: 对本地函数调用（如回调 `d!`）也执行 tuple→enum 自动重写
 - 主预处理 `Calcit::Local` 分支: 增加 local fn 调用的重写+类型检查（clone 避免借用冲突）
 - `try_rewrite_single_tuple_to_enum_tuple()`: 增加变体验证 — 重写后立即检查 tag 是否是 enum 的合法 variant，不合法则发出警告
 
 ### `src/bin/cr_tests/type_fail.rs`
+
 - 新增 `type_fail_type_slot_enum_invalid_variant` 测试，验证 TypeSlot 绑定的 enum 在自动重写路径下能正确检测不存在的 variant
 
 ### `calcit/type-fail/type-slot-enum-invalid-variant.cirru`
+
 - 新增测试 fixture：声明 `defenum Action`、通过 TypeSlot 绑定、调用 `takes-action $ :: :nonexistent |hello`，期望产生 variant 不存在警告
 
 ## 知识点

package/editing-history/2026-0414-1500-loose-record-syntax.md

@@ -0,0 +1,32 @@
+# 2026-04-14 15:00 — `?{}` 松散 Record 语法
+
+## 概要
+
+新增 `?{}` 松散 record 语法，允许不声明 struct 就创建 record，与 `::` 无类型 tuple 对称。
+在函数参数有 struct 类型标注时，预处理阶段自动改写为 `%{} StructDef ...`。
+
+## 改动文件
+
+| 文件 | 变更 |
+|------|------|
+| `src/calcit/proc_name.rs` | 新增 `NativeLooseRecord` proc 变体，`?{}` 序列化，类型签名 |
+| `src/data/cirru.rs` | `"?{}"` token 解析为 `Calcit::Proc(NativeLooseRecord)` |
+| `src/calcit/record.rs` | `LOOSE_RECORD_NAME`、`is_loose()`、`from_loose_pairs()` |
+| `src/builtins/records.rs` | `call_loose_record()` 运行时：验证 tag 键、排序、排重 |
+| `src/builtins.rs` | 分发 `NativeLooseRecord => call_loose_record(args)` |
+| `src/calcit.rs` | Display: 松散 record 显示为 `(?{} ...)` |
+| `src/runner/preprocess.rs` | `try_rewrite_loose_record_args_to_struct_records`、类型推断、skip core arg check |
+| `ts-src/js-record.mts` | JS 运行时 `_$q__$M_` 函数 |
+| `calcit/test-record.cirru` | `test-loose-record-rewrite` 集成测试 |
+| `docs/features/records.md` | 文档：松散 record 语法、自动改写、类型对称表 |
+
+## 性能优化
+
+- **预处理改写链合并重建**：三步改写（map→record、loose→struct、tuple→enum）原先每步都重建 `ys` (CalcitList)，优化为仅在有改写时统一重建一次，减少 CalcitList push 操作。
+- **JS 排序比较器修正**：将重复字段检测从 sort comparator 中移出（comparator 内 throw 违反排序契约），改为排序后线性扫描相邻元素，行为更可靠。
+
+## 知识点
+
+- `EdnTag::cmp` 按全局 tag 池分配顺序排序（整数 index），**不是**字典序。record 字段排序必须用 `ref_str().cmp()` 保持字母序。
+- CalcitList 基于 persistent ternary tree，`.clone()` 是 O(1) 引用计数操作。
+- Sort comparator 不应抛异常——不同排序算法对异常行为未定义。

package/editing-history/2026-0414-2259-bidir-type-check-refactor.md

@@ -0,0 +1,63 @@
+# 202604142259 — Bidirectional Type Checking Architecture Refactoring
+
+## 概要
+
+将 `src/runner/preprocess.rs`（6199 行单体文件）拆分为模块化目录结构，
+按双向类型检查（bidirectional type checking）的概念分离关注点。
+
+## 改动详情
+
+### 模块拆分
+
+`preprocess.rs` → `preprocess/` 目录模块：
+
+| 模块 | 行数 | 职责 |
+|---|---|---|
+| `mod.rs` | ~4744 | 预处理核心：符号解析、宏展开、作用域管理、特殊语法 |
+| `type_inference.rs` | ~693 | 类型合成（synthesis）：自下而上推导表达式类型 |
+| `type_checking.rs` | ~402 | 类型检查（checking）：自上而下验证参数类型 |
+| `type_rewriting.rs` | ~398 | 类型定向重写：根据期望类型重写 AST 字面量 |
+
+### 代码去重
+
+1. **统一参数重写循环** (`rewrite_args_by_expected_type`)：
+   - 原先 4 个 `try_rewrite_*_args_to_*` 函数各自包含相同的外层循环（~30 LOC × 4）
+   - 提取为泛型 `rewrite_args_by_expected_type<F>` 函数，4 个入口各只保留闭包调用
+
+2. **统一参数类型检查循环** (`check_arg_types_loop`)：
+   - 原先 `check_local_fn_call_arg_types` 和 `check_user_fn_arg_types` 共享相同的
+     zip → resolve_type_value → matches_with_bindings → gen_check_warning 模式
+   - 提取为泛型 `check_arg_types_loop<F>` 函数，包含 variadic 处理和 spread 跳过逻辑
+
+3. **统一引用节点构建** (`build_struct_ref_node` / `build_enum_ref_node`)：
+   - 原先 map→record 和 loose-record→struct 各自复制 Import vs Struct/Enum 分支
+   - 提取为共享的 `build_struct_ref_node` 和 `build_enum_ref_node` 函数
+
+### Proc 推导提取
+
+- `infer_type_from_expr` 中的 `Calcit::Proc` 分支（~100 行 match arms）
+  提取为独立的 `infer_proc_call_return_type` 函数，提高可读性
+
+## 双向类型检查映射
+
+参照 Dunfield & Krishnaswami 的框架：
+
+| 方向 | 模块 | 入口函数 |
+|---|---|---|
+| **Synthesis** (⇒) | `type_inference` | `infer_type_from_expr`, `resolve_type_value` |
+| **Checking** (⇐) | `type_checking` | `check_*_arg_types`, `check_function_return_type` |
+| **Rewriting** (结构适配) | `type_rewriting` | `try_rewrite_*` |
+| **Context** (线程局部) | `mod.rs` | `EXPECTED_FN_TYPE`, `EXPECTED_STRUCT_TYPE` |
+
+## 为后续 match 语法扩展铺路
+
+- `type_checking.rs` 的 `check_arg_types_loop` 模式可直接复用于 match 分支检查
+- `type_inference.rs` 中已有 `infer_if_return_type` 作为分支合并的模板
+- 未来只需在相应模块中添加新函数，无需修改 `mod.rs` 的核心调度
+
+## 验证
+
+- `cargo check --lib` ✅ 零警告
+- `cargo clippy --lib -- -D warnings` ✅ 零警告
+- `cargo fmt` ✅ 格式一致
+- 链接器问题（`ld: library 'System' not found`）是环境问题，非代码变更引起

package/editing-history/2026-0415-0120-match-syntax-exhaustiveness.md

@@ -0,0 +1,20 @@
+# match syntax with exhaustiveness checking
+
+## Summary
+
+Added native `match` syntax for enum pattern matching with compile-time exhaustiveness detection,
+as a safer alternative to `tag-match` macro. See `drafts/match-syntax-rfc.md` for full design.
+
+## Files modified
+
+- `src/calcit/syntax_name.rs` — `CalcitSyntax::Match`
+- `src/builtins/syntax.rs` — `syntax_match()` runtime
+- `src/builtins.rs` — dispatch entry
+- `src/runner/preprocess/mod.rs` — `preprocess_match()` with exhaustiveness
+- `src/codegen/emit_js.rs` — `gen_match_code()` JS output
+- `calcit/test-enum.cirru` — test cases
+
+## Key takeaway
+
+Cirru indentation creates pair-based `(pattern body)` children — same format as `tag-match`.
+Flat alternating format doesn't survive Cirru serialization round-trips.

package/lib/js-record.mjs

@@ -1,5 +1,5 @@
 import { CalcitImpl } from "./js-impl.mjs";
-import { castTag, toString, findInFields } from "./calcit-data.mjs";
+import { newTag, castTag, toString, getStringName, findInFields } from "./calcit-data.mjs";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 import { CalcitStruct } from "./js-struct.mjs";
 export class CalcitRecord {
@@ -116,6 +116,28 @@ export let new_impl_record = (impl, name, ...fields) => {
     let structRef = new CalcitStruct(nameTag, fieldNames, new Array(fieldNames.length).fill(null), [impl]);
     return new CalcitRecord(nameTag, fieldNames, undefined, structRef);
 };
+/** Loose record: `?{} :field1 val1 :field2 val2` – record without a declared struct.
+ *  Fields are sorted by tag index. The record name is "?" (sentinel). */
+export let _$q__$M_ = (...xs) => {
+    if (xs.length % 2 !== 0) {
+        throw new Error("?{} expected pairs of :field value");
+    }
+    let pairs = [];
+    for (let i = 0; i < xs.length; i += 2) {
+        pairs.push([castTag(xs[i]), xs[i + 1]]);
+    }
+    pairs.sort((a, b) => a[0].idx - b[0].idx);
+    // Check for duplicate fields after sorting
+    for (let i = 1; i < pairs.length; i++) {
+        if (pairs[i][0].idx === pairs[i - 1][0].idx) {
+            throw new Error(`?{} received duplicate field: :${getStringName(pairs[i][0])}`);
+        }
+    }
+    let fieldNames = pairs.map((p) => p[0]);
+    let values = pairs.map((p) => p[1]);
+    let looseTag = newTag("?");
+    return new CalcitRecord(looseTag, fieldNames, values);
+};
 export let fieldsEqual = (xs, ys) => {
     if (xs === ys) {
         return true; // special case, referential equal

package/lib/package.json

@@ -1,10 +1,10 @@
 {
     "name": "@calcit/procs",
-    "version": "0.12.17",
+    "version": "0.12.18",
     "main": "./lib/calcit.procs.mjs",
     "devDependencies": {
         "@types/node": "^25.0.9",
-        "typescript": "^5.9.3"
+        "typescript": "^6.0.2"
     },
     "scripts": {
         "compile": "rm -rf lib && tsc",

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@calcit/procs",
-  "version": "0.12.17",
+  "version": "0.12.18",
   "main": "./lib/calcit.procs.mjs",
   "devDependencies": {
     "@types/node": "^25.0.9",
-    "typescript": "^5.9.3"
+    "typescript": "^6.0.2"
   },
   "scripts": {
     "compile": "rm -rf lib && tsc",

package/ts-src/js-record.mts

@@ -119,6 +119,29 @@ export let new_impl_record = (impl: CalcitImpl, name: CalcitValue, ...fields: Ar
   return new CalcitRecord(nameTag, fieldNames, undefined, structRef);
 };
 
+/** Loose record: `?{} :field1 val1 :field2 val2` – record without a declared struct.
+ *  Fields are sorted by tag index. The record name is "?" (sentinel). */
+export let _$q__$M_ = (...xs: Array<CalcitValue>): CalcitValue => {
+  if (xs.length % 2 !== 0) {
+    throw new Error("?{} expected pairs of :field value");
+  }
+  let pairs: Array<[CalcitTag, CalcitValue]> = [];
+  for (let i = 0; i < xs.length; i += 2) {
+    pairs.push([castTag(xs[i]), xs[i + 1]]);
+  }
+  pairs.sort((a, b) => a[0].idx - b[0].idx);
+  // Check for duplicate fields after sorting
+  for (let i = 1; i < pairs.length; i++) {
+    if (pairs[i][0].idx === pairs[i - 1][0].idx) {
+      throw new Error(`?{} received duplicate field: :${getStringName(pairs[i][0])}`);
+    }
+  }
+  let fieldNames = pairs.map((p) => p[0]);
+  let values = pairs.map((p) => p[1]);
+  let looseTag = newTag("?");
+  return new CalcitRecord(looseTag, fieldNames, values);
+};
+
 export let fieldsEqual = (xs: Array<CalcitTag>, ys: Array<CalcitTag>): boolean => {
   if (xs === ys) {
     return true; // special case, referential equal