Array

// An array holds a fixed number of values of one type, side by side. `int32[4]` is "four int32
// values": the element type, then the count in square brackets. The count is part of the type,
// so an `int32[4]` and an `int32[5]` are different types, and an array never grows or shrinks.
//
// The elements live inline, right inside the variable, exactly like the bytes of a single
// integer do. Nothing is allocated, and copying an array copies every element.
import Io::PrintLine;

func Main() -> int {
    // An array literal lists the elements in square brackets.
    let primes: int32[4] = [2, 3, 5, 7];

    // Elements are numbered from zero, so the last one sits at `length - 1`.
    PrintLine("first {}, last {}", primes[0], primes[primes.length - 1]);
    PrintLine("length {}", primes.length);

    // `for` walks an array element by element, just as it walked a range.
    var sum: int32 = 0;
    for prime in primes {
        sum += prime;
    }
    PrintLine("sum {}", sum);

    // When the position matters, walk the indices instead. `..` stops before its upper bound,
    // which is exactly the set of valid indices.
    for i in 0..primes.length {
        PrintLine("primes[{}] = {}", i, primes[i]);
    }

    // `let` freezes the elements too. To change one, the array must be `var`.
    var scores: int32[3] = [10, 20, 30];
    scores[1] = 25;

    // Assigning an array copies all of its elements. Changing the copy leaves the original
    // alone, because the two variables share nothing.
    var copy = scores;
    copy[0] = 99;
    PrintLine("scores {} {} {}", scores[0], scores[1], scores[2]);
    PrintLine("copy   {} {} {}", copy[0], copy[1], copy[2]);

    // Two arrays of the same type are equal when every element is.
    PrintLine("scores == copy  {}", scores == copy);

    // Every index must be below `length`, and it is checked. A constant index past the end,
    // `primes[7]`, does not compile:
    //     error: index 7 is out of range for an array of 4 elements
    // An index computed while the program runs is checked as it runs, and one past the end stops
    // the program with `Panic: index out of range` rather than read memory beyond the array.
    return 0;
}