module test {
    void show(Object o=Null) {
        @Inject Console console;
        console.print(o);
    }

    void run() {
        // an array literal has Constant mutability; it is **not** mutable
        immutable Int[] literalArray = [1,2,3];
        show($"{literalArray=}, {&literalArray.actualType=}");

        // obtaining the size or any element of an array is easy
        show($"{literalArray.size=}, {literalArray[2]=}");

        // modifications to a Constant array result in a new Constant array;
        // in Computer Science, this is called a persistent data structure
        immutable Int[] biggerArray = literalArray + 4;
        show($"{biggerArray=}, {&biggerArray.actualType=}");

        immutable Int[] biggestArray = biggerArray + biggerArray;
        show($"{biggestArray=}, {&biggestArray.actualType=}");

        // arrays can be accessed using the bracket operators
        show($"element at {biggestArray[2]=}");

        // attempts to modify an immutable array "in place" will result in an
        // exception at runtime
        try {
            biggestArray[2] = 99;
        } catch (ReadOnly e) {
            show($"immutable array not modified: {biggestArray=}");
        }

        // fixed-size arrays are like C/Java/C# arrays; their elements are
        // all set to the default value of the array Element type
        Int[] fixedLengthArray = new Int[10];
        show($"element at {fixedLengthArray[2]=}");

        // you can also initialize all the elements to a specific value
        Int[] negOnes = new Int[3](-1);
        show($"{negOnes=}");

        // ... or using a lambda
        Int[] counting = new Int[5](i -> i);
        show($"{counting=}");

        // attempts to modify a fixed-size array "in place" will succeed
        counting[1] = 99;
        show($"replaced [1]=99: {counting=}");

        // attempts to add or delete elements from a fixed-size array will
        // raise an exception
        try {
            counting += 101;
        } catch (ReadOnly e) {
            show($"Fixed mutability array not appendable: {counting=}");
        }

        // you can ask an array for its mutability
        show($"{literalArray.mutability=}, {fixedLengthArray.mutability=}");

        // you can convert an array from one mutability to another; the
        // Persistent mutability is just like the Constant mutability,
        // except that the array doesn't have to be immutable, so the
        // array can hold elements that are mutable, but no elements can
        // be added, removed, or replaced
        Int[] constantToMutable = biggestArray.toArray(Mutable);
        show($|{constantToMutable=}, {&constantToMutable.actualType=},\
              | {constantToMutable.mutability=}
            );
        Int[] constantToFixed = biggestArray.toArray(Fixed);
        show($|{constantToFixed=}, {&constantToFixed.actualType=},\
              | {constantToFixed.mutability=}
            );
        Int[] fixedToPersistent = counting.toArray(Persistent);
        show($|{fixedToPersistent=}, {&fixedToPersistent.actualType=},\
              | {fixedToPersistent.mutability=}
            );
        Int[] fixedToConstant = counting.toArray(Constant);
        show($|{fixedToConstant=}, {&fixedToConstant.actualType=},\
              | {fixedToConstant.mutability=}
            );

        // a slice of an array is an array; this is very handy
        Int[] slice = constantToMutable[1..2];
        show($"{slice=}");

        // slices may rely on the array that they are sliced from; to ensure that
        // changes to the original array don't appear in the slice, the slice
        // must be reified
        constantToMutable[1] = 17; // this will appear in the slice
        slice = slice.reify();
        constantToMutable[2] = 18; // this will NOT appear in the slice
        show($"{constantToMutable=}, {slice=}");

        // slices can be inclusive or exclusive
        show($"{constantToMutable[1..2]=}");
        show($"{constantToMutable[1..<2]=}");
        show($"{constantToMutable[1>..2]=}");
        show($"{constantToMutable[1>..<2]=}");

        // creating a new Mutable array uses the simplest form of the constructor;
        // a Mutable array
        Int[] variableArray = new Int[];
        show($"new {variableArray=}");

        // you can specify an estimated capacity for a new Mutable array, but the
        // capacity is just an optimization hint!
        Int[] willBeGiantArray = new Int[](999);
        show($"new {willBeGiantArray=}, {willBeGiantArray.capacity=}");

        // you can easily add and remove data from a Mutable array
        for (Int i : 10..1) {
            variableArray.add(i);
        }
        show($"NASA count-down: {variableArray=}");

        // remove unlucky numbers in Japanese
        variableArray.remove(4);
        show($"lucky count-down: {variableArray=}");

        // delete by index works as well
        variableArray.delete(variableArray.size-1);
        show($"aborted count-down: {variableArray=}");
    }
}