Kernel numeric classes:

<NUMBER> [abstract]
    <REAL> [abstract]
        <RATIONAL> [abstract]
            <INTEGER> [abstract]
                <SMALL-INTEGER> [sealed]

<NUMBER> methods:
    >, <=, >= [from <, =]
    /=, ZERO? [from =]
    EXPT by <SHORT-INTEGER>

<REAL> methods: 
    MODULO, REMAINDER [from floor/, truncate/], 
    FLOOR, CEILING, ROUND, TRUNCATE [from floor/, etc.]
    POSITIVE?, NEGATIVE?, ABS, MIN, MAX [from <]

<INTEGER> methods:
    ODD?, EVEN? [from LOGAND, =]
    LOGBIT? [from ASH, LOGAND, =]

<SHORT-INTEGER> methods:
    +, *, -, UNARY -, FLOOR/, CEILING/, ROUND/, TRUNCATE/.
    INTEGRAL? [always true]
    LOGAND, LOGIOR, LOGXOR, LOGNOT, ASH, LOGBIT?
    ID?, =, =HASH, <.


Primitive indices are <small-integer> (array, sequence, etc.)

Operations on small integers must yield small integers.  If an overflow occurs,
an error should be signalled (but portable applications can't count on this
happening.)

Note: if LOGANDC2, etc., aren't deleted, then they'd be <INTEGER> methods.

Note: / has kernel no methods.

Note: ID? must be generic if complex, etc., are moved into libraries and we
      want to preserve the current semantics.

Note: Glossing over the distinction between BINARY= and =, BINARY< and <, etc.
      Since infix won't have N-ary operators, this distinction is probably no
      longer necessary.


Float library:

	<FLOAT> [sealed]
            <SINGLE-FLOAT>
            <DOUBLE-FLOAT>
            <EXTENDED-FLOAT>

<SINGLE-FLOAT>, <DOUBLE-FLOAT>, <EXTENDED-FLOAT> methods:
    +, *, -, unary -, /, FLOOR/, CEILING/, ROUND/, TRUNCATE/.
    INTEGRAL? [always false ???]
    ID?, =, =HASH, <.

Methods that implement float contagion are defined for the cross product of
<SINGLE-FLOAT>, <DOUBLE-FLOAT>, <EXTENDED-FLOAT> and <SHORT-INTEGER>.  Mixed
precision < and = are correctly implementable using contagion; It's only when
there are ratios that we have to worry about losing precision with contagion.

<FLOAT> functions: 
    SIN, COS, TAN, ASIN, ACOS, ATAN, SINH, COSH, TANH, ASINH,
    ACOSH, ATANH, EXP, LOG, SQRT:
        [GF defined] These functions take a float and return a float with the
        same class.

    ATAN2[GF defined], EXPT:
        These two-arg functions must do float contagion.

Note: Semantics can be simplified slightly (made less arbitrary) by not
      allowing integer arguments to these functions.  In CL, integers are
      arbitrarily coerced to single precision (a dubious convenience.)


Extended precision library:
    [<real>]
	[<rational>]
            <RATIO> [sealed]
	    [<integer>]
                <EXTENDED-INTEGER> [sealed]


Explicit AS required to convert small to extended or vice-versa.  It is a type
error to pass an extended int to an operation expecting a small int, even if
the integer could be coerced to a small integer.

Extended integers are contagious.  Operations on mixed short and extended
integers produce an extended result.

<EXTENDED-INTEGER>, <RATIO> methods:
    NUMERATOR, DENOMINATOR [GF defined, result is an <EXTENDED-INTEGER>]
    +, *, -, UNARY -, /, FLOOR/, CEILING/, ROUND/, TRUNCATE/.
    =, <, ID?, =HASH, INTEGRAL?
    EXPT [second arg must be <INTEGER>???]

<EXTENDED-INTEGER> methods:
    LOGAND, LOGIOR, LOGXOR, LOGNOT
    LCM, GCD [GF defined]
    ASH [second arg must be <SMALL-INTEGER>]

<SINGLE-FLOAT>, <DOUBLE-FLOAT>, <EXTENDED-FLOAT> methods:
    FLOOR/, CEILING/, ROUND/, TRUNCATE/ [override float library methods]
    =, <: [To do mixed float/rational compare, RATIONALIZE the float.]
    RATIONALIZE [GF defined]


Complex library:
    <COMPLEX>
	[complex subtypes]

<complex> (complex single-float, complex double-float)?