取长避短：Fun 语法的第二条设计线

# 取长避短：Fun 语法的第二条设计线

上一篇《少用符号，多写单词》写完之后，我把里面的例子逐条放到 9.5.1 上跑了一遍，又对着核心仓库 9.4.9 以后的提交看了一遍。

有几处需要订正，另有一串小地方要补。订正本身不复杂，但把它们和管道、软关键字、运算符重载放在一起看，会露出另一条设计线。

上一篇讲的是“复杂度落在谁身上”。这一篇讲的是“一个特性的好处和代价，能不能分开拿”。

Fun 的答案经常是：**好处拿走，代价留在门外。** 不是全支持，也不是不支持，而是只支持那个“好”的部分，然后极力避开它会带来的弱点。

管道是最好的例子。

## 一、`end` 后面的分号：只取“块尾干净”这一点

先说我上一篇文章开头的那个说法：`end if` 为什么要有 `end if` 和分号两层收尾。

这句话在 9.4.8 之前是对的。9.4.9 之后，`end if`、`end case`、`end loop`、`end do`、`end try`、`end fun`、`end class` 后面的分号都可以省了。官方文法里，代码块那条规则从：

```text
代码块 ::= ( 条件 | 分支 | 循环 | 异常 | 函数 | 类 ) ';'
```

变成了：

```text
代码块 ::= ( 条件 | 分支 | 循环 | 异常 | 函数 | 类 ) ';'?
```

所以下面两种写法现在都对：

```fun
if ok then
  ?. 'yes';
end if;

if ok then
  ?. 'yes';
end if
```

第二种少一个分号，跑起来一样。

但这条规则有一个很重要的边界：**它不是自动分号插入。** 它只免掉 `end <block>` 后面那一个分号，块内部的语句仍然要分号，`end` 前面的最后一条语句也仍然要分号。

```fun
fun classify(n)
  if n = 0 then
    ?. 'zero';
  end if
end fun

classify(0);
classify(-1);
```

这段能跑，因为省掉的只是 `end if` 和 `end fun` 后面的分号。`?. 'zero';` 的分号还在，`classify(0);` 的分号也还在。如果把调用后面的分号也去掉，解析器就会把两条调用粘在一起，报语法错误。这不是新规则的问题，是 Fun 从来没有“按行断句”这回事。

为什么只做这么一点？因为再往前走一步，就是 JavaScript 那种自动分号插入。那件事的代价，写过 JS 的人都清楚：换行不再是空白，某些行首的括号和方括号会被吸到上一行，工具链要跟着做一套容错规则。

Fun 要的是“块尾干净”这一点好处。它不要自动分号插入那套代价。于是它在文法里加了一个 `?`，把“块的收尾”和“语句的收尾”分开，然后停住。

## 二、三种引号都能跨行：词法的顺带结果

上一篇文章里，我给三种引号各写了一个例子，但只在反引号那一行注了“可跨行”。这个注脚是错的，或者至少是漏了。

Fun 的三种引号都能跨行：

```fun
var a = 'one
two';
var b = "three
four";
var c = `five
six`;

?. a;
?. b;
?. c;
```

输出是：

```text
one
two
three
four
five
six
```

单引号里要写单引号，双写；双引号里要写双引号，也双写。除此之外，换行就是普通字符。

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

输出：

```text
it's
say "hi"
```

这不是一个“多行字符串特性”，而是词法分析的自然结果。引号在词法里是分隔符，`[^']`、`[^"]`、`[^`]` 这些字符类本来就包含换行。设计者没有额外做“只在反引号里允许换行”的限制，也没有做 heredoc、缩进剥离、模板插值那一整套。

Fun 要的是“字符串可以自然跨行”这一点好处。它不要“字符串里再嵌一门模板语言”的代价。需要插值的时候，字符串上有一个 `.eval()`，自己拼；不需要的时候，就是纯文本。模板语言该解决的问题，留给模板语言。

这里要补一个上一篇没写清楚的点：`.eval()` 不是反引号专属，三种引号都行。字符串在 Fun 里只有一种值类型，`.eval()` 是字符串的方法，跟它用哪种引号写出来无关。

```fun
var name = 'Fun';

?. 'hello, $name'.eval();
?. "hello, $name".eval();
?. `hello, $name`.eval();
```

三行输出都是 `hello, Fun`。反引号在这里没有额外能力，它只是三种写法中的一种。区别仍然只在词法层：引号怎么嵌套、引号本身怎么转义。到了运行期，它们都是同一个字符串。

这也解释了为什么 Fun 不需要模板字符串：插值不是引号的功能，而是字符串的方法。想拼就显式调用 `.eval()`，不想拼就保持纯文本。语言不必为某一种引号单独记一套“这个引号会插值、那个不会”的规则。

代价当然有：少一个收尾引号，后面的代码会被整段吞进字符串，报错位置还经常指在文件末尾。这个代价是局部的、可见的，Fun 选择接受它。

## 三、函数不止五种：多给轻的，不给重的

上一篇说 Fun 的函数有五种长相：命名块、`fun(a){...}`、`(a){...}`、`{...}`、`a -> expr`。这个数在当时是一个好用的简化，但它不是全集。

至少还应该补上三种：

```fun
var g = -> 7;                 # 零参箭头
var h = (x, y) -> x + y;      # 多参箭头
var five() = 5;               # 带参数的 var 函数别名

?. g();      # 7
?. h(2, 3);  # 5
?. five();   # 5
```

零参箭头是最好用的一个。写回调、写延迟执行、写“先包起来，等会儿再算”，它比 `{ ... }` 更短，也比 `fun () { ... }` 更轻：

```fun
var later = -> work();
```

多参箭头省掉了 `fun` 和花括号，适合一行能算完的纯函数。`var five() = 5;` 则是把“无参函数”写成了一个变量声明，标准库里不少内建别名就是这么来的。

所以现在的函数写法，按重量排，大概是：

| 写法 | 形态 | 适合 |
| --- | --- | --- |
| `fun name(args) ... end fun` | 命名块 | 算法骨架、递归 |
| `fun (args) { ... }` | 匿名块，带 `fun` | 语句体回调 |
| `(args) { ... }` | 匿名块 | 语句体回调，更短 |
| `{ ... }` | 零参匿名块 | 延迟执行 |
| `args -> expr` | 单参表达式 | 一行变换 |
| `(args) -> expr` | 多参表达式 | 一行变换，多参 |
| `-> expr` | 零参表达式 | thunk |
| `var name(args) = expr` | 命名表达式 | 内建别名、短函数 |

这些写法不是无限扩张出来的。每一种都对应一个真实的重量级：命名、语句体、表达式体、零参、多参。Fun 要的是“函数足够轻”这一点好处，不要“函数语法覆盖所有调用形态”的代价。

所以它没有再加模式匹配 lambda、默认参数语法、可变参数语法那一套。需要默认值，就用命名参数加 `null` 判断；需要变参，就用列表。这些做法不如专门语法顺手，但它们不需要语言再学一套新规则。

## 四、软关键字：只软在点号后面

9.4.9 还有一条改动：词法器开始记录“当前这个点号是不是成员访问”，于是所有保留字都可以当成员名：

```fun
var o = new [];
o.fun = 1;
o.end = 2;
o.if = 3;

?. o.fun;   # 1
?. o.end;   # 2
?. o.if;    # 3
```

这条改动解决的是一个很具体的问题：从 JSON、数据库、外部 API 拿到的字段名，经常正好是 `end`、`class`、`fun`、`if` 这类保留字。如果语言不允许 `o.fun`，用户就得写 `o['fun']`，代码里会多出一堆方括号。

顺带澄清一个容易混进来的词：`type` 不是关键字。它只是标准库 `lib-type.fun` 里的一个函数，`type(x)` 和 `o.type` 本来就不会和词法器打架。软关键字规则处理的始终是真正的保留字，不是“看起来像类型系统的词”。

Fun 要的是“保留字可以当成员名”这一点好处。它不要“所有关键字在任何位置都可以当标识符”的代价。`fun` 出现在语句开头，仍然是函数定义；`if` 出现在条件位置，仍然是分支；`end` 出现在块尾，仍然是收尾。它只软在点号后面，因为那里是名字和关键字最常打架、而且打架代价最高的位置。

同一个思路还出现在关键字别名上。Fun 的关键字不是硬编码在词法里的，而是过一层 `ParseAlias`，所以可以在启动时加载别名包：

```text
fun.exe -key:key_cn.ini   # 中文关键字
fun.exe -key:key_fr.ini   # 法文关键字
fun.exe -key:key_pua.ini  # 自定义
```

这也不是“把语言翻译成另一种语言”。别名只换关键字的拼写，语义、库、工具都不变。它解决的是本地化和可访问性，不是让一门语言变成另一门语言。Fun 没有为此去改文法，也没有让中文关键字进入标准库和文档的主路径。

要本地化的好处，不要分裂生态的代价。这也是取长避短。

## 五、管道：要数据流，不要运行时

管道是这套思路最干净的一个样本。

```fun
var f = a -> a * 2;
var g = a -> a + 3;

?. g(f(1 + 2) + 3);    # 12
?. 1 + 2 | f + 3 | g;  # 12
```

Fun 要的好处很明确：把“从内往外读”的嵌套调用，改成“从左往右读”的数据流。`1 + 2` 先给 `f`，加 `3`，再给 `g`。读的时候眼睛不用来回找括号。

代价怎么避开？Fun 没有为管道新增任何运行时概念。它只在词法里加了一个 `|`，在文法里加了两条归约规则：

```text
Exp opPipe VarExp   # 右边是一个名字
Exp opPipe FunCall  # 右边是一次调用
```

两条规则的动作是同一个：把左边的值包成参数表，构造一次普通的函数调用。再往下，虚拟机、执行器、类型系统完全不知道“管道”的存在。它看到的只是一句 `f(值)`。

这一步很关键。很多语言给管道单独设计求值逻辑，甚至把管道做成一个对象，可以 `.map`、`.filter`、`.tap`。那样表达力更强，但运行时要多一种值、多一套求值规则、多一组调试语义。Fun 没有走这条路。

它也主动放弃了管道的一些“完整形态”：

- 不支持多参数占位。`值 | f(a, _)` 这种写法不存在。管道只做一件事：把左边的值作为右边的唯一实参。要多参数，写 lambda 或者命名函数。
- 不支持反向管道。没有 `f | 值` 这种从右往左的写法。
- 不支持管道对象和内省。你不能在管道中间插一个 `.tap` 看值，想看就拆成中间变量。
- 不支持自定义管道优先级。`|` 的优先级是文法里写死的，比大多数二元运算符都低，所以一整条链能自然串起来。

这些限制不是缺陷清单，而是成本清单。每一条“不支持”，都对应一个“运行时不用新增什么”。Fun 用表达力换来了零运行时成本，换来了文法里只有两条规则，换来了调试时管道会还原成普通调用。

这就是取长避短的完整动作：先想清楚这个特性真正的好处是什么，再想清楚它通常带来的代价是什么，然后把两者切开，只拿好处。

## 六、同一把尺子：还有这些取舍

把管道、分号、软关键字放在一起，会发现它们不是孤例。Fun 的很多语法点都能用同一把尺子量：

| 特性 | 取的好部分 | 避开的成本 | 停在哪 |
| --- | --- | --- | --- |
| 管道 | 左到右的数据流 | 运行时新语义、参数占位歧义 | 两条文法规则，解析期归约 |
| 分号省略 | 块尾干净 | 自动分号插入的歧义 | 只免 `end <block>` 后一个 |
| 软关键字 | 保留字可作成员名 | 全局上下文关键字的解析复杂度 | 只在点号后 |
| 关键字别名 | 中文/法文/自定义拼写 | 改文法、分裂生态 | 只换词法层的词 |
| 运算符重载 | 自定义符号行为 | 用户定义优先级/结合性 | 表查找，优先级固定 |
| `and` / `or` | 一行取默认值 | 完整真值类型/可选类型 | 借用 Lua 的操作数返回 |
| 单继承 | 类复用与多态 | 多继承、MRO、mixin | 一条方法链 |
| 正则/时间字面量 | 高频值直接写 | 嵌入模板/日期语言 | 字面量加少量方法 |
| JIT / 内联汇编 | 性能逃生舱 | 核心语法变复杂 | 库层加字符串 |
| FFI | 直接调原生库 | 为每种签名写绑定代码 | 一行签名字符串 |
| `case` | 多路分支 | 完整模式匹配与解构 | 值匹配加集合/正则 |
| 显式 `end` | 块边界无歧义 | 花括号和缩进的脆弱 | 用冗长换明确 |
| `?.` 输出 | 高频操作最短 | 关键字、函数、格式化噪音 | 两个标点 |

这张表不是穷举，它只是同一把尺子的几个刻度。

有几条值得单独说。

**运算符重载**。Fun 允许 `this['+'] = ...` 这样的写法，让对象自己决定 `+` 的行为。但它只做表查找，不改变优先级和结合性。实测 `x .+ 2 * 3` 会按 `(x .+ 2) * 3` 解析，而不是按用户想象的 `x .+ (2 * 3)`。你想要自定义符号的好处，就得接受它按固定的点号优先级走。Fun 没有给用户定义优先级的能力，因为那会把文法变成用户可编程的东西。

**`and` / `or`**。它们返回操作数，不是布尔值：

```fun
var name = user.name or 'anonymous';
```

一行就能取默认值，比三元运算符和 `if` 都短。但 Fun 没有因此引入一套完整的真值类型，也没有加可选类型语法。它只是借了 Lua 的求值语义，然后停住。

**单继承**。Fun 支持类、继承和多态，但只支持单继承。方法查找就是沿着一条链往上走，没有多继承、没有 mixin、没有复杂的 MRO。想要组合多个能力，用包含或者表来拼。这是用一点表达力换来了一个非常小的心智模型。

**正则和时间字面量**。`/.../`、`%...%`、`$'...'` 和 `@'...'` 让脚本里的高频值可以直接写。但 Fun 没有把正则做成一套完整的文法，也没有把时间做成一套日期表达式语言。字面量加几个方法，够用就停。

**JIT 和内联汇编**。Fun 可以内联 C 和汇编，但它是通过字符串和库层接口做的，不是在核心语法里加一套汇编文法。性能逃生舱开在库层，核心语法保持干净。

**FFI**。调原生库也一样。Fun 用一行签名字符串描述参数和返回值，而不是为每个库生成一套绑定代码。要的是“能直接调”的好处，避开的是“为每种签名写一层胶水”的成本。

**`case` 和 `try`**。`case` 支持值匹配，`when` 里可以放集合和正则；`try` 允许 `except` 和 `finally` 并存。但它们都没有走到完整模式匹配、解构、类型化异常分支那一步。需要判断异常类型，就用 `case`。这也是停在“够用”的位置。

**`@` 上下文值**。`@` 在函数里是返回值，在 `case` 里是匹配值，在 `except` 里是异常。它省掉了 `result`、`matched`、`exception` 几个专用名字，代价是读一行代码时得知道自己在哪个块里。这个代价是接受的，因为它局部、可见，而且 `@` 的出现频率足够高。

**`?.` 输出**。这是另一类：它取的是“高频操作最短”的好处，避开的是“关键字、函数调用、格式化参数”的噪音。但它没有避开“新手第一眼看不懂”这个代价。这个代价是故意接受的，因为输出实在太高频，熟练之后的扫读收益更大。

所以“取长避短”不是“零代价”。有些代价是避开的，比如运行时新概念、文法歧义、工具链负担；有些代价是接受的，比如啰嗦、第一眼门槛、动态类型的运行期错误。区别在于：**避开的代价会伤害语言的核心，接受的代价是局部的、可见的、可以学的。**

动态类型就是最明显的“接受代价”。Fun 不要类型标注的仪式，换来的是写脚本时的零负担；代价是字段拼错、类型不对要到运行期才发现。它没有假装这个代价不存在，而是用自动转换、显式转换和 `SAFE=...` 编译期安全构建去兜底。知道代价在哪，比假装没有代价更重要。

## 七、一张订正表

把这次核对的结果收在一起。前一列是先前的说法，后一列是 9.5.1 上的现状。

| 先前的说法 | 9.5.1 的现状 | 性质 |
| --- | --- | --- |
| `end if` 后面要分号 | 9.4.9 起可省，`;` 仍接受 | 版本更新 |
| 只有反引号可跨行 | 三种引号都可跨行 | 订正 |
| `.eval()` 只在反引号上有 | 三种引号的字符串都能 `.eval()` | 订正 |
| `type` 是关键字 | `type` 是标准库函数，不在关键字表里 | 澄清 |
| 函数有五种写法 | 还有零参箭头、多参箭头、`var name(args)=expr` | 补充 |
| 点号后可接的符号列表没写 `-` | `opAny` 包含 `-`，`n .- 3` 可用 | 订正 |
| `+` 专门做数字加法 | 时间也能 `+` / `-` | 订正 |
| `=~` 可当布尔用 | 返回匹配对象，不是 `true` | 澄清 |
| Fun 没有单行 `if` | 不能省 `end if`；写在一行是合法的 | 澄清 |
| 运行时约 0.3 MB | Windows `fun.exe` 约 345 KB，Linux `funcmd` 约 711 KB | 平台差异 |

表里前面几条是这次主要想补的，后面几条是顺手校准。它们不影响上一篇的主论点，但会影响读者照着例子写代码时的预期。

## 八、写在版本边上

语言文章有两种写法。一种写“这门语言是什么”，一种写“这门语言现在是什么”。前者能放很久，后者需要标日期。

上一篇的主论点，我现在仍然这么看：Fun 把复杂度从读代码的人身上，挪到写代码的人和实现语言的人身上。`end if` 的显式收尾、`?.` 的短记号、`=` 的位置消歧、一切皆表的值模型，都是这条线的产物。

这次补记的三处，反而把这条线照得更清楚。

分号可以省，但只省在 `end` 后面。这说明 Fun 想要的从来不是“少敲一个分号”，而是“块的边界由 `end if` 自己说清楚”。分号只是语句的收尾，不是块的收尾。把它省掉，块的结构反而更纯。

三种引号都能跨行，但 Fun 没有做模板字符串。这说明它要的是“字符串就是字符串”，不是“字符串里再嵌一门语言”。任意字符串上的 `.eval()` 是逃生舱，不是主路径；它不属于某一种引号，也不改变引号的语义。

函数多了几种轻量写法，但 Fun 没有把函数变成模式匹配机。这说明它要的是“函数是一等公民，按场景给不同的重量”，不是“函数要覆盖所有调用形态”。

管道只有两条文法规则，但 Fun 没有把它做成运行时对象。这说明它要的是“数据从左往右流”这一点可读性，不是“管道要能表达一切”。

取长避短比“全支持”和“不支持”都难。全支持只要往上堆，不支持只要说不。取长避短要求你知道：这个特性的好处到底是哪一点，代价到底是哪一点，两者能不能切开。

Fun 的很多小设计，都是这么切出来的。分号那个改动只有一行文法，`';'?`。管道只有两条规则和一个 token。软关键字只有一个词法状态。它们看起来都不大，但它们是同一把尺子量出来的。

一门语言的性格，不只看它支持什么，也看它拒绝把什么带进来。

---

*本文的语法行为在 Fun 9.5.1 上逐条运行验证；版本与提交信息对照核心仓库 9.4.9（2026-10-28）至 9.5.2（2026-10-31）。示例中的 `#` 注释、`?.` 输出和 `end X` 收尾均为 Fun 原生写法。*