Number limit

// Every number type carries facts about itself as associated constants, written with `::` after
// the type's name: `int16::Max`, `uint8::Bits`, `float64::Epsilon`. They are declared in `Core`,
// so a lesson that uses them imports each type it asks about and lists `Core` as a dependency.
//
// Because they are constants, they work anywhere a constant does, including inside another
// `const`. And because they belong to a concrete type, a generic function cannot reach them
// through its type parameter: `T::Max` is rejected with "'Max' not found in extend for type 'T'".
// For that case `Core` offers `MaximumOf` and `MinimumOf`, which work the limit out from a sample
// value of the type.
//
// Floats have more limits than integers, because "smallest" means two different things: `Lowest`
// is the most negative finite value, and `MinPositive` the smallest normal value above zero.
// `Epsilon` is the gap between 1.0 and the next float up.
import Core::{ MaximumOf, MinimumOf, float32, float64, int16, uint16, uint8 };
import Io::PrintLine;

// A limit can define another constant.
const LargestPort: uint16 = uint16::Max;

// A generic function asks `Core` for the limits of its own type parameter.
func Span<T>(sample: T) -> T {
    return MaximumOf<T>(sample) - MinimumOf<T>(sample);
}

func Main() -> int {
    // Integers: the range, and the storage behind it.
    PrintLine("int16      {} to {}, {} bits in {} bytes", int16::Min, int16::Max, int16::Bits,
        int16::Bytes);
    PrintLine("port       up to {}", LargestPort);
    PrintLine("uint8 span {}", Span<uint8>(0));

    // Floats: the finite range, and how finely it is divided.
    PrintLine("float32    {} to {}", float32::Lowest, float32::Max);
    PrintLine("float64    {} to {}", float64::Lowest, float64::Max);
    PrintLine("smallest   {}", float64::MinPositive);
    PrintLine("epsilon    {}", float64::Epsilon);

    // Epsilon is the smallest step 1.0 can take. Anything smaller added to 1.0 is lost.
    let one = 1.0;
    PrintLine("1 + e      {}", one + float64::Epsilon);
    PrintLine("1 + e / 2  {}", one + float64::Epsilon / 2.0);

    // A limit makes a bounds check read like what it means.
    let reading: int32 = 40000;
    PrintLine("fits int16 {}", reading <= int16::Max && reading >= int16::Min);
    return 0;
}