The Fortress Language Specification - CiteSeerX

The rules below are designed to forbid certain forms of notational ambiguity that can arise if the name of a functional
method happens to be used also as the name of a variable. For example, suppose that trait T has a functional method
of one parameter named n ; then in the code
do
a: T = t
n: Z = 14
z = na
end
it might not be clear whether the intended meaning was to invoke the functional method n on a or to multiply a by
14 . The rules specify that such a situation is a static error.
The rules for reassociating a loose juxtaposition are as follows:
• First the loose juxtaposition is broken into nonempty chunks; wherever there is a non-function element followed
by a function element, the latter begins a new chunk. Thus a chunk consists of some number (possibly zero) of
functions followed by some number (possibly zero) of non-functions.
• It is a static error if any non-function element in a chunk is an unparenthesized identifier f and is followed by
another non-function element whose type is such that f can be applied to that latter element as a functional
method.
• The non-functions in each chunk, if any, are replaced by a single element consisting of the non-functions grouped
left-associatively into binary juxtapositions.
• What remains in each chunk is then grouped right-associatively.
• It is a static error if an element of the original juxtaposition was the last element in its chunk before reassociation,
the chunk was not the last chunk (and therefore the element in question is a non-function element), the element
was an unparenthesized identifier f , and the type of the following chunk after reassociation is such that f can
be applied to that following chunk as a functional method.
• Finally, the sequence of rewritten chunks is grouped left-associatively.
(Notice that no analysis of the types of newly constructed chunks is needed during this process.)
Here is an example: n (n + 1) sin 3 n x log log x . Assuming that sin and log name functions in the usual manner
and that n , (n + 1) , and x are not functions, this loose juxtaposition splits into three chunks: n (n + 1) and
sin 3 n x and log log x . The first chunk has only two elements and needs no further reassociation. In the second
chunk, the non-functions 3 n x are replaced by ((3 n) x) . In the third chunk, there is only one non-function,
so that remains unchanged; the chunk is the right-associated to form (log (log x)) . Finally, the three chunks are
left-associated, to produce the final interpretation ((n (n + 1)) (sin ((3 n) x))) (log (log x)) . Now the original juxtaposition
has been reduced to binary juxtaposition expressions.
The rules for reassociating a tight juxtaposition follow a different strategy:
• If the tight juxtaposition contains no function element, or if only the last element is a function, go on to the
next step. Otherwise, consider the leftmost function element and examine the element that follows it. If that
latter element is not parenthesized, it is a static error; otherwise, replace the two elements with a single element
consisting of a new juxtaposition of the two elements (in the same order), and perform a type analysis on this new
juxtaposition. (At this point, it is a static error if this new juxtaposition is preceded in the overall juxtaposition
by a non-function element that is an unparenthesized identifier f , and the type of the new juxtaposition is such
that f can be applied to it as a functional method.) Then repeat this step on the original juxtaposition (which is
now one element shorter).
• The overall juxtaposition now either is a single element or consists entirely of non-function elements. It is a
static error the overall juxtaposition now contains a non-function element that is an unparenthesized identifier
f , and the type of the following element is such that f can be applied to it as a functional method.
131