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))
f (ArgumentList (null))
f()
overloaded with different parameter signatures, which create different functions:
f (Object[] a)
f (Object o)
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:
does allow accessing parameter types within the function implementation.
But using it, it is impossible to pass several variable-length parameter lists, like:
or to have the variable-length parameter list mixed with other definite parameters, like:
The ArgumentList() function would allow doing that.
|
Yet, currently, such an approach is discontinued because:
ArgumentList()
function behaves more like a special operator rather
than a normal function, which creates ambiguity.
hyperTargetExists()
function),
a subsequent better implementation made it unnecessary.