The Fortress Language Specification - CiteSeerX

‘}’. If such a clause contains only one trait, the enclosing braces may be elided. A trait reference is either a declared
trait identifier or an abbreviated type for aggregate expressions (discussed in Section 13.28).
Every trait extends the trait Object. A trait with an extends clause extends every trait listed in its extends clause.
If a trait T extends trait U , we call T a subtrait of U and U a supertrait of T . Extension is transitive; if T extends
U it also extends all supertraits of U . Extension is also reflexive: T extends itself. The extension relation induced
by a program is the smallest relation satisfying these conditions. This relation must form an acyclic hierarchy rooted
at trait Object.
We say that trait T strictly extends trait U if and only if (i) T extends U and (ii) T is not U . We say that trait T
immediately extends trait U if and only if (i) T strictly extends U and (ii) there is no trait V such that T strictly
extends V and V strictly extends U . We call U an immediate supertrait of T and T an immediate subtrait of U .
A trait with an excludes clause excludes every trait listed in its excludes clause. If a trait T excludes a trait U ,
the two traits are mutually exclusive. No third trait can extend them both and neither can extend the other. A trait U
can optionally have an excludes clause.
If a trait declaration of T includes a comprises clause, the trait must not be extended with immediate subtraits other
than those that listed in its comprises clause. If a trait T has an empty comprises clause, no other traits can
extend T .
For example, the following trait declaration:
trait Catalyst extends Object
self.catalyze(reaction: Reaction):()
end
declares a trait Catalyst with no modifiers, no static parameters, no excludes clauses, no comprises clauses, and
no where clauses. Trait Catalyst extends a trait named Object. A single method (named catalyze ) is declared,
which has a parameter of type Reaction and the return type (). The special name self is explicitly declared as a
parameter. See Section 9.2 for details about when self is implicitly declared, and to which entity it refers.
The following example trait:
trait Molecule comprises { OrganicMolecule, InorganicMolecule }
mass():Mass
end
comprises of two traits: OrganicMolecule and InorganicMolecule. Therefore, the following trait declaration is not
allowed:
(∗ Not allowed! ∗)
trait ExclusiveMolecule extends Molecule end
Traits OrganicMolecule and InorganicMolecule may be exclusive:
trait OrganicMolecule extends Molecule excludes InorganicMolecule end
trait InorganicMolecule extends Molecule end
OrganicMolecule and InorganicMolecule exclude each other, even though only OrganicMolecule has an excludes
clause. For example, the following trait declaration is not allowed:
(∗ Not allowed! ∗)
trait InclusiveMolecule extends { InorganicMolecule, OrganicMolecule } end
A trait is allowed to have multiple immediate supertraits. The following trait has two immediate supertraits:
trait Enzyme extends { OrganicMolecule, Catalyst } end
71