{"id":64,"date":"2015-05-22T12:00:39","date_gmt":"2015-05-22T17:00:39","guid":{"rendered":"http:\/\/www.playwithlua.com\/?p=64"},"modified":"2015-05-19T23:44:35","modified_gmt":"2015-05-20T04:44:35","slug":"my-lua-init-file","status":"publish","type":"post","link":"http:\/\/www.playwithlua.com\/?p=64","title":{"rendered":"My Lua init file"},"content":{"rendered":"

I don’t think it’ll surprise anyone when I say that I think Lua is a great language. But, it does have a very small standard library. So, there are a few other utilities that I end up including or writing in almost everything I do. Luckily, Lua has a facility for loading them automatically when I open up the REPL.
\n<\/p>\n

How to invoke it<\/h2>\n

Lua, when the REPL starts up, reads an environment variable called LUA_INIT<\/code>. If this variable contains Lua code, it runs it; otherwise, if it begins with an “@” symbol, it’ll read it as the name of a file to run. So, in my .bashrc<\/code> I have this line:<\/p>\n

\r\n# Lua init\r\nexport LUA_INIT=\"@$HOME\/.lua\/init.lua\"\r\n<\/pre>\n
My .lua directory<\/h2>\n
There are three things I load every time: the “inspect” library<\/a> and the “middleclass” library<\/a>, both by Enrique Garcia, and LPeg<\/a>, by Roberto Ierusalimschy. So, here’s the complete listing of what I have:<\/p>\n
\r\n-rw-rw-r-- 1 randrews randrews  1465 May 17 22:52 init.lua\r\n-rw-rw-r-- 1 randrews randrews  9183 May 10 12:36 inspect.lua\r\n-rwxrwxr-x 1 randrews randrews 52048 May 17 22:49 lpeg.so\r\n-rw-rw-r-- 1 randrews randrews  6116 May 10 11:45 middleclass.lua\r\n-r--r--r-- 1 randrews randrews  6286 May 17 22:49 re.lua\r\n<\/pre>\n
(re<\/code> is a regular expression library that comes with LPeg)<\/p>\n
The init.lua<\/code> file itself starts out by including the three libraries:<\/p>\n\n
package.<\/span>path =<\/span> package.<\/span>path ..<\/span> ";"<\/span> ..<\/span> os.getenv<\/span>(<\/span>"HOME"<\/span>)<\/span> ..<\/span> "\/.lua\/?.lua"<\/span>\npackage.<\/span>cpath =<\/span> package.<\/span>cpath ..<\/span> ";"<\/span> ..<\/span> os.getenv<\/span>(<\/span>"HOME"<\/span>)<\/span> ..<\/span> "\/.lua\/?.so"<\/span>\ninspect =<\/span> require<\/span> 'inspect'<\/span>\nclass =<\/span> require<\/span> 'middleclass'<\/span>\nlpeg =<\/span> require<\/span> 'lpeg'<\/span>\nre =<\/span> require<\/span> 're'<\/span><\/pre><\/div><\/div><\/div>\n\n
Note that I have to stick the .lua<\/code> directory on to both package.path<\/code> and package.cpath<\/code>, because in all likelihood I’m not running the REPL from the .lua<\/code> directory itself: the normal path element of \"?.lua\"<\/code> won’t find these.<\/p>\n
Table utilities<\/h2>\n
After that, I put in a few things that I think make using tables easier. To begin with, I noticed that most of the standard library functions in the table<\/code> table take a table as the first parameter, meaning it would be very convenient to call them as methods. So, I make a shortcut to create a table that has table<\/code> as its metatable:<\/p>\n\n
setmetatable<\/span>(<\/span>table<\/span>,<\/span>\n             {<\/span> __call =<\/span> function<\/span>(<\/span>_,<\/span> ...<\/span>)<\/span>\n                   return<\/span> setmetatable<\/span>(<\/span>{<\/span>...<\/span>}<\/span>,<\/span> table<\/span>.<\/span>mt)<\/span> end<\/span> }<\/span>)<\/span>\n \ntable<\/span>.<\/span>mt =<\/span> {<\/span>\n    __index =<\/span> table<\/span>,<\/span>\n    __tostring =<\/span> function<\/span>(<\/span>self)<\/span>\n        return<\/span> "{"<\/span> ..<\/span> self:<\/span>map(<\/span>tostring<\/span>)<\/span>:<\/span>concat(<\/span>", "<\/span>)<\/span> ..<\/span> "}"<\/span>\n    end<\/span>\n}<\/span><\/pre><\/div><\/div><\/div>\n\n
This means I can do something like this:<\/p>\n\n
t =<\/span> table<\/span>(<\/span>1<\/span>,<\/span>2<\/span>,<\/span>3<\/span>)<\/span>\nprint<\/span>(<\/span>t)<\/span> -- prints "{1, 2, 3}"<\/span>\nt:<\/span>insert(<\/span>4<\/span>)<\/span>\ns =<\/span> t:<\/span>concat(<\/span>":"<\/span>)<\/span> -- s is now "1:2:3:4"<\/span><\/pre><\/div><\/div><\/div>\n\n
It’s just a convenient shorthand, and having a real tostring<\/code> is very helpful in the REPL.<\/p>\n
Higher-order functions<\/h2>\n
You may have noticed that map<\/code> function in there. I also defined a couple handy functions of my own in table<\/code>. That’s the first, map<\/code>, which transforms a table into another table using a function:<\/p>\n\n
t =<\/span> table<\/span>(<\/span>1<\/span>,<\/span>2<\/span>,<\/span>3<\/span>,<\/span>4<\/span>)<\/span>\nt2 =<\/span> t:<\/span>map(<\/span>function<\/span>(<\/span>x)<\/span> return<\/span> x*<\/span>x end<\/span>)<\/span>\nprint<\/span>(<\/span>t2)<\/span> -- prints "{1, 4, 9, 16}"<\/span><\/pre><\/div><\/div><\/div>\n\n
It’s much more terse than a for<\/code> loop, and present in all functional languages. It’s defined like this:<\/p>\n\n
function<\/span> table<\/span>:<\/span>map(<\/span>fn,<\/span> ...<\/span>)<\/span>\n    local<\/span> t =<\/span> table<\/span>(<\/span>)<\/span>\n    for<\/span> _,<\/span> e in<\/span> ipairs<\/span>(<\/span>self)<\/span> do<\/span>\n        local<\/span> _,<\/span> r =<\/span> fn(<\/span>e,<\/span> ...<\/span>)<\/span>\n        t:<\/span>insert(<\/span>r)<\/span>\n    end<\/span>\n    return<\/span> t\nend<\/span><\/pre><\/div><\/div><\/div>\n\n
Any extra parameters you pass to map<\/code> are passed through to the callback.<\/p>\n
The next function is another simple one, select<\/code>. This builds a new table from all the elements for which a callback function returns true:<\/p>\n\n
t =<\/span> table<\/span>(<\/span>1<\/span>,<\/span>2<\/span>,<\/span>3<\/span>,<\/span>4<\/span>,<\/span>5<\/span>)<\/span>\nodds =<\/span> t:<\/span>select(<\/span> function<\/span>(<\/span>n)<\/span> return<\/span> n%<\/span>2<\/span> ==<\/span> 1<\/span> end<\/span> )<\/span><\/pre><\/div><\/div><\/div>\n\n
This is another straightforward but very handy function that can make a lot of things more concise:<\/p>\n\n
function<\/span> table<\/span>:<\/span>select(<\/span>query)<\/span>\n    local<\/span> t =<\/span> table<\/span>(<\/span>)<\/span>\n \n    self:<\/span>map(<\/span> function<\/span>(<\/span>el)<\/span>\n            if<\/span> query(<\/span>el)<\/span> then<\/span> t:<\/span>insert(<\/span>el)<\/span> end<\/span>\n    end<\/span>)<\/span>\n \n    return<\/span> t\nend<\/span><\/pre><\/div><\/div><\/div>\n\n
Reduce<\/h2>\n
The final utility I put in is reduce<\/code>. This reduces a table down to one value, given a function (and an optional initial value). For example, here’s how to use reduce<\/code> to find the maximum value of a table of numbers:<\/p>\n\n
t =<\/span> table<\/span>(<\/span>1<\/span>,<\/span>7<\/span>,<\/span>3<\/span>,<\/span>19<\/span>,<\/span>4<\/span>)<\/span>\nmax<\/span> =<\/span> t:<\/span>reduce(<\/span> function<\/span>(<\/span>a,<\/span>b)<\/span>\n    if<\/span> a ><\/span> b then<\/span> return<\/span> a\n    else<\/span> return<\/span> b\nend<\/span> )<\/span><\/pre><\/div><\/div><\/div>\n\n
This will call the function on the first two elements, 1 and 7, returning 7. Then it will call it with the result of the first call and the third element, 3. Then the result of that and the next element, and so on:<\/p>\n
\r\n1, 7  ==> 7\r\n7, 3  ==> 7\r\n7, 19 ==> 19\r\n19, 4 ==> 19\r\n<\/pre>\n
You can optionally pass in a second argument that will be used as the initial value; if you don’t then the first thing in the array is the initial value:<\/p>\n\n
function<\/span> table<\/span>:<\/span>reduce(<\/span>fn,<\/span> init)<\/span>\n    local<\/span> i =<\/span> 1<\/span>\n    local<\/span> accum =<\/span> init\n    if<\/span> init ==<\/span> nil<\/span> then<\/span>\n        accum =<\/span> self[<\/span>1<\/span>]<\/span>\n        i =<\/span> 2<\/span>\n    end<\/span>\n \n    while<\/span> i <=<\/span> #<\/span>self do<\/span>\n        accum =<\/span> fn(<\/span>accum,<\/span> self[<\/span>i]<\/span>)<\/span>\n        i =<\/span> i +<\/span> 1<\/span>\n    end<\/span>\n \n    return<\/span> accum\nend<\/span><\/pre><\/div><\/div><\/div>\n\n
There are a few short functions dealing with numeric arrays that are just calls to reduce<\/code>:<\/p>\n\n
function<\/span> table<\/span>:<\/span>sum(<\/span>)<\/span>\n    return<\/span> self:<\/span>reduce(<\/span> function<\/span>(<\/span>a,<\/span>b)<\/span> return<\/span> a+<\/span>b end<\/span>,<\/span> 0<\/span> )<\/span>\nend<\/span>\n \nfunction<\/span> table<\/span>:<\/span>max<\/span>(<\/span>comp)<\/span>\n    return<\/span> self:<\/span>reduce(<\/span> function<\/span>(<\/span>a,<\/span>b)<\/span>\n            if<\/span> a ><\/span> b then<\/span> return<\/span> a\n            else<\/span> return<\/span> b end<\/span> end<\/span> )<\/span>\nend<\/span>\n \nfunction<\/span> table<\/span>:<\/span>min<\/span>(<\/span>comp)<\/span>\n    return<\/span> self:<\/span>reduce(<\/span> function<\/span>(<\/span>a,<\/span>b)<\/span>\n            if<\/span> a <<\/span> b then<\/span> return<\/span> a\n            else<\/span> return<\/span> b end<\/span> end<\/span> )<\/span>\nend<\/span><\/pre><\/div><\/div><\/div>\n\n
Notice that I have to pass an initial value to the call in sum<\/code>: this is because without it the sum of an empty table would be nil<\/code>, and it’s more useful for it to be zero.<\/p>\n
The code<\/h2>\n
As always, the code is available on Github<\/a>. To use it, you’ll need to build your own copy of LPeg since that binary is for my system (you can obtain it on their page<\/a>), and set the LUA_INIT<\/code> environment variable, which is different depending on what system you’re on: for Unix (or Mac) you should put it in your login script, which is probably .bashrc<\/code>, .profile<\/code>, or something like that. For Windows you’ll have to go through the control panel.<\/p>\n","protected":false},"excerpt":{"rendered":"
I don’t think it’ll surprise anyone when I say that I think Lua is a great language. But, it does have a very small standard library. So, there are a few other utilities that I end up including or writing in almost everything I do. Luckily, Lua has a facility for loading them automatically when […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[1],"tags":[],"_links":{"self":[{"href":"http:\/\/www.playwithlua.com\/index.php?rest_route=\/wp\/v2\/posts\/64"}],"collection":[{"href":"http:\/\/www.playwithlua.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/www.playwithlua.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/www.playwithlua.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/www.playwithlua.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=64"}],"version-history":[{"count":0,"href":"http:\/\/www.playwithlua.com\/index.php?rest_route=\/wp\/v2\/posts\/64\/revisions"}],"wp:attachment":[{"href":"http:\/\/www.playwithlua.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=64"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/www.playwithlua.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=64"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/www.playwithlua.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=64"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}