手动多于自动：Fun 语法的第三条设计线

# 手动多于自动：Fun 语法的第三条设计线

前两篇讲了两个方向。第一篇讲复杂度落在谁身上，Fun 把它从读代码的人身上挪到写代码的人和实现语言的人身上。第二篇讲取长避短，一个特性的好处拿走，代价留在门外。

这一篇讲第三条线：**凡是自动会替人猜的地方，Fun 把开关交回给写代码的人。**

不是不用自动。Fun 也自动转换类型，也自动给未赋值的变量一个 null，也自动把内层赋值写回外层。它只是在一类地方特别固执：当自动版本必须猜一个没有标准答案的问题时，它不猜，让你写。

转义怎么解，换行加不加，参数按值还是按引用，模块要不要别名，循环引用谁来破，字符串下标按字符还是按字节，正则用哪种定界符，格式化走哪套模式，热点要不要下沉到 C 或汇编。这些事在别的语言里多半有一套默认答案，Fun 也有默认，但它把另一条路留得很明显，而且通常只差一个标点、一个关键字、一次方法调用。

手动多，字就多。Fun 认这个账。

---

## 一、转义：解析期一个字都不动

先看一行 Windows 路径：

```fun
var path = 'C:\new\table';
?. path;              # C:\new\table
?. path.length();     # 12
```

十二个字符，一个不少。`\n` 在这里不是换行，是反斜杠加字母 n。`\t` 也不是制表符。Fun 的词法分析器不处理反斜杠转义，单引号、双引号、反引号都一样，字面写什么，值就是什么。

要转义，得自己叫：

```fun
var s = 'a\nb';
?. s.length();        # 4
?. s.escape();        # a，换行，b
```

`.escape()` 认 `\b`、`\t`、`\n`、`\f`、`\r`、`\"`、`\'`、`` \` ``、`\/`、`\\`，也认 `\xHH` 和 `\uHHHH`。它是一个运行时方法，不是解析器的一部分。

字符串本身怎么表示引号？叠写。单引号里写两个单引号，双引号里写两个双引号：

```fun
?. 'it''s';           # it's
?. "say ""hi""";      # say "hi"
```

三种引号都能跨行，换行就是普通字符。Fun 没有为某一种引号单独记一套“这个会插值、那个不会”的规则。要插值，显式调 `.eval()`：

```fun
var name = 'Fun';
?. 'hello, $name'.eval();      # hello, Fun
?. "hello, $name".eval();      # hello, Fun
?. `hello, $name`.eval();      # hello, Fun
```

`.eval()` 也不是反引号专属。字符串在 Fun 里只有一种值类型，三种引号只是三种写法，到了运行期都一样。

它也不只能插值。`lib-orm-gen.fun` 用 `.eval()` 把模板字符串变成 Fun 源码，给每张表生成对应的类；官方 Quine 整份源码只有一行，靠反引号字符串嵌套自身，再 `.eval()` 一次。要不要把字符串当代码，是调用点决定的，不是字符串字面量的属性。

这套设计的好处很具体。写路径不用双写反斜杠，写正则不用先过一遍字符串转义，生成代码时不用数到底有几层 `\\`。坏处也很具体：从 C 过来的人，第一天总会把 `'a\nb'` 当成三个字符然后怀疑解释器坏了。（吐槽：它不是坏了，它只是拒绝替你做主。）

自动转义的语言，把“反斜杠是不是特殊字符”这个决定藏进了词法。Fun 把它拿出来，变成一个你可以调、也可以不调的方法。代价是多一次调用，好处是字面所见即所得。

---

## 二、输出：换行也是一个可以选的标点

Fun 的输出不是 `print`，是问号加一个后缀。后缀决定这一行怎么收尾：

| 写法 | 收尾 |
| --- | --- |
| `? expr;` | 什么都不加 |
| `?, expr;` | 一个空格 |
| `?: expr;` | 一个制表符 |
| `?. expr;` | 一个换行 |

```fun
? 'a';
?, 'b';
?: 'c';
?. 'd';
```

输出是 `a b c`，中间隔一个空格，然后一个制表符，最后是 `d` 和换行。拼进度条、逐个打印数组、对齐列，都不用先在字符串里拼 `\n` 和 `\t`：

```fun
for i = 1 to 3 do
  ? i & ' ';
end do;
?. 'done';
```

输出 `1 2 3 done`。

大多数语言把换行固定在 `print` 里，想要不换行就换一个函数，或者传一个 `end: ''` 参数。Fun 把这件事下放到标点：句号是换行，逗号是空格，冒号是制表，什么都没有就是原样。高频操作最短，这个思路上一篇已经说过。

代价是第一次见的人完全猜不出来。`?.` 在 JavaScript 里是可选链，在 Fun 里是换行输出；`?:` 在别的语言里像三目运算符的一部分，在 Fun 里是制表符。这个冲突真实存在，而且不小。Fun 接受它，因为输出实在太高频，熟练之后的扫读收益大于第一眼的门槛。

自动加换行，是替人决定“这一行结束了”。Fun 把这个决定放在标点上，你写哪个，就是哪个。

---

## 三、传参：引用写在调用点

Fun 的函数定义不标引用。形参就是名字，没有 `var` 语法：

```fun
fun swap(a, b)
  var t = a;
  a = b;
  b = t;
end fun;

var i = 1;  var j = 2;

swap(i, j);
?. i & ' ' & j;          # 1 2

swap(var i, var j);
?. i & ' ' & j;          # 2 1
```

按值还是按引用，由调用者写。`swap(i, j)` 复制两个值进去，函数里怎么改都动不到外面。`swap(var i, var j)` 把形参直接别名为实参变量，函数里的写回在调用结束后还在。

这条规则和 Delphi、C++ 正好相反。它们把引用标记写在形参声明上，读函数定义才知道这个参数会不会被改写。Fun 把标记挪到调用点，读调用这一行就知道。副作用摆在第一眼能看到的地方。

对象和字符串本来就是引用类型，赋值复制的是引用，不是缓冲区：

```fun
var a = 'hello';
var b = a;
b[0] = 'H';
?. a;                    # Hello
```

Fun 没有写时复制。`b` 改了，`a` 跟着改。这是预期行为，不是 bug。`lib-cstruct.fun` 的 `goBytes` 就靠这个语义工作：回调拿到的参数字符串就是调用者缓冲区的别名，往里面写就是写回调用者。

要一份独立的副本，得自己说。集合有 `@clone()`：

```fun
var s1 = [1, 2, 3];
var s2 = s1.@clone();
s1[0] = 11;
?. s2[0];                # 1
```

别的语言里，自动按引用、自动写时复制，是替人决定“这次赋值到底想共享还是想复制”。Fun 不猜。共享是默认，复制要显式。代价是调用点更长，还得记住哪些类型是引用。好处是读代码时不用猜，看到 `var` 就知道这里会写回，看不到就知道不会。

---

## 四、模块：别名加不加，你自己定

`use` 有两种形态。不加 `as`，模块顶层的名字直接注入当前作用域；加 `as`，整个模块绑成一个变量：

```fun
use 'fun-ref.fun';
swap(var i, var j);

use 'fun-ref.fun' as lib;
lib.swap(var i, var j);
```

第一种写法短，适合小脚本。库里的函数就像自己写的一样，直接调。第二种写法把命名空间收进一个名字，适合库多、名字容易撞的地方。

`use` 还认 `:` 前缀，从二进制内嵌资源里取模块，不读磁盘：

```fun
use ':fd.bnf.fd' as rules;
```

同名冲突的规则也有两套。同一个文件里重复声明，第一次有效，后面的声明被忽略；`use` 注入同名，后到的覆盖先到的。两套规则方向相反，但各有理由：同文件重名多半是笔误，`use` 多个模块后到者胜是设计内行为。

还有一个容易踩的边界：`use ... as X` 里的 `X` 只在它所在的那个块内可见。

```fun
if ok then
  use 'lib-crypt.fun' as libCr;
end if;

Cr = libCr;              # libCr not found
```

两个平台分支各自 `use` 一个 `libCr`，出了 `end if` 就都不在了。想把句柄交出去，得在块里赋值，或者把 `use` 提到外层。

自动合并命名空间的语言，替人决定“模块名要不要成为前缀”。Fun 把这件事做成可选的：不加别名就合并，加别名就隔离，块作用域再给你一层局部控制。代价是大项目容易撞名，还得记住别名的作用域。好处是小脚本不用写一堆 `import` 仪式，需要隔离时也有现成的手段。

---

## 五、内存：引用计数只做一半

Fun 的垃圾回收是引用计数。对象引用数归零就释放，没有分代，没有标记清除，也没有并发 GC。

```fun
class Node()
  var next = null;
end class;

var a = Node();
var b = Node();
a.next = b;
b.next = a;

a = null;
b = null;
# 两个 Node 互相引用，引用计数都不归零
```

这段代码跑完，两个对象还在堆上。Fun 不检测循环引用，也不会在某个时刻停下来扫一遍。作者的态度很明确：环是程序员自己造的，自己破。把 `a.next = null;` 写在丢掉 `a` 之前，环就断了。

这是“做一半留一半”的典型。归零一定收，环一定不收。听起来像偷工减料，但另一半是有意留的：确定性析构。

引用计数归零的那一刻，对象立刻销毁。文件句柄、`VirtualAlloc` 的内存、COM 的 `IDispatch` 指针、native 资源，都能在可预测的时点释放。没有 stop-the-world，没有“GC 什么时候跑”的不确定性。对 FFI 和系统脚本来说，这比“能自动收环”更值钱。

代价也很实在。长生命周期的服务、常驻 Agent、互相引用的闭包和集合，一旦成环就会持续泄漏。Fun 没有假装这个代价不存在，它只是选了确定性这一半，把另一半交给写代码的人。

（吐槽：说是 GC，其实只保证一半。归零一定收，环一定不收，剩下的一半靠你记性。）

---

## 六、字符串就是内存

Fun 的字符串不只是字符序列。它可以直接当内存用。

整数下标走字符，小数下标走字节：

```fun
var s = 'AB';
?. s[0];        # 字符 A
?. s[0.5];      # 第一个字符的低字节
?. s[-1];       # 最后一个字符
?. s[-.5];      # 最后一个字符的低字节
```

小数索引的整数部分定位字符，小数部分定位字符内部的字节。Unicode 构建下，一个字符两个字节，`0.5` 就是低字节，`0.1` 就是高字节。ANSI 构建下字符一个字节，这套索引仍然成立，只是字节和字符重合。

这套索引不是为了花哨。它是 Fun 字符串内存布局的直接映射。C 结构体里的 `char`、`short`、`int`、指针，都能用字符串加偏移读写。`lib-cstruct.fun` 的 `goBytes` 就是靠它遍历缓冲区，ANSI 每次加 1.0，Unicode 每次加 0.5。

再往下是裸地址：

```fun
var p = s.toNum(ptr: -1);        # 字符串数据区地址
var list = [1, 2, 3];
var base = list.@count('ptr');   # CList 数据区地址
(base + 8).move(base, 16);       # 把后两个元素往前搬
```

`@count('ptr')` 拿到集合数据区的裸地址，`.move()` 把一块内存搬到另一块。标准库的 `lib-stack.fun` 删中间元素，就是这三行：

```fun
if prev < curr then
  var p = list.@count('ptr') + prev * SizeOfPtr;
  (p + SizeOfPtr).move(p, (curr - prev) * SizeOfPtr);
end if;
list.@count(-1); // resize -1
```

`SizeOfPtr` 是本机字长，32 位上是 4，64 位上是 8。这段代码没有任何边界检查，也没有任何抽象。它就是 C 里会写的那种东西，只不过写在了脚本里。

代价是真实发生过的。`@count('ptr')` 早先经过 32 位的 `fun.int` 中转，在 x86_64 上地址被砍掉半截，`.move` 自然搬错地方。这件事在 64 位移植时列成 H-04，后来改成 `fun.intptr` 才清掉。验证放在 `fun/test/ptr-primitives.fun`，不只跑增删，还专门断言取到的地址大于 4GB，免得旧实现蒙混过关。

自动内存安全的语言，不会给你 `s[0.5]`，也不会给你 `.move()`。Fun 给了，而且不打算给每个原语都套一层安全检查。它的路线是：默认托管，窗口留给你，掉下去自己负责。这也是它敢说自己能碰系统级语言饭碗的原因。FFI、cstruct、JIT、汇编，全都踩在“字符串就是内存”这一块地基上。

---

## 七、同一件事，允许几种写法

Fun 不追求绝对正交。一个概念一种写法，是设计者的美学，不是使用者的刚需。Fun 更愿意让每种场景都有顺手的写法，哪怕这些写法在语义上重叠。

字符串有单引号、双引号、反引号。三种都能跨行，三种都能 `.eval()`，区别只在引号自己怎么转义、怎么嵌套。正则也有三种：

```fun
var a = /\d+-\d+/;
var b = %\w+%;
var c = $' \d+ \s* - \s* \d+ 'x;
```

`/.../` 最常用，但不能含空格，因为词法把空白排除了。`%...%` 是备选，同样不能含空格。`$'...'` 走完整的字符串文法，可以带空格和注释，配 `x` 扩展模式，适合写复杂的、需要排版的表达式。三种都接 `gimsux` 旗标。

数字有十进制、`0x` 十六进制、`0b` 二进制，`.5` 这种省略整数部分的小数也认。时间有 `@"2026-11-03 12:00:00"` 这样的字面量。集合下标有正向和负向，`list[-1]` 就是最后一个元素。

还有一种歧义，Fun 直接用一个点解决：

```fun
var list = [10, 20, 30];
list.[101] = 'x';      # 键 101
?. list[101];          # nil，第 102 个元素不存在
?. list.[101];         # x
```

`list[101]` 是索引，`list.[101]` 是键。点号一加，走 hash 索引，不再碰数组位置。JavaScript 里 `arr[1000] = 'x'` 会把稀疏数组撑到长度 1001，因为语言分不清索引 1000 和键 1000。Fun 不猜，让你写一个点。

格式化也一样。同一个 `.format()`，按接收者类型走三套模式语言：

```fun
?. 'Error: %s at %s/%s.'.format('a', 10, 3);
?. 1234.5.format('###,##0.00');            # 1,234.50
var t = @"2026-11-03 12:34:56";
?. t.format('yyyy-mm-dd hh:nn:ss:zzz');
```

字符串走 `%s`，数字走 `FormatFloat` 的 `#` 和 `0`，时间走 Delphi 的 `yyyy`、`mm`、`nn`、`zzz`。三套模式不是一套 printf 硬套所有类型。字符串通道在 FPC 构建下只认 `%s`，`%d`、`%x`、`%f` 会报 `Invalid argument index`，因为实参统一按字符串传。这是一个真实的缺口，不是文档没写。

自动的语言会给你一个万能 `format`，然后在类型不对时悄悄转，或者抛一个你看不懂的错。Fun 给你三套模式，每套只管一种类型。代价是要记三套规则，好处是每套都能把话说完。

连关键字都能换。启动时加 `-key:key_cn.ini` 是中文关键字，`key_fr.ini` 是法文，`key_pua.ini` 留给你自己造。别名只换词法层的拼写，语义、库、工具都不动。换不换由启动参数决定，不跟系统 locale 自动走。Windows 构建实测可用，Linux 构建目前没把别名包编进去，`-key:` 会被静默忽略，这是另一笔账。

---

## 八、性能：四级逃生舱，自己往下跳

Fun 的解释器不快。同一个曼德博分形，纯解释跑 2310 毫秒，大致在 Perl 和 Python 之间。这个数字不用辩解，tree-walking 加 variant 动态类型就是这个代价。

Fun 的答案不是把解释器做快，是让你在热点上跳下去。四级通道，一级比一级低：

```fun
# L1：FFI，调现成 C 库
var getpid = 'libc.so.6'.getapi('getpid', ':i');
?. getpid();
```

```fun
# L2：运行时编 C
var c = `#!c ii:i
  int add(int a, int b) { return a + b; }
`;
var jit = NewJit(c);
?. jit.call(1, 2);
jit.del();
```

L3 是内联汇编，`#!asm` 或者 `#!hex`，直接把机器码写进可执行内存。L4 是反向回调，把 Fun 闭包用 `@toCallback` 变成机器码能调的函数指针。

同一个分形，汇编路径实测 19 毫秒，约 120 倍。C 路径 20 毫秒。四级在 Linux x86_64 上都能跑通。

这套东西没有一级是自动的。Fun 不会在运行时偷偷把热点函数编译成机器码，也不会猜你哪个循环值得下沉。你得自己判断，自己写，自己承担平台差异和安全边界。

代价是明显的。`#!asm` 片段和架构强相关，`#!hex` 写错一个字节就是段错误，TCC 编出来的代码没有标准库，FFI 签名串写错就是未定义行为。默认构建下，任何脚本都能执行任意机器码。Fun 的安全模式不是运行时开关，是编译期另出一个二进制：

```bash
SAFE=strict ./make-linux-x86_64.sh
```

出来的 `funcmd-safe` 按能力分级拦掉原生调用、裸地址、文件访问和代码加载。默认构建一条检查都不带，保持零运行时成本。要安全，重新编一个；要性能，用默认的。这个选择也交给你。

自动 JIT 的语言，替人决定“哪里值得编译”。Fun 不猜。它把四条路修好，走不走、走哪条，是写代码的人的事。

---

## 九、这条线画在哪

把上面这些放在一起，会发现 Fun 并不是什么都手动。它自动转换类型，自动把未赋值的变量当 null，自动把内层赋值写回外层，`and` 和 `or` 还自动返回操作数。这些自动化没有隐藏决定，只是省掉样板。

它手动的地方，有一个共同点：自动版本必须猜一个没有标准答案的问题。

| 特性 | 自动会怎么猜 | Fun 交给你的开关 | 代价 |
| --- | --- | --- | --- |
| 字符串转义 | 解析期把 `\n` 解成换行 | 字面原样，`.escape()` 显式解码 | 要记得调 |
| 输出换行 | `print` 固定加换行 | `?`、`?,`、`?:`、`?.` 四个后缀 | 第一次看不懂 |
| 传参 | 对象按引用，标量按值 | 调用点写 `var` 才按引用 | 调用点更长 |
| 模块 | 自动合并命名空间 | `as` 别名可选，作用域自选 | 大项目易撞名 |
| 内存 | tracing GC 自动收环 | 引用计数，环自己破 | 长跑会漏 |
| 字符串下标 | 只能按字符 | `s[0.5]` 按字节，`s.[key]` 强制键 | 不安全，平台相关 |
| 正则 | 一种字面量 | `/.../`、`%...%`、`$'...'x` | 要记三种 |
| 格式化 | 一个万能 printf | 时间、数字、字符串三套模式 | 三套规则 |
| 性能 | 自动 JIT、自动向量化 | FFI、TCC、汇编、回调四级 | 自己判断热点 |
| 安全 | 运行时开关 | 编译期 `SAFE=...` 另出一个二进制 | 要重新构建 |

这张表不是穷举。它只是同一条线上的几个刻度。

手动多于自动，不等于“什么都自己来”。它更像一种责任划分：凡是语言能替你做、而且做完不会掩盖一个选择的，语言做；凡是做完会掩盖选择的，语言把选择摆出来，连同代价一起摆出来。

这也是它和前两条线的关系。第一条线把复杂度挪给写代码的人，第二条线把特性的代价切掉，第三条线把剩下的决定权交回去。三条线合起来，才是 Fun 的性格：它不假装自己什么都知道。

写到这里，我发现这篇比前两篇更像说明书。也对，手动的东西，不摆出来就说不清。自动是替你决定，手动是让你决定。Fun 多数时候选后者，然后把账本一起递给你。

你可以不翻。但别假装账本不存在。