Array

(λ [(Ref (Array a)), (Ref (Array a))] Bool)

                    (/= a b)
                

compares two arrays and inverts the result.

(λ [(Ref (Array a)), (Ref (Array a))] Bool)

                    (= a b)
                

compares two arrays.

(λ [(Ref (λ [&a] Bool)), (Ref (Array a))] Bool)

                    (all? f a)
                

checks whether all of the elements in a match the function f.

(λ [Int] (Array t))

allocates an uninitialized array. You can initialize members using aset-uninitialized.

(λ [(Ref (λ [&a] Bool)), (Ref (Array a))] Bool)

                    (any? f a)
                

checks whether any of the elements in a match the function f.

(λ [(Array t), Int, t] (Array t))

sets an array element at the index n to a new value.

(λ [(Ref (Array t)), Int, t] ())

sets an array element at the index n to a new value in place.

(λ [(Ref (Array t)), Int, t] ())

sets an uninitialized array member. The old member will not be deleted.

(λ [(Array a), Int, (Ref (λ [&a] a))] (Array a))

                    (aupdate a i f)
                

transmutes (i.e. updates) the element at index i of an array a using the function f.

(λ [(Ref (Array a)), Int, (Ref (λ [&a] a))] ())

                    (aupdate! a i f)
                

transmutes (i.e. updates) the element at index i of an array a using the function f in place.

(λ [(Ref (Array (Array a)))] (Array a))

                    (concat xs)
                

returns a new array which is the concatenation of the provided nested array xs.

(λ [(Ref (Array a))] (Array a))

copies an array.

(λ [(Ref (λ [&a] Bool)), (Ref (Array a))] (Array a))

                    (copy-filter f a)
                

filters the elements in an array.

It will create a copy. If you want to avoid that, consider using endo-filter instead.

(λ [(Ref (λ [&a] b)), (Ref (Array a))] (Array b))

                    (copy-map f a)
                

maps over an array a using the function f.

This function copies the array. If you don’t want that, use endo-map.

(λ [(Array a)] ())

deletes an array. This function should usually not be called manually.

(λ [(Ref (Array a)), &a] Int)

                    (element-count a e)
                

counts the occurrences of element e in an array.

(λ [(Ref (Array a))] Bool)

                    (empty? a)
                

checks whether the array a is empty.

(λ [(Ref (λ [&a] Bool)), (Array a)] (Array a))

filters array members using a function. This function takes ownership.

(λ [(Ref (λ [a] a)), (Array a)] (Array a))

applies a function f to an array a. The type of the elements cannot change.

(λ [(Ref (Array a))] (Array (Pair Int a)))

                    (enumerated xs)
                

creates a new array of Pairs where the first position is the index and the second position is the element from the original array xs.

(λ [(Ref (λ [&a] Bool)), (Ref (Array a))] (Maybe a))

                    (find f a)
                

finds an element in a that matches the function f and wraps it in a Just.

If it doesn’t find an element, Nothing will be returned.

(λ [(Ref (λ [&a] Bool)), (Ref (Array a))] (Maybe Int))

                    (find-index f a)
                

finds the index of the first element in a that matches the function f and wraps it in a Just.

If it doesn’t find an index, Nothing will be returned.

(λ [(Ref (Array a))] (Maybe a))

                    (first a)
                

takes the first element of an array and returns a Just.

Returns Nothing if the array is empty.

(λ [(Ref (Array a)), &a] (Maybe Int))

                    (index-of a e)
                

gets the index of element e in an array and wraps it on a Just.

If the element is not found, returns Nothing

(λ [(Ref (Array a))] (Maybe a))

                    (last a)
                

takes the last element of an array and returns a Just.

Returns Nothing if the array is empty.

(λ [(Ref (Array t))] Int)

gets the length of the array.

(λ [(Ref (Array a))] (Maybe a))

                    (maximum xs)
                

gets the maximum in an array (elements must support <) and wraps it in a Just.

If the array is empty, it returns Nothing.

(λ [(Ref (Array a))] (Maybe a))

                    (minimum xs)
                

gets the minimum in an array (elements must support >) and wraps it in a Just.

If the array is empty, returns Nothing

(λ [(Ref (Array t)), Int] &t)

gets a reference to the nth element from an array a.

(λ [(Array a)] (Array a))

removes the last element of an array and returns the new array.

(λ [(Ref (Array a))] a)

removes an element value from the end of an array a in-place and returns it.

(λ [(Ref (Array a)), (Ref (λ [&a] Bool))] Int)

                    (predicate-count a pred)
                

counts the number of elements satisfying the predicate function pred in an array.

(λ [(Ref (Array a)), Int] (Array a))

                    (prefix-array xs end-index)
                

gets a prefix array to end-index.

(λ [(Ref (Array a))] String)

                    (prn x)
                

(λ [(Array a), a] (Array a))

adds an element value to the end of an array a.

(λ [(Ref (Array a)), a] ())

adds an element value to the end of an array a in-place.

(λ [a, a, a] (Array a))

                    (range start end step)
                

creates an array from start to end with step between them (the elements must support <, <=, >=, and to-int).

(λ [(Array t)] (Ptr t))

returns an array a as a raw pointer—useful for interacting with C.

(λ [(Ref (λ [a, &b] a)), a, (Ref (Array b))] a)

                    (reduce f x xs)
                

will reduce an array xs into a single value using a function f that takes the reduction thus far and the next value. The initial reduction value is x.

As an example, consider this definition of sum based on reduce:

(defn sum [x]
  (reduce + 0 x))

It will sum the previous sum with each new value, starting at 0.

(λ [&a, (Array a)] (Array a))

                    (remove el arr)
                

removes all occurrences of the element el in the array arr, in place.

(λ [Int, (Array a)] (Array a))

                    (remove-nth i arr)
                

removes element at index idx from the array arr.

(λ [Int, (Ref (λ [] a))] (Array a))

                    (repeat n f)
                

repeats the function f n times and stores the results in an array.

(λ [Int, (λ [Int] a)] (Array a))

                    (repeat-indexed n f)
                

repeats function f ntimes and stores the results in an array.

This is similar to repeat, but the function f will be supplied with the index of the element.

(λ [Int, &a] (Array a))

                    (replicate n e)
                

repeats element e n times and stores the results in an array.

(λ [(Array a)] (Array a))

                    (reverse a)
                

reverses an array.

(λ [(Array a)] (Array a))

                    (sort arr)
                

Perform an in-place heapsort of a given owned array.

(λ [(Ref (Array a))] ())

                    (sort! arr)
                

Perform an in-place heapsort of a given array.

(λ [(Array a), (Ref (λ [&a, &a] Bool))] (Array a))

                    (sort-by arr f)
                

Perform an in-place heapsort of a given owned array by a comparison function.

(λ [(Ref (Array a)), (Ref (λ [&a, &a] Bool))] ())

                    (sort-by! arr f)
                

Perform an in-place heapsort of a given array by a comparison function.

(λ [(Ref (Array a))] (Array a))

                    (sorted arr)
                

Perform a heapsort in a new copy of given array.

(λ [(Ref (Array a)), (Ref (λ [&a, &a] Bool))] (Array a))

                    (sorted-by arr f)
                

Perform a heapsort in a new copy of given array by a comparison function.

(λ [(Ref (Array a))] String)

converts an array to a string.

(λ [(Ref (Array a)), Int, Int] (Array a))

                    (subarray xs start-index end-index)
                

gets a subarray from start-index to end-index.

(λ [(Ref (Array a)), Int] (Array a))

                    (suffix-array xs start-index)
                

gets a suffix array from start-index.

(λ [(Ref (Array a))] a)

                    (sum xs)
                

sums an array (elements must support + and zero).

(λ [(Ref (Array (Array a)))] Int)

                    (sum-length xs)
                

returns the sum of lengths from a nested array xs.

(λ [(Array a), Int, Int] (Array a))

                    (swap a i j)
                

swaps the indices i and j of an array a.

(λ [(Ref (Array a)), Int, Int] ())

                    (swap! a i j)
                

swaps the indices i and j of an array a in place.

(λ [(Ref (Array a))] a)

                    (unsafe-first a)
                

takes the first element of an array.

Generates a runtime error if the array is empty.

(λ [(Ref (Array a))] a)

                    (unsafe-last a)
                

takes the last element of an array.

Generates a runtime error if the array is empty.

(λ [] (Array a))

                    (zero)
                

returns the empty array.

(λ [(Ref (λ [&a, &b] c)), (Ref (Array a)), (Ref (Array b))] (Array c))

                    (zip f a b)
                

maps over two arrays using a function f that takes two arguments. It will produces a new array with the length of the shorter input.

The trailing elements of the longer array will be discarded.