The Fortress Language Specification - CiteSeerX

e called with. In other words, we expand these declarations so that there exists a declaration for each number of
arguments that can be passed to it.
A declaration with k keyword parameters corresponds to 2 k declarations which cannot be called with elided arguments,
one for each subset of the keyword parameters. For example, the following declaration:
f(x = 5, y = 6, z = 7) : Z
would be expanded into:
f(x = 5, y = 6, z = 7) : Z
f(x = 5, y = 6) : Z
f(x = 5, z = 7) : Z
f(y = 6, z = 7) : Z
f(x = 5) : Z
f(y = 6) : Z
f(z = 7) : Z
f() : Z
Note that even though expanded declarations still have keyword parameters, they cannot be called with elided arguments
any more. A declaration with keyword parameters is applicable to a call if any one of the expanded declarations
is applicable.
A declaration with a varargs parameter corresponds to an infinite number of declarations, one for every number of
arguments that may be passed to the varargs parameter. In practice, we can bound that number by the maximum
number of arguments that the functional is called with anywhere in the program (in other words, a given program
will contain only a finite number of calls with different numbers of arguments). The expansion described here is a
conceptual one to simplify the description of the semantics; we do not expect any real implementation to actually
expand these declarations at compile time. For example, the following declaration:
f(x : Z, y : Z, z : Z . . .) : Z
would be expanded into:
f(x : Z, y : Z, z : Z . . .) : Z
f(x : Z, y : Z) : Z
f(x : Z, y : Z, z 1 : Z) : Z
f(x : Z, y : Z, z 1 : Z, z 2 : Z) : Z
f(x : Z, y : Z, z 1 : Z, z 2 : Z, z 3 : Z) : Z
. . .
Notice that the expansion includes the original declaration. This declaration is retained to account for the case when a
tuple expression with a varargs expression is passed as an argument to a call; even though this declaration still has a
varargs parameter, it’s called with a fixed number of arguments. A declaration with a varargs parameter is applicable
to a call if any one of the expanded declarations is applicable.
15.5 Overloading Resolution
Several declarations may be applicable to a given functional call. Therefore, it is necessary to determine which
declaration is dispatched to. The basic principle is that, for any functional call, we wish to identify a unique declaration
that is the most specific among all declarations applicable to the call at run time. If there is no such declaration, then
the call is undefined, which is a static error. If there are two or more such declarations, no one of which is more specific
than all the others, the call is said to be ambiguous, which is also a static error. As discussed in Chapter 33, it is a
static error for overloaded declarations to admit ambiguous calls at run time, whether such calls actually appear in the
program or not.
123