The Fortress Language Specification - CiteSeerX

37.3 Operators and Their Properties
For some types, such as the integers Z or the rationals Q , results are always exact, and algebraic properties can be
expected to be obeyed exactly. For other types, such as floating-point numbers, results are not always numerically
exact, and algebraic properties can be expected to be obeyed only approximately. For example, given three floatingpoint
values a and b and c , it may well be that a + (b + c) is not equal to (a + b) + c ; but we would expect their
values to be reasonably close—unless, of course, overflow occurred in one expression but not the other.
In order to address the difficulties of such approximate computation, many of the traits described in this section come
in two varieties: approximate and exact. The + operator on integers or rationals is correctly described by the trait
Associative, and the + operator on floating-point numbers is correctly described by the trait ApproximatelyAssociative.
An important distinction is that the predicate used to test acceptability of exact algebraic properties is = , which is
required to be an equivalence relation and therefore transitive, but a type-dependent binary predicate (typically ≈ )
may be used to test acceptability of approximate algebraic properties, and this predicate is required only to be reflexive
and symmetric.
trait UnaryOperatorT extends UnaryOperatorT, ⊙,opr ⊙
opr ⊙(self): T
end
A unary operator is a prefix operator that takes one argument and returns a value of the same type. Note that ⊙ is a
static parameter, used here as a “variable” name for an operator.
trait BinaryOperatorT extends BinaryOperatorT, ⊙,opr ⊙
opr ⊙(self,other: T): T
end
A binary operator is an infix operator that takes two arguments of the same type and returns a value of that type. Thus,
for example, any trait T that extends BinaryPredicateT, + necessarily has an infix method for the operator + ,
and that operator takes two operands of type T and returns a value of type T .
trait IdentityOperatorT extends IdentityOperatorT
extends { UnaryOperatorT,IDENTITY }
opr IDENTITY(self):T = self
property ∀(a:T) (IDENTITY a) = a
end
The trait IdentityOperator provides a definition of the unary IDENTITY operator, which simply returns its argument.
The trait Object extends IdentityOperatorObject , so the IDENTITY operator is defined for every type whatsoever.
(This operator may not be terribly useful for applications programming, but it has technical uses for specifying
contracts and algebraic properties in libraries. It is used, for example, when defining the trait BooleanAlgebra in
terms of the trait Ring: because every value is its own inverse with respect to the “exclusive OR” operator in a Boolean
Algebra, IDENTITY is the appropriate additive inverse operator for use with the trait Ring in this connection.)
trait ApproximatelyCommutativeT extends ApproximatelyCommutativeT, ⊙, ≈,opr ⊙,opr ≈
extends { BinaryOperatorT, ⊙, ReflexiveT, ≈, SymmetricT, ≈ }
property ∀(a:T, b: T) (a ⊙ b) :≈: (b ⊙ a)
end
The trait ApproximatelyCommutative requires the operator ⊙ to be approximately commutative; that is, reversing
the operands produces a result that is considered to be “close enough” as determined by the specified ≈ predicate.
trait CommutativeT extends CommutativeT, ⊙,opr ⊙
extends { ApproximatelyCommutativeT, ⊙, =, EquivalenceRelationT, = }
end
252