Named Parameters

wiki

Lua supports named parameters by passing a table to a function. PiL Chap 5 describes this [1]. Therefore, the following function and call with positional arguments:

local function pipe(input, output)
  output:write(input:read'*a')
end
pipe(io.stdin, io.stdout)

may be written in a named parameter style as

local function pipe(t)
  local input  = assert(t.input)
  local output = assert(t.output)
  output:write(input:read'*a')
end
pipe({input=io.stdin, output=io.stdout})
pipe{input=io.stdin, output=io.stdout}  -- the following shorter syntax is equivalent and preferrred

Optionally, some type of argument checking is performed, which in the most rudimentary form involves the assert's above must could get more complicated like StructuralPatternMatching. It may be possible for a function to support both named and positional calling conventions:

local function pipe(...)
  local input, output
  if type(...) == 'table' then
    local t = ...
    input, output = assert(t.input or t[1]), assert(t.output or t[2])
  else
    input, output = ...
  end
  output:write(input:read'*a')
end
pipe(io.stdin, io.stdout)               -- positional form
pipe{input=io.stdin, output=io.stdout}  -- named form
pipe{io.stdin, output=io.stdout}        -- mixed form (positional and named)
pipe{io.stdin, io.stdout}               -- mixed form (using only positional)

Optional/default parameters can also be supported via

input, output = assert(t.input or t[1] or io.stdin), assert(t.output or t[2] or io.stdout)

To avoid ambiguity, the above assumes, however, that the first positional parameter can never be a table, or at least that if it is a table then it can be distinguished from a table of named parameters.

The programmer must remember to change the parenthesis from '()' to '{}' when using the named or mixed parameter forms.

One disadvantage of the named form is that the table construction does have some amount of overhead due to the table allocation. Benchmarking can determine how significant this is in practice. In a tight computationally intensive loop, it might be an issue.

Error handling in the named form is also somewhat more complicated and the code more verbose/ugly, but the same issues occur if a positional parameter has a nested structure that must be checked.

The named form does not preserve trailing nil's because trailing nil's are ignored in table constructors. Therefore, the following calls are indistinguishable:

f{a,b,nil,d=d}
f{a,b,d=d}

Here's some other, less conventional, possible ways to do named parameters:

f(a, b, {c=c})
f('a',a, 'b',b, 'c',c)  -- note: Perl supports a syntactic sugar for this: `a=>$a` is `'a',$a`
f(params().a(a).b(b).c(c)) -- C++ chained method call style.
f('c,b,a', c,b,a)  -- note: parameter resolution can be memoized (see link below)
f'c=$(c),b=$(b),a=$(a)' -- variant of above with StringInterpolation [1] syntax sugar for f('c=$(c),b=$(b),a=$(a)',c,b,c)

Named Parameters

See Also