使用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有所帮助。


展开阅读全文
©️2020 CSDN 皮肤主题: 编程工作室 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值