"Abstraction of numeric types with the usual binary
operations:

- subtraction, `x - y`,
- multiplication, `x * y`, and
- division, `x / y`, along with

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")
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 numeric types, this
operation results in a
[[remainder|Integral.remainder]].

When the given number is `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);

}