lua工具库penlight--07函数编程（二）

列表压缩

列表压缩是以紧凑的方式通过指定的元素创建表。在 Python里，你可以说：

 ls = [x for x in range(5)]  # == [0,1,2,3,4]

 

在 Lua，使用pl.comprehension :

 > C = require('pl.comprehension').new()

 > = C ('x for x=1,10') ()

 {1,2,3,4,5,6,7,8,9,10}

 

C是一个函数，它将一个列表字符串编译成一个函数。在这种情况下，该函数有没有参数。考虑一个字符串作为函数参数括号是冗余的，因此可以：

 > = C 'x^2 for x=1,4' ()

 {1,4,9,16}

 > = C '{x,x^2} for x=1,4' ()

 {{1,1},{2,4},{3,9},{4,16}}

 

注意该表达式可以是任何变量x的函数!

基本的语法到目前为止是 for ，可以是任何 Lua for理解的语句，也可以只是变量，在这种情况下的值将来自该参数的“语句”。在这里我强调，“语句”是可以带列表参数的函数：

 > = C '2*x for x' {1,2,3}

 > = C '2*x for x' {1,2,3}

 {2,4,6}

 > dbl = C '2*x for x'

 > = dbl {10,20,30}

 {20,40,60}

 

这里是稍微更加明确说明，1是的占位符参数，指传递给“语句”的第一个参数。

 > = C '2*x for _,x in pairs(_1)' {10,20,30}

 {20,40,60}

 > = C '_1(x) for x'(tostring,{1,2,3,4})

 {'1','2','3','4'}

 

当您想要一些收集结果的迭代器，如io.lines，此扩展的语法非常有用。这里“语句”创建一个函数，为文件中所有行创建一个表：

 > f = io.open('array.lua')

 > lines = C 'line for line in _1:lines()' (f)

 > = #lines

 118

 

许多函数都可以应用到“语句”的结果：

 > = C 'min(x for x)' {1,44,0}

 0

 > = C 'max(x for x)' {1,44,0}

 44

 > = C 'sum(x for x)' {1,44,0}

 45

 

（这些是相当于减少操作）。

可能在for的后面有条件，用来筛选输出。下面这条“语句”收集偶数列表：

 > = C 'x for x if x % 2 == 0' {1,2,3,4,5}

 {2,4}

 

可能有多个for部分：

 > = C '{x,y} for x = 1,2 for y = 1,2' ()

 {{1,1},{1,2},{2,1},{2,2}}

 > = C '{x,y} for x for y' ({1,2},{10,20})

 {{1,10},{1,20},{2,10},{2,20}}

 

这些“语句”很有用，特别是处理多个变量时，如果用其他的Penlight函数，不是那么轻易达到目的。

 

 

从函数创建函数

Lua 函数像任何其他值，当然你不能乘或添加它们（原文，of course you cannot multiply or add them.）。有意义的操作是函数组成compose，即函数调用链 （如(f * g)(x)是f(g(x)).)

 > func = require 'pl.func'

 > printf = func.compose(io.write,string.format)

 > printf("hello %s\n",'world')

 hello world

 true

 

许多功能需要您将一个函数作为参数传递，如应用于所有值的序列或作为一个回调。经常，有用的函数具有错误的参数数目。所以有必要将传给函数的两个参数变为一个参数，一个绑定到一个给定值的额外参数。

部分应用的 有n 个参数的函数，并返回 n-1 个参数，它的第一个参数绑定到一些值：

 > p2 = func.bind1(print,'start>')

 > p2('hello',2)

 start>  hello   2

 > ops = require 'pl.operator'

 > = tablex.filter({1,-2,10,-1,2},bind1(ops.gt,0))

 {-2,-1}

 > tablex.filter({1,-2,10,-1,2},bind1(ops.le,0))

 {1,10,2}

（译注：即有些函数是两个参数，但是调用者只能传递一个参数，于是需要一个bind1，绑定一个预定的值，这样传入的一个参数与这个预定值比较。）

不幸的是最后一个例子结果相反，因为bind1总是绑定的第一个参数 ！（译注：0<x，结果都是比0大的）。此外不幸的是，之前我困惑 '扩充' 与 '部分应用'，所以bind1的旧名称是curry— — 此别名仍然存在。

 

这是一种特殊的形式的函数参数绑定。这里是另一种方法说的打印示例：

 > p2 = func.bind(print,'start>',func._1,func._2)

 > p2('hello',2)

 start>  hello   2

 

这里1 和 2是占位符变量，分别对应于第一和第二个参数。

func 会让人分心，所以可以把 pl.func拉到本地上下文中。这里是筛选器的例子：

 > utils.import 'pl.func'

 > tablex.filter({1,-2,10,-1,2},bind(ops.gt, _1, 0))

 {1,10,2}

（译注：即不用写func）

tablex.merge可以合并两个表。此示例演示绑定函数最后一个参数的用处。

 > S1 = {john=27, jane=31, mary=24}

 > S2 = {jane=31, jones=50}

 > intersection = bind(tablex.merge, _1, _2, false)

 > union = bind(tablex.merge, _1, _2, true)

 > = intersection(S1,S2)

 {jane=31}

 > = union(S1,S2)

 {mary=24,jane=31,john=27,jones=50}

 

当用bind 把print绑定时，我们得到有两个参数的函数，而我们真正想要的是使用 varargs ，就像print一样（译注：可变参数）。这是_0的作用:

 > _DEBUG = true

 > p = bind(print,'start>', _0)

 return function (fn,_v1)

     return function(...) return fn(_v1,...) end

 end

（译注：上面的是bind后输出的结果，不是手工输入的）

 > p(1,2,3,4,5)

 start>  1       2       3       4       5

 

我已经开启全局DEBUG标志，以便打印出生成的函数来。它是实际的函数， 第一次调用绑定值的 v1到 ' start >'。

 

占位符表达式

在Penlight中的常见模式是把函数应用于一个表或序列的所有元素，如tablex.map或seq.filter。Lua 有匿名函数，虽然他们可能有点乏味：

 > = tablex.map(function(x) return x*x end, {1,2,3,4})

 {1,4,9,16}

 

pl.func允许您定义的占位符表达式，可以砍倒烦恼的打字，并且还使您的意图更明确。首先，我们把pl.func的引入到我们的上下文，以提供表达式中使用占位符变量，例如1，2，等等 （c + + 程序员将会认识到这从 Boost 库借鉴)

 > utils.import 'pl.func'

 > = tablex.map(_1*_1, {1,2,3,4})

 {1,4,9,16}

 

可以生成的最多 5 个参数的函数。

 > = tablex.map2(_1+_2,{1,2,3}, {10,20,30})

 {11,22,33}

 

这些表达式可以使用任意函数，他们必须首先注册到函数编程库。func.register引入单个函数，func.import导入整个表的功能，如math.

 > sin = register(math.sin)

 > = tablex.map(sin(_1), {1,2,3,4})

 {0.8414709848079,0.90929742682568,0.14112000805987,-0.75680249530793}

 > import 'math'

 > = tablex.map(cos(2*_1),{1,2,3,4})

 {-0.41614683654714,-0.65364362086361,0.96017028665037,-0.14550003380861}

 

常见的操作是对调用一组对象的方法：

 > = tablex.map(_1:sub(1,1), {'one','four','x'})

 {'o','f','x'}

 

PEs 的操作有一些限制。例如， __len 元方法不能被普通的 Lua 表重写，因为我们需要定义一个特殊的函数来表达#_1':

 > = tablex.map(Len(_1), {'one','four','x'})

 {3,4,1}

 

同样对于比较运算符，不能比较不同的类型，必须表示为一个特殊的函数：

 > = tablex.filter(Gt(_1,0), {1,-1,2,4,-3})

 {1,2,4}

 

函数返回多个值是非常有用的。例如， tablex.pairmap期望函数返回键和值，并返回新值和键。

 > = pairmap(Args(_2,_1:upper()),{fred=1,alice=2})

 {ALICE=2,FRED=1}

 

PEs 不能包含nil值，因为 PE 函数参数表示为一个数组。相反，提供一个特别的值称为Nil。所以请用1:f(Nil,1) 而不是 1:f(nil,1).

 

占位符表达式，不能自动作为 Lua 函数的使用，必须将调用运算符重载构造函数调用如_1(1)。如果您想要强制一个 PE 要返回一个函数，请使用 func.I .

 > = tablex.map(_1(10),{I(2*_1),I(_1*_1),I(_1+2)})

 {20,100,12}

 

在这里我们考虑含有单个参数函数的表，然后用10调用它们。

用 PEs 的基本理念是用引号界定一个表达式，因此它不会立即进行计算，而是变成了一个以后可以应用到的某些参数的函数。基本机制是包裹值和占位符，这样普通的Lua 运算符有建立一个表达式树的效果。(这样你可以使用 PEs做符号代数，请参阅symbols.lua中的示例，testsym.lua演示了象征性分化的测试)。

 

规则是如果任何运算符有 PE 操作数，结果会被引号引起。有时我们需要显式引用的东西。例如，如果该元素值是set里的，我们会想传递一个必须返回 true的函数给筛选器。set[1]是的明显的表达式，但是它没有返回所需的结果，因为它直接计算结果，得到了nil。索引比二元运算相比，如加法 （set +1适当地使用引号），有些不同。所以有显式引用或包装操作的需求。这就是function干的事情， 在这种情况下，PE应该是 (set)[1]。这适用于函数，方便的替代办法是注册函数： (math.sin)(_1)。这就相当于使用lines' 方法:

 for line in I(_(f):read()) do print(line) end

 

'类文件' 的对象都可以工作，只要有返回下一行的read方法。如果你有一个 LuaSocket 客户，被服务器逐行‘推’，那么_(s):receive ‘*l’将会创建一个迭代器用于接收输入。这些形式可以方便的调整您的数据流量，使它可以传递到pl.seq'的函数.

 

占位符表达式可以和序列的包装表达式混合。lexer.lua 将给我们双值标记，其中的第一个是类型，第二个是值。我们筛选出类型为 'iden'，使用map提取实际值， 获取唯一值，最后将结果存到list中。

 > str = 'for i=1,10 do for j = 1,10 do print(i,j) end end'

 > = seq(lexer.lua(str)):filter('==','iden'):map(_2):unique():copy()

 {i,print,j}

 

这看起来特别密集（我总是觉得不应该在一行程序解决一切!） ；关键是map的行为，它使用序列的两个值，因此_2返回的值部分。（因为filter在这里使用额外的参数，它只操作类型值。)

使用占位符表达式，有一些性能需求要考虑到。实例化一个 PE 需要构建和编译一个函数，这不是这种快速的操作。所以要获得最佳性能，从循环里分解出 PEs  ；

 local fn = I(_1:f() + _2:g())

 for i = 1,n do

     res[i] = tablex.map2(fn,first[i],second[i])

 end