天道酬勤

王垠40行代码 之理解

前言

最近用AI 分析了王银的所谓40行牛逼代码,最后也是一知半解,但这里做下结论记录一下。

正文

一、CPS 到底是什么?用你熟悉的东西类比

你写 JS/C# 肯定见过"回调地狱"和 async/await。其实:

  • Direct Style(直写风格)​:return x 隐式地把结果"交回去"。
  • CPS 风格:不再用 return,而是把"接下来要干什么"做成一个函数 k(叫 continuation/续延),显式传进去。每个函数多一个参数 k,算完就调用 (k 结果)。

换句话说,CPS 就是把"return 之后要执行的代码"显式地变成了一个回调函数。你平时写的 async/await,编译器底层正是把它"脱糖"成这种 CPS 风格的回调链。所以王垠说这东西本质是个编译器——没说错。

二、这 40 行在干嘛

它是一个 CPS 变换器(CPS transformer)​:输入一段普通的 Scheme 表达式(直写风格),自动输出等价的 CPS 风格代码。而且它做到了两个很难的优化:

  1. 正确的尾调用(proper tail-call)​——递归不会爆栈。
  2. if 表达式不复制上下文(does not duplicate contexts)​——这是它比朴素 CPS 变换聪明的地方,否则 if 的两个分支会把后续代码复制两份,代码量爆炸。

它依赖一个 pmatch.scm(模式匹配宏)来拆解语法树。核心是一个递归函数 cps1,对每种语法节点做不同处理。

三、代码逐块拆解

(define cps
  (lambda (exp)
    (letrec ([trivial? (lambda (x) (memq x '(zero? add1 sub1)))]
             [id (lambda (v) v)]
             [ctx0 (lambda (v) `(k ,v))]      ; 尾上下文
             [fv (let ([n -1])
                   (lambda () (set! n (+ 1 n))
                     (string->symbol (string-append "v" (number->string n)))))]
             [cps1 (lambda (exp ctx) (pmatch exp ...))])
      (cps1 exp id))))

各部件作用:
添加到对话部件作用trivial?判断是不是"平凡原语"(zero?/add1/sub1)。这些不需要再 CPS 化,直接内联,避免无谓的开销。

id恒等续延:(lambda (v) v)。什么都不做,把值原样返回。作为最顶层的初始 continuation。

ctx0尾上下文:(lambda (v) (k ,v))。表示"这是最外层,结果直接交给最终续延 k"。用于识别尾位置,做尾调用优化。

fv生成器:每次调用吐出 v0、v1、v2…… 这种临时变量名,用来给中间结果命名(因为 CPS 化后每个中间值都得有个名字)。

cps1核心递归函数:(cps1 表达式 续延),把表达式变换成 CPS,并把"后续"交给 ctx 这个续延参数。

 

cps1 用模式匹配处理 5 种节点:

  1. 变量 [,x (guard (not (pair? x))) (ctx x)]
    原子(变量/数字)直接交给续延 ctx。
  2. if [(if ,test ,conseq ,alt) ...]
    先 CPS 化 test;如果当前是尾上下文(ctx0 或 id),就直接生成 (if t 分支1 分支2),不复制上下文;否则给两个分支各生成一个新的续延 k,再做 if。这就是"不复制上下文"的关键。
  3. lambda [(lambda (,x) ,body) (ctx (lambda (,x k) ,(cps1 body ctx0)))]
    给每个函数显式加一个参数 k(这就是"传递 continuation"),函数体在尾上下文里变换。
  4. 二元运算 [(,op ,a ,b) ...]
    先 CPS 化左操作数 a 得到 v1,再 CPS 化右操作数 b 得到 v2,最后 (ctx (op v1 v2))。
  5. 函数调用(rator rand)[(,rator ,rand) ...]
    先 CPS 化函数 r,再 CPS 化参数 d:
    • 如果 r 是平凡原语 → 直接 (ctx (r d));
    • 如果是尾位置(ctx 就是 ctx0)→ (r d k),这就是尾调用:直接把续延 k 传下去,不套新 lambda,所以不爆栈;
    • 否则生成一个临时变量 u 和闭包 (lambda (u) (ctx u)) 作为续延传进去。

主要事cps函数的输出:

cps(x)                           =  x
cps((lambda (x) x))              =  (lambda (x k) (k x))
cps((lambda (x) (x 1)))          =  (lambda (x k) (x 1 k))
cps((if (f x) a b))              =  (f x (lambda (v0) (if v0 a b)))
cps((lambda (x) (if (f x) a b))) =  (lambda (x k) (f x (lambda (v0) (if v0 (k a) (k b)))))

 

拆开看每一条变换的"为什么":

  1. (lambda (x) x) → (lambda (x k) (k x))
    每个函数都自动多了一个参数 k,原来的 return x 变成了 k(x)。这就是"续延传递"——把"接下来干啥"显式传进来。

  2. (lambda (x) (x 1)) → (lambda (x k) (x 1 k))
    注意结尾是 (x 1 k) 而不是 (x 1 (lambda (u) (k u)))。这就是尾调用优化:当前调用已经在"最后一步",续延 k 直接传下去,不再多包一层 lambda,所以递归不会无限涨栈。

  3. (if (f x) a b) → (f x (lambda (v0) (if v0 a b)))
    if 不在尾位置时,test 部分的续延被变成了一个回调 (lambda (v0) ...)——这正是"回调地狱"的原型。

  4. (lambda (x) (if (f x) a b)) → ... (if v0 (k a) (k b))
    if 在尾位置时,两个分支直接 (k a)、(k b),没有把外层上下文复制两份——这就是原注释里说的 "does not duplicate contexts for if-expressions"。

a894eae65920445132d2c679dcb13dce

 

26bd3531d1a0b073ecd4113eee107a0d

 

一句话点透

cps() 这个函数本身就是一个编译器(代码→代码的变换):把"直写风格"的 return 全部改写成 k(...) 回调。你写 C# 的 async/await、JS 的 Promise 链,编译器在底层干的就是同一件事——把同步代码"脱糖"成这种续延传递风格。王垠那 40 行之所以被当成杰作,是因为它用极小篇幅、且正确地(带尾调用 + if 不复制)完成了这个编译器核心。

合适的处理思路

88341eed8f52777845c19a90959fd5e4

 

[(if ,test ,conseq ,alt)
 ;; 关键判定:当前是否处于"尾位置"?
 (if (or (eq? ctx ctx0) (eq? ctx id))      ; ← 见功力这一行
     ;; 是尾位置:两分支直接复用同一个外层续延 ctx0,零复制
     `(if ,(cps1 test id) ,(cps1 conseq ctx0) ,(cps1 alt ctx0))
     ;; 非尾位置:才给两分支各造一个新续延 k
     (let ([k (fv)])
       `(let ([,k ,(cps1 test id)])
          ,(cps1 `(if ,k ,conseq ,alt) (lambda (v) `(,ctx ,v))))))]

  

核心对应:隐式栈 → 显式参数

SICP 里 fact 从递归过程改写成迭代过程,关键一步是引入 accumulator,把"还没乘完的那部分"从调用栈上(隐式挂起)搬进了参数(显式传递)。

王垠 CPS 的尾调用优化,做的是同一件事——把"接下来要做的计算"封装成续延 k 作为参数传下去,从而不依赖调用栈增长。

三者在 fact 上的骨架完全同构:

递归过程(SICP)    (define (f n) (if (= n 1) 1 (* n (f (- n 1)))))
                       ↑ 每层返回前都挂起一个 n 在栈上 → 空间 O(n)

迭代过程(SICP)    (define (f-iter p c m) (if (> c m) p (f-iter (* c p) (+ c 1) m)))
                       ↑ "待乘乘积"提前累积进参数 p → 空间 O(1),尾递归

王垠 CPS 版         (lambda (n k) (if (zero? n) (k 1)
                                (f (sub1 n) (lambda (v) (k (* n v))))))
                       ↑ "待乘的部分"封进续延 k 传下去 → 尾调用,空间 O(1)

  你看,CPS 版的 (lambda (v) (k (* n v))) 本质上就是 SICP 迭代版的 (* c p)——都是"把待完成的工作作为参数一直往下带"。

维度SICP 迭代过程王垠 CPS
改造方式 程序员手动改写(想出 accumulator) cps() 自动对任意程序做同一变换
适用范围 单个函数(如 factorial) 任意程序的所有控制结构
底层保障 依赖语言支持尾调用 变换本身就把一切变成尾调用

两个要分清的边界(别混淆)

  1. "不复制上下文"是 SICP 阶乘没覆盖的额外难点。SICP 的 fact 只有一个递归分支,不存在 if 两路复制的问题。而真实程序里 if 有两个分支,朴素 CPS 会把后续代码复制两份(我们上一轮看到的爆炸)。王垠那行 ctx === ctx0 || ctx === id 特判,是 SICP 例子里根本不会出现、却恰恰是 40 行最见功力的地方。​所以 CPS 比 SICP 尾递归"多解决了一个问题"。

  2. 两个层面的"递归"别混:SICP 区分"递归过程(语法)"和"迭代过程(运行时)";王垠 CPS 变换后代码里仍然有递归调用(比如 f (sub1 n) k),但因为是尾调用,运行时栈不增长——这恰恰就是 SICP"迭代过程"赖以成立的底层机制(proper tail call)。所以结论可以钉死:CPS 产出代码的"尾调用不涨栈"性质,正是 SICP 线性迭代过程的保证机制。

0d8dde222d62a90b7f3e46e865a80e7f

 

最值得记住的一句话:SICP 迭代版的 (* c p) 和 CPS 版的 (lambda (v) (k (* n v))),是同一个东西的两种写法——都是"把还没算完的工作,作为显式参数带着往下走"。区别只是 SICP 让你手动写,王垠让 cps() 对任意程序自动写;而"不复制上下文"那一行特判,是 SICP 单分支 fact 永远碰不到、却正是 40 行最见功力的额外一刀。

 

最后附带 王银的代码

;;; 王垠《40 行代码》中的 CPS 变换器(依赖 pmatch 模式匹配宏)

(define cps
  (lambda (exp)
    (letrec
        ;; 判断是不是"平凡原语"——不需再 CPS 化,直接内联
        ([trivial? (lambda (x) (memq x '(zero? add1 sub1)))]
         ;; 恒等续延:值原样返回(顶层入口用)
         [id (lambda (v) v)]
         ;; 尾上下文:结果直接交给最外层续延 k
         [ctx0 (lambda (v) `(k ,v))]
         ;; 临时变量名生成器:每次调用吐出 v0, v1, v2 ...
         [fv (let ([n -1])
               (lambda ()
                 (set! n (+ 1 n))
                 (string->symbol
                  (string-append "v" (number->string n)))))]
         ;; 核心递归:把 exp 变换成 CPS,并把"后续"交给续延 ctx
         [cps1
          (lambda (exp ctx)
            (pmatch exp

              ;; 1. 原子(变量 / 数字):直接交给当前续延 ctx
              [,x (guard (not (pair? x))) (ctx x)]

              ;; 2. if 表达式 —— 全文最见功力的部分
              [(if ,test ,conseq ,alt)
               (if (trivial? test)
                   (let ([t (fv)])
                     `(let ([,t ,(cps1 test id)])
                        ,(cps1 `(if ,t ,conseq ,alt) ctx)))
                   (if (or (eq? ctx ctx0) (eq? ctx id))
                       ;; ★ 关键特判:当前处于尾位置
                       ;;   → 两个分支直接复用同一个 k,不复制上下文
                       `(if ,(cps1 test id)
                            ,(cps1 conseq ctx0)
                            ,(cps1 alt ctx0))
                       ;; 非尾位置:生成一个续延 k,两个分支共享它
                       ;;   (只多一层间接,不复制代码)
                       (let ([k (fv)])
                         `(let ([,k (lambda (,k) ,(ctx k))])
                            (if ,(cps1 test id)
                                ,(cps1 conseq (lambda (v) `(,k ,v)))
                                ,(cps1 alt (lambda (v) `(,k ,v))))))))]

              ;; 3. lambda:显式加一个续延参数 k,函数体在尾上下文变换
              [(lambda (,x) ,body)
               (ctx `(lambda (,x k) ,(cps1 body ctx0)))]

              ;; 4. 二元运算 (op a b)
              [(,op ,a ,b)
               (if (trivial? op)
                   (let ([v1 (fv)] [v2 (fv)])
                     `(let ([,v1 ,(cps1 a id)])
                        (let ([,v2 ,(cps1 b id)])
                          ,(ctx `(,op ,v1 ,v2)))))
                   (cps1 `(,op ,a ,b)
                         (lambda (v)
                           (if (memq op '(= + - * / < > <= >= car cdr cons))
                               (ctx v)
                               (error "unknown binary operator" op))))]

              ;; 5. 函数调用 (rator rand)
              [(,rator ,rand)
               (if (trivial? rator)
                   (ctx `(,rator ,(cps1 rand id)))
                   (cps1 rator
                         (lambda (r)
                           (cps1 rand
                                 (lambda (d)
                                   ;; ★ 尾位置 → 直接把续延变量 k 传下去,
                                   ;;   不再套新 lambda(proper tail-call,不涨栈)
                                   (if (eq? ctx ctx0)
                                       `(,r ,d k)
                                       (let ([u (fv)])
                                         `(,r ,d (lambda (,u) ,(ctx u))))))))))])])
      ;; 入口:从最外层恒等续延 id 开始
      (cps1 exp id))))

 

posted @ 2026-11-04 15:07  JulyLuo  阅读(13)  评论(1)    收藏  举报