Fork me on GitHub
Announcement: We are hiring a PhD student to do research on functional high performance computing, including work on Futhark itself. See here for more details.


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].

See also

Reference manual: slicing.