Generic sum

// A sum can be built from type parameters: `T | U` is "a T or a U", whatever they turn out to be.
// That raises a question the SumType lesson already answered. A sum is a set of types, so when
// `T` and `U` are the same type, `T | U` has only one member and collapses to that type.
// `Choose<int32, int32>` returns a plain `int32`, ready for arithmetic.
//
// The collapse matters to a generic `match`. `Side` cannot write a second arm `second: U =>`:
// at `Side<int32, int32>` that arm would come after `first: int32 =>`, which already matched
// everything, and the instantiation is rejected — "match arm is unreachable because an earlier
// pattern matches every value", with a note "in 'Side' instantiated with T = int32, U = int32
// by the call at ..." that points at the call in `Main` responsible. An `else` arm is never
// reported as unreachable, so a match over `T | U` ends in `else` and stays valid for every pair
// of type arguments.
import Io::PrintLine;

// Hands back one of two values of possibly different types.
func Choose<T, U>(takeFirst: bool, first: T, second: U) -> T | U {
    if takeFirst {
        return first;
    }
    return second;
}

// Which member a `T | U` holds. When the sum has collapsed, the first arm takes every value.
func Side<T, U>(value: T | U) -> char8[..] {
    return match value {
        first: T => "first",
        else => "second"
    };
}

func Main() -> int {
    // Two different types: the result keeps whichever member it was given.
    let port = Choose<int32, bool>(true, 8080, false);
    let flag = Choose<int32, bool>(false, 8080, true);
    PrintLine("int32 | bool    {} {}", Side<int32, bool>(port), Side<int32, bool>(flag));

    // The same type twice: `int32 | int32` is `int32`, so the result is an ordinary number.
    let count: int32 = Choose<int32, int32>(false, 3, 4);
    PrintLine("int32 | int32   {}", count + 1);

    // A collapsed sum has nothing to tell apart. The `else` arm is still there, unused.
    PrintLine("collapsed side  {}", Side<int32, int32>(count));
    return 0;
}