The Fortress Language Specification - CiteSeerX

17.3 Coercion Invocations
One may invoke a coercion explicitly with the syntax: Trait. coercion (expr) . Overloading resolution (described
in Section 15.5) applies in the usual way if the specified trait has more than one coercion that applies to the actual
argument.
One way to think about coercion is that explicit calls to coercion declarations are automatically inserted into the
arguments of functional calls and the right-hand sides of assignment expressions and variable definitions. If trait U
has a coercion from type T , then whenever a functional, f , is declared with a parameter of type U , a call f(t) where
t has type T can be rewritten to f(U. coercion (t)) making the declaration of f applicable to the call. However, this
rewriting does not occur if there exists a declaration that is applicable to the call before the rewriting (see Section 17.5
for further discussion).
If coercion is possible for more than one element of a tuple argument, a cross-product effect is obtained. For example,
in this code:
object X
coercion (kiki :Y ) = . . .
coercion (tutu : Q) = . . .
hack(other : X) = 1
end
object Y end
object Q end
foo(dodo : X) = 2
bar(hyar : X,yon : X) = 3
bar(hyar : Q,yon : Q) = 4
the following method invocations are valid:
X.hack(Y )
X.hack(Q)
Because there is no declaration of hack applicable to Y and Q , these invocations are rewritten to:
X.hack(X. coercion (Y ))
X.hack(X. coercion (Q))
Similarly, the function calls in the left-hand side of the following are valid and rewritten to the right-hand side:
foo(Y ) is rewritten to foo(X. coercion (Y ))
foo(Q) is rewritten to foo(X. coercion (Q))
bar(Y, X) is rewritten to bar(X. coercion (Y ), X)
bar(Q, X) is rewritten to bar(X. coercion (Q), X)
bar(X, Y ) is rewritten to bar(X, X. coercion (Y ))
bar(X, Q) is rewritten to bar(X, X. coercion (Q))
bar(Y, Y ) is rewritten to bar(X. coercion (Y ), X. coercion (Y ))
bar(Q, Q) is rewritten to bar(Q, Q)
bar(Q, Y ) is rewritten to bar(X. coercion (Q), X. coercion (Y ))
bar(Y, Q) is rewritten to bar(X. coercion (Y ), X. coercion (Q))
Note that the call bar(Q, Q) remains unchanged because there exists a declaration for bar that is applicable without
coercion.
To continue the example, let us illustrate a point about type parameters. If we add the following definitions:
139