struct 与 match：代数数据与模式匹配

struct：一个记录

(struct circle (r)     #:transparent)
(struct rect   (w h)   #:transparent)

(define c (circle 5))

(circle-r c)      ; ⇒ 5      访问字段：结构体名-字段名
(circle? c)       ; ⇒ #t     类型谓词，自动生成
(rect? c)         ; ⇒ #f

一行 struct，白送你三样东西：构造函数（circle）、字段访问器（circle-r）、类型谓词（circle?）。

; 不加 #:transparent
> (opaque-pt 1 2)
#<opaque-pt>                              ; ← 打印不出内容，调试时你是瞎的
> (equal? (opaque-pt 1 2) (opaque-pt 1 2))
#f                                        ; ← 内容一样，但不相等！

; 加了 #:transparent
> (clear-pt 1 2)
#(struct:clear-pt 1 2)                    ; ← 能看见内容
> (equal? (clear-pt 1 2) (clear-pt 1 2))
#t                                        ; ← 按内容比较

代数数据类型：两种「组合」

「代数数据类型」（ADT）这个名字唬人，其实只有两个概念：

而 Java 长期以来只有积类型（class 有字段），没有像样的和类型 —— 你只能用继承 + instanceof 硬凑，而编译器完全不知道「子类就这么几个」。这就是为什么 Java 17 的 sealed 是一个大事：它终于把和类型补上了。

match：模式匹配

(define (area s)
  (match s
    [(circle r)  (* pi r r)]
    [(rect w h)  (* w h)]))

(area (rect 3 4))    ; ⇒ 12

看清楚 (circle r) 干了两件事：① 判断 s 是不是一个 circle；② 如果是，把它的字段解构出来绑到 r 上。

没有 match 的话，你得这么写：

; ✗ 没有 match 的世界
(define (area s)
  (cond
    [(circle? s) (let ([r (circle-r s)])        ; 先判断，再手动取字段
                   (* pi r r))]
    [(rect? s)   (let ([w (rect-w s)]
                       [h (rect-h s)])
                   (* w h))]))

match 把「判断 + 解构」合并成了一个动作。这就是它全部的价值 —— 而这个价值大到所有现代语言都在补它（Java 21 的 record pattern、Python 3.10 的 match、C# 的 pattern matching）。

match 能匹配的东西（比你想的多）

; 列表结构
(match '(1 2 3)
  [(list a b c) (list 'three a b c)])          ; ⇒ '(three 1 2 3)

; 「头 + 剩下的」—— 省略号
(match '(1 2 3 4 5)
  [(list first rest ...) (list first rest)])   ; ⇒ '(1 (2 3 4 5))

; 字面量（注意这个，它是解释器的基础）
(match '(add 1 2)
  [(list 'add a b) (+ a b)]                    ; ⇒ 3
  [(list 'mul a b) (* a b)])

; 谓词
(match 42
  [(? even? n) (list 'even n)])                ; ⇒ '(even 42)

; 守卫（when）
(match 15
  [(? number? n) #:when (> n 10) 'big]
  [_ 'small])                                  ; ⇒ 'big

; _ 是通配符：匹配任何东西，不绑定

(match expr
  [(? number? n)        n]
  [(? symbol? x)        (lookup x env)]
  [(list 'if c t e)     (if (my-eval c env) …)]
  [(list 'lambda ps b)  (make-closure ps b env)]
  [(list f args ...)    (my-apply …)])

诚实时间：Racket 在这一局输给了 Kotlin

看这个。我故意漏掉一个分支：

(struct circle (r) #:transparent)
(struct rect (w h) #:transparent)
(struct tri (a b c) #:transparent)     ; ← 三种图形

(define (area s)
  (match s
    [(circle r) 'circle]
    [(rect w h) 'rect]))               ; ← 漏了 tri！

Racket 编译时一声不吭。直到运行到那一行：

> (area (tri 3 4 5))
match: no matching clause for (tri 3 4 5)

运行时才炸。而 Kotlin：

sealed interface Shape
data class Circle(val r: Double) : Shape
data class Rect(val w: Double, val h: Double) : Shape
data class Tri(val a: Double, val b: Double, val c: Double) : Shape

fun area(s: Shape): Double = when (s) {
    is Circle -> …
    is Rect   -> …
}   // ✗ 编译错误：'when' expression must be exhaustive,
    //             add necessary 'is Tri' branch or 'else' branch

真正的重点：让非法状态无法表示

ADT 最大的价值不是「代码更短」，是它能让某些 bug 在物理上不可能存在。

看这个你一定写过的东西：

// ✗ 一个典型的「非法状态可表示」的设计
data class UiState(
    val isLoading: Boolean,
    val data: List<Item>?,
    val error: String?
)

这个类型能表示多少种状态？2 × 2 × 2 = 8 种（每个字段有/无）。

但你的业务里只有 3 种是合法的：加载中、成功、失败。

剩下 5 种是什么？「正在加载并且已经有数据并且还报了个错」—— 这是什么鬼？它没有意义，但你的类型系统允许它存在，于是：

• 你必须在每一处使用它的地方写防御性判断：if (isLoading) … else if (error != null) … else if (data != null) …
• 你必须记住那个隐含的优先级（先判 loading 还是先判 error？）—— 而且团队里每个人记的可能不一样
• 总有一天，某个 bug 会让这三个字段进入一个自相矛盾的组合，然后 UI 显示成一团乱麻

用和类型重写：

// ✓ 非法状态在物理上不存在
sealed interface UiState {
    object Loading : UiState
    data class Success(val data: List<Item>) : UiState
    data class Failure(val error: String) : UiState
}

现在可能状态数 = 3。一个不多，一个不少。

• 「加载中还带着错误」写不出来 —— 不是「不该写」，是编译器不让
• Success 里的 data 不可空 —— 因为成功了就一定有数据，这是类型说的
• when 强制你处理所有三种情况

回流

type Action =
  | { type: "add"; payload: Item }
  | { type: "remove"; id: string }
  | { type: "clear" };

function reducer(state: State, action: Action): State {
  switch (action.type) {
    case "add":    return [...state, action.payload];  // ← 这里 TS 知道有 payload
    case "remove": return state.filter(x => x.id !== action.id);
    case "clear":  return [];
  }
}

(match s
  [(circle r) …]
  [(rect w h) …]
  [other (error 'area "未处理的图形类型: ~a" other)])
;  ↑ 这一行不是可选的。它是你在动态语言里能买到的、最便宜的保险。

下一章

我们已经能处理任意形状的有限数据了。

下一章处理无限的。是的，无限 —— 一个包含所有自然数的列表，你可以对它 map、filter，然后取出前五个。

而这件事的机制，正是 Kotlin 的 Sequence、JS 的 function*、Java 的 Stream 共同的祖先。