Rows

This page is under active development. It may contain bugs or incomplete descriptions.

TODO: Update with function and type signatures.

This module defines operations on rows, which are data-jetted arrays. Since PLAN is untyped, these are also used as the building blocks for tuples, records, and datatypes.

They are defined with []:

arr=[10 64 42]

arr
[10 64 42]

null

(null xs)
> xs : Row a
> Bool

Checks if a row is empty.

null returns TRUE if the given row is empty, and FALSE otherwise.

null []         == 1
null [1 2 3]    == 0
null [0]        == 0

arity

(arity x)
> x : a
> Nat

Returns the arity of a function or row.

arity returns the number of arguments a function takes, or the number of elements in a row plus one.

arity add        == 2
arity [1 2 3]    == 4
arity []         == 1

len

(len xs)
> xs : Row a
> Nat

Returns the length of a row.

len counts the number of elements in a given row.

len [1 2 3]    == 3
len []         == 0
len [9]        == 1

idx

(idx i xs)
> i  : Nat
> xs : Row a
> a

Retrieves an element from a row at a specified index.

idx returns the element at the given index in the row. Indexing starts at 0.

idx 1 [10 20 30]    == 20
idx 0 [5 6 7]       == 5
idx 2 [1]           == 0 (out of bounds)

last

(last xs)
> xs : Row a
> a

Retrieves an element from the end of a row.

last [10 20 30]    == 30
last [5 6 7]       == 7
last [] 2          == 0

get

(get xs i)
> xs : Row a
> i  : Nat
> a

Retrieves an element from a row at a specified index.

get is an alias for idx. It returns the element at the given index in the row.

get [10 20 30] 1    == 20
get [5 6 7] 0       == 5
get [1] 2           == 0 (out of bounds)

mut

(mut i v xs)
> i  : Nat
> v  : a
> xs : Row a
> Row a

Modifies an element in a row at a specified index.

mut returns a new row with the element at the given index replaced by the provided value.

mut 1 99 [10 20 30]    == [10 99 30]
mut 0 5 [1 2 3]        == [5 2 3]
mut 3 4 [1 2]          == [1 2 0 4]

put

(put xs i v)
> xs : Row a
> i  : Nat
> v  : a
> Row a

Modifies an element in a row at a specified index.

put is an alias for mut. It returns a new row with the element at the given index replaced by the provided value.

put [10 20 30] 1 99    == [10 99 30]
put [1 2 3] 0 5        == [5 2 3]
put [1 2] 3 4          == [1 2 0 4]

switch

(switch i d xs)
> i  : Nat
> d  : b
> xs : Row a
> a

Selects a value from a row based on an index, with a fallback value.

switch returns the element at the given index if it exists, otherwise it returns the fallback value.

switch 1 0 [10 20 30]    == 20
switch 3 0 [10 20 30]    == 0 (fallback)
switch 0 99 []           == 99 (fallback)

c0, c1, c2, c3, c4, c5, c6, c7, c8, c9

Creates a row constructor of the specified arity.

These functions create row constructors of arity 0 to 9 respectively.

c3 1 2 3      == [3 2 1]
c0            == []
c2 b#a b#b    == [b#b b#a]

v0, v1, v2, v3, v4, v5, v6, v7, v8, v9

Creates a row of the specified arity.

These functions create rows of arity 0 to 9 respectively, with the arguments in reverse order.

v3 1 2 3      == [1 2 3]
v0            == []
v2 b#a b#b    == [b#a b#b]

isRow

(isRow x)
> x : a
> Bool

Checks if a value is a row.

isRow returns TRUE if the given value is a row, and FALSE otherwise.

isRow [1 2 3]    == 1
isRow []         == 1
isRow 3          == 0

foldr

(foldr f xs)
> f  : (a > b)
> xs : Row a
> b

Folds a row from right to left.

foldr applies a binary function to a starting value (from the right) and all elements of the row, going from right to left.

foldr sub 0 [1 2 3]    == 1
foldr v2 [] [1 2 3]    == [1 [2 [3 []]]]
foldr add 0 []         == 0

foldl

(foldl f xs)
> f  : (a > b)
> xs : Row a
> b

Folds a row from left to right.

foldl applies a binary function to a starting value (from the left) and all elements of the row, going from left to right.

foldl sub 0 [1 2 3]    == 0
foldl v2 [] [1 2 3]    == [[[[] 1] 2] 3]
foldl add 0 [1]        == 1

foldr1

(foldr1 f xs)
> f  : (a > b)
> xs : Row a
> b

Folds a non-empty row from right to left using the last element as the initial accumulator.

foldr1 sub [1 2 3 10]        == 0
foldr1 strWeld [%a %b %c]    == %abc
foldr1 max [1 5 3 2]         == 5

unfoldr

(unfoldr f s)
> f : (a > b)
> s : a
> a

Builds a row from a seed value using a function that returns either a value and a new seed, or nothing.

unfoldr n&(if (gth n 0) (SOME [n dec-n]) NONE) 5    == [5 4 3 2 1]
unfoldr n&(if (lth n 3) (SOME [n inc-n]) NONE) 0    == [0 1 2]
unfoldr _&NONE 0                                    == []

strictRow

(strictRow x)
> x : a
> Row a

Forces evaluation of all elements in a row.

strictRow [1 2 3]                  == [1 2 3] ; ensures all elements are evaluated
strictRow (map (mul 2) [1 2 3])    == [2 4 6] ; forces computation
strictRow []                       == []

weld

(weld xs ys)
> xs : Row a
> ys : Row a
> Row a

Concatenates two rows.

weld combines two rows into a single row, with the elements of the first row followed by the elements of the second row.

weld [1 2] [3 4]    == [1 2 3 4]
weld [] [5 6]       == [5 6]
weld [1 2] []       == [1 2]

gen

(gen l f)
> l : Nat
> f : (Nat > a)
> Row a

Generates a row based on a function and a length.

gen creates a row of the specified length, where each element is the result of applying the given function to its index.

gen 3 (add 2)    == [2 3 4]
gen 4 id         == [0 1 2 3]
gen 0 | mul 2    == []

fst

(fst xs)
> xs : Row a
> a

Returns the first element of a row.

fst retrieves the leftmost element of a given row.

fst [1 2 3]    == 1
fst [9]        == 9
fst []         == 0

snd

(snd xs)
> xs : Row a
> a

Returns the second element of a row.

snd retrieves the second element of a given row. If the row has fewer than two elements, it returns 0.

snd [1 2 3]    == 2
snd [9]        == 0
snd []         == 0

thr

(thr xs)
> xs : Row a
> a

Returns the third element of a row.

thr retrieves the third element of a given row. If the row has fewer than three elements, it returns 0.

thr [1 2 3 4]    == 3
thr [1 2]        == 0
thr []           == 0

map

(map f xs)
> f  : (a > b)
> xs : Row a
> Row b

Applies a function to each element of a row.

map creates a new row by applying the given function to each element of the input row.

map (mul 2) [1 2 3]            == [2 4 6]
map fst [[1 2] [3 4] [5 6]]    == [1 3 5]
map (add 1) []                 == []

foreach

(foreach xs f)
> xs : Row a
> f  : (a > b)
> Row b

Alias for map with arguments reversed.

foreach is an alias for map. It applies a function to each element of a row.

foreach [1 2 3] (mul 2)            == [2 4 6]
foreach [[1 2] [3 4] [5 6]] fst    == [1 3 5]
foreach [] (add 1)                 == []

rev

(rev xs)
> xs : Row a
> Row a

Reverses a row.

rev creates a new row with the elements of the input row in reverse order.

rev [1 2 3]    == [3 2 1]
rev [9]        == [9]
rev []         == []

curry

(curry f x y)
> f : (Row a > b)
> x : a
> y : a
> a

Converts a function that takes a row to a curried function.

curry takes a function that expects a row as its argument and returns a function that takes two arguments separately.

See the function definition in sire/sire_05_row.sire.

uncurry

(uncurry f xs)
> f  : (a > a)
> xs : Row a
> f (Row a)

Converts a curried function to a function that takes a row.

uncurry takes a function that expects two separate arguments and returns a function that takes a row of two elements.

uncurry add [1 2]    == 3
uncurry sub [5 3]    == 2
uncurry v2 [1 2]     == [1 2]

rowCons

(rowCons e xs)
> e  : a
> xs : Row a
> Row a

Prepends an element to a row.

rowCons creates a new row with the given element as the first element, followed by all elements of the input row.

rowCons 1 [2 3]    == [1 2 3]
rowCons b#a []     == [b#a]
rowCons 0 [1]      == [0 1]

rowSnoc

(rowSnoc xs e)
> xs : Row a
> e  : a
> Row a

Appends an element to a row.

rowSnoc creates a new row with all elements of the input row, followed by the given element as the last element.

rowSnoc [1 2] 3    == [1 2 3]
rowSnoc [] b#a     == [b#a]
rowSnoc [0] 1      == [0 1]

rowApply

(rowApply f xs)
> f  : (a > b)
> xs : Row a
> b

Applies a function to a row of arguments.

rowApply takes a function and a row of arguments, and applies the function to those arguments.

rowApply add [2 3]    == 5
rowApply gte [3 4]    == 0
rowApply lte [3 4]    == 1

rowRepel

(rowRepel f xs)
> f  : (a > b)
> xs : Row a
> b

Applies a function to a row of arguments in reverse order.

rowRepel takes a function and a row of arguments, and applies the function to those arguments in reverse order.

rowRepel add [2 3]    == 5
rowRepel gte [3 4]    == 1
rowRepel lte [3 4]    == 0

slash

(slash xs s e)
> xs : Row a
> s  : Nat
> e  : Nat
> a

Extracts a slice from a row, from index s to index e, padding with zeros if necessary.

slash [1 2 3 4 5] 1 3    == [2 3]
slash [1 2 3] 0 5        == [1 2 3 0 0]
slash [1 2 3] 2 2        == []

slice

(slice xs s e)
> xs : Row a
> s : Nat
> e : Nat
> a

Similar to slash, but doesn't pad with zeros. It returns a slice from index s up to (but not including) index e.

slice [1 2 3 4 5] 1 3    == [2 3]
slice [1 2 3] 0 5        == [1 2 3]
slice [1 2 3] 2 2        == []

chunks

(chunks n xs)
> n  : Nat
> xs : Row a
> Row a

Splits a row into chunks of a specified size.

chunks 2 [1 2 3 4 5]    == [[1 2] [3 4] [5]]
chunks 3 [1 2 3 4]      == [[1 2 3] [4]]
chunks 5 [1 2 3]        == [[1 2 3]]

rep

(rep x n)
> x : a
> n : Nat
> Row a

Creates a row by repeating a value a specified number of times.

rep 3 2         == [3 3]
rep b#aaab 3    == [b#aaab b#aaab b#aaab]
rep [] 2        == [[] []]

rowIndexed

(rowIndexed xs)
> xs : Row a
> Row (Nat, a)

Creates a row of pairs, where each pair contains the index and the corresponding element from the input row.

rowIndexed [10 20 30]       == [[0 10] [1 20] [2 30]]
rowIndexed [b#aba b#bab]    == [[0 b#aba] [1 b#bab]]
rowIndexed []               == []

findIdx

(findIdx f xs d k)
> f  : (a > Bool)
> xs : Row a
> d  : b
> k  : (a > b)
> a

Finds the index of the first element in a row that satisfies a predicate function.

findIdx (lte 5) [1 3 5 7 9] 0 id              == 2
findIdx (lte 10) [1 3 5 7 9] 0 id             == 0
findIdx even [1 3 5 7] {not found} showNat    == {not found}

elemIdx

(elemIdx e xs d k)
> e  : a
> xs : Row a
> d  : a
> k  : a
> a

Finds the index of the first occurrence of a specific element in a row.

elemIdx 5 [1 3 5 7 5] b#{not found} id        == 2
elemIdx b#a [b#b b#a b#c] b#{not found} id    == 1
elemIdx 4 [1 2 3] b#{not found} id            == b#{not found}

has

(has e xs)
> e  : a
> xs : Row a
> Bool

Checks if a row contains a specific element.

has 3 [1 2 3 4 5]      == 1
has b#a [b#b b#c]      == 0
has [] [[1] [2] []]    == 1

rowAnd

(rowAnd xs)
> xs : Row Bool
> Bool

Performs a logical AND operation on all elements of a row.

rowAnd [TRUE TRUE FALSE]    == 0
rowAnd [TRUE TRUE TRUE]     == 1
rowAnd []                   == 1

rowOr

(rowOr xs)
> xs : Row Bool
> Bool

Performs a logical OR operation on all elements of a row.

rowOr [FALSE FALSE TRUE]     == 1
rowOr [FALSE FALSE FALSE]    == 0
rowOr []                     == 0

sum

(sum xs)
> xs : Row Nat
> Nat

Calculates the sum of all elements in a row.

sum [1 2 3 4 5]          == 15
sum [10 (sub 10 3) 3]    == 20
sum []                   == 0

sumOf

(sumOf f xs)
> f  : (a > Nat)
> xs : Row a
> Nat

Applies a function to each element of a row and then calculates the sum of the results.

sumOf (mul 2) [1 2 3 4]    == 20
sumOf (pow 2) [1 2 3]      == 14
sumOf id []                == 0

all

(all f xs)
> f  : (a > Bool)
> xs : Row a
> Bool

Checks if all elements in a row satisfy a given predicate.

all even [2 4 6 8]     == 1
all (lte 0) [1 2 3]    == 1
all id []              == 1

any

(any f xs)
> f  : (a > Bool)
> xs : Row a
> Bool

Checks if any element in a row satisfies a given predicate.

any odd [2 4 5 8]        == 1
any (gte 0) [1 2 3 4]    == 0
any id []                == 0

zip

(zip xs ys)
> xs : Row a
> ys : Row b
> Row (a, b)

Combines two rows into a row of pairs.

zip [1 2 3] [b#a b#b b#c]    == [[1 b#a] [2 b#b] [3 b#c]]
zip [1 2] [b#a b#b b#c]      == [[1 b#a] [2 b#b]]
zip [] [1 2 3]               == []

zipWith

(zipWith f xs y)
> f : (a > b > c)
> xs : Row a
> y : Row b
> Row c

Combines two rows using a given function.

zipWith add [1 2 3] [4 5 6]                == [5 7 9]
zipWith mul [1 2 3] [1 2 3]                == [1 4 9]
zipWith zip [[1 2] [1 2]] [[3 4] [3 4]]    == [[[1 3] [2 4]] [[1 3] [2 4]]]

cat

(cat x)
> xs : Row (Row a)
> Row a

Concatenates a row of rows into a single row.

cat [[1 2 3 4] [3 4] [5]]    == [1 2 3 4 5]
cat [[] [1 2] [3]]           == [1 2 3]
cat []                       == []

catMap

(catMap f x)
> f  : (a > Row b)
> xs : Row a
> Row b

Applies a function to each element of a row and concatenates the results.

catMap (rep 2) [1 2 3]     == [2 2 2 2 2 2]
catMap id [[1 2] [3 4]]    == [1 2 3 4]

take

(take n x)
> n  : Nat
> xs : Row a
> Row a

Returns the first n elements of a row.

take 3 [1 2 3 4 5]    == [1 2 3]
take 2 [b#a b#b]      == [b#a b#b]
take 5 [1 2 3]        == [1 2 3]

drop

(drop n xs)
> n  : Nat
> xs : Row a
> Row a

Removes the first n elements from a row.

drop 2 [1 2 3 4 5]          == [3 4 5]
drop 3 [b#a b#b b#c b#d]    == [b#d]
drop 5 [1 2 3]              == []

rev

(rev xs)
> xs : Row a
> Row a

Reverses the order of elements in a row.

rev [1 2 3 4 5]          == [5 4 3 2 1]
rev [b#a b#b b#c b#d]    == [b#d b#c b#b b#a]
rev []                   == []

span

(span f xs)
> f  : (a > Bool)
> xs : Row a
> Row (Row a)

Splits a row into two parts: the longest prefix that satisfies a predicate and the rest.

span (gte 3) [1 2 3 4 1 2 3 4]    == [[1 2 3] [4 1 2 3 4]]
span even [2 4 6 7 8 9]           == [[2 4 6] [7 8 9]]
span FALSE [1 2 3]                == [[] [1 2 3]]

splitAt

(splitAt i xs)
> i  : Nat
> xs : Row a
> Row (Row a)

Splits a row at a given index.

splitAt 3 [1 2 3 4 5]    == [[1 2 3] [4 5]]
splitAt 0 [1 2 3]        == [[] [1 2 3]]
splitAt 5 [1 2 3]        == [[1 2 3] []]

intersperse

(intersperse e xs)
> e  : a
> xs : Row a
> Row a

Intersperses an element between every element of a row.

intersperse 0 [1 2 3]    == [1 0 2 0 3]
intersperse b#a [b#b]    == [b#b]
intersperse 0 []         == []

insert

(insert i e xs)
> i  : Nat
> e  : a
> xs : Row a
> Row a

Inserts an element at a specified index in a row.

insert 1 b#x [b#a b#b b#c]    == [b#a b#x b#b b#c]
insert 0 1 [1 2 3]            == [1 1 2 3]
insert 3 4 [1 2 3]            == [1 2 3 4]

Sorting and Filtering

sort

(sort xs)
> xs : Row a
> Row a

Sorts a row in ascending order.

sort [3 1 4 1 5]      == [1 1 3 4 5]
sort [b#c b#a b#b]    == [b#a b#b b#c]
sort []               == []

sortBy

(sortBy f xs)
> f  : (a > Nat)
> xs : Row a
> Row a

Sorts a row using a custom comparison function.

sortBy (flip cmp) [1 3 2]      == [3 2 1]
sortBy (cmp) [[1 2] [] [1]]    == [[] [1] [1 2]]

sortOn

(sortOn f xs)
> f  : (a > b)
> xs : Row a
> Row b

Sorts a row by applying a function to each element before comparing.

sortOn (even) [1 3 2]             == [3 1 2]
sortOn len [[1 2] [3] [4 5 6]]    == [[3] [1 2] [4 5 6]]

sortUniq

(sortUniq xs)
> xs : Row a
> Row a

Sorts a row and removes duplicate elements.

sortUniq [3 1 4 1 5 3]    == [1 3 4 5]
sortUniq [b#a b#b b#a]    == [b#a b#b]
sortUniq []               == []

filter

(filter f xs)
> f  : (a > Bool)
> xs : Row a
> Row a

Keeps only the elements of a row that satisfy a predicate.

filter even [1 2 3 4 5]               == [2 4]
filter (neq b#a) [b#a b#b b#a b#c]    == [b#b b#c]
filter (const TRUE) [1 2 3]           == [1 2 3]

delete

(delete e xs)
> e  : a
> xs : Row a
> Row a

Removes all occurrences of a value from a row.

delete 3 [1 2 3 4 3 5]      == [1 2 4 5]
delete b#a [b#a b#b b#a]    == [b#b]
delete 42 [1 2 3]           == [1 2 3]

findIdxMany

(findIdxMany f xs)
> f  : (a > Bool)
> xs : Row a
> List a

Finds all indices where a predicate is satisfied.

findIdxMany even [1 2 3 4 5 6]         == [1 [3 [5 0]]]
findIdxMany (eql b#a) [b#a b#b b#a]    == [0 [2 0]]
findIdxMany (const FALSE) [1 2 3]      == 0

elemIdxMany

(elemIdxMany e xs)
> e  : a
> xs : Row a
> Either (List a) Nat

Finds all indices where a specific element occurs.

elemIdxMany 3 [1 2 3 4 3 5]      == [2 [4 0]]
elemIdxMany b#a [b#a b#b b#a]    == [0 [2 0]]
elemIdxMany 42 [1 2 3]           == 0