    "Abstraction of numeric types with the usual binary
     operations:

     - addition, `x + y`,
     - subtraction, `x - y`,
     - multiplication, `x * y`, and
     - division, `x / y`, along with
     - additive inverse `-x`.

     A concrete class which implements this interface should be
     a mathematical _ring_. That is:

     - both addition, `+`, and multiplication, `*`, should be
       associative and commutative,
     - there should be additive and multiplicative identities,
       denoted `0` and `1` respectively, satisfying `x+0 == x`
       and `x*1 == x`,
     - every instance `x` should have an additive inverse `-x`,
       satisfying `x + -x == 0`, and
     - multiplication should distribute over addition,
       satisfying `x*(y+z) == x*y + x*z`.

     It is preferred, but not required, that the class be a
     mathematical _field_. That is, in addition to the above:

     - every instance `x` such that `x!=0` should have a
       multiplicative inverse `1/x`, satisfying `x * 1/x == 1`.

     For numeric types which are not fields, for example,
     [[Integer]], there is still a division operation, which is
     understood to produce a [[remainder|Integral.remainder]].
     The division operation should satisfy:

     - `x*y / y == x`

     for any instance `y` other than `0`.

     For numeric types which _are_ fields, division never
     produces a remainder, and division should additionally
     satisfy:

     - `x/y * y == x`

     for any instance `y` other than `0`.

     Some numeric types, for example complex numbers, do not
     have a [[total order|Comparable]]. Numeric types with a
     total order also satisfy [[Number]]."
    see (`interface Number`)
    by ("Gavin")
    tagged("Numbers")
    shared interface Numeric<Other> of Other
            satisfies Invertible<Other>
            given Other satisfies Numeric<Other> {

        "The product of this number and the given number."
        shared formal Other times(Other other);

        "The quotient obtained by dividing this number by the
         given number. For [[integral|Integral]] numeric types,
         this operation rounds toward `0`, the additive identity,
         and results in a [[remainder|Integral.remainder]].

         When the given [[divisor|other]] is exactly `0`, the
         additive identity, the behavior depends on the numeric
         type:

         - For some numeric types, including [[Integer]],
           division by `0` results in an exception.
         - For others, including [[Float]], it results in a
           special value of the type, for example, [[infinity]]."
        see (`function Integral.remainder`,
             `value infinity`)
        shared formal Other divided(Other other);

    }