The Fortress Language Specification - CiteSeerX

Syntactically, an object declaration begins with an optional sequence of modifiers followed by the special reserved
word object , followed by the identifier of the object, optional static parameters (described in Chapter 11), optional
value parameters, optional traits the object extends, an optional declaration of thrown checked exceptions (discussed
in Chapter 14), an optional where clause (discussed in Section 11.6), an optional contract for the object (discussed in
Section 12.4), a list of method declarations, field declarations, and property declarations (described in Section 19.6),
and finally the special reserved word end . If an object declaration has no extends clause, the object implicitly
extends only trait Object. A throws clause does not include naked type variables. Every element in a throws
clause is a subtype of CheckedException. If an object declaration has a contract, the contract is evaluated as function
contracts (described in Section 12.4) when the object is created.
There are two kinds of object declarations: singleton object declarations and parametric object declarations. A singleton
object declaration does not have any static or value parameter; it declares a sole, stand-alone object. There are two
kinds of parametric object declarations: statically parametric objects and dynamically parametric objects. Statically
parametric objects are parameterized by static parameters and dynamically parametric objects are parameterized by
value parameters (possibly with static parameters). A dynamically parametric object declaration includes a constructor
declaration and every call to the constructor of such an object with the same argument yields a new object. A statically
parametric object declaration does not include a constructor declaration and every instantiation of such an object with
the same argument yields the same singleton object. Initialization of parametric objects is entirely demand-driven as
described in Section 22.6.
Each value parameter of a parameterized object declaration may be preceded by a sequence of field modifiers or the
special modifier transient : A value parameter preceded by the modifier transient doesn’t correspond to a field
in an instantiation of the object. transient parameters are not in scope of the object’s method declarations.
Fields can be also explicitly defined within a parameterized object declaration as within a singleton object declaration.
All fields of an object are initialized before that object is made available to subsequent computations. Syntactically,
method declarations in object declarations are identical to method declarations in trait declarations.
For example, the following empty list object extending trait List:
object Empty extends { List }
first() = throw Error
rest() = throw Error
cons(x) = Cons(x,self)
append(xs) = xs
end
has no fields and four methods.
Here is an example of a parameterized Cons object extending trait ListT :
object ConsT(first : T,rest : ListT)
extends ListT
cons(x) = Cons(x,self)
append(xs) = Cons(first,rest.append(xs))
end
Note that this declaration implicitly introduces the “factory” function ConsT(first : T,rest : ListT) :ConsT
which is used in the body of the object declaration to define the cons and append methods. Multiple factory functions
can be defined by overloading a parametric object with functions. For example: Cons(first : T) = Cons(first, Empty) .
10.2 Field Declarations
Syntax:
78