The Fortress Language Specification - CiteSeerX

The following restrictions apply: No two keyword-value pairs may have the same keyword. No keyword-value pair
may precede a plain expression. No varargs expression may follow a keyword-value pair or precede a plain expression.
There must be at least one item. If there is exactly one item, it must be a varargs expression or a keyword-value pair
(because an expression “(e) ” is simply a parenthesized expression, not a tuple.) Also, there can be at most one item
with a varargs expression. In a varargs expression, the expression “e” must be of type OrderedGeneratorT for
some T .
The type of a tuple expression is a tuple type (as discussed in Section 8.4), which may be described by taking the
tuple expression and replacing each element expression with its type, except that a varargs expression having type
OrderedGeneratorT is replaced by T . . . (for the most specific T possible). The element expressions are all
evaluated before the tuple is constructed, and if there is a varargs expression then the generator is used to construct a
HeapSequence (described in Section 40.3) containing all the generated values; this HeapSequence then becomes an
element of the tuple. Tuples are value objects. There are no explicit deconstructors for tuples except multiple variable
declarations as discussed in Section 6.3.
13.28.1 Distinguishing a Keyword-Value Pair from an Equality Expression
Because a keyword-value pair shares a syntax with an equality expression, we provide rules for disambiguation:
• If an expression “identifier = e ” has no parentheses around it, then it is an equality expression unless it is part
of a tuple expression with more than one element expression.
• If the expression is in immediately surrounding parentheses with no other expression in the parentheses, then
it is an equality expression unless the parenthesized expression is part of a juxtaposition sequence and is to be
used as an argument to a function, in which case the parenthesized expression is a tuple expression.
• Adding parentheses makes the expression an equality expression.
• In the rare situations where “(identifier = e) ” is treated as an equality expression and it must be a tuple
expression, “tuple(identifier = e) ” makes it a tuple expression where “tuple ” is an identity function defined
in the Fortress standard libraries (as described in Section 13.32.4).
13.29 Comprehensions
Syntax:
Comprehension ::= { Expr | GeneratorList }
| { Expr ↦→ Expr | GeneratorList }
| 〈 Expr | GeneratorList 〉
| [ (ArrayComprehensionLeft | GeneratorList) + ]
ArrayComprehensionLeft ::= Id ↦→ Expr
| ( Id , IdList ) ↦→ Expr
Fortress provides comprehension syntax for several aggregate expressions (described in Section 13.28). Generators
(described in Section 13.17) produce values and bind the values to the identifiers that are used in the left-hand side of
the token | (left-hand body). Most generators, unlike the sequential generator, may execute each evaluation of the
left-hand body in a separate implicit thread. Comprehensions evaluate to aggregate values and have corresponding
aggregate types.
A set comprehension is enclosed in braces, with a left-hand body separated by the token | from a generator list. For
example, the comprehension:
{ x 2 | x ← {0, 1, 2, 3, 4, 5}, xMOD 2 = 0 }
114