The Fortress Language Specification - CiteSeerX

evaluates to “miles are larger” . A more interesting example is described in Section 6.5.
13.22 Typecase Expressions
Syntax:
Flow ::= typecase TypecaseBindings in (TypecaseTypeRefs ⇒ Expr + ) + [Else] end
TypecaseBindings ::= Id
| Binding
| ( BindingList )
Binding ::= Id = Expr
BindingList ::= Binding (, Binding) ∗
TypecaseTypeRefs ::= TypeRef
| ( TypeRefList )
A typecase expression begins with the special reserved word typecase followed by a sequence of bindings (either
an identifier or a sequence of an identifier followed by the token = , followed by an expression), followed by the
special reserved word in , a sequence of typecase clauses (each consisting of a sequence of guarding types followed
by the token ⇒ , followed by a sequence of expressions), an optional else clause (consisting of the special reserved
word else followed by a sequence of expressions), and finally the special reserved word end .
A typecase expression evaluates its bindings and checks each typecase clause to determine which typecase clause
matches. A single identifier x (where x is a valid local identifier) as the binding of a typecase expression is a
shorthand for x = x . Each subexpression in the bindings is evaluated and its value is bound to the corresponding
identifier. To find a matched typecase clause, the guarding types of each typecase clause are compared to the types of
the identifiers bound in the bindings in order. The right-hand side of the first matched clause (and only that clause) is
evaluated. If no matched clause is found, a MatchFailure exception is thrown. The right-hand side of each clause
forms a block expression and has the various properties of block expressions (described in Section 13.11). The optional
else clause always matches. The value of a typecase expression is the value of the right-hand side of the matched
clause. The type of a typecase expression is the union type of the types of all right-hand sides of the typecase
clauses.
For example:
typecase x = myLoser.myField in
String ⇒ x.append(“foo”)
Number ⇒ x + 3
Object ⇒ yogiBerraAutograph
end
Note that “x ” has a different type in each clause.
13.23 Atomic Expressions
Syntax:
Flow ::= atomic Expr
| tryatomic Expr
As Fortress is a parallel language, an executing Fortress program consists of a set of threads (See Section 4.4 for a
discussion of parallelism in Fortress). In multithreaded programs, it is often convenient for a thread to evaluate some
expressions atomically. For this purpose, Fortress provides atomic expressions.
106