extra-array

Functions

• accumulate()
• adjacentCombine()
• adjacentCombine$()
• allOf()
• anyOf()
• append()
• append$()
• at()
• back()
• cartesianProduct()
• chunk()
• clear$()
• clone()
• compare()
• concat()
• concat$()
• copy()
• copy$()
• copyWithin()
• copyWithin$()
• count()
• countAs()
• countEach()
• cut()
• cutAt()
• cutAtRight()
• cutRight()
• cycle()
• deepClone()
• difference()
• drop()
• dropRight()
• dropWhile()
• dropWhileRight()
• endsWith()
• entries()
• every()
• exclusiveScan()
• exclusiveScan$()
• fill()
• fill$()
• filter()
• filter$()
• filterAt()
• find()
• findAll()
• findIndex()
• findLastIndex()
• findRight()
• first()
• flat()
• flatMap()
• forEach()
• from()
• from$()
• fromApplication()
• fromApply()
• fromCall()
• fromInvocation()
• fromIterable()
• fromIterable$()
• fromRange()
• front()
• get()
• getAll()
• getPath()
• group()
• groupToMap()
• hasInfix()
• hasPath()
• hasPermutation()
• hasPrefix()
• hasSubsequence()
• hasSuffix()
• hasUnsortedValue()
• hasValue()
• head()
• ientries()
• iinfixes()
• ikeys()
• includes()
• inclusiveScan()
• inclusiveScan$()
• index()
• indexOf()
• indexRange()
• infix()
• infixes()
• init()
• interleave()
• intermix()
• interpolate()
• intersection()
• intersperse()
• ipermutations()
• iprefixes()
• is()
• isDisjoint()
• isEmpty()
• isEqual()
• isSorted()
• isubsequences()
• isuffixes()
• isUnique()
• ivalues()
• join()
• keys()
• last()
• lastIndexOf()
• left()
• length()
• map()
• map$()
• max()
• maxEntry()
• maximum()
• maximumEntries()
• maximumEntry()
• maximums()
• middle()
• min()
• minEntry()
• minimum()
• minimumEntries()
• minimumEntry()
• minimums()
• moveWithin()
• moveWithin$()
• partialSort()
• partialSort$()
• partition()
• partitionAs()
• partitionEach()
• permutation()
• permutation$()
• permutations()
• permute$()
• pop()
• pop$()
• popBack()
• popBack$()
• popFront()
• popFront$()
• prefix()
• prefixes()
• prepend()
• prepend$()
• push()
• push$()
• pushBack()
• pushBack$()
• pushFront()
• pushFront$()
• randomInfix()
• randomPermutation()
• randomPermutation$()
• randomPrefix()
• randomSubsequence()
• randomSuffix()
• randomValue()
• range()
• rangedPartialSort()
• rangedPartialSort$()
• rangedSort()
• rangedSort$()
• rangeEntries()
• reduce()
• reduceRight()
• reject()
• reject$()
• rejectAt()
• remove()
• remove$()
• removePath$()
• repeat()
• resize$()
• reverse()
• reverse$()
• right()
• rotate()
• rotate$()
• scanUntil()
• scanUntilRight()
• scanWhile()
• scanWhileRight()
• search()
• searchAdjacentDuplicate()
• searchAdjacentDuplicateValue()
• searchAll()
• searchInfix()
• searchInfixAll()
• searchInfixRight()
• searchMaximumValue()
• searchMaximumValues()
• searchMinimumValue()
• searchMinimumValues()
• searchMismatch()
• searchMismatchedValue()
• searchRight()
• searchSubsequence()
• searchUnsortedValue()
• searchValue()
• searchValueAll()
• searchValueRight()
• set()
• set$()
• setPath$()
• shallowClone()
• shift()
• shift$()
• shuffle$()
• size()
• slice()
• slice$()
• some()
• sort()
• sort$()
• splice()
• splice$()
• split()
• splitAt()
• startsWith()
• subsequence()
• subsequences()
• suffix()
• suffixes()
• swap()
• swap$()
• swapRanges()
• swapRanges$()
• symmetricDifference()
• tail()
• take()
• takeRight()
• takeWhile()
• takeWhileRight()
• toReversed()
• toSorted()
• toSpliced()
• union()
• union$()
• unique()
• unshift()
• unshift$()
• value()
• values()
• with()
• zip()

Type Aliases

• CombineFunction
• CompareFunction
• EndFunction
• Entries
• IEntries
• ILists
• Lists
• MapFunction
• ProcessFunction
• ReadFunction
• ReduceFunction
• SwapFunction
• TestFunction

function accumulate

accumulate: <T, U = T>(
    x: T[],
    fr: ReduceFunction<T, T | U>,
    acc?: T | U
) => (T | U)[];

• Perform inclusive prefix scan from left to right.

  Parameter x

  an array

  Parameter fr

  reduce function (acc, v, i, x)

  Parameter acc

  initial value

  Returns

  [fr(acc, v₀), fr(fr(acc, v₀), v₁)...]

function adjacentCombine

adjacentCombine: <T>(x: T[], fc: CombineFunction<T>, acc: T) => T[];

• Combine adjacent values of an array.

  Parameter x

  an array

  Parameter fc

  combine function (u, v)

  Parameter acc

  initial value

  Returns

  [fc(acc, v₀), fc(v₀, v₁)...] | vᵢ ∈ x

function adjacentCombine$

adjacentCombine$: <T>(x: T[], fc: CombineFunction<T>, acc: T) => T[];

• Combine adjacent values of an array!

  Parameter x

  an array (updated!)

  Parameter fc

  combine function (u, v)

  Parameter acc

  initial value

  Returns

  x = [fc(acc, v₀), fc(v₀, v₁)...] | vᵢ ∈ x

function allOf

allOf: <T>(x: T[], ft?: TestFunction<T> | null) => boolean;

• Examine if all values satisfy a test.

  Parameter x

  an array

  Parameter ft

  test function (v, i, x)

  Returns

  true if ft(vᵢ) = true for all vᵢ ∈ x

function anyOf

anyOf: <T>(x: T[], ft?: TestFunction<T> | null) => boolean;

• Examine if any value satisfies a test.

  Parameter x

  an array

  Parameter ft

  test function (v, i, x)

  Returns

  true if ft(vᵢ) = true for some vᵢ ∈ x

function append

append: <T>(x: T[], ...vs: T[]) => T[];

• Add value to the end.

  Parameter x

  an array

  Parameter vs

  values to add

  Returns

  x ⧺ vs

function append$

append$: <T>(x: T[], ...vs: T[]) => T[];

• Add values to the end!

  Parameter x

  an array (updated!)

  Parameter vs

  values to add

  Returns

  x = x ⧺ vs

function at

at: <T>(x: T[], i: number) => T;

• Get value at index.

  Parameter x

  an array

  Parameter i

  index

  Returns

  x[i]

function back

back: <T>(x: T[], vd?: T) => T | undefined;

• Get last value.

  Parameter x

  an array

  Parameter vd

  default value

  Returns

  x[|x|-1] || vd

function cartesianProduct

cartesianProduct: <T, U = T>(
    xs: T[][],
    fm?: MapFunction<T[], T[] | U> | null
) => (T[] | U)[];

• Obtain cartesian product of arrays.

  Parameter xs

  arrays

  Parameter fm

  map function (vs, i)

  Returns

  x₀ × x₁ × ... = {[v₀, v₁, ...] | v₀ ∈ x₀, v₁ ∈ x₁, ...] }

function chunk

chunk: <T>(x: T[], n?: number, s?: number) => T[][];

• Break array into chunks of given size.

  Parameter x

  an array

  Parameter n

  chunk size [1]

  Parameter s

  chunk step [n]

  Returns

  x[0..n] ⧺ x[s..s+n] ⧺ x[2s..2s+n] ⧺ ...

function clear$

clear$: <T>(x: T[]) => T[];

• Remove all elements from an array!

  Parameter x

  an array (updated!)

  Returns

  cleared x

function clone

clone: <T>(x: T[]) => T[];

• Shallow clone an array.

  Parameter x

  an array

  Returns

  shallow clone of x

function compare

compare: <T, U = T>(
    x: T[],
    y: T[],
    fc?: CompareFunction<T | U> | null,
    fm?: MapFunction<T, T | U> | null
) => number;

• Compare two arrays (lexicographically).

  Parameter x

  an array

  Parameter y

  another array

  Parameter fc

  compare function (a, b)

  Parameter fm

  map function (v, i, x)

  Returns

  x<y: -ve, x=y: 0, x>y: +ve

function concat

concat: <T>(...xs: T[][]) => T[];

• Append values from arrays.

  Parameter xs

  arrays

  Returns

  x₀ ⧺ x₁ ⧺ ... | [x₀, x₁, ...] = xs

function concat$

concat$: <T>(x: T[], ...ys: Iterable<T>[]) => T[];

• Append values from arrays!

  Parameter x

  an array (updated!)

  Parameter ys

  arrays to append

  Returns

  x = x ⧺ y₀ ⧺ y₁ ⧺ ...] | [y₀, y₁, ...] = ys

function copy

copy: <T>(x: T[], y: T[], j?: number, i?: number, I?: number) => T[];

• Copy part of array to another.

  Parameter x

  target array

  Parameter y

  source array

  Parameter j

  write index [0]

  Parameter i

  read begin index [0]

  Parameter I

  read end index [|x|]

  Returns

  x[0..j] ⧺ y[i..I] ⧺ x[j+I-i..]

function copy$

copy$: <T>(x: T[], y: T[], j?: number, i?: number, I?: number) => T[];

• Copy part of array to another!

  Parameter x

  target array (updated!)

  Parameter y

  source array

  Parameter j

  write index [0]

  Parameter i

  read begin index [0]

  Parameter I

  read end index [|x|]

  Returns

  x = x[0..j] ⧺ y[i..I] ⧺ x[j+I-i..]

function copyWithin

copyWithin: <T>(x: T[], j?: number, i?: number, I?: number) => T[];

• Copy part of array within.

  Parameter x

  an array

  Parameter j

  write index [0]

  Parameter i

  read begin index [0]

  Parameter I

  read end index [|x|]

  Returns

  x[0..j] ⧺ x[i..I] ⧺ x[j+I-i..]

function copyWithin$

copyWithin$: <T>(x: T[], j?: number, i?: number, I?: number) => T[];

• Copy part of array within!

  Parameter x

  an array (updated!)

  Parameter j

  write index [0]

  Parameter i

  read begin index [0]

  Parameter I

  read end index [|x|]

  Returns

  x = x[0..j] ⧺ x[i..I] ⧺ x[j+I-i..]

function count

count: <T>(x: T[], ft: TestFunction<T>) => number;

• Count values which satisfy a test.

  Parameter x

  an array

  Parameter ft

  test function (v, i, x)

  Returns

  Σtᵢ | tᵢ = 1 if ft(vᵢ) else 0; vᵢ ∈ x

function countAs

countAs: <T, U = T>(
    x: T[],
    fm?: MapFunction<T, T | U> | null
) => Map<T | U, number>;

• Count occurrences of each distinct value.

  Parameter x

  an array

  Parameter fm

  map function (v, i, x)

  Returns

  Map {value ⇒ count}

function countEach

countEach: <T, U = T>(
    x: T[],
    fm?: MapFunction<T, T | U> | null
) => Map<T | U, number>;

• Count occurrences of each distinct value.

  Parameter x

  an array

  Parameter fm

  map function (v, i, x)

  Returns

  Map {value ⇒ count}

function cut

cut: <T>(x: T[], ft: TestFunction<T>) => T[][];

• Break array when test passes.

  Parameter x

  an array

  Parameter ft

  test function (v, i, x)

  Returns

  [x[0..j], x[j..k], ...] | ft(x[i]) = true; i = j, k, ...

function cutAt

cutAt: <T>(x: T[], is: number[]) => T[][];

• Break array at given indices.

  Parameter x

  an array

  Parameter is

  split ±indices (left to right)

  Returns

  [x[0..j], x[j..k], ...] | ft(x[i]) = true; i = j, k, ...; i ∈ is

function cutAtRight

cutAtRight: <T>(x: T[], is: number[]) => T[][];

• Break array after given indices.

  Parameter x

  an array

  Parameter is

  split ±indices (left to right)

  Returns

  [x[0..j+1], x[j+1..k], ...] | ft(x[i]) = true; i = j, k, ...; i ∈ is

function cutRight

cutRight: <T>(x: T[], ft: TestFunction<T>) => T[][];

• Break array after test passes.

  Parameter x

  an array

  Parameter ft

  test function (v, i, x)

  Returns

  [x[0..j+1], x[j+1..k], ...] | ft(x[i]) = true; i = j, k, ...

function cycle

cycle: <T>(x: T[], i?: number, n?: number) => T[];

• Obtain values that cycle through array.

  Parameter x

  an array

  Parameter i

  begin ±index [0]

  Parameter n

  number of values [|x|]

function deepClone

deepClone: <T>(x: T[]) => T[];

• Deep clone an array.

  Parameter x

  an array

  Returns

  deep clone of x

function difference

difference: <T, U = T>(
    x: T[],
    y: T[],
    fc?: CompareFunction<T | U> | null,
    fm?: MapFunction<T, T | U> | null
) => T[];

• Obtain values not present in another array.

  Parameter x

  an array

  Parameter y

  another array

  Parameter fc

  compare function (a, b)

  Parameter fm

  map function (v, i, x)

  Returns

  x - y = {v | v ∈ x, v ∉ y}

function drop

drop: <T>(x: T[], n?: number) => T[];

• Discard first n values only.

  Parameter x

  an array

  Parameter n

  number of values [1]

  Returns

  x[n..]

function dropRight

dropRight: <T>(x: T[], n?: number) => T[];

• Discard last n values only.

  Parameter x

  an array

  Parameter n

  number of values [1]

  Returns

  x[0..-n]

function dropWhile

dropWhile: <T>(x: T[], ft: TestFunction<T>) => T[];

• Discard values from left, while a test passes.

  Parameter x

  an array

  Parameter ft

  test function (v, i, x)

  Returns

  x[T..] | ft(x[i]) = true ∀ i ∈ [0, T-1] & ft(x[T]) = false

function dropWhileRight

dropWhileRight: <T>(x: T[], ft: TestFunction<T>) => T[];

• Discard values from right, while a test passes.

  Parameter x

  an array

  Parameter ft

  test function (v, i, x)

  Returns

  x[0..T-1] | ft(x[i]) = true ∀ i ∈ [T, |x|-1] & ft(x[T-1]) = false

function endsWith

endsWith: <T, U = T>(
    x: T[],
    y: T[],
    fc?: CompareFunction<T | U> | null,
    fm?: MapFunction<T, T | U> | null
) => boolean;

• Examine if array ends with a suffix.

  Parameter x

  an array

  Parameter y

  search suffix

  Parameter fc

  compare function (a, b)

  Parameter fm

  map function (v, i, x)

  Returns

  x[|x|-|y|..] = y?

function entries

entries: <T>(x: T[]) => Entries<T>;

• Obtain all index-value pairs.

  Parameter x

  an array

  Returns

  [[0, v₀], [1, v₁], ...] | vᵢ = x[i]

function every

every: <T>(x: T[], ft?: TestFunction<T> | null) => boolean;

• Examine if all values satisfy a test.

  Parameter x

  an array

  Parameter ft

  test function (v, i, x)

  Returns

  true if ft(vᵢ) = true for all vᵢ ∈ x

function exclusiveScan

exclusiveScan: <T, U = T>(
    x: T[],
    fr: ReduceFunction<T, T | U>,
    acc: T | U
) => (T | U)[];

• Perform exclusive prefix scan from left to right.

  Parameter x

  an array

  Parameter fr

  reduce function (acc, v, i, x)

  Parameter acc

  initial value

  Returns

  [acc, fr(acc, v₀), fr(fr(acc, v₀), v₁)...]

function exclusiveScan$

exclusiveScan$: <T>(x: T[], fr: ReduceFunction<T, T>, acc: T) => T[];

• Perform exclusive prefix scan from left to right!

  Parameter x

  an array (updated!)

  Parameter fr

  reduce function (acc, v, i, x)

  Parameter acc

  initial value

  Returns

  x = [acc, fr(acc, v₀), fr(fr(acc, v₀), v₁)...]

function fill

fill: <T>(x: T[], v: T, i?: number, I?: number) => T[];

• Fill with given value.

  Parameter x

  an array

  Parameter v

  value

  Parameter i

  begin index [0]

  Parameter I

  end index [|x|]

  Returns

  x' | x' = x; x'[i..I] = v

function fill$

fill$: <T>(x: T[], v: T, i?: number, I?: number) => T[];

• Fill with given value!

  Parameter x

  an array (updated!)

  Parameter v

  value

  Parameter i

  begin index [0]

  Parameter I

  end index [|x|]

  Returns

  x | x[i..I] = v

function filter

filter: <T>(x: T[], ft: TestFunction<T>) => T[];

• Keep values which pass a test.

  Parameter x

  an array

  Parameter ft

  test function (v, i, x)

  Returns

  [v₀, v₁, ...] | ft(vᵢ) = true; vᵢ ∈ x

function filter$

filter$: <T>(x: T[], ft: TestFunction<T>) => T[];

• Keep values which pass a test!

  Parameter x

  an array (updated!)

  Parameter ft

  test function (v, i, x)

  Returns

  x = [v₀, v₁, ...] | ft(vᵢ) = true; vᵢ ∈ x

function filterAt

filterAt: <T>(x: T[], is: number[]) => T[];

• Keep values at given indices.

  Parameter x

  an array

  Parameter is

  indices

  Returns

  v₀, v₁, ... | vᵢ = x[i]; i ∈ is

function find

find: <T>(x: T[], ft: TestFunction<T>) => T;

• Find first value passing a test.

  Parameter x

  an array

  Parameter ft

  test function (v, i, x)

  Returns

  first v | ft(v) = true; v ∈ x

function findAll

findAll: <T>(x: T[], ft: TestFunction<T>) => T[];

• Keep values which pass a test.

  Parameter x

  an array

  Parameter ft

  test function (v, i, x)

  Returns

  [v₀, v₁, ...] | ft(vᵢ) = true; vᵢ ∈ x

function findIndex

findIndex: <T>(x: T[], ft: TestFunction<T>) => number;

• Find index of first value passing a test.

  Parameter x

  an array

  Parameter ft

  test function (v, i, x)

  Returns

  first index of value, -1 if not found

function findLastIndex

findLastIndex: <T>(x: T[], ft: TestFunction<T>) => number;

• Find index of last value passing a test.

  Parameter x

  an array

  Parameter ft

  test function (v, i, x)

  Returns

  last index of value, -1 if not found

function findRight

findRight: <T>(x: T[], ft: TestFunction<T>) => T;

• Find last value passing a test.

  Parameter x

  an array

  Parameter ft

  test function (v, i, x)

  Returns

  last v | ft(v) = true; v ∈ x

function first

first: <T>(x: T[], vd?: T) => T | undefined;

• Get first value.

  Parameter x

  an array

  Parameter vd

  default value

  Returns

  x[0] || vd

function flat

flat: (
    x: unknown[],
    n?: number,
    fm?: MapFunction<unknown, unknown> | null,
    ft?: TestFunction<unknown> | null
) => unknown[];

• Flatten nested array to given depth.

  Parameter x

  a nested array

  Parameter n

  maximum depth [-1 ⇒ all]

  Parameter fm

  map function (v, i, x)

  Parameter ft

  flatten test function (v, i, x) [is]

  Returns

  flat iterable

function flatMap

flatMap: (
    x: unknown[],
    fm?: MapFunction<unknown, unknown> | null,
    ft?: TestFunction<unknown> | null
) => unknown[];

• Flatten nested array, based on map function.

  Parameter x

  an array

  Parameter fm

  map function (v, i, x)

  Parameter ft

  flatten test function (v, i, x) [is]

  Returns

  flat iterable

function forEach

forEach: <T>(x: T[], fp: ProcessFunction<T>) => void;

• Call a function for each value.

  Parameter x

  an array

  Parameter fp

  process function (v, i, x)

function from

from: <T>(x: Iterable<T>) => T[];

• Convert an iterable to array.

  Parameter x

  an iterable

  Returns

  x as array

function from$

from$: <T>(x: Iterable<T>) => T[];

• Convert an iterable to array!

  Parameter x

  an iterable (updatable if array!)

  Returns

  x as array

function fromApplication

fromApplication: <T>(fm: MapFunction<T, T>, v: T, n: number) => T[];

• Generate array from repeated function application.

  Parameter fm

  map function (v, i)

  Parameter v

  start value

  Parameter n

  number of values

  Returns

  [v, fm(v), fm(fm(v)), ...]

function fromApply

fromApply: <T>(fm: MapFunction<T, T>, v: T, n: number) => T[];

• Generate array from repeated function application.

  Parameter fm

  map function (v, i)

  Parameter v

  start value

  Parameter n

  number of values

  Returns

  [v, fm(v), fm(fm(v)), ...]

function fromCall

fromCall: <T>(fn: () => T, n: number) => T[];

• Generate array from repeated function invocation.

  Parameter fn

  function

  Parameter n

  number of values

  Returns

  [fn(), fn(), ...]

function fromInvocation

fromInvocation: <T>(fn: () => T, n: number) => T[];

• Generate array from repeated function invocation.

  Parameter fn

  function

  Parameter n

  number of values

  Returns

  [fn(), fn(), ...]

function fromIterable

fromIterable: <T>(x: Iterable<T>) => T[];

• Convert an iterable to array.

  Parameter x

  an iterable

  Returns

  x as array

function fromIterable$

fromIterable$: <T>(x: Iterable<T>) => T[];

• Convert an iterable to array!

  Parameter x

  an iterable (updatable if array!)

  Returns

  x as array

function fromRange

fromRange: (v: number, V: number, dv?: number) => number[];

• Generate array from given number range.

  Parameter v

  start number

  Parameter V

  end number, excluding

  Parameter dv

  step size [1]

  Returns

  [v, v+dv, v+2dv, ...]

function front

front: <T>(x: T[], vd?: T) => T | undefined;

• Get first value.

  Parameter x

  an array

  Parameter vd

  default value

  Returns

  x[0] || vd

function get

get: <T>(x: T[], i: number) => T;

• Get value at index.

  Parameter x

  an array

  Parameter i

  index

  Returns

  x[i]

function getAll

getAll: <T>(x: T[], is: number[]) => T[];

• Get values at indices.

  Parameter x

  an array

  Parameter is

  indices

  Returns

  [x[i₀], x[i₁], ...] | [i₀, i₁, ...] = is

function getPath

getPath: (x: unknown[], p: number[]) => unknown;

• Get value at path in a nested array.

  Parameter x

  a nested array

  Parameter p

  path

  Returns

  x[i₀][i₁][...] | [i₀, i₁, ...] = p

function group

group: <T, U = T>(
    x: T[],
    fc?: CompareFunction<T | U> | null,
    fm?: MapFunction<T, T | U> | null
) => T[][];

• Keep similar values together and in order.

  Parameter x

  an array

  Parameter fc

  compare function (a, b)

  Parameter fm

  map function (v, i, x)

  Returns

  [x[0..k], x[k..l], ...] | fc(x[i], x[j]) = 0; i, j = 0..k / k..l / ...

function groupToMap

groupToMap: <T, U = T>(
    x: T[],
    fm?: MapFunction<T, T | U> | null
) => Map<T | U, T[]>;

• Segregate each distinct value.

  Parameter x

  an array

  Parameter fm

  map function (v, i, x)

  Returns

  Map {key ⇒ values}

function hasInfix

hasInfix: <T, U = T>(
    x: T[],
    y: T[],
    fc?: CompareFunction<T | U> | null,
    fm?: MapFunction<T, T | U> | null
) => boolean;

• Examine if array contains an infix.

  Parameter x

  an array

  Parameter y

  search infix

  Parameter fc

  compare function (a, b)

  Parameter fm

  map function (v, i, x)

  Returns

  x[i..I] = y for some i, I?

function hasPath

hasPath: (x: unknown[], p: number[]) => boolean;

• Check if nested array has a path.

  Parameter x

  a nested array

  Parameter p

  path

  Returns

  x[i₀][i₁][...] exists? | [i₀, i₁, ...] = p

function hasPermutation

hasPermutation: <T, U = T>(
    x: T[],
    y: T[],
    fc?: CompareFunction<T | U> | null,
    fm?: MapFunction<T, T | U> | null
) => boolean;

• Examine if array has a permutation.

  Parameter x

  an array

  Parameter y

  search permutation

  Parameter fc

  map function (v, i, x)

  Parameter fm

  compare function (a, b)

  Returns

  x contains a shuffled version of y?

function hasPrefix

hasPrefix: <T, U = T>(
    x: T[],
    y: T[],
    fc?: CompareFunction<T | U> | null,
    fm?: MapFunction<T, T | U> | null
) => boolean;

• Examine if array starts with a prefix.

  Parameter x

  an array

  Parameter y

  search prefix

  Parameter fc

  compare function (a, b)

  Parameter fm

  map function (v, i, x)

  Returns

  x[0..|y|] = y?

function hasSubsequence

hasSubsequence: <T, U = T>(
    x: T[],
    y: T[],
    fc?: CompareFunction<T | U> | null,
    fm?: MapFunction<T, T | U> | null
) => boolean;

• Examine if array has a subsequence.

  Parameter x

  an array

  Parameter y

  search subsequence

  Parameter fc

  compare function (a, b)

  Parameter fm

  map function (v, i, x)

  Returns

  x[i₀] ⧺ x[i₁] ⧺ ... = y, for some i₀, i₁, ...? | i₀ < i₁ < ...

function hasSuffix

hasSuffix: <T, U = T>(
    x: T[],
    y: T[],
    fc?: CompareFunction<T | U> | null,
    fm?: MapFunction<T, T | U> | null
) => boolean;

• Examine if array ends with a suffix.

  Parameter x

  an array

  Parameter y

  search suffix

  Parameter fc

  compare function (a, b)

  Parameter fm

  map function (v, i, x)

  Returns

  x[|x|-|y|..] = y?

function hasUnsortedValue

hasUnsortedValue: <T, U = T>(
    x: T[],
    fc?: CompareFunction<T | U> | null,
    fm?: MapFunction<T, T | U> | null
) => boolean;

• Examine if array has an unsorted value.

  Parameter x

  an array

  Parameter fc

  compare function (a, b)

  Parameter fm

  map function (v, i, x)

  Returns

  x is not sorted?

function hasValue

hasValue: <T, U = T>(
    x: T[],
    v: T,
    fc?: CompareFunction<T | U> | null,
    fm?: MapFunction<T, T | U> | null
) => boolean;

• Examine if array has a value.

  Parameter x

  an array

  Parameter v

  search value

  Parameter fc

  compare function (a, b)

  Parameter fm

  map function (v, i, x)

  Returns

  v ∈ x?

function head

head: <T>(x: T[], vd?: T) => T | undefined;

• Get first value.

  Parameter x

  an array

  Parameter vd

  default value

  Returns

  x[0] || vd

function ientries

ientries: <T>(x: T[]) => IEntries<T>;

• List all index-value pairs.

  Parameter x

  an array

  Returns

  [0, v₀], [1, v₁], ... | vᵢ = x[i]

function iinfixes

iinfixes: <T>(x: T[], n?: number) => IterableIterator<T[]>;

• List all possible infixes.

  Parameter x

  an array

  Parameter n

  number of values [-1 ⇒ any]

  Returns

  [], x[0..1], x[0..2], ..., x[1..2], ... if n<0; only of length n otherwise

function ikeys

ikeys: <T>(x: T[]) => IterableIterator<number>;

• List all indices.

  Parameter x

  an array

  Returns

  0, 1, ..., |x|-1

function includes

includes: <T>(x: T[], v: T, i?: number) => boolean;

• Check if array has a value.

  Parameter x

  an array

  Parameter v

  search value

  Parameter i

  begin index [0]

  Returns

  v ∈ x[i..]?

function inclusiveScan

inclusiveScan: <T, U = T>(
    x: T[],
    fr: ReduceFunction<T, T | U>,
    acc?: T | U
) => (T | U)[];

• Perform inclusive prefix scan from left to right.

  Parameter x

  an array

  Parameter fr

  reduce function (acc, v, i, x)

  Parameter acc

  initial value

  Returns

  [fr(acc, v₀), fr(fr(acc, v₀), v₁)...]

function inclusiveScan$

inclusiveScan$: <T>(x: T[], fr: ReduceFunction<T, T>, acc: T) => T[];

• Perform inclusive prefix scan from left to right!

  Parameter x

  an array (updated!)

  Parameter fr

  reduce function (acc, v, i, x)

  Parameter acc

  initial value

  Returns

  x = [fr(acc, v₀), fr(fr(acc, v₀), v₁)...]

function index

index: <T>(x: T[], i: number) => number;

• Get zero-based index for an element in array.

  Parameter x

  an array

  Parameter i

  ±index

  Returns

  i' | x[i'] = x[i]; i' ∈ [0, |x|]

function indexOf

indexOf: <T>(x: T[], v: T, i?: number) => number;

• Find first index of a value.

  Parameter x

  an array

  Parameter v

  search value

  Parameter i

  begin index [0]

  Returns

  index of v in x[i..] if found else -1

function indexRange

indexRange: <T>(x: T[], i?: number, I?: number) => [number, number];

• Get zero-based index range for part of array.

  Parameter x

  an array

  Parameter i

  begin ±index [0]

  Parameter I

  end ±index (exclusive) [|x|]

  Returns

  [i', I'] | i' ≤ I'; i', I' ∈ [0, |x|]

function infix

infix: <T>(x: T[], n?: number, fr?: ReadFunction<number> | null) => T[] | null;

• Pick an arbitrary infix.

  Parameter x

  an array

  Parameter n

  number of values [-1 ⇒ any]

  Parameter fr

  random number generator ([0, 1))

  Returns

  x[i..j] if n<0; x[i..i+n] otherwise | i, j ∈ 0..|x|

function infixes

infixes: <T>(x: T[], n?: number) => T[][];

• Obtain all possible infixes.

  Parameter x

  an array

  Parameter n

  number of values [-1 ⇒ any]

  Returns

  [[], x[0..1], x[0..2], ..., x[1..2], ...] if n<0; [only of length n] otherwise

function init

init: <T>(x: T[]) => T[];

• Get values except last.

  Parameter x

  an array

  Returns

  x[0..|x|-1]

function interleave

interleave: <T>(xs: T[][]) => T[];

• Place values from iterables alternately.

  Parameter xs

  arrays

  Returns

  [x₀[0], x₁[0], ..., x₀[1], x₁[0], ...] | [x₀, x₁, ...] = xs

function intermix

intermix: <T>(
    x: T[],
    y: T[],
    m?: number,
    n?: number,
    s?: number,
    t?: number
) => T[];

• Place values of an array between another.

  Parameter x

  an array

  Parameter y

  another array

  Parameter m

  number of values from x [1]

  Parameter n

  number of values from y [1]

  Parameter s

  step size for x [m]

  Parameter t

  step size for y [n]

  Returns

  x[0..m] ⧺ y[0..n] ⧺ x[s..s+m] ⧺ y[t..t+n] ⧺ ... ⧺ x[k*s..|x|-1] | k ∈ W

function interpolate

interpolate: <T>(x: T[], fc: CombineFunction<T>) => T[];

• Estimate new values between existing ones.

  Parameter x

  an array

  Parameter fc

  combine function (a, b)

  Returns

  [x[0], fc(x[0], x[1]), x[1], fc(x[1], x[2]), ..., x[|x|-1]]

function intersection

intersection: <T, U = T>(
    x: T[],
    y: T[],
    fc?: CompareFunction<T | U> | null,
    fm?: MapFunction<T, T | U> | null
) => T[];

• Obtain values present in both arrays.

  Parameter x

  an array

  Parameter y

  another array

  Parameter fc

  compare function (a, b)

  Parameter fm

  map function (v, i, x)

  Returns

  x ∩ y = {v | v ∈ x, v ∈ y}

function intersperse

intersperse: <T>(x: T[], v: T) => T[];

• Place a separator between every value.

  Parameter x

  an array

  Parameter v

  separator

  Returns

  [x[0], v, x[1], v, ..., x[|x|-1]]

function ipermutations

ipermutations: <T>(x: T[], n?: number) => IterableIterator<T[]>;

• List all possible permutations.

  Parameter x

  an array

  Parameter n

  number of values [-1 ⇒ any]

  Returns

  [], arrangements of length 1, of length 2, ... if n<0; only of length n otherwise

function iprefixes

iprefixes: <T>(x: T[], n?: number) => IterableIterator<T[]>;

• List all possible prefixes.

  Parameter x

  an array

  Parameter n

  number of values [-1 ⇒ any]

  Returns

  [], x[..1], x[..2], ... if n<0; x[..n] otherwise

function is

is: (v: unknown) => v is unknown[];

• Check if value is an array.

  Parameter v

  a value

  Returns

  v is an array?

function isDisjoint

isDisjoint: <T, U = T>(
    x: T[],
    y: T[],
    fc?: CompareFunction<T | U> | null,
    fm?: MapFunction<T, T | U> | null
) => boolean;

• Examine if arrays have no value in common.

  Parameter x

  an array

  Parameter y

  another array

  Parameter fc

  compare function (a, b)

  Parameter fm

  map function (v, i, x)

  Returns

  x ∩ y = Φ?

function isEmpty

isEmpty: <T>(x: T[]) => boolean;

• Check if an array is empty.

  Parameter x

  an array

  Returns

  |x| = 0?

function isEqual

isEqual: <T, U = T>(
    x: T[],
    y: T[],
    fc?: CompareFunction<T | U> | null,
    fm?: MapFunction<T, T | U> | null
) => boolean;

• Examine if two arrays are equal.

  Parameter x

  an array

  Parameter y

  another array

  Parameter fc

  compare function (a, b)

  Parameter fm

  map function (v, i, x)

  Returns

  x = y?

function isSorted

isSorted: <T, U = T>(
    x: T[],
    fc?: CompareFunction<T | U> | null,
    fm?: MapFunction<T, T | U> | null
) => boolean;

• Examine if array is sorted.

  Parameter x

  an array

  Parameter fc

  compare function (a, b)

  Parameter fm

  map function (v, i, x)

  Returns

  x is sorted?

function isubsequences

isubsequences: <T>(x: T[], n?: number) => IterableIterator<T[]>;

• List all possible subsequences.

  Parameter x

  an array

  Parameter n

  number of values [-1 ⇒ any]

  Returns

  elements selected by bit from 0..2^|x| if n<0; only of length n otherwise

function isuffixes

isuffixes: <T>(x: T[], n?: number) => IterableIterator<T[]>;

• List all possible suffixes.

  Parameter x

  an array

  Parameter n

  number of values [-1 ⇒ any]

  Returns

  x[0..], x[1..], x[2..], ... if n<0; x[-n..] otherwise

function isUnique

isUnique: <T, U = T>(
    x: T[],
    fc?: CompareFunction<T | U> | null,
    fm?: MapFunction<T, T | U> | null
) => boolean;

• Examine if there are no duplicate values.

  Parameter x

  an array

  Parameter fc

  compare function (a, b)

  Parameter fm

  map function (v, i, x)

  Returns

  ∀ vᵢ, vⱼ ∈ x, is vᵢ ≠ vⱼ?

function ivalues

ivalues: <T>(x: T[]) => IterableIterator<T>;

• List all values.

  Parameter x

  an array

  Returns

  v₀, v₁, ... | vᵢ = x[i]

function join

join: <T>(x: T[], sep?: string) => string;

• Join values together into a string.

  Parameter x

  an array

  Parameter sep

  separator [,]

  Returns

  "${v₀}${sep}${v₁}..." | vᵢ ∈ x

function keys

keys: <T>(x: T[]) => number[];

• Obtain all indices.

  Parameter x

  an array

  Returns

  [0, 1, ..., |x|-1]

function last

last: <T>(x: T[], vd?: T) => T | undefined;

• Get last value.

  Parameter x

  an array

  Parameter vd

  default value

  Returns

  x[|x|-1] || vd

function lastIndexOf

lastIndexOf: <T>(x: T[], v: T, i?: number) => number;

• Find last index of a value.

  Parameter x

  an array

  Parameter v

  search value

  Parameter i

  begin index [|x|-1]

  Returns

  last index of v in x[0..i] if found else -1

function left

left: <T>(x: T[], n?: number) => T[];

• Keep first n values only.

  Parameter x

  an array

  Parameter n

  number of values [1]

  Returns

  x[0..n]

function length

length: <T>(x: T[], i?: number, I?: number) => number;

• Find the length of an array.

  Parameter x

  an array

  Parameter i

  begin ±index [0]

  Parameter I

  end ±index (exclusive) [X]

  Returns

  |x[i..I]|

function map

map: <T, U = T>(x: T[], fm: MapFunction<T, T | U>) => (T | U)[];