That’s frustrating, I hadn’t run into that with assert specifically! Thanks for providing that example. It’s a good instance of a case where multivals contribute to the large number of tradeoffs when determining argument order for your Lua functions.

Please note that the “opposite” way of using assert is intended: somewhat resembling Go, it’s a common idiom for a failed function to return 2 values: nil, "some error message". You can then plug it straight into assert like below (as shown in “PIL”):

local f = assert(io.open(filename))

and expect assert to print the error message in case of a problem.

As a side note, the freely available old edition of PIL is for a super ancient version of Lua, but I’d still resoundingly recommend reading it for all the tricks and ideas it communicates.

What do you think of this?

assertm = function(x, ...)
  assert(unpack(arg), x)
  return unpack(arg)
end

It’s not a problem unless you try to do something like this:

a, b = assert(getthings(), "no things when $FOO")

and then you can just do that instead:

a, b = getthings()
assert(a, "no things when $FOO")

Thanks for reading the post and replying to it! While I did cover some of what you mention here, I also completely missed some stuff, like how wrapping a function call with parentheses limits its return values to 1 or how you can pass negative values to select to get values from the end of the multival. I’ll add those to the post - thanks so much for pointing them out!

Please do note that this post is not intended to be an anti-Lua rant. I’m a frequent Lua user and my motivation is to help people get a better sense for how Lua will behave in certain edge cases, not to criticize the language as a whole. Perhaps I could make this clearer in the post.

I do have some responses to your comment:

“Multi-values” just aren’t a thing in Lua. This is not a data structure [1].

While it’s convenient not to think of them as a data structure while programming Lua, that’s actually not the case. They are a datastructure in my opinion, just a second-class one with extra rules surrounding them. They have a length, they have a maximum size, and they have contents which can be addressed by index. This is the thesis of my post.

Lua also restricts the number of parameters to 255. Again, this is not a data structure per se.

Again - while it’s convenient to think of this as not a data structure, it absolutely is - it’s an array of items limited to 255 elements (in practice, this limit appears to actually be at 253 for some reason). Also note that this restriction applies to both arguments and return values, but only applies to literal values - this is why, for instance, you can pass a ... that contains 255 items to a function successfully, but you can’t pass the same 255 items by writing them out literally in a Lua file. See the following code for an example:

local function range1(tab, acc, n)
  if n < 1 then return tab
  else
    tab[acc] = acc
    return range1(tab, acc+1, n-1)
  end
end

local function range(n)
  if n < 1 then error("n must be >= 1") end
  return range1({}, 1, n)
end

local function increment_each_value(first, ...)
  if first then
    return first + 1, increment_each_value(...)
  end
end

local x = range(1000)

local y = function(...)
  return increment_each_value(...)
end

print(y(table.unpack(x)))

Your example of a tail call isn’t one. A proper tail call just returns the result of a single function call.

This is the whole point of the section you’re referring to. Maybe I can be clearer that I don’t actually think the first example of range is a tail call - I already demonstrate it blowing the stack to show that it is not tail recursive. This is intended to demonstrate one of the places where the understanding that “multivals are not a data structure” would trip someone up - if multivals really weren’t a data structure, why would a call at the end of a multival not be a tail call? The reason it’s not a tail call is because it’s not actually in tail position - it’s inside a data structure that just happens to not have delimiters, instead being represented by multiple adjacent values separated by commas.

You might argue that this is all obvious, but it tripped me up the first time I ran into it. Thinking about it for a bit made it make sense, but my initial instinct was that the initial implementation of range was tail recursive. Finding out that it wasn’t was part of the motivation for writing this post.

Note that the second implementation of range in the post is properly tail recursive, and the distinction between the two implementations is what I’m trying to illustrate there.

Imagine that the syntax to return a multival looked like <<<1, 2, 3>>> instead of 1, 2, 3. (I’m not actually proposing this! It’s just a thought experiment.) It would then be immediately obvious that calling a function at the end of the multival was not in tail position:

local function range1(acc, n)
  if n < 1 then return
  elseif n == 1 then return acc
  else return <<<acc, range1(acc+1, n-1)>>>
  end
end

local function range(n)
  if n < 1 then error("n must be >= 1") end
  return range1(1, n)
end

You make a good point that tail calls do not require recursion, just returning a single function call. I’ll try to see if there’s a way to add this to the post that fits well.

Returning multiple values from a function used to be an uncommon feature of programming languages, but it’s not like it’s new…

I didn’t mean to imply that this was a recent feature in programming languages, just that it was a relatively unusual one.

Thanks again for your detailed critique of my article!

It may look like a data structure, but it’s an annoying one to use

I think this is part of the point of the article; multivals are troublesome because it has many properties of a data structure, (the ... expression is a compound thing that contains other things) but it’s not first-class in a way that allows it to be used in the ways you would expect to be able to use data structures.

Edit: Ruby doesn’t support multiple values, but it does have syntactic sugar for returning an array which appears like it’s returning multiple values. Smalltalk doesn’t support it either. Forth doesn’t support returning any amount of values, only pushing values onto the stack, which is loosely analogous but a different thing.

I mostly use it as a host language for Fennel. I use that to write games in LÖVE. I’ve also done some experimenting with web programming using OpenResty.

Thanks for your comments on the tone of the article. I definitely didn’t intend for this to be a rant or to be taken as a criticism of Lua as a whole. I’ll see if I can soften the language to make it more clear that I’m trying to warn about potential gotchas rather than just criticizing the language generally.

Could you elaborate more on how my explanation of dynamic scoping is wrong? I definitely don’t want to mislead people there.