lua工具库penlight--01简介
lua的设计目标是嵌入式语言，所以和其它动态语言（如python、ruby）相比其自带的库缺少很多实用功能。
好在有lua社区有Penlight，为lua提供了许多强大的功能，接下来的几篇博客，我会简译Penlight的wiki。
目的
常有人说lua不带电池。因为lua的目标是可以运行在各种机器上的简洁语言，（有些机器甚至不
支持布尔系统）。lua类似于操作系统内核（注：即不是完整的系统，只有基本功能），lua的作者
并没有把围绕lua开发完整的生态系统看做自己的职责。这是社区的角色。
软件设计的原则是识别通用模式，并复用。这不但让代码更易管理，而且更易阅读。
Penlight使用了许多编码原则，这样你的代码变得更简洁。如在Lua里通常用{unpack(t)}复制
表，但这只对“小”表有用而且不健壮。因此Penlight提供了tablex.deepcopy()，它可以用来复制
嵌套的表和相关联的元表，所以可以用它复制复杂对象。
lua默认采用这样的错误处理：如果参数类型错误，抛出错误；如果有问题，返回nil,message。
也有些例外的函数，如input.fields默认是返回message并立即关闭程序（可以改变默认方式）。
对脚本而言，与提供堆栈跟踪相比，这是更合适的方式。词法函数为了简化编码，总是返回错误，
必须用pcall封装。
如果你习惯Python的约定，注意lua里的索引从1开始。
lua不建议用table.foreach，而是泛型for，但是使用Penlight提供的高阶函数，它在某些情况下
特别有用。注意tablex.foreach，颠倒了顺序，先传值，之后索引。虽然乖张，符合预期要更好。
Penlight唯一外部依赖是 LuaFileSystem (lfs )，如果你想dir.copyfile在Windows上成功工作
，你需要 alien 或 LuaJIT 。（如果失败，会调用等效的shell命令）
注入还是不注入
人们很早就意思到大的程序里需要保证命名清晰的方法，如tables (Lua), namespaces (C++)
或modules (Python)。在大公司里很容易遇到命名冲突，在一些简单的语言，如Lua，并没有提
供像C++那样解决命名冲突的详细机制，因此更易遇到。在一小圈朋友里‘Bruce‘是唯一的，不需
要加姓。这取决于你写十多行的脚本，还是上万行的程序。
Penlight提供了正规和非正规两种方式，你可以随意使用。
正规方式：
local utils = require 'pl.utils'
utils.printf("%s\n","hello, world!")
非正规方式： require 'pl'
utils.printf("%s\n","That feels better") require ‘pl’ 让所有的Penlight模块可用，而不需要单独调用。
正规方式在写模块时更好。
Andrew Starks贡献了另一种方法，很好的在两种方法里取得了平衡。
require'pl.import_into'返回一个函数，它有一个表参数，把Penlight库导入，如果参数为空，返回一个新的。
local pl = require'pl.import_into'()
pl表是一个 ‘lazy table’，即按需载入，因此可以使用pl.utils.printf，这样不会污染全局。
如果你在lua5.2里使用 _ENV来定义模块，要用Penlight可以这么做：
local _ENV,M = require 'pl.import_into' ()
function answer ()
-- all the Penlight modules are available!
return pretty.write(utils.split '10 20 30', '')
end
return M默认把Penlight放在_ENV里，可能会对模块造成意外效果（和 module(…,package.seeall)一样）
。为了方便和安全，你需要向这个函数传入true，这样module M就和_ENV不一样，只包含导出的
函数。（注：对lua5.2不了解，这句话不解）
你想把pl.stringx里的函数导入到标准库里，可以这么做：
require 'pl' stringx.import()
或者，更快的：
require('pl.stringx').import()
更好的方法师把表导入到局部环境，这样可以让名称简介。> require 'pl' > utils.import(math) --把math里的函数直接导入到全局 > = sin(1.2) 0.93203908596723
当第一次require来导入时，utils.import 的参数也可以是字符串。在module里使用时，import会
把符号导入到module的上下文。
对于动态语言，保持全局域简洁是很重要的。 pl.strict模块，引入了简单的强制措施：全局变量必须
声明。如下：
> require 'pl.strict' > print(x) stdin:1: variable 'x' is not declared > x = nil > print(x) nil
strict模块符合Penlight的“用时加载”策略。
strict也禁止对全局变量赋值，除非在主程序里。如果你想绕过这个机制使用rawset和rawget。
如果你想让strict全局生效，在pl/init.lua最后加上require 'pl.strict',并在主程序里调用。
从1.1.0之后，strict提供了strict.module函数来创建（或修改）模块，以符合此机制。
如：
-- mymod.lua
local strict = require 'pl.strict'
local M = strict.module (...)
function M.answer ()
return 42
end
return M如果你不小心错打成 mymod.Answer()，你会得到运行时错误：“variable ‘Answer’ is not declared
in ‘mymod’”。
这对已有的模块也有效，也可以修改lua标准库。
strict.make_all_strict(_G)
这样当你错打成math.cosine时会得到错误信息，而不是nil。
Penlight的函数参数是什么？
许多Penlight里的函数的参数是函数，如map，它把函数作用到table的每个元素上。
pl.operator 导出了lua里的运算符，且和Python里的名字一样。如 operator.gt表示">".
map函数传递任何参数到函数，因此可以简写ls:filter(function(x) return x > 0 end)
为ls:filter(‘>’,0)
最后，pl.func支持Boost lambda（译注：C++里的）的占位符，如一个乘法的匿名函数可以
表示为；_1*_2.
可以直接用，在Penlight里的所有的函数参数都会通过 utils.function_arg ，pl.func在这个
函数中注册。所以你可以直接在标准函数里使用占位符。
> _1 = func._1
> = List{10,20,30}:map(_1+1)
{11,21,31}
（译注：_1,_2表示第几个参数）另外一个有用的是utils.string_lambda ，也会自动调用
> = List{10,20,30}:map '|x| x + 1'
{11,21,31}
（译注：即|x|=x+1）少用循环的利弊
循环是一种更机器的方式，如：
local res = {}
for i = 1,#ls do
res[i] = fun(ls[i])
end
但是这可以更高效的写作，ls:map(fun)，不但代码更少，而且更易理解。
通常人们认为，这么写效率低，更消耗内存。如ls1:map2(‘*’,ls2):reduce ‘+’
会产生多余的临时对象。但是效率是相对的。
写循环容易出错而且乏味。（译注：省略了许多议论，结论是利大于弊）
通用函数
utils.memoize用来存储需要多次调用且花销大的函数。它可以保存调用函数后的已有结果，
如果参数相同直接返回结果。
sum = utils.memoize(function(n)
local sum = 0
for i = 1,n do sum = sum + i end
return sum
end)
...
s = sum(1e8) --takes time!
...
s = sum(1e8) --returned saved value!应用支持
app.parse_args是一个简单的命令行参数解析器，支持gnu风格。
app.appfile，用来存储应用的配置。
prett模块让table更易读。（译注：省略了很多用法讲解，可以直接看api）
简单的面向对象
提供了面想对象的支持，
-- animal.lua
class = require 'pl.class'
class.Animal()
function Animal:_init(name)
self.name = name
end
function Animal:__tostring()
return self.name..': '..self:speak()
end
class.Dog(Animal)
function Dog:speak()
return 'bark'
end
class.Cat(Animal)
function Cat:_init(name,breed)
self:super(name) -- must init base!
self.breed = breed
end
function Cat:speak()
return 'meow'
end
class.Lion(Cat)
function Lion:speak()
return 'roar'
end
fido = Dog('Fido')
felix = Cat('Felix','Tabby')
leo = Lion('Leo','African')
$ lua -i animal.lua
> = fido,felix,leo
Fido: bark Felix: meow Leo: roar
> = leo:is_a(Animal)
true
> = leo:is_a(Dog)
false
> = leo:is_a(Cat)
true
也可以这么写： local class = require 'pl.class'
class.Named {
_init = function(self,name)
self.name = name
end;
__tostring = function(self)
return 'boo '..self.name
end;
}
b = Named 'dog'
print(b)
--> boo dog
Penlight提供了一些有用的类如：List，Set，Map，MultiMap,OrderdMap.
所有的类有catch函数，可以处理未预料的情况，如：Strings:catch(function(self,name)
return function() error("no such method "..name,2) end
end)
上面只是简单的输出错误，但你可以创造一些好玩的，如； Strings:catch(List.default_map_with(string))
ls = Strings{'one','two','three'}
asserteq(ls:upper(),{'ONE','TWO','THREE'})
asserteq(ls:sub(1,2),{'on','tw','th'})
（译注：list没有upper,sub,但是catch让没有的函数都执行string里函数）cast类型转换，它不产生新对象，而是返回你传入的对象。
local sizes = ls:map '#' --即取长度
asserteq(sizes, {3,3,5})
asserteq(utils.type(sizes),'Strings')
asserteq(sizes:is_a(Strings),true)
sizes = Vector:cast(sizes)
asserteq(utils.type(sizes),'Vector')
asserteq(sizes+1,{4,4,6})
（译注，ls即Strings{'one','two','three'}）utils.type可以返回类中_name属性的字符串。
属性模式，我们想控制用户对属性的访问，但不想让用户，使用obj:get_field()这么长
的代码访问。解决办法如下：
local MyProps = class(class.properties)
local setted_a, got_b
function MyProps:_init ()
self._a = 1
self._b = 2
end
function MyProps:set_a (v)
setted_a = true
self._a = v
end
function MyProps:get_b ()
got_b = true
return self._b
end
local mp = MyProps()
mp.a = 10
asserteq(mp.a,10)
asserteq(mp.b,2)
asserteq(setted_a and got_b, true) 规则是内部的变量以"_"开头，当访问mp.a时先检查特定的getter（取值器），
get_a。同理setter（设定器)也被使用了。
当然这也带来了更多的花销，所以你需要自己把握。
原文：http://stevedonovan.github.io/Penlight/api/topics/01-introduction.md.html