{"id":40,"date":"2011-07-24T00:35:23","date_gmt":"2011-07-24T05:35:23","guid":{"rendered":"http:\/\/www.playwithlua.com\/?p=40"},"modified":"2020-05-22T13:38:30","modified_gmt":"2020-05-22T18:38:30","slug":"a-short-trick-transparent-containers","status":"publish","type":"post","link":"http:\/\/www.playwithlua.com\/?p=40","title":{"rendered":"A short trick: transparent containers"},"content":{"rendered":"

I thought of this today, and I thought it might make an interesting short post. One of the small annoyances of Lua is that it doesn’t have a lot of convenient support for arrays. You can implement arrays with tables, of course, but they’re still tables: they don’t have default metatables (so you can’t do things like join<\/code>), they don’t pretty-print (so it’s a hassle to see what you have), and there’s still only one iterator (using ipairs<\/code> with a for loop). You can do it but it’s not exactly convenient. So I started thinking about how exactly I’d add all that stuff.
\n<\/p>\n

Creating an array<\/h2>\n

First, let’s recognize that not all tables are going to have this behavior, and that they actually shouldn’t. An array is a CS concept, an abstract data structure, that just happens to be a primitive in most languages and implementable with a table in Lua. We want to make a way to create arrays, and some handy default behaviors for arrays, and that’s it.<\/p>\n

So what I did was make a table to be used as the metatable for all arrays, called _array<\/code>. Then I made an array<\/code> function, global, that would make a table and set that as its metatable. Then, to save a little typing, I aliased that function to A<\/code>:<\/p>\n\n

_array =<\/span> {<\/span>\n   -- Functions go here<\/span>\n}<\/span>\n \nfunction<\/span> array(<\/span>...<\/span>)<\/span>\n   return<\/span> setmetatable<\/span>(<\/span>{<\/span>...<\/span>}<\/span>,<\/span> _array)<\/span>\nend<\/span>\n \nA =<\/span> array<\/pre><\/div><\/div><\/div>\n\n
So now I can make an array by saying array(1, 4, 9)<\/code>, or more likely (because short is good for simple concepts), A(1, 4, 9)<\/code>.<\/p>\n
Pretty-printing<\/h2>\n
Making an array and then seeing table: 0x100116290<\/code> when I print it out is a little less than useful. It’s really helpful for exploratory programming (not to mention debugging) if I don’t have to write a for loop by hand whenever I want to inspect an array. So, the first thing I’m going to add is a __tostring<\/code> metamethod. This is so easy to do using the Lua standard library that I’m surprised I even have to, that it’s not built in:<\/p>\n\n
__tostring =<\/span>\n   function<\/span>(<\/span>tbl)<\/span>\n      local<\/span> strings =<\/span> {<\/span>}<\/span>\n      for<\/span> k,<\/span> v in<\/span> ipairs<\/span>(<\/span>tbl)<\/span> do<\/span> strings[<\/span>k]<\/span> =<\/span> tostring<\/span>(<\/span>v)<\/span> end<\/span>\n      return<\/span> '['<\/span> ..<\/span> table.concat<\/span>(<\/span>strings,<\/span> ', '<\/span>)<\/span> ..<\/span> ']'<\/span>\n   end<\/span><\/pre><\/div><\/div><\/div>\n\n
This metamethod gets called whenever something needs to become a string; notably, because tostring<\/code> told it to. We feed everything in the array into tostring<\/code>, then join it all up with commas and put it in brackets. This function will get a bit smaller shortly though.<\/p>\n
Iteration<\/h2>\n
There are two things I want to provide for iteration. First, I want to have an each<\/code> function that I pass a function to (along with some arguments) and it will invoke it on every element in the array. Pretty standard stuff:<\/p>\n\n
   each =<\/span>\n      function<\/span>(<\/span>list,<\/span> fn,<\/span> ...<\/span>)<\/span>\n         local<\/span> r =<\/span> array(<\/span>)<\/span>\n         for<\/span> k,<\/span>v in<\/span> pairs<\/span>(<\/span>list)<\/span> do<\/span>\n            r[<\/span>k]<\/span> =<\/span> fn(<\/span>v,<\/span> ...<\/span>)<\/span>\n         end<\/span>\n         return<\/span> r\n      end<\/span><\/pre><\/div><\/div><\/div>\n\n
This returns another array containing all the return values of the invocations, so I can do stuff like this:<\/p>\n\n
A(<\/span>1<\/span>,<\/span>4<\/span>,<\/span>9<\/span>)<\/span>:<\/span>each(<\/span>function<\/span>(<\/span>v)<\/span> return<\/span> v*<\/span>v end<\/span>)<\/span> -- ==&gt; [1, 16, 81]<\/span><\/pre><\/div><\/div><\/div>\n\n
Since it’s created with array<\/code>, I can chain them together; the return value will also support each<\/code>. And of course, now that we can do this, we can refactor __tostring<\/code> to this:<\/p>\n\n
   __tostring =<\/span>\n      function<\/span>(<\/span>tbl)<\/span>\n         local<\/span> strings =<\/span> tbl:<\/span>each(<\/span>tostring<\/span>)<\/span>\n         return<\/span> '['<\/span> ..<\/span> table.concat<\/span>(<\/span>strings,<\/span> ', '<\/span>)<\/span> ..<\/span> ']'<\/span>\n      end<\/span><\/pre><\/div><\/div><\/div>\n\n
Transparency<\/h2>\n
The other kind of iteration I want to do is the neat trick: I want to be able to treat an array of objects just like an object. Suppose I have a bunch of objects, like strings, and I want to invoke a string method on them, like this one I shamelessly stole from Rails:<\/p>\n\n
function<\/span> string<\/span>.<\/span>ordinalize(<\/span>str)<\/span>\n   local<\/span> num =<\/span> tonumber<\/span>(<\/span>str)<\/span>\n   local<\/span> endings =<\/span> {<\/span>"st"<\/span>,<\/span> "nd"<\/span>,<\/span> "rd"<\/span>}<\/span>\n   if<\/span> num &gt;=<\/span> 11<\/span> and<\/span> num &lt;=<\/span> 13<\/span> then<\/span>\n\t  return<\/span> num ..<\/span> "th"<\/span>\n   elseif<\/span> num %<\/span> 10<\/span> &gt;<\/span> 0<\/span> and<\/span> num %<\/span> 10<\/span> &lt;=<\/span> #<\/span>endings then<\/span>\n\t  return<\/span> num ..<\/span> endings[<\/span>num %<\/span> 10<\/span>]<\/span>\n   else<\/span>\n\t  return<\/span> num ..<\/span> "th"<\/span>\n   end<\/span>\nend<\/span><\/pre><\/div><\/div><\/div>\n\n
It would be neat if I could make the array take any message it doesn’t understand and pass it along to all its elements, so this:<\/p>\n\n
foo:<\/span>ordinalize(<\/span>)<\/span><\/pre><\/div><\/div><\/div>\n\n
is the same as this:<\/p>\n\n
A(<\/span>foo[<\/span>1<\/span>]<\/span>:<\/span>ordinalize(<\/span>)<\/span>,<\/span> foo[<\/span>2<\/span>]<\/span>:<\/span>ordinalize(<\/span>)<\/span>,<\/span> foo[<\/span>3<\/span>]<\/span>:<\/span>ordinalize(<\/span>)<\/span>)<\/span><\/pre><\/div><\/div><\/div>\n\n
So let’s do that. This has a lot in common with each<\/code>, so maybe we can write this as a special case of that. We’ll make a function that calls a method on an object given its name, pass that inte each<\/code>, and return the result.<\/p>\n
A method call (using the colon) is just a lookup of a name followed by calling that function, with the object as the first argument, like this:<\/p>\n\n
function<\/span> send_msg(<\/span>obj,<\/span> name,<\/span> ...<\/span>)<\/span>\n   return<\/span> (<\/span>obj[<\/span>name]<\/span>)<\/span>(<\/span>obj,<\/span> ...<\/span>)<\/span>\nend<\/span><\/pre><\/div><\/div><\/div>\n\n
So, our function to create a function like this and send it to each<\/code> is this:<\/p>\n\n
   send =<\/span>\n      function<\/span>(<\/span>msg)<\/span>\n         return<\/span> function<\/span>(<\/span>list,<\/span> ...<\/span>)<\/span>\n                   local<\/span> function<\/span> fn(<\/span>v,<\/span> ...<\/span>)<\/span>\n                      return<\/span> (<\/span>v[<\/span>msg]<\/span>)<\/span>(<\/span>v,<\/span> ...<\/span>)<\/span>\n                   end<\/span>\n \n                   return<\/span> _array.<\/span>each(<\/span>list,<\/span> fn,<\/span> ...<\/span>)<\/span>\n                end<\/span>\n      end<\/span><\/pre><\/div><\/div><\/div>\n\n
What we’ll do in __index<\/code> is call this (with a name) to get a function (method) that takes the array and any extra arguments, and then return it (so that the caller can pass into it an array and some extra arguments). Here’s the finished __index<\/code>, that handles that and each<\/code>:<\/p>\n\n
   __index =<\/span>\n      function<\/span>(<\/span>t,<\/span> name)<\/span>\n         if<\/span> name ==<\/span> 'each'<\/span> then<\/span> return<\/span> _array.<\/span>each\n         else<\/span> return<\/span> _array.<\/span>send(<\/span>name)<\/span> end<\/span>\n      end<\/span><\/pre><\/div><\/div><\/div>\n\n
Now, we can do stuff like this:<\/p>\n\n
A(<\/span>1<\/span>,<\/span>10<\/span>,<\/span>33<\/span>)<\/span>:<\/span>each(<\/span>tostring<\/span>)<\/span>:<\/span>ordinalize(<\/span>)<\/span> -- ==&gt; [1st, 10th, 33rd]<\/span>\nA(<\/span>'foo'<\/span>,<\/span>'bar'<\/span>,<\/span>'baz'<\/span>)<\/span>:<\/span>sub(<\/span>1<\/span>,<\/span>1<\/span>)<\/span> -- ==&gt; [f, b, b]<\/span><\/pre><\/div><\/div><\/div>\n\n
Next steps<\/h2>\n
There are a lot more functions that it would be handy to do to arrays other than just each<\/code> and passing through method calls. We could want to reverse them, or partition them, or filter elements out. inject<\/code> is handy in more places than you’d expect. Ruby has a really complete set; if you want to try adapting some methods from Ruby’s Enumerable library<\/a> into this, the code is here<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"
I thought of this today, and I thought it might make an interesting short post. One of the small annoyances of Lua is that it doesn’t have a lot of convenient support for arrays. You can implement arrays with tables, of course, but they’re still tables: they don’t have default metatables (so you can’t do […]<\/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\/40"}],"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=40"}],"version-history":[{"count":0,"href":"http:\/\/www.playwithlua.com\/index.php?rest_route=\/wp\/v2\/posts\/40\/revisions"}],"wp:attachment":[{"href":"http:\/\/www.playwithlua.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=40"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/www.playwithlua.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=40"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/www.playwithlua.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=40"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}