The Fortress Language Specification - CiteSeerX

A value e is a left identity for a binary operator ⊙ if the result of ⊙ always equals the right-hand operand whenever
e is the left-hand operand. For example, 0 is a left identity for the + operator on integers and the empty set is a left
identity for the ∪ operator on sets.
trait HasRightIdentityT extends HasRightIdentityT, ⊙,opr ⊙
extends { BinaryOperatorT, ⊙, EquivalenceRelationT, = }
isRightIdentity():Boolean
property ∀(a:T, b: T) b.isRightIdentity() →:((a ⊙ b) = a)
end
A value e is a right identity for a binary operator ⊙ if the result of ⊙ always equals the right-hand operand whenever
e is the left-hand operand. For example, 0 is a right identity (as well as a left identity) for the + operator on integers
and the empty set is a right identity (as well as a left identity) for the ∪ operator on sets. By way of contrast, 1 is a
right identity for division of rationals but not a left identity.
value object Identityopr ⊙ end
trait HasIdentityT extends HasIdentityT, ⊙,opr ⊙
extends { HasLeftIdentityT, ⊙, HasRightIdentityT, ⊙ }
where { T coerces Identity⊙ }
property ∀(a:T) (a ⊙ Identity⊙) = a
property ∀(a:T) (Identity⊙ ⊙ a) = a
property ∀(a:T) a.isLeftIdentity() ↔ (a = Identity⊙)
property ∀(a:T) a.isRightIdentity() ↔ (a = Identity⊙)
end
If the same value is both a left identity and a right identity for ⊙ , then it may be called simply an identity—in fact,
the identity, for it is unique and may be obtained by coercing the object named Identity⊙ to type T .
value object Zeroopr ⊗ end
trait ApproximateZeroAnnihilation T extends ApproximateZeroAnnihilationT, ⊗, ≈,
opr ⊗,opr ≈
extends { BinaryOperatorT, ⊗, ReflexiveT, ≈, SymmetricT, ≈ }
property ∀(a:T) (Zero⊗ ⊗ a) :≈: Zero⊗
property ∀(a:T) (a ⊗ Zero⊗) :≈: Zero⊗
end
An operator ⊗ obeys approximate zero annihilation if and only if there is an element (call it z ) that when used as
either operand of ⊗ causes the result to be “close enough” to z as determined by the specified ≈ predicate. This
zero element may be obtained by coercing the object named Zero⊗ to type T .
trait ZeroAnnihilationT extends ZeroAnnihilationT, ⊗,opr ⊗
extends { ApproximateZeroAnnihilationT, ⊗, =, EquivalenceRelationT, = }
end
An operator ⊗ obeys zero annihilation if and only if there is an element (call it z ) that when used as either operand of
⊗ causes the result to equal z . (It follows that z is both a left idempotent element and a right idempotent element for
⊗ . However, the trait ZeroAnnihilationT, ⊗ intentionally does not extend the traits HasLeftZeroesT, ⊗,name
and HasRightZeroesT, ⊗,name because there is not always a practical requirement for methods that determine
whether any value is left idempotent or right idempotent; sometimes it suffices to know only that one particular
element, produced by coercing Zero⊗ to type T , has that property.)
trait UnaryOperatorSubstitutionLawsT extends UnaryOperatorSubstitutionLawsT, ⊙, =,
opr ⊙,opr ≃
255