使用Lua Function表示Lambda calculus

http://blog.csdn.net/yuanlin2008/article/details/8627081

很多程序语言所带给你的“完美”的感觉都来自于数学抽象之美。

在Lua中，function被描述成“具有真正的词法范围的一类值”(first-class values with proper lexical scoping)。

所谓的“一类值”，应该满足以下条件:

• 可以被保存到变量和数据结构中
• 可以被当作子程序的参数和返回值
• 可以在运行期创建
• 具有内在标识，不依赖于任何给定的名称

大多数语言的基本数据类型，比如int，就属于“一类值”。很多语言中的函数实现，只能满足其中一些条件。比如在C中可以将函数指针保存到变量中，可以将函数指针当作参数和返回值。这样的函数实现一般不会被算作“一类值"。

在Lua中，所有的值都是“一类”值，包括function本身。函数可以被保存到任何的变量或者table中，可以被当作参数和返回值使用，所有的函数（更准确的说应该是closure）都是运行期被创建的，函数本身并没有名字，名字只是对函数的引用而已。作为“一类值”的function更为抽象，可以用来表示很多的"Functional Programming"的概念。比如“高阶函数”(Higher-order functions)，“匿名函数”(Anonymous functions")。这些功能在很多语言中都是通过特殊的语法来支持的，而在lua中则不需要。

而所谓的“真正词法范围”，则是说Lua function可以访问外围函数中的局部变量。这是通过lua的closure来实现的。

“具有真正的词法范围的一类值”使得Lua function可以用来表示"Lambda calculus"。Lambda calculus是Functional Programming的数学基础。他使用抽象的function和一套简单的规则来构建一个完整的等价于"Turing Machine"的计算模型。使用Lua function来表示Lambda calculus可以让你从另一个更真实的角度去理解Lambda calculus的语义，同时也可以更深入的体会Lua function功能的强大。并且对于程序员来说，这本身也是一个非常有趣的尝试。

Lambda calculus是一个操作lambda expression的系统。Lambda expression由variable，function abstraction和function application组成。我们可以使用一个Lua function的定义来代表一个function abstraction。这个function接受一个参数，也就是variable，并返回一个function。而对这个function的调用，就是function application。这样，我们就有了lambda calculus基本规则对应的lua实现。Lambda calculus可以通过如此简单的基本规则构建出各种高层语义，比如数据类型，算数和逻辑运算，循环和递归等等。这也就是说，理论上我们可以仅仅使用lua function，而不需要任何其他的语言功能，来进行任何的计算。我想这也就是"functional programming"的极限了吧。

我们首先来看一些最简单的function。

Identity

λx.x

单位函数直接返回应用的参数。对应的lua function为:

function identity(x)
    return x;
end

将一个identity应用到identity，结果还应该是identity。

λx.x λx.x=>λx.x

print(identity(identity) == identity)

Lua中的结果应该是true

Self Application Function

λs.(s s)

自应用函数将参数应用到参数本身。对应的lua function为:

function self_apply(s)
    return s(s);
end

将自应用函数应用到identity，最终会得到identity：

λs.(s s) λx.x => λx.x λx.x => λx.x

print(self_apply(identity) == identity);

将自应用函数应用到自身，会造成估值不能结束:

λs.(s s) λs.(s s) => λs.(s s) λs.(s s) =>...

同样，对于lua调用

self_apply(self_apply)

也会一直无限循环下去。由于self_apply函数中的s(s)是一个tail call，所以这个无限循环不会造成调用栈溢出。

Function Application Function

λf.λa.(f a)

函数应用函数将参数f应用到参数a上。对应的lua function为:

function apply(f)
    return (function(a)
        return f(a);
    end);
end

这个lua function与对应的lambda expression的语义完全一致：最外层函数接受一个参数f，函数体为λa.(f a)，也就是一个参数为a的函数。而这个内层函数的函数体为(f a)，也就是将f应用到a。

如果将此函数应用到identity：

λf.λa.(f a) λx.x => λa.(λx.x a)

会得到一个参数为a的函数。而对于lua function也是如此：

apply(identity)

会返回一个带有identity upvalue的函数对象。

如果将此函数连续应用到identity：

λf.λa.(f a) λx.x λx.x =>λa.(λx.x a) λx.x => λx.x λx.x => λx.x

效果就和将identity应用到自身是一样的。

对应的lua调用：

print(apply(identity)(identity) == identity)

应该返回true。

接下来，我们开始构建一些基础的function，并在这些基础上构建更高层的语义。

Boolean Values

在lambda calculas中，我们可以通过函数来表示boolean values。

• TRUE可以表示成λf.λs.f，代表选择两个参数中的第一个。
• FALSE可以表示成λf.λs.s，代表选择两个参数中的第二个。

其对应的lua function为：

function TRUE(f)
    return (function(s)
        return f;
    end);
end

function FALSE(f)
    return (function(s)
        return s;
    end);
end

我们可以测试一下这个lambda expression:

TRUE identity apply == λf.λs.f identity apply => λs.identity apply => identity

FALSE identity apply == λf.λs.s identity apply => λs.s apply => apply

同样，对应的lua调用也成立：

print(TRUE(identity)(apply) == identity) -- true
print(FALSE(identity)(apply) == apply) -- true

Condition

根据Boolean value的定义，我们可以构造出条件判断的lambda function:

λt.λf.λb.(b t f)

这个表达式的语义是根据boolean值b，来选择t或者f。如果b为TRUE，就选择t，否则选择f。

其对应的lua function为：

function COND(t)
    return (function(f)
        return (function(b)
            return b(t)(f);
        end);
    end);
end

我们可以通过将条件表达式应用到identity，apply和TRUE，来看一下结果：

λt.λf.λb.(b t f) identity apply TRUE => 
λf.λb(b identity f) apply TRUE => 
λb(b identity apply) TRUE => 
TRUE identity apply => 
identity

同样，对应的Lua调用也成立：

print(COND(identity)(apply)(TRUE) == identity) -- true

这等同于如下逻辑：

if(true)
    return identity
else
    return apply

至此，我们已经看到，仅仅使用lua function，就可以构造出基于if...else...的逻辑判断语义。

NOT

λb.(COND FALSE TRUE b) == λb.(λt.λf.λb(b t f) FALSE TRUE b) => λb(b FALSE TRUE)

这个表达式的语义是：当b为TRUE时，选择FALSE，否则选择TRUE。

对应的lua function:

function NOT(b)
    return b(FALSE)(TRUE);
end

print(NOT(TRUE) == FALSE); -- true
print(NOT(NOT(TRUE)) == TRUE); --true

AND

λx.λy.(COND y FALSE x) == λx.λy.(λt.λf.λb(b t f) y FALSE x) => λx.λy.(x y FALSE)

这个表达式的语义是：当x为TRUE时，选择y，否则选择FALSE。

对应的lua function:

function AND(x)
    return (function(y)
        return x(y)(FALSE);
    end);
end

print(AND(TRUE)(TRUE) == TRUE); -- true
print(AND(TRUE)(FALSE) == FALSE); -- true
print(AND(FALSE)(TRUE) == FALSE); -- true
print(AND(FALSE)(FALSE) == FALSE); -- true

OR

λx.λy.(COND TRUE y x) == λx.λy.(λt.λf.λb(b t f) TRUE y x) => λx.λy.(x TRUE y)

这个表达式的语义是：当x为TRUE时，选择TRUE，否则选择y。

对应的lua function:

function OR(x)
    return (function(y)
        return x(TRUE)(y);
    end);
end

print(OR(TRUE)(TRUE) == TRUE); -- true
print(OR(TRUE)(FALSE) == TRUE); -- true
print(OR(FALSE)(TRUE) == TRUE); -- true
print(OR(FALSE)(FALSE) == FALSE); -- true

至此，我们已经有了基本的逻辑运算符NOT，AND和OR。可以通过他们来组合出更复杂的boolean逻辑表达式。

Natural Numbers

使用lambda expression表示自然数，我们首先要定义0。我们将0定义为identity。

zero = identity

然后，定义一个succ函数，代表自然数n的下一个自然数：

λn.λb.(b FALSE n)

function succ(n)
    return (function(b)
        return b(FALSE)(n);
    end);
end

这样我们就可以定义出自然数1~9:

one     = succ(zero);
two     = succ(one);
three   = succ(two);
four    = succ(three);
five    = succ(four);
six     = succ(five);
seven   = succ(six);
eight   = succ(seven);
nine    = succ(eight);

每个自然数都使用一个函数来表示。

接着我们需要定义一个函数iszero来判断一个自然数是否为0：

λn.(n TRUE)

然后我们定义一个函数iszero，用来判断是否是0:

λn.(n TRUE)

function iszero(n)
    return n(TRUE);
end

print(iszero(zero) == TRUE) -- true
print(iszero(one) == FALSE) -- true

最后，我们还可以定义一个pred函数，用来获得一个自然数的前一个自然数：

λn.(COND zero (n FALSE) (iszero n)) => λn.((iszero n) zero (n FALSE))

function pred(n)
    return iszero(n)(zero)(n(FALSE));
end

这里面包含了当n为0时的特殊处理。当n为0时，返回0。

print(pred(one) == zero) -- true

至此，我们有了基本的自然数的表示方法。接下来，我们将利用自然数来计数，进行一个简单的循环。

Loop

在Functional Programming中，循环使用递归调用来进行。Lambda calculus的递归调用是通过将一个Y Conbinator函数引用到一个stepper函数来实现的。stepper函数代表了循环的每一次需要做的事情，而YConbinator函数则多次调用这个stepper函数，来表示循环。

Y Conbinator:

λf.(λx.(f (x x)) λx.(f (x x)))

function recursive(f)
    return (function(x)
        return f(x(x))
    )(function(x)
        return f(x(x))
    end)
end

stepper函数我们将它设计为传入一个自然数然后递减：

λs.λn.(COND zero (s (pred n) (iszero n))

function stepper(next_step)
    return (function(n)
        return COND(zero)(next_step(pred(n))(iszero(n))
    end)
end

当我们调用：

recursive(stepper)(five)

这个调用并没有之循环5次，而是会无限递归下去，直到栈溢出。原因在于我们对于lambda expression的reduction采用的是normal order，而lua版本实际上等于applicative order reduction。Applicative order reduction在此情况下会无限递归。解决这个问题的办法就是延迟一些字表达式的估值。我们可以将这两个函数改写为：

function recursive(f)
    return (function(x)
        return f(function(dummy) return x(x) end)
    end)(function(x)
        return f(function(dummy) return x(x) end)
    end)
end

function stepper(next_step)
    return (function(n)
        return COND(function(dummy)
            return zero
        end)(function(dummy)
            print("one step");
            return next_step(identity)(pred(n))
        end)(iszero(n))(identity)
    end)
end

当我们再次调用:

recursive(stepper)(five)

我们会看到这个循环正确的执行了5次。

综上所述，我们已经使用lua function作为lambda calculas的表示形式，从新构建了一个包含了高层语义的计算模型，从而也体会到了lua function高度抽象的能力。希望对大家学习lambda calculus和lua function有所帮助。