Destructure

// `.0` and `.1` work, but they say nothing about what each member means, and a function that
// uses a tuple's members many times fills up with them. Destructuring unpacks a tuple into named
// bindings in one step: `let (x, y) = pair;` declares `x` from `pair.0` and `y` from `pair.1`.
//
// The pattern on the left mirrors the tuple's shape. It needs one name per member, it may nest
// to unpack a tuple inside a tuple, and `_` stands for a member that is not wanted.
import Io::PrintLine;

func Divide(numerator: int32, denominator: int32) -> (int32, int32) {
    return (numerator / denominator, numerator % denominator);
}

func Bounds(values: int32[..]) -> (int32, int32) {
    var low = values[0];
    var high = values[0];
    for value in values {
        if value < low {
            low = value;
        }
        if value > high {
            high = value;
        }
    }
    return (low, high);
}

func Main() -> int {
    // The basic form: one name per member.
    let pair = (3, 4);
    let (x, y) = pair;
    PrintLine("x {} y {}", x, y);

    // It reads best straight off a function call that returns several results.
    let (quotient, remainder) = Divide(17, 5);
    PrintLine("17 / 5 is {} remainder {}", quotient, remainder);

    // `_` skips a member. Only the high bound is needed here.
    let readings: int32[6] = [12, 9, 15, 4, 7, 11];
    let (_, high) = Bounds(readings);
    PrintLine("highest reading {}", high);

    // `var` makes every name mutable, just as it does for a single binding.
    var (low, top) = Bounds(readings);
    low -= 1;
    top += 1;
    PrintLine("padded range {}..={}", low, top);

    // A nested pattern unpacks a tuple inside a tuple, all the way down.
    let segment = ((0, 0), (6, 8));
    let ((x1, y1), (x2, y2)) = segment;
    PrintLine("from {},{} to {},{}", x1, y1, x2, y2);

    // Destructuring only declares new names. Assigning to existing ones, `(a, b) = (b, a);`,
    // is rejected: the left side of `=` has to be a single place.
    return 0;
}