The Fortress Language Specification - CiteSeerX

of overloaded declarations satisfies any one of the three rules, it is considered valid overloading. In addition, the overloaded
declarations must have static parameters that are identical (up to α-equivalence). Also, valid overloading for
declarations that contain keyword or varargs parameters is determined by analyzing the expansion of these declarations
into declarations without such parameters, as described in Section 15.4.
Section 33.2 states the Subtype Rule, which stipulates that the parameter type of one declaration be a subtype of the
parameter type of the other. In this case, there is no possibility of ambiguous calls, because one declaration is more
specific than the other. This section also places a restriction on the return types of the overloaded declarations to ensure
that type safety is not violated. Section 33.3 defines the Incompatibility Rule that, if satisfied by a pair of declarations,
guarantees that neither declaration is applicable to the same functional call. In Section 33.4, the More Specific Rule
requires the existence of a declaration that is more specific than both overloaded declarations in the situation that both
are applicable to a given call.
In the remainder of this chapter we build on the terminology and notation defined in Chapter 15 and Chapter 17.
33.2 Subtype Rule
If the parameter type of one declaration is a subtype of the parameter type of another then there is no possibility
of ambiguous calls because the most specific declaration will be dispatched to. This is the basis of the Subtype
Rule. The Subtype Rule also requires a relationship between the return types of the two declarations. Without such a
requirement, a program may be statically well typed but have a runtime error because the return type of a dynamically
resolved functional is not a subtype of the return type of the statically resolved functional.
The Subtype Rule for Functions and Functional Methods: Suppose that f (P) : U and f (Q) : V are two distinct
function or functional method declarations both visible at some point Z in a Fortress program (Z need not be the site
of a call). If P ≺ Q and U ≼ V then f (P) and f (Q) are valid overloadings.
The Subtype Rule for Dotted Methods: Suppose that P 0 .f (P) : U and Q 0 .f (Q) : V are two distinct dotted
method declarations provided by a trait or object C. If (P 0 ,P) ≺ (Q 0 ,Q) and U ≼ V then P 0 .f (P) and Q 0 .f (Q)
are valid overloadings.
33.3 Incompatibility Rule
The basic idea behind the Incompatibility Rule is that if there is no call to which two overloaded declarations are both
applicable then there is no potential for ambiguous calls. In such a case, we say that the declarations are incompatible.
Without coercion, incompatibility is equivalent to exclusion. However, the presence of coercion complicates the
definition of incompatibility. To formally define incompatibility we first define the following notation. For types T
and U, we say that T and U do not share coercions, and write T ≬ U, if any type that coerces to T excludes any type
that coerces to U:
T ≬ U ⇐⇒ ∀A, B : A→T ∧ B →U =⇒ A ♦ B.
We say that T is incompatible with U, and write T U, if T and U exclude, reject each other, and do not share
228