The Fortress Language Specification - CiteSeerX

coercions:
T U ⇐⇒ T ♦ U ∧ T −〉 U ∧ U−〉 T ∧ T ≬ U
⇐⇒ T ♦ U
∧ (∀A : A→T =⇒ A ♦ U)
∧ (∀B : B →U =⇒ B ♦ T)
∧ (∀A, B : A→T ∧ B →U =⇒ A ♦ B)
Note that if T U then no type is substitutable for both T and U.
The Incompatibility Rule for Functions and Functional Methods: Suppose that f (P) and f (Q) 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 then f (P) and f (Q) are valid overloadings.
The Incompatibility Rule for Dotted Methods: Suppose that P 0 .f (P) and Q 0 .f (Q) are two distinct dotted method
declarations provided by a trait or object C. If P Q then P 0 .f (P) and Q 0 .f (Q) are valid overloadings.
33.4 More Specific Rule
If neither the Subtype Rule nor the Incompatibility Rule holds for a pair of overloaded declarations then they may
still be valid overloadings if the More Specific Rule is satisfied. The More Specific Rule requires that for any two
declarations there exists a third applicable declaration that is at least as specific as both.
This rule is complicated by the fact that functions and functional methods can overload. Recall that functional methods
can be viewed semantically as top-level functions, as described in Section 9.2. However, treating functional methods
as top-level functions for determining valid overloading is too restrictive. In the following example:
trait Z
opr −(self): Z
end
trait R
opr −(self): R
end
if the functional methods were interpreted as top-level functions then this program would define two top-level functions
with parameter types Z and R . These declarations would be statically rejected as invalid overloadings because there
is no relation between Z and R ; another trait may extend them both without declaring its own version of the functional
method which may lead to an ambiguous call at run time. To allow such overloading, we define different restrictions
on overloaded function declarations and overloaded functional method declarations. When function and functional
method declarations are overloaded, the more restrictive rule for function declarations is used. This rule follows.
The More Specific Rule for Functions and Functional Methods: Suppose that f (P) and f (Q) are two function
or functional method declarations both visible at some point Z in a Fortress program (Z need not be the site of a call)
such that neither P nor Q is a subtype of the other and P and Q are not incompatible with one another. Let S be the
set of types that P defines coercions from and T be the set of types that Q defines coercions from. f (P) and f (Q) are
valid overloadings if all of the following hold:
• either P ♦ Q or there is a declaration f (P ∩ Q) visible at Z, and
• either P ⊳ Q or Q ⊳ P or for all P ′ ∈ S and Q ′ ∈ T one of the two conditions holds:
229