{"id":366,"date":"2011-07-04T23:43:01","date_gmt":"2011-07-04T15:43:01","guid":{"rendered":"http:\/\/gergely.imreh.net\/blog\/?p=366"},"modified":"2011-07-04T23:43:01","modified_gmt":"2011-07-04T15:43:01","slug":"language-of-the-month-lua-part-2","status":"publish","type":"post","link":"https:\/\/gergely.imreh.net\/blog\/2011\/07\/language-of-the-month-lua-part-2\/","title":{"rendered":"Language of the Month: Lua, part 2"},"content":{"rendered":"

I’m a few days behind schedule since Lua was June’s language, but here it comes, some summary of my experience, after setting things up in the first part<\/a>.<\/p>\n

\"A<\/a>
Lua is not this painful, indeed, just the opposite<\/figcaption><\/figure>\n

Overview<\/h2>\n

I really liked this language, and I’m sure I’ll keep learning it. Very useful and lots of interesting concepts. I haven’t seen an embedded language before, and some parts<\/p>\n

Most of what I picked up was from Beginning Lua Programming<\/a> and\u00a0Programming in Lua<\/a>.\u00a0Lua Missions<\/a> was another very useful experience: a “fill in the blank” type of source code collection, which drilled my understanding of the Lua concepts. Some sections felt a little short, so maybe later I’ll think whether there are any more questions I can come up with. Very well worth the time!<\/p>\n

There are two things that stand out: tables and local environments.<\/p>\n

Tables<\/h3>\n

If I have to refer to my knowledge of Python, then Lua tables are like Python lists and dicts rolled into one and then some. Here’s one such table:<\/p>\n

x = {1, 2, 3, y = \"something\", [\"or else\"]=\"what\"}<\/pre>\n
The first three elements are giving an array (and one can loop over them), then the last two are key-value pairs. One tricky thing is that the “y” there is actually a string (the same as [“y”]), just made it more readable with syntactic sugar. Since variables (references to variables) can be keys as well, this can get confusing if one has a variable called “y”… There are quite a few things about tables that are confusing, but actually pretty consistent so my fuses are not blowing that much as they were in the beginning (for example: how the length is looked up, how to iterate through the different values) .<\/p>\n
They are very complex animals so some things are quite complex to do, which in turn enables quite complex things to be done. Pretty much any kind of data structure can be built upon them. So all in all, I’m enjoying them with all their quirks. Also, “weak tables” are an interesting concept (where certain table entries can garbage collected).<\/p>\n
Scopes<\/h3>\n
In Python, the name spaces and environments seem to be on the sidelines (at least what I’ve seen so far): people need it and have to us it, but nothing more than that. In Lua this is taken to a whole new level: scopes can be essential parts of the way algorithms are implemented and neat tricks can be played.<\/p>\n
I tried to come up with some good example and failed, here’s a “duh” one:<\/p>\n
function newCounter ()\r\n    local i = 0\r\n    return function ()   -- anonymous function\r\n        i = i + 1\r\n        return i\r\n    end\r\nend\r\n\r\nc1 = newCounter()\r\nprint(c1())  -- 1\r\nprint(c1())  -- 2<\/pre>\n
This is a bit like Python’s “yield<\/a>” type of generator, without anything special.<\/p>\n
Also, in Python there are only two kinds of variables (I think): local and global: either just for you or for everyone. Here they have one more: upvalues, where the variable is local to a parent, so children environment can access them but the parent’s parents cannot. They are strange beasts as well, e.g. the code itself cannot really know if a variable is upvalue or global, only that it can access that.<\/p>\n
And of course these scopes help embedding to not just be possible but straightforward and powerful. Local environments can be restricted, some things selectively enabled, and all this transparently, so the script running might not even know that it’s being in the Matrix.<\/p>\n
The Lua Experience<\/h2>\n
Good<\/h3>\n