Deprecated. The purpose of this function is to create a variable-length argument list to pass it to another function.

Basically, it works similar to Array() function. The difference is that what this function creates is not an array of actual argument values but rather the list of subqueries that calculate them. This allows passing to the function along with the arguments also their intended datatypes. For instance, calling:

f (ArgumentList ((Object[]) null))
may be treated differently as calling simply:
f (ArgumentList (null))
Essentially, the effect is the same as having the function f() overloaded with different parameter signatures, which create different functions:
f (Object[] a)
f (Object o)
The ArgumentList() would allow doing the same for arbitrary parameter signatures, at that, a particular parameter signature would be resolved dynamically, within the implementation of the function.

Currently, any variable-length parameter signature:
f (...)
does allow accessing parameter types within the function implementation. But using it, it is impossible to pass several variable-length parameter lists, like:
f (..., ...)
or to have the variable-length parameter list mixed with other definite parameters, like:
f (String s, ..., Boolean b)
The ArgumentList() function would allow doing that.

Yet, currently, such an approach is discontinued because:

  1. The ArgumentList() function behaves more like a special operator rather than a normal function, which creates ambiguity.
  2. In those few situation when it was actually used (e.g. see hyperTargetExists() function), a subsequent better implementation made it unnecessary.