Fork me on GitHub
Source file: arrays.fut

# Arrays

Futhark arrays are written as values enclosed in square brackets.

``let arr = [1,2,3]``

The type of `arr` is `[]i32` (or `[3]i32` to be pedantic). The element type of an array can be another array:

``let marr = [[1,2,3], [4,5,6]]``

The type of `marr` is `[][]i32`. Arrays must be regular, meaning that all elements must have the same shape. An array such as `[[1,2], [3]` is illegal.

Arrays can be indexed from zero:

``let first = arr[0]``

And sliced:

``let tail = arr[1:]``

We can even slice or index only some dimensions:

``let innermost = marr[:,1:2]``

This produces `[[2], [5]]`. Slices are inclusive in the starting position and exclusive in the ending position as Dijkstra wills it.

Strides are also supported. Generally, The expression `a[i:j:s]` returns a slice of the array `a` from index `i` (inclusive) to `j` (exclusive) with a stride of `s`. If the stride is positive, then `i <= j` must hold, and if the stride is negative, then `j <= i` must hold. For example, we can reverse an array like this:

``let arr_reversed = arr[::-1]``

Some syntactic sugar is provided for concisely specifying arrays of intervals of integers. The expression `x...y` produces an array of the integers from `x` to `y`, both inclusive. The upper bound can be made exclusive by writing `x..<y`. For example:

``let arr_range = 1...3``

It is usually necessary to enclose a range expression in parentheses, because they bind very loosely. A stride can be provided by writing `x..y...z`, with the interpretation “first `x`, then `y`, up to `z`”. For example:

``let strided = 1..3...7``

Now `strided` contains `[1, 3, 5, 7]`.