The Fortress Language Specification - CiteSeerX

the function is evaluated with the parameter of the function bound to the value of the argument expression. The value
and the type of a function call are the value and the type of the function body.
Here are some examples:
sqrt(x)
arctan(y, x)
If the function’s argument is not a tuple, then the argument need not be parenthesized:
sqrt 2
sin x
log log n
13.7 Function Expressions
Syntax:
Value ::= fn ValParam [IsType] [Throws] ⇒ Expr
Function expressions denote function values; they do not require evaluation. Syntactically, they start with the special
reserved word fn followed by a parameter, optional return type, optional throws clause, ⇒, and finally an expression.
The type of a function expression is an arrow type consisting of the function’s parameter type followed by the
token → , followed by the function’s return type, and the function’s optional throws clause. Unlike declared functions
(described in Chapter 12), function expressions are not allowed to include static parameters nor where clauses
(described in Chapter 11).
Here is a simple example:
fn (x :Double) ⇒if x < 0 then −x else x end
13.8 Operator Applications
Syntax:
Expr ::= Op Expr
| Expr Op [Expr]
Value ::= LeftEncloser ExprList RightEncloser
To support a rich mathematical notation, Fortress allows most Unicode characters that are specified to be mathematical
operators to be used as operators in Fortress expressions, as well as various tokens described in Chapter 16. Most of
the operators can be used as prefix, infix, postfix, or nofix operators as described in Section 16.3; the fixity of an
operator is determined syntactically, and the same operator may have definitions for multiple fixities.
Syntactically, an operator application consists of an operator and its argument expressions. If the operator is a prefix
operator, it is followed by its argument expression. If the operator is an infix operator, its two argument expressions
come both sides of the operator. If the operator is a postfix operator, it comes right after its argument expression. Like
function calls, argument expressions are evaluated in parallel. After evaluating argument expressions to values, the
body of the operator definition is evaluated with the parameters of the operator bound to the values of the argument
expressions. The value and the type of an operator application are the value and the type of the operator body.
Here are some examples:
95