The Fortress Language Specification - CiteSeerX

A function declaration may be separated from its definition. An abstract function declaration can be provided for
overloaded function definitions. When the parameter type of an abstract function declaration includes a type that is
declared with a comprises clause, it is a static error if the corresponding function definitions do not cover every
immediate subtype of the type.
Syntactically, an abstract function declaration is a function declaration without a body. Parameter names may be elided
but parameter types cannot be omitted. Additionally, when a function’s type is not parameterized, Fortress provides
an alternative mathematical notation for an abstract function declaration: function name followed by the token : ,
followed by an arrow type.
For example, after the following abstract function declaration:
printMolecule(Molecule):()
where trait Molecule is defined as follows:
trait Molecule comprises {OrganicMolecule, InorganicMolecule} end
the programmer could write:
printMolecule(molecule:Molecule) = . . .
or could write:
printMolecule(molecule:OrganicMolecule) = . . .
printMolecule(molecule:InorganicMolecule) = . . .
For the latter, the programmer must provide a definition for every immediate subtype of Molecule, or it is a static
error.
12.4 Function Contracts
Syntax:
Contract ::= [Requires] [Ensures] [Invariant]
Requires ::= requires Expr +
Ensures ::= ensures (Expr + [provided Expr]) +
Invariant ::= invariant Expr +
Function contracts consist of three optional clauses: a requires clause, an ensures clause, and an invariant
clause. All three clauses are evaluated in the scope of the function body.
The requires clause consists of a sequence of expressions of type Boolean. The requires clause is evaluated
during a function call before the body of the function. If any expression in a requires clause does not evaluate to
true , a CallerViolation exception is thrown.
The ensures clause consists of a sequence of ensures subclauses. Each such subclause consists of a sequence
of expressions of type Boolean, optionally followed by a provided subclause. A provided subclause begins
with the special reserved word provided followed by an expression of type Boolean. For each subclause in the
ensures clause of a contract, the provided subclause is evaluated immediately after the requires clause during a
function call (before the function body is evaluated). If a provided subclause evaluates to true , then the expressions
preceding this provided subclause are evaluated after the function body is evaluated. If any expression evaluated
after function evaluation does not evaluate to true , a CalleeViolation exception is thrown. The expressions preceding
the provided subclause can refer to the return value of the function. A result variable is implicitly bound to a return
value of the function and is in scope of the expressions preceding the provided subclause. The implicitly declared
result shadows any other declaration with the same name in scope.
89