[ << ] | [ < ] | [ Up ] | [ > ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |

### 6.11.3 Rest arguments

Rest arguments allow one to write functions that take a variable number of arguments:

// This function sums its arguments. int sum(... int[] nums) { int total=0; for(int i=0; i < nums.length; ++i) total += nums[i]; return total; } sum(1,2,3,4); // returns 10 sum(); // returns 0 // This function subtracts subsequent arguments from the first. int subtract(int start ... int[] subs) { for(int i=0; i < subs.length; ++i) start -= subs[i]; return start; } subtract(10,1,2); // returns 7 subtract(10); // returns 10 subtract(); // illegal

Putting an argument into a rest array is called *packing*.
One can give an explicit list of arguments for the rest
argument, so `subtract`

could alternatively be implemented as

int subtract(int start ... int[] subs) { return start - sum(... subs); }

One can even combine normal arguments with rest arguments:

sum(1,2,3 ... new int[] {4,5,6}); // returns 21

This builds a new six-element array that is passed to `sum`

as
`nums`

. The opposite operation, *unpacking*, is not allowed:

subtract(... new int[] {10, 1, 2});

is illegal, as the start formal is not matched.

If no arguments are packed, then a zero-length array (as opposed to
`null`

) is bound to the rest parameter. Note that default
arguments are ignored for rest formals and the rest argument is not
bound to a keyword.

In some cases, keyword-only parameters are helpful to avoid arguments intended
for the rest parameter to be assigned to other parameters. For example, here
the use of `keyword`

is to avoid `pnorm(1.0,2.0,0.3)`

matching
`1.0`

to `p`

.

real pnorm(real keyword p=2.0 ... real[] v) { return sum(v^p)^(1/p); }

The overloading resolution in `Asymptote`

is similar to the
function matching rules used in C++. Every argument match is given a
score. Exact matches score better than matches with casting, and
matches with formals (regardless of casting) score better than packing
an argument into the rest array. A candidate is maximal if all of the
arguments score as well in it as with any other candidate. If there
is one unique maximal candidate, it is chosen; otherwise, there is an
ambiguity error.

int f(path g); int f(guide g); f((0,0)--(100,100)); // matches the second; the argument is a guide int g(int x, real y); int g(real x, int x); g(3,4); // ambiguous; the first candidate is better for the first argument, // but the second candidate is better for the second argument int h(... int[] rest); int h(real x ... int[] rest); h(1,2); // the second definition matches, even though there is a cast, // because casting is preferred over packing int i(int x ... int[] rest); int i(real x, real y ... int[] rest); i(3,4); // ambiguous; the first candidate is better for the first argument, // but the second candidate is better for the second one

[ << ] | [ < ] | [ Up ] | [ > ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |

This document was generated on *May 24, 2014* using *texi2html 5.0*.