"Abstraction of _ordinal types_, that is, of types where 
 each instance has a [[successor]] and [[predecessor]], such 
 as:
  
 - types which represent or are isomorphic to the 
   mathematical integers, for example, [[Integer]] and other 
   [[Integral]] numeric types, and even [[Character]], along 
   with
 - enumerated types which are isomorphic to the mathematical
   integers under modular arithmetic, for example, the days
   of the week, and
 - enumerated types which are isomorphic to a bounded range 
   of integers, for example, a list of priorities.
 
 The _increment_ operator `++` and _decrement_ operator `--`
 are defined for all types which satisfy `Ordinal`.
 
     function increment() {
         count++;
     }
 
 Many ordinal types have a [[total order|Comparable]]. If an
 ordinal type has a total order, then it should satisfy:
 
 - `x.successor >= x`, and
 - `x.predecessor <= x`.
 
 An ordinal enumerated type `X` with a total order has 
 well-defined `maximum` and `minimum` values where
 `minimum<x<maximum` for any other instance `x` of `X`.
 Then the `successor` and `predecessor` operations should
 satisfy:
 
 - `minimum.predecessor==minimum`, and
 - `maximum.successor==maximum`."
see (`class Character`, 
     `class Integer`, 
     `interface Integral`, 
     `interface Comparable`,
     `interface Enumerable`)
by ("Gavin")
shared interface Ordinal<out Other> of Other
        given Other satisfies Ordinal<Other> {
    
    "The successor of this value."
    shared formal Other successor;
    
    "The predecessor of this value."
    shared formal Other predecessor;
    
}