Nested '...' usage, currying?

[Eidolarr]

Hey, for giggles I was trying to write a curry function. It looked something like this

function curry(f, ...)
  return function (..)
    f(..., ..)
  end
end

where the two dots are a different set of variable arguments from the three dots. So if I could define a channel greeting function as follows:

GreetChannel =  curry(SendChatMessage, "Hello, channel!", "CHANNEL", GetDefaultLanguage("player"))

so that

GreetChannel(1)

greets my channel 1 with "Hello, channel!". Is there any way for Lua to distinguish between differing sets of variable arguments?

I can't even seem to get this to work! I assume for the same reason

function curry(f, x, ...)
  if x or select("#", ...) > 0 then
    return curry(function(...) f(x, ...) end, ...)
  else
    return f
  end
end

I read the lua-users wiki article on currying, but it's not quite as general as the form of currying I am seeking. Any insight?

[Shirik]

Originally Posted by Casull Hey, for giggles I was trying to write a curry function. It looked something like this function curry(f, ...) return function (..) f(..., ..) end end where the two dots are a different set of variable arguments from the three dots. So if I could define a channel greeting function as follows: GreetChannel = curry(SendChatMessage, "Hello, channel!", "CHANNEL", GetDefaultLanguage("player")) so that GreetChannel(1) greets my channel 1 with "Hello, channel!". Is there any way for Lua to distinguish between differing sets of variable arguments? I can't even seem to get this to work! I assume for the same reason function curry(f, x, ...) if x or select("#", ...) > 0 then return curry(function(...) f(x, ...) end, ...) else return f end end I read the lua-users wiki article on currying, but it's not quite as general as the form of currying I am seeking. Any insight?

It won't work anything like what you want it to look like, for several reasons.

Reason 1: Tuples are immutable. You cannot put them together like you want to. Take the following example:

function foo(...)
   return ..., 4;
end
print(foo(1,2,3)); -- Outputs 1,4

The ... will be shortened to a single term.


Reason 2: ... is not a valid upvalue. You can only use it in the current context. take the following example:

function foo(...)
   local f = function() return ... end;  -- Error
   return f;
end

local bar = foo(1,2,3);
print(bar());

At the location marked "Error", the following results: "cannot use '...' outside a vararg function near '...'"

It follows from reason 2 that there should never be a case where you need a "second" ... tuple. It, concurrently, follows from reason 1 that even if you did, you would not be able to operate on it in the sense that you desired to in the first place. Your only real solution is to generate a table from the tuple in the form:

function foo(...)
   return {...};
end

local t1 = foo(1,2,3);
local t2 = foo(4,5,6);
-- Concatenate them
local t = {};
for _,v in ipairs(t1) do
   table.insert(t, v);
end

for _,v in ipairs(t2) do
   table.insert(t, v);
end

print(unpack(t)) -- Outputs 1,2,3,4,5,6

Do note, however, that this solution is not perfect. It will, for example, have flaws when iterated over if nils are present in the tuple. Concurrently, trailing nils will not be preserved. Still, it is the most efficient, effective solution to your problem.

[Malreth]

For completeness sake, I'll post the solution I worked out...

function append(a, n, b, ...)
	if n == 0 then
		return a
	else
		return b, append(a, n-1, ...)
	end
end

function curry(f, ...)
	local n, v = select("#", ...), {...}
	return function (x)
		return f(append(x, n, unpack(v, 1, n)))
	end
end

> p = curry(print, "apple", "banana", "clinton", nil)
> p("socrates")	--> apple	banana	clinton	nil	socrates
> p("lamp")	--> apple	banana	clinton	nil	lamp

Unlike the solution that I posted over on the Blizzard forums, this one correctly handles trailing nils and doesn't generate extra garbage (at the expense of some minor processing time for the recursion). Like the solution on the Blizzard forums, it simplifies the inner closure to a single argument (otherwise it's not really a curry).

Enjoy!