The Fortress Language Specification - CiteSeerX

– P ′ ♦ Q ′ , or
– there is a declaration f (P ′ ∩ Q ′ ) visible at Z.
Recall that P ∩ Q is the intersection of types P and Q as defined in Section 8.8. If for some type S we have S ≼ P
and S ≼ Q then S ≼ (P ∩ Q), but it’s not necessarily the case that S = (P ∩ Q) since another type may be more
specific than both P and Q. For example, suppose the following:
trait S comprises {U, V } end
trait T comprises {V, W } end
trait U extends S excludes W end
trait V extends {S, T } end
trait W extends T end
f(s :S) = 1
f(t :T) = 1
f(v : V ) = 1
Because of the comprises clauses of S and T and the excludes clause of U, any subtype of both S and T must be
a subtype of V . Thus, V = S ∩ T , and the declaration f(V ) “disambiguates” f(S) and f(T), i.e., it is applicable to
and more specific for any call to which both f(S) and f(T) are applicable.
This requirement should not be difficult to obey, especially because the compiler can give useful feedback. First
example:
foo(x :Number, y : Z64) = . . .
foo(x : Z64, y : Number) = . . .
Assuming that Z64 ≺ Number, the compiler reports that these two declarations are a problem because of ambiguity
and suggests that a new declaration for foo(Z64, Z64) would resolve the ambiguity. Second example:
bar(x :Printable) = . . .
bar(x :Throwable) = . . .
Assuming that Printable and Throwable are neither comparable by the subtyping relation nor disjoint, the compiler
reports that these two declarations are a problem because Printable and Throwable are incomparable but possibly
overlapping types. As a result, these two declarations are statically rejected.
The More Specific Rule for Dotted Methods: Suppose that P 0 .f (P) and Q 0 .f (Q) are two dotted method declarations
provided by a trait or object C such that neither (P 0 ,P) nor (Q 0 ,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. P 0 .f (P) and Q 0 .f (Q) are valid overloadings if all of the following hold:
• either P ♦ Q or there is a declaration R 0 .f (P ∩ Q) provided by C with R 0 ≼ (P 0 ∩ Q 0 ), and
• either P ⊳ Q or Q ⊳ P or for all P ′ ∈ S and Q ′ ∈ T one of the two conditions holds:
– P ′ ♦ Q ′ , or
– there is a declaration R 0 .f (P ′ ∩ Q ′ ) provided by C with R 0 ≼ (P 0 ∩ Q 0 ).
Unlike for functions and functional methods, the More Specific Rule for dotted methods only applies to dotted methods
that are provided by the same trait or object. This is possible because two dotted methods are applicable to a given
call A 0 .f(A) only if they are both provided by the trait or object A 0 . This is not the case for functional methods as the
following rule shows.
230