p-array

The array module provides utility functions for working with arrays.

use p-array as a

Type Check

isarray[val]

Returns true if val is an array.

use p-array as a
a.isarray[list[1; 2; 3]]  -- true
a.isarray[42]              -- false

Creation

from[val]

Creates an array from an iterable or array-like value.

of[...args]

Creates an array from the given arguments.

range[start; end; step]

Creates an array of numbers from start to end (exclusive). step defaults to 1.

use p-array as a
a.from[///hello///]          -- ["h", "e", "l", "l", "o"]
a.of[1; 2; 3]               -- [1, 2, 3]
a.range[0; 5]               -- [0, 1, 2, 3, 4]
a.range[0; 10; 2]           -- [0, 2, 4, 6, 8]

Query

len[arr]

Returns the number of elements.

first[arr]

Returns the first element.

last[arr]

Returns the last element.

use p-array as a
const xs be list[10; 20; 30]
a.len[xs]    -- 3
a.first[xs]  -- 10
a.last[xs]   -- 30

Transform

flatten[arr; depth]

Flattens nested arrays to the specified depth (default: all levels).

unique[arr]

Returns a new array with duplicate values removed.

compact[arr]

Returns a new array with all falsy values removed.

sortasc[arr]

Returns a new array sorted in ascending numeric order.

sortdesc[arr]

Returns a new array sorted in descending numeric order.

use p-array as a
a.flatten[[[1; 2]; [3; [4; 5]]]]   -- [1, 2, 3, 4, 5]
a.unique[list[1; 2; 2; 3; 1]]      -- [1, 2, 3]
a.compact[list[0; 1; null; 2; //////; 3]]  -- [1, 2, 3]
a.sortasc[list[3; 1; 2]]           -- [1, 2, 3]
a.sortdesc[list[3; 1; 2]]          -- [3, 2, 1]

Grouping

chunk[arr; size]

Splits the array into chunks of the given size.

zip[...arrs]

Zips multiple arrays into an array of tuples.

unzip[arr]

Unzips an array of tuples into separate arrays.

groupby[arr; fn]

Groups elements by the result of calling fn on each element.

use p-array as a
a.chunk[list[1; 2; 3; 4; 5]; 2]  -- [[1, 2], [3, 4], [5]]
a.zip[list[1; 2]; list[///a///; ///b///]]  -- [[1, "a"], [2, "b"]]

a.groupby[list[1; 2; 3; 4; 5]; fn x to
  if x mod 2 eq 0 then ///even/// else ///odd///
]
-- { odd: [1, 3, 5], even: [2, 4] }

Aggregation

sum[arr]

Returns the sum of all elements.

product[arr]

Returns the product of all elements.

min[arr]

Returns the smallest element.

max[arr]

Returns the largest element.

count[arr; fn]

Returns the number of elements for which fn returns true.

use p-array as a
const xs be list[1; 2; 3; 4; 5]
a.sum[xs]       -- 15
a.product[xs]   -- 120
a.min[xs]       -- 1
a.max[xs]       -- 5
a.count[xs; fn x to x gt 2]  -- 3