prelude.Array
Part of prelude.
let Array.is_empty (xs: Array[T]): Bool
Whether the array has no elements.
let Array.concat (a: Array[T]) (b: Array[T]): Array[T]
A new array with b's elements after a's. Neither input is changed.
let Array.contains (xs: Array[T]) (needle: T): Bool
Whether any element equals needle, compared structurally.
let Array.any (xs: Array[T]) (f: (T) -> Bool): Bool
Whether f holds for at least one element. Stops at the first that passes; false for an empty array.
let Array.slice (xs: Array[T]) (start: Int) (end: Int): Array[T]
The elements from start up to but NOT including end.
Out-of-range bounds are clamped rather than an error, and a start past end gives an empty array — so slicing near the end of an array needs no arithmetic to stay safe.
let Array.reverse (xs: Array[T]): Array[T]
A new array in the opposite order.
let Array.all (xs: Array[T]) (f: (T) -> Bool): Bool
Whether f holds for every element. Stops at the first that fails; TRUE for an empty array, which is the convention everywhere and still surprises people.
let Array.find (xs: Array[T]) (f: (T) -> Bool): Option[T]
The first element f accepts, or None.
let Array.find_index (xs: Array[T]) (f: (T) -> Bool): Option[Int]
The index of the first element f accepts, or None.
let Array.index_of (xs: Array[T]) (needle: T): Option[Int]
The index of the first element equal to needle, or None.
let Array.first (xs: Array[T]): Option[T]
The first element, or None when the array is empty.
let Array.last (xs: Array[T]): Option[T]
The last element, or None when the array is empty.
let Array.take (xs: Array[T]) (n: Int): Array[T]
The first n elements, or all of them if there are fewer. Never an error.
let Array.drop (xs: Array[T]) (n: Int): Array[T]
Everything after the first n elements, or nothing if there are fewer.
let Array.sum_int (xs: Array[Int]): Int
The sum, which OVERFLOWS like any other addition and stops the program rather than wrapping.
let Array.sum_float (xs: Array[Float]): Float
The sum, left to right. Floating-point addition is not associative, so a different order can give a different last digit.
let Array.join (parts: Array[String]) (sep: String): String
Namespaced under Array, not String, since 2026-08-25: both take an Array[String]. String. used to mean two different things, "first parameter is a String" for most of it and "produces a String" for these two, and x.f(a) = T.f(x, a) needs it to mean exactly one. parts.join(", ") now works and reads the right way round.
let Array.sort_by (arr: Array[T]) (le: (T, T) -> Bool): Array[T]
Sorted by a \"less than or equal\" predicate.
STABLE: elements le considers equivalent keep their original order, which is what makes sorting by one key and then another produce the ordering people expect.
Merge sort with O(n log n) comparisons and O(n) auxiliary storage.
let Array.sort_int (arr: Array[Int]): Array[Int]
Sorted ascending.
let Array.sort_float (arr: Array[Float]): Array[Float]
Sorted ascending. NaN does not compare, so an array containing one has no meaningful order.
let Array.zip (a: Array[T]) (b: Array[U]): Array[Zipped[T, U]]
Pairs elements positionally, stopping at the shorter array.
let Array.concat_all (parts: Array[String]): String
Joins in ONE allocation. Building a large string by repeated .concat is quadratic; this is what the compiler's own emitter uses for anything that accumulates.
let Array.sort_string (arr: Array[String]): Array[String]
Sorted by BYTE order, not by any locale's alphabet — so uppercase sorts before lowercase, and accented letters sort after z.
let Array.map (self: Array[T]) (f: (T) -> U): Array[U]
A new array holding f applied to each element, in order. The result's element type is whatever f returns, so mapping can change it.
Implemented by the compiler itself, so it has no Plum source to read.
let Array.filter (self: Array[T]) (f: (T) -> Bool): Array[T]
A new array holding the elements f says true about, in their original order.
Implemented by the compiler itself, so it has no Plum source to read.
let Array.fold (self: Array[T]) (init: U) (f: (U, T) -> U): U
Reduces the array to one value: starts at init and calls f(acc, element) for each element, left to right.
Implemented by the compiler itself, so it has no Plum source to read.
let Array.len (self: Array[T]): Int
How many elements the array holds.
Implemented by the compiler itself, so it has no Plum source to read.
let Array.push (self: Array[T]) (x: T): Array[T]
A new array with x added at the end. The receiver is unchanged, but when it is dying the compiler reuses its cell rather than copying, so acc = acc.push(x) in a loop does not go quadratic.
Implemented by the compiler itself, so it has no Plum source to read.
let Array.remove (self: Array[T]) (i: Int): Array[T]
A new array with the element at index i left out. Out of range is a runtime error.
Implemented by the compiler itself, so it has no Plum source to read.
let Array.set (self: Array[T]) (i: Int) (v: T): Array[T]
A new array with index i holding v. Out of range is a runtime error.
Implemented by the compiler itself, so it has no Plum source to read.