简单易懂的程序语言入门小册子（7）：基于文本替换的解释器，加入continuation，重构解释器

时间：2014-05-05 22:13:58 阅读：337 评论：0 收藏：0 [点我收藏+]

或许在加入continuation之前要先讲讲费这么大劲做这个有什么意义。毕竟用不用continuation的计算结果都是一样的。不过，这是一个兴趣使然的系列，学习这些知识应该完全出于好奇与好玩的想法。所以我才不会告诉你们通过控制continuation可以实现call-with-current-continuation和异常处理等功能呢。

我先简要描述一下加入continuation后解释器是怎么工作的。加入continuation后的解释器是以迭代的方式工作的。迭代的状态量有两个，第一个是一个待求值的表达式或者求到的值，第二个是Continuation。假设解释器的输入是 $M$ ，那么一开始的状态表示为 $\left<M, {mt}\right>_v$ 。第一个状态量是个表达式 $M$ ，这时解释器开始对 $M$ 求值。这个过程用记号 $\rightarrow_{v}$ 表示。这个过程可能会将一些“下一步要做的事”保存到continuation。求值到最后，状态会变为 $\left<V, \kappa\right>_c$ （如果没有无限循环）。注意到下标变成c， $V$ 是一个值，所以不能再求值了，下一步要做的是从continuation $\kappa$ 中取出“下一步要做的事”执行。这个过程也叫做“将continuation $\kappa$ 应用到值 $V$ ”，用记号 $\rightarrow_{c}$ 表示。一个解释器的执行过程就是 $\rightarrow_{v}$ 和 $\rightarrow_{c}$ 交替运行，就好像太极里阴阳交替一样。解释器执行到最后状态会变成 $\left<V, {mt}\right>_c$ ，已求得值 $V$ ，又没有“下一步要做的事”，也就是运行结束了，输出 $V$ 。说了这么多，本质上整个过程还是一句话：递归转迭代。顺便一提，加入continuation后的解释器叫做CK machine。

先列出目前为止的所有求值过程（call-by-value）：

e v a l (X) e v a l (b) e v a l (λ X . M) e v a l ((+ M N)) e v a l ((? M N)) e v a l ((i s z e r o M)) e v a l ((i s z e r o M)) e v a l ((M N)) e v a l ((f i x X 1 X 2 M)) = = = = = = = = = X b λ X . M e v a l (M) + e v a l (N) e v a l (M) ? e v a l (N) t r u e 其中 e v a l (M) = 0 f a l s e, 其中 e v a l (M) \neq 0 e v a l (L [X \leftarrow e v a l (N)]) 其中 e v a l (M) = λ X . L λ X 2 . M [X 1 \leftarrow (f i x X 1 X 2 M)]

$\begin{equation*}\begin{array}{lcl} eval(X) &=& X \\ eval(b) &=& b \\ eval(\lambda X.M) &=& \lambda X.M \\ eval((+ \; M \; N)) &=& eval(M) + eval(N) \\ eval((- \; M \; N)) &=& eval(M) - eval(N) \\ eval(({iszero} \; M)) &=& {true} \\ && \text{其中} eval(M) = 0 \\ eval(({iszero} \; M)) &=& {false}, \\ && \text{其中} eval(M) \neq 0 \\ eval((M \; N)) &=& eval(L[X \leftarrow eval(N)]) \\ && \text{其中} eval(M) = \lambda X.L \\ eval(({fix} \; X_1 \; X_2 \; M)) &=& \lambda X_2.M[X_1 \leftarrow ({fix} \; X_1 \; X_2 \; M)] \end{array}\end{equation*}$ 下面分别介绍各个情况下如何加入continuation。

值与fix表达式

值是最简单的情况，直接应用continuation。

? X, κ ? v ? b, κ ? v ? λ X . M, κ ? v \to v \to v \to v ? X, κ ? c ? b, κ ? c ? λ X . M, κ ? c

$\begin{equation*}\begin{array}{lcl} \left<X, \kappa\right>_v &\rightarrow_v& \left<X, \kappa\right>_c \\ \left<b, \kappa\right>_v &\rightarrow_v& \left<b, \kappa\right>_c \\ \left<\lambda X.M, \kappa\right>_v &\rightarrow_v& \left<\lambda X.M, \kappa\right>_c \\ \end{array}\end{equation*}$

fix表达式和值的情况类似：

? (f i x X 1 X 2 M), κ ? v \to v ? λ X 2 . M [X 1 \leftarrow (f i x X 1 X 2 M)], κ ? c

$\begin{equation*}\begin{array}{lcl} \left<({fix} \; X_1 \; X_2 \; M), \kappa\right>_v &\rightarrow_v& \left<\lambda X_2.M[X_1 \leftarrow ({fix} \; X_1 \; X_2 \; M)], \kappa\right>_c \end{array}\end{equation*}$

基本运算

用 $(o^n \; M_1 \; M_2 \; ... \; M_n)$ 表示基本运算，其中 $o^n$ 是运算符， $M_1, ..., M_n$ 是参数， $n$ 是代表参数个数。在我们的语言里目前有两个两参数的基本运算 $o^2=\{+, -\}$ 和一个单参数的基本运算 $o^1=\{{iszero}\}$ 。

计算基本运算前要先对所有参数求值。这里规定从左到右求值。当解释器在求第 $i$ 个参数 $M_i$ 的值时，需要保存到continuation的数据有：运算符 $o^n$ 、已求到的值 $V_1, ..., V_{i-1}$ （其中 $V_1=eval(M), ..., V_{i-1}=eval(M_{i-1})$ ）以及还没求值的参数 $M_{i+1}, ..., M_n$ 。因此，包含基本运算的continuation定义为：

κ = | m t ? o p d, κ, o n, (V 1 . . . V i ? 1), (M i + 1 . . . M n) ?

$\begin{equation*}\begin{array}{lcl} \kappa &=& {mt} \\ &|& \left<{opd}, \kappa, o^n, (V_1 \; ... \; V_{i-1}), (M_{i+1} \; ... \; M_n)\right> \end{array} \end{equation*}$

求值过程为：

? (o n M 1 M 2 . . . M n), κ ? v ? V, ? o p d, κ, o n, (M i + 1 . . . M n), (V 1 . . . V i ? 1) ? ? c ? V, ? o p d, κ, o n, (), (V 1 . . . V n ? 1) ? ? c \to v \to c \to c ? M 1, ? o p d, κ, o n, (M 2 . . . M n), () ? ? v ? M i + 1, ? o p d, κ, o n, (. . . M n), (V 1 . . . V i ? 1 V) ? ? v ? V', κ ? c 其中 V' = o n (V 1, . . ., V n ? 1, V)

$\begin{equation*}\begin{array}{lcl} \left<(o^n \; M_1 \; M_2 \; ... \; M_n), \kappa\right>_v &\rightarrow_v& \left<M_1, \left<{opd}, \kappa, o^n, (M_2 \; ... \; M_n), ()\right>\right>_v \\ \left<V, \left<{opd}, \kappa, o^n, (M_{i+1} \; ... \; M_n), (V_1 \; ... \; V_{i-1})\right>\right>_c &\rightarrow_c& \left<M_{i+1}, \left<{opd}, \kappa, o^n, (... \; M_n), (V_1 \; ... \; V_{i-1} V)\right>\right>_v \\ \left<V, \left<{opd}, \kappa, o^n, (), (V_1 \; ... \; V_{n-1})\right>\right>_c &\rightarrow_c& \left<V‘, \kappa\right>_c \\ && \text{其中} V‘ = o^n(V_1, ..., V_{n-1}, V) \end{array}\end{equation*}$

函数调用

函数调用 $(M \; N)$ 先计算 $M$ 的值， $N$ 保存到continuation：

? (M N), κ ? v \to v ? M, ? a r g, κ, N ? ? v

$\begin{equation*}\begin{array}{lcl} \left<(M \; N), \kappa\right>_v &\rightarrow_v& \left<M, \left<{arg}, \kappa, N\right>\right>_v \end{array}\end{equation*}$

$M$ 计算完后从continuation取出

$N$ 计算（我们采用call-by-value的调用方式），同时保存

$M$ 的计算结果

$V$ ：

? V, ? a r g, κ, N ? ? c \to c ? N, ? f u n, κ, V ? ? v

$\begin{equation*}\begin{array}{lcl} \left<V, \left<{arg}, \kappa, N\right>\right>_c &\rightarrow_c& \left<N, \left<{fun}, \kappa, V\right>\right>_v \end{array}\end{equation*}$

$N$ 也计算完后，进行

$\beta$ 归约：

? V, ? f u n, κ, λ X . L ? ? c \to c ? L [X \leftarrow V], κ ? v

$\begin{equation*}\begin{array}{lcl} \left<V, \left<{fun}, \kappa, \lambda X.L\right>\right>_c &\rightarrow_c& \left<L[X \leftarrow V], \kappa\right>_v \end{array}\end{equation*}$ 这个地方很有意思，可以看到函数调用最后 $\beta$ 归约的过程不会使continuation增长。所有求值过程中，会导致continuation增长的几个过程是基本运算中对参数的计算过程、函数调用中对函数的计算过程以及对参数的计算过程。一般也认为函数调用中函数的这个位置（也就是

(MN)

$(M \; N)$ 中

$M$ 这个位置）也算参数位置，所以判断一个函数调用是不是尾调用的依据是： 这个函数调用表达式是不是在一个参数位置，如果在参数位置，就不是尾调用。

上面分析的求值过程里增加了两种continuation：

κ = | | . . . ? a r g, κ, N ? ? f u n, κ, V ?

$\begin{equation*}\begin{array}{lcl} \kappa &=& ... \\ &|& \left<{arg}, \kappa, N\right> \\ &|& \left<{fun}, \kappa, V\right> \end{array} \end{equation*}$

代码实现

函数value-of/k是 $\rightarrow_v$ 。函数apply-cont是 $\rightarrow_c$ 。编写代码要注意对value-of/和apply-cont的调用都必须是尾调用。

过程 $\rightarrow_v$ 的代码：

出于写起来方便的原因，使用函数来保存continuation。用(end-cont)表示空的continuation mt。 (end-cont)只有在程序结束的时候才会运行一次。这里让(end-cont)打印了个">> Done!"，这个打印只会运行一次。如果打印了超过一次，或者没打印，那么代码肯定有错。

过程 $\rightarrow_c$ 的代码：

寄存器风格的代码实现

这小节换个方式写代码。求值过程有两个状态量：当前计算的表达式和当前的continuation。我们用两个全局变量the-exp和the-cont来保存这两个状态量。使用全局变量后，函数value-of/k和apply-cont就不再需要参数。另外，还需要一个全局变量来保存下一步是要进行 $\rightarrow_v$ 还是 $\rightarrow_c$ 。这个全局变量叫the-pc。这三个全局变量被称作寄存器（所以叫寄存器风格）。当the-pc的值为逻辑假#f时，解释器运行结束。现在解释器运行时就是不断的执行the-pc直到the-pc的值是#f。 mainloop是这个主循环的过程：