Writable slice

// A plain slice, `int32[..]`, is read-only: it can look at the elements but never change them.
// A writable slice, `var int32[..]`, may also write through to the array it views. Taking a
// range of a `var` array gives a writable view; taking one of a `let` array gives a read-only
// one.
//
// The surprise is that the view's writability has nothing to do with how the view itself is
// bound. `let view = storage[..];` is a writable view held in an immutable binding: `view[0] = 1`
// is fine, because it changes the array, while `view = ...` is rejected, because it would change
// the binding. A `var` binding of a read-only view is the reverse: it can be pointed somewhere
// else, but it can never write an element.
import Io::PrintLine;

// A function that changes its argument's elements asks for a writable view.
func Fill(values: var int32[..], value: int32) {
    for i in 0..values.length {
        values[i] = value;
    }
}

// A function that only reads asks for a read-only view, and a writable one is accepted too.
func Show(label: char8[..], values: int32[..]) {
    PrintLine("{} {} {} {} {} {}", label, values[0], values[1], values[2], values[3], values[4]);
}

func Main() -> int {
    var storage: int32[5] = [1, 2, 3, 4, 5];
    Show("start  ", storage);

    // A `let` binding, a writable view. Writing through it writes the array.
    let view = storage[1..4];
    view[0] = 20;
    Show("view   ", storage);

    // The function writes through its view, so the change shows up in `storage`. An array
    // becomes a read-only view on its own, but a writable one has to be asked for with a range.
    // `Fill(storage[..], 0)` would fill all of it, while `Fill(storage, 0)` stops with
    //     error: no matching overload for 'Fill' with argument types (int32[5], int)
    Fill(storage[3..], 0);
    Show("filled ", storage);

    // A `var` binding, a read-only view. It may move along the array, but `cursor[0] = 9`
    // would be rejected.
    var cursor: int32[..] = storage[..2];
    PrintLine("cursor  starts at {}", cursor[0]);
    cursor = storage[2..];
    PrintLine("cursor  moved to {}", cursor[0]);

    // A writable view may be stored as a read-only one, which then sees later writes too.
    let reader: int32[..] = view;
    view[1] = 30;
    PrintLine("reader  sees {}", reader[1]);
    return 0;
}