Tuple pattern

// A `match` looks at one value. To decide on two values together, put them in a tuple and match
// the tuple. Each arm is then a tuple pattern with one part per member, and the arm is taken only
// when every part matches its member:
//
//     (0, 0)    both members are 0
//     (x, 0)    the second member is 0, and the first is bound to `x`
//     (_, y)    any first member, ignored, and the second bound to `y`
//
// A part can be any pattern you have met so far: a literal, a name, `_` or a range. Arms are tried
// from top to bottom, so the most specific ones go first, and a guard can follow the pattern as
// usual. A pair of numbers has far more combinations than any list of arms, so a match on one ends
// with `else`, which decides what all the others mean. A pair of `bool`s has only four, so its
// arms can list them all, and the compiler checks that none is missing.
import Io::{ Print, PrintLine };

// Where a point lies. Literal parts test a member, names bind one, and `_` ignores one.
func Locate(point: (int32, int32)) {
    match point {
        (0, 0) => PrintLine("the origin"),
        (x, 0) => PrintLine("on the x axis, {} across", x),
        (0, y) => PrintLine("on the y axis, {} up", y),
        (x, y) if x == y => PrintLine("on the diagonal, {} each way", x),
        (_, y) if y > 0 => PrintLine("above the x axis, {} up", y),
        else => PrintLine("below the x axis")
    }
}

func Main() -> int {
    let points: (int32, int32)[6] = [(0, 0), (4, 0), (0, 6), (3, 3), (-1, 5), (2, -7)];
    for point in points {
        Print("({}, {}) is ", point.0, point.1);
        Locate(point);
    }

    // The tuple need not exist beforehand: build it right in the `match` from the values the
    // decision depends on. This is FizzBuzz, decided by both remainders at once.
    for n in 1..=15 {
        match (n % 3, n % 5) {
            (0, 0) => Print("FizzBuzz"),
            (0, _) => Print("Fizz"),
            (_, 0) => Print("Buzz"),
            else => Print("{}", n)
        }
        if n < 15 {
            Print(" ");
        }
    }
    PrintLine("");

    // Two `bool`s make four combinations, and these arms list them all, so no `else` is needed.
    // Leave one out and the compiler names it:
    //     error: match on '(bool8, bool8)' is not exhaustive; missing (true, false)
    let raining = true;
    let windy = false;
    let advice = match (raining, windy) {
        (true, true) => "a raincoat",
        (true, false) => "an umbrella",
        (false, true) => "a jacket",
        (false, false) => "nothing extra"
    };
    PrintLine("rain without wind: take {}", advice);

    // A struct can be taken apart the same way, by field name instead of position:
    // `Point { x: 0, y } =>` tests `x` and binds `y`. A field written alone, like `y`, is short
    // for `y: y`.
    return 0;
}