The Fortress Language Specification - CiteSeerX

expr
∑
type wrapper
∑
body R, ⊞
e R
e R, +
gs
lv := e,gs () noReduction lv := e NoReduction, ⊕
〈 e | gs 〉 ListE closeList singletonOpen(e) OpenList, ++
Figure 32.2: Desugaring of expressions with generators. Top to bottom: big operators (here ∑ is used as an example;
the appropriate library function is called on the right-hand side), assignments, and comprehensions (here list
comprehensions are shown; with the exception of array comprehensions, other comprehensions are similar to list
comprehensions).
provided GeneratorList into a nested series of calls to generate . For example, when we perform the desugaring
T Z64, +[x ← xs, y ← ys, x ≠ y](x · y) we obtain the following code:
xs.generateZ64, +(fn x ⇒
ys.generateZ64, +(fn y ⇒
if x ≠ y then (x · y) else Identity+ end))
Some example desugarings of expressions with generators are shown in Figure 32.2 for big operators, assignments,
and list comprehensions (set and multiset comprehensions are similar to list comprehensions).
The simplest desugarings are the ones for big operators such as ∑ . The type of the traversal corresponds to the type
of the result. The body expression used is exactly the body expression of the big operator. The wrapper function is
named by the big operator itself. For example, the ∑ operator has the following declaration:
opr ∑ R extends CommutativeMonoidR, +(rhs : () → R): R = rhs()
Assignments desugar in a manner similar to big operators. However, they make use of the special NoReduction type,
which is a singleton type which extends CommutativeMonoidNoReduction, ⊕ . We can think of NoReduction
as composing the writes of the assignments in parallel. The wrapper noReduction is defined as follows:
noReduction(rhs : () → NoReduction): () = do
rhs()
()
end
Lists also desugar in a similar way. The desugaring given in Figure 32.2 makes use of the OpenList type—such a list
is constructed with an updatable tail cell, permitting partially-constructed lists to be appended in constant time using
the ++ (DOUBLE PLUS) operator. The closeList operation converts the result into an ordinary non-updatable list.
An array comprehension simply desugars into a factory function call and a series of assignments:
[ i 1 = e 1 | gs 1
i 2 = e 2 | gs 2
. . .
i n = e n | gs n ]
−→
do a = array()
a[i 1 ] := e 1 , gs 1
a[i 2 ] := e 2 , gs 2
. . .
a[i n ] := e n ,gs n
a
end
The desugaring of a for loop depends upon the set of reduction variables. We conceptually desugar the for loop
with reduction variables, r 1 , r 2 , . . ., r n , reduced using the reduction operator ⊕ for type (T 1 , T 2 , . . . T n ) as follows:
for gs do block end
−→
223