Convert

// A conversion happens on its own only when nothing can be lost: widening within one family and
// one signedness, such as `int8` to `int32` or `float32` to `float64`. Every other conversion is
// asked for with `as`, because every other conversion can change the value. Writing `as` is how
// you tell the compiler, and the next reader, that the change is intended.
import Io::PrintLine;

func Main() -> int {
    // Widening needs no `as`. Every `int8` is also an `int32`, so the compiler converts silently.
    let small: int8 = 100;
    let widened: int32 = small;
    PrintLine("widen        int8 {} becomes int32 {}", small, widened);

    // Narrowing must be asked for, and keeps only the low bits that fit. 300 needs nine bits, an
    // `int8` has eight, and what survives is 300 - 256.
    let big: int32 = 300;
    let narrowed = big as int8;
    PrintLine("narrow       int32 {} becomes int8 {}", big, narrowed);

    // Changing signedness keeps the bits and reads them differently: -1 has every bit set, and
    // eight set bits read as an unsigned number are 255.
    let negative: int32 = -1;
    let reinterpreted = negative as uint8;
    PrintLine("sign         int32 {} becomes uint8 {}", negative, reinterpreted);

    // Integers and floats are different families, so crossing between them always needs `as`.
    // Float to integer drops the fraction: it truncates toward zero rather than rounding.
    let ratio = 3.9;
    let negativeRatio = -3.9;
    PrintLine("float->int   {} becomes {}", ratio, ratio as int32);
    PrintLine("float->int   {} becomes {}", negativeRatio, negativeRatio as int32);

    // A float too large for the integer type does not keep low bits the way narrowing does. It
    // saturates: it becomes the largest value the type holds, or the smallest, below the range.
    let huge = 1e10;
    PrintLine("float->int   {} becomes {}", huge, huge as int32);

    let count: int32 = 7;
    PrintLine("int->float   {} becomes {}", count, count as float64);

    // A narrower float keeps fewer digits, so float64 to float32 needs `as` as well.
    let pi = 3.141592653589793;
    PrintLine("narrow float {} becomes {}", pi, pi as float32);

    // A character is a number underneath, its code point, and `as` shows it.
    let letter = 'A';
    PrintLine("char->int    {} becomes {}", letter, letter as uint32);

    // A boolean becomes 1 or 0. In the other direction, zero is false and anything else is true.
    let yes = true;
    let five = 5;
    PrintLine("bool->int    {} becomes {}", yes, yes as int);
    PrintLine("int->bool    {} becomes {}", five, five as bool);

    // None of the conversions above reported a problem. A conversion with `as` never fails: it
    // always produces a value, and when the original does not fit, that value is simply a
    // different one. To find out first whether a value fits, compare it with the target type's
    // limits — comparisons are the next part, and choosing what to do with the answer the one
    // after.
    return 0;
}