The Fortress Language Specification - CiteSeerX

Note that a trait declaration inherits all method declarations declared by all of its supertraits–there’s no real notion of
overriding, just overloading (as discussed in Chapter 15). A trait declaration provides the method declarations that it
declares or inherits.
There are two sorts of method declarations: dotted method declarations and functional method declarations. Syntactically,
a dotted method declaration is identical to a function declaration, except that a special self parameter is provided
immediately before the name of the method. When a method is invoked, the self parameter is bound to the object
on which it is invoked. If no self parameter is provided explicitly, it is implicitly a parameter with name self . An
explicit self parameter may be an identifier other than self , in which case self is not necessarily declared within
that method.
A functional method declaration does not have a self parameter before the method name. Instead, it has a parameter
named self at an arbitrary position in its parameter list. This parameter is not given a type and implicitly has the
type of the enclosing declaration. Semantically, functional method declarations can be viewed as top-level functions.
For example, the following overloaded functional methods f declared within a trait declaration A:
trait A
f(self, t : T) = e 1
f(s :S,self) = e 2
end
f(a, t)
may be rewritten as top-level functions as follows:
trait A
internalF(t :T) = e 1
internalF(s :S) = e 2
end
f 1 (a :A, t :T) = a.internalF(t)
f 2 (s :S, a :A) = a.internalF(s)
f 1 (a, t)
where internalF is a freshly generated name. Functional method declarations may be overloaded with top-level
function declarations. An abstract function declaration (described in Section 12.3) can be provided also for overloaded
functional method declarations. See Chapter 15 for a discussion of overloaded functionals in Fortress.
A non-self self parameter can be used within nested object expressions (described in Section 13.9) to name the outer
object in methods of the inner:
object
m() = object
notSelf .getOuterSelf () = self(∗ “self” declared in outer scope ∗)
getInnerSelf () = self(∗ regular inner “self” ∗)
end
end
When a method declaration includes a body expression, it is called a method definition. A method declaration that
does not have its body expression is referred to as an abstract method declaration. An abstract method declaration
may include the modifier abstract . An abstract method declaration may elide parameter names but parameter types
cannot be omitted except for the self parameter.
Here is an example trait Enzyme which provides methods mass , catalyze , and reactionSpeed :
trait Enzyme extends { OrganicMolecule, Catalyst }
reactionSpeed():Speed
catalyze(reaction) = reaction.accelerate(reactionSpeed())
73