The Fortress Language Specification - CiteSeerX

• both are plain types in the same position,
• both are varargs types, or
• both are keyword-type pairs with the same keyword.
Every tuple type is a subtype of Object, and no other nontuple type. There is no other type that encompasses all
tuples. Tuple types are covariant; a tuple type X is a subtype of tuple type Y if and only if:
• the correspondence between their element types is bijective;
• for each element type in X , the type in the element type is a subtype of the type in the corresponding element
type in Y ; and
• the keyword-type pairs in X and Y appear in the same order.
Note that, unlike record types in some other programming languages, the tuple type (foo = P,bar = Q,baz = R)
is not a subtype of (foo = P,bar = Q) , nor is (P, Q, R) a subtype of (P, Q) . While (Z, Z) is not a subtype of
(Z . . .) , there exists a coercion from the former to the latter (as described in Section 17.7).
For every tuple type X there is a tuple type X ′ that is the “sorted form” of the type, created by simply reordering the
keyword-type pairs so that their keywords are in lexicographically ascending order. X ′ may be the same as X (as,
for example, if X contains fewer than two keyword-type pairs). There is a coercion from tuple type X to tuple type
Y if and only if X and Y have the same sorted form.
A tuple type excludes any nontuple type other than Object. Two tuple types exclude each other unless the correspondence
between their element types is bijective. Two tuple types with a bijective correspondence between their element
types exclude each other if either any type in an element type in one excludes the type in the corresponding element
type in the other, or their keyword-type pairs do not appear in the same order.
Intersection of nonexclusive tuple types are defined elementwise; the intersection of nonexclusive tuple type X and
Y is a tuple type with exactly corresponding elements, where the type in each element type is the intersection of the
types in the corresponding element types of X and Y . Note that intersection of any exclusive types is BottomType
as described in Section 8.6.
8.5 Arrow Types
Syntax:
TypeRef ::= ArrowType
ArrowType ::= ArrowTypeRef → ArrowTypeRef [Throws]
ArrowTypeRef ::= TypeRef (× TypeRef ) ∗
| TypeRef ˆ Number
Functions can be passed as arguments and returned as values. See Chapter 12 for a discussion of functions. The types
of function values are called arrow types. Every arrow type is a subtype of Object. Arrow types are not trait types.
They cannot be extended by other trait types. Syntactically, an arrow type consists of the type of a parameter to the
function followed by the token → , followed by the type of a return value, and optionally a throws clause which
specifies thrown checked exceptions. Here are some examples:
(R64, R64) → R64
N → (N, N) throws IOException
(String, N . . .,p = Printer) → N
Fortress supports alternative mathematical notations for arrow types whose parameter types or return types are tuple
types:
66