简单易懂的程序语言入门小册子（2）：基于文本替换的解释器，加入整数类型

为了有条不紊地实现一个解释器，我将按以下三个步骤走：

1. 明确语法 
2. 针对语法描述求值过程  
3. 根据求值过程编写代码实现

语法

$\lambda$演算不适合作为一门实际使用的程序语言。 $\lambda$演算只有变量和函数两种类型，而其他常用类型如整数、布尔、字符等都没有。 虽然可以通过编码的方式表示这些常用类型，但这样也很麻烦。 通常直接扩展$\lambda$演算，加入一些常用类型以及针对这些类型的基本运算。 这种扩展后的语言简称为ISWIM，全称未知……

为简单起见，我只加入整数类型，以及加法和减法。 扩展后的语法如下：

$$\begin{eqnarray*}   M, N, L &=& X \\           &|& b \\           &|& \lambda X.M \\           &|& (+ \; M \; N) \\           &|& (- \; M \; N) \\           &|& (M \; N) \end{eqnarray*}$$ 新加入的第二行$b$表示一个整数， 第四行是一个加法运算的表达式， 第五行是一个减法运算的表达式。

求值过程

为了描述一个计算这门语言的解释器的求值过程，首先要明确求值停止条件。 我们规定当归约到$X$，$b$，$\lambda X.M$这三种表达式之一时，认为解释器已经求出了最终结果。 这三种表达式称为值，用字母$V$表示。

$$\begin{eqnarray*}   V &=& X \\     &|& b \\     &|& \lambda X.M \end{eqnarray*}$$

用记号$eval(M)$表示表达式$M$的求值结果。 对于值，求值只需返回它们自身。

$$\begin{eqnarray*}   eval(X) &=& X \\   eval(b) &=& b \\   eval(\lambda X.M) &=& \lambda X.M \end{eqnarray*}$$ 加减法和函数调用这三行是递归定义，所以求值过程也是递归的。 $$\begin{eqnarray*}   eval((+ \; M \; N)) &=& eval((+ \; V_1 \; V_2)) \\   eval((- \; M \; N)) &=& eval((- \; V_1 \; V_2)) \\   eval((M \; N)) &=& eval((V_1 \; V_2)) \end{eqnarray*}$$ 其中$V_1=eval(M)$，$V_2=eval(N)$。

为了让解释器尽量简单，假设输入的程序是正确的。 也就是说，对于加减法运算的$V_1$和$V_2$都是整数，记为$b_1$和$b_2$； 函数调用里的$V_1$是一个函数$\lambda X.L$。

加减法如字面本意，就是作加减法。 函数调用过程是一个$\beta$归约过程。

$$\begin{eqnarray*}   eval((+ \; b_1 \; b_2)) &=& b_1 + b_2 \\   eval((- \; b_1 \; b_2)) &=& b_1 - b_2 \\   eval((\lambda X.L \; V_2)) &=& eval(L[X \leftarrow V_2]) \end{eqnarray*}$$

由于加入了新的语法，替换过程也要添加相应的过程。 这里列上整个替换过程：

$$\begin{eqnarray*}   X_1[X_1 \leftarrow N] &=& N \\   X_2[X_1 \leftarrow N] &=& X_2 \\   &&其中X_1 \neq X_2 \\   b[X \leftarrow N] &=& b \\   (\lambda X_1.M)[X_1 \leftarrow N] &=& (\lambda X_1.M) \\   (\lambda X_1.M)[X_2 \leftarrow N] &=& (\lambda X_3.M[X_1 \leftarrow X_3][X_2 \leftarrow N]) \\   &&其中X_1 \neq X_2, X_3 \notin FV(N), X_3 \notin FV(M)\backslash\{X_1\} \\   (+ \; M_1 \; M_2)[X \leftarrow N] &=& (+ \; M_1[X \leftarrow N] \; M_2[X \leftarrow N]) \\   (- \; M_1 \; M_2)[X \leftarrow N] &=& (- \; M_1[X \leftarrow N] \; M_2[X \leftarrow N]) \\   (M_1 \; M_2)[X \leftarrow N] &=& (M_1[X \leftarrow N] \; M_2[X \leftarrow N]) \end{eqnarray*}$$

最后总结求值过程如下：

$$\begin{eqnarray*}   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((M \; N)) &=& eval(L[X \leftarrow eval(N)]) \\                  && 其中 eval(M) = \lambda X.L \end{eqnarray*}$$

实现

这里使用Racket语言来编写解释器。 解释器输入不使用字符串，而是用Racket的符号系统。 使用符号系统是为了简化语法分析的工作。 利用Racket的模式匹配可以方便地实现语法分析。 另外，计算机输入$\lambda$还是很麻烦的，所以在具体实现的语言中用(lambda X M)代替$\lambda X.M$。

解释器是一个实现了$eval$函数的程序。 代码是求值过程的公式逐句转换，就不一一解释了。 value-of是求值过程：

substitute是替换过程：

在替换过程中有一处需要生成新变量(new-tmp-var)。 新变量不能和被代入的表达式中的自由变量重名。 一个选取新变量的方法就是选择程序里肯定不会出现的变量名。 我假定输入的程序没有以井号“#”开头的变量。 新生成的就以井号加数字的方式命名：#1, #2, #3,...。

测试一下：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

'a >> 'a   12 >> 12   '(+ 12 13) >> 25   '(- 32 23) >> 9   '(lambda x (+ x 1)) >> '(lambda x (+ x 1))   '((lambda x (- x 1)) 22) >> 21   '(((lambda x x) (lambda y y)) 11) >> 11   '(((lambda x (lambda y x)) y) 0) >> 'y

惰性求值

惰性求值指对一个表达式，只有在需要它的计算结果时才对它求值。

对于函数调用的求值过程，参数$N$可以先不进行求值：

$$\begin{eqnarray*}   eval((M \; N)) &=& eval(L[X \leftarrow N]) \\                  && 其中 eval(M) = \lambda X.L \end{eqnarray*}$$ 这种函数调用的求值方式就叫做call-by-name。 Call-by-name是一种惰性求值的调用方式。

在函数调用过程中先对参数求值的调用方式叫做call-by-value。 下面用例子展示这两种调用方式的不同。

Call-by-value：

$$\begin{eqnarray*}   &&(\lambda x.(+ \; x \; x) \; (+ \; 2 \; 3)) \\   &\rightarrow& (\lambda x.(+ \; x \; x) \; 5) \\   &\rightarrow& (+ \; 5 \; 5) \\   &\rightarrow& 10 \end{eqnarray*}$$

Call-by-name：

$$\begin{eqnarray*}   &&(\lambda x.(+ \; x \; x) \; (+ \; 2 \; 3)) \\   &\rightarrow& (+ \; (+ \; 2 \; 3) \; (+ \; 2 \; 3)) \\   &\rightarrow& (+ \; 5 \; 5) \\   &\rightarrow& 10 \end{eqnarray*}$$ Call-by-name的过程中$(+ \; 2 \; 3)$被计算了两次。 为了避免重复计算，有另一种同为惰性求值的调用方式叫call-by-need。 Call-by-need以后再介绍。

在两者都能成功求值的情况下，call-by-name的求值结果和call-by-value的求值结果是一样的。 它们的区别在于两者的求值过程不同。 看下面这个表达式：

$$((\lambda y.\lambda x.x \; (\lambda x.(x \; x) \; \lambda x.(x \; x))) \; (+ \; 12 \; 21))$$

如果用call-by-value的方式求值，必然要先求$(\lambda x.(x \; x) \; \lambda x.(x \; x))$的值。 而$(\lambda x.(x \; x) \; \lambda x.(x \; x))$是个无限循环。 所以call-by-value的调用方式会陷入死循环。

如果用call-by-name的方式求值，由于函数$\lambda y.\lambda x.x$中的函数体其实没涉及到$y$的， 所以$(\lambda x.(x \; x) \; \lambda x.(x \; x))$这个参数就函数调用过程后默默地消失了：

$$\begin{eqnarray*}   &&((\lambda y.\lambda x.x \; (\lambda x.(x \; x) \; \lambda x.(x \; x))) \; (+ \; 12 \; 21)) \\   &\rightarrow& (\lambda x.x \; (+ \; 12 \; 21)) \\   &\rightarrow& (+ \; 12 \; 21) \\   &\rightarrow& 33 \end{eqnarray*}$$

Call-by-name的代码实现只需在原来的基础上改一行：