The Fortress Language Specification - CiteSeerX

A dotted method invocation consists of a subexpression (called the receiver expression), followed by ‘.’, followed by
an identifier, an optional list of type arguments (described in Chapter 12) and a subexpression (called the argument
expression). Unlike in function calls (described in Section 13.6), the argument expression must be parenthesized, even
if it is not a tuple. There must be no whitespace on either side of the ‘.’, and there must be no whitespace on the
left-hand side of the left parenthesis of the argument expression. The receiver expression evaluates to the receiver of
the invocation (bound to the self parameter (discussed in Section 9.2) of the method). A coercion invocation (discussed
in Chapter 17) has a similar syntax to a dotted method invocation.
The subexpressions of a method invocation are evaluated in parallel; evaluation steps of the subexpressions can be
interleaved, and even reordered, to form an evaluation of the method invocation. See Section 4.4 for a discussion of the
semantics of their concurrent evaluation. A method invocation may include explicit instantiations of type parameters
but most method invocations do not include them; the type arguments are statically inferred from the context of the
method invocation (as described in Chapter 20). After the subexpressions of a dotted method invocation are evaluated
to values, the body of the method is evaluated with the parameter of the method bound to the value of the argument
expression. The value and the type of a dotted method invocation are the value and the type of the method body.
We say that methods or functions (collectively called as functionals) may be applied to (also “invoked on” or “called
with”) an argument. We use “call”, “invocation”, and “application” interchangeably.
Here are some examples:
myString.toUppercase()
myString.replace(“foo”, “few”)
SolarSystem.variation((π/2 radian)/452million year)
myNum.add(otherNum) (∗ NOT myNum.add otherNum ∗)
13.5 Naked Method Invocations
Syntax:
Expr ::= Id Expr
Method invocations that are not prefixed by receivers are naked method invocations. A naked method invocation is
either a functional method call (See Section 9.2 for a discussion of functional methods) or a method invocation within
a trait or object that provides the method declaration. Syntactically, a naked method invocation is same as a function
call except that the method name is used instead of an arbitrary expression denoting the applied method. Like function
calls, an argument expression need not be parenthesized unless it is a tuple. After the argument expression is evaluated
to a value, the body of the method is evaluated with the parameter of the method bound to the value of the argument
expression. The value and the type of a naked method invocation are the value and the type of the method body.
13.6 Function Calls
Syntax:
Expr ::= Expr Expr
A function call consists of two subexpressions: an expression denoting the applied function and an argument expression.
The argument expression and the expression denoting the applied function are evaluated in parallel: evaluation
steps of the subexpressions can be interleaved, and even reordered when forming an evaluation of the function call.
See Section 4.4 for a description of the semantics of parallel evaluation. As with languages such as Scheme and the
Java Programming Language, function calls in Fortress are call-by-value. An argument expression is evaluated to a
value before the function is applied. After the subexpressions of a function call are evaluated to values, the body of
94