Generic

// The Overload lesson wrote one function per type: an `Area` for `int` and
// another for `float64`, with the same body. A generic function writes that
// body once.
//
// A name in angle brackets after the function name is a type parameter. It
// stands for a type the caller supplies, and the compiler produces a separate
// version of the function for each type actually used.
import Io::PrintLine;

// Both arguments must be the same type `T`, and the result is that type too,
// so two `int` values give back an `int` and two `float64` values a `float64`.
func Larger<T>(first: T, second: T) -> T {
    if first > second {
        return first;
    }
    return second;
}

// Nothing in this body depends on what `T` can do, so it accepts any type.
func Pick<T>(useFirst: bool, first: T, second: T) -> T {
    if useFirst {
        return first;
    }
    return second;
}

func Main() -> int {
    // Usually `T` is inferred from the arguments. Four types and no conversion
    // anywhere: each type used compiles its own version of the function.
    PrintLine("Larger(3, 9)                  {}", Larger(3, 9));
    PrintLine("Larger(2.5, 1.5)              {}", Larger(2.5, 1.5));
    PrintLine("Larger('a', 'z')              {}", Larger('a', 'z'));
    PrintLine("Pick(true, \"yes\", \"no\")       {}", Pick(true, "yes", "no"));

    // `T` can also be given explicitly in angle brackets at the call. That
    // matters when the arguments alone would choose a different type. Bare
    // literals become `int`, but with `<uint8>` they become `uint8`, and so
    // does the result — which is why adding 100 wraps around here.
    PrintLine("Larger(200, 7) + 100          {}", Larger(200, 7) + 100);
    PrintLine("Larger<uint8>(200, 7) + 100   {}", Larger<uint8>(200, 7) + 100);

    // `Larger` uses `>` on a `T` it knows nothing about. That is checked once
    // `T` is known: calling `Larger` with a type that has no `>` is rejected
    // when that version of `Larger` is compiled.
    //
    // Watch out: a function with an unconstrained `T` cannot print its value.
    // `PrintLine("{}", first)` inside `Larger` is refused, because `{}` needs
    // a type known to be printable and `T` promises nothing. That is why each
    // function here returns its value for `Main` to print. A bound such as
    // `<T: Display>`, taught in the Generics part, is how `T` makes that promise.
    return 0;
}