Shortcut. Converts the input to an array via [#`arr`](#function-arr) and asserts that every element satisfies the given test function. Returns the resulting array.

### `function prim`

Links: [source](fpx.mjs#L136); [test/example](test/test.mjs#L1130).

Shortcut for asserting that the input is a primitive. Throws for non-primitive inputs. Returns the input as-is.

### `function bool`

Links: [source](fpx.mjs#L137); [test/example](test/test.mjs#L1147).

Similar to `val ?? false` but `val` must be [#nil](#function-isnil) or a [#boolean](#function-isbool), otherwise throws.

### `function num`

Links: [source](fpx.mjs#L138); [test/example](test/test.mjs#L1162).

Similar to `val ?? 0` but `val` must be [#nil](#function-isnil) or a [#number](#function-isnum), otherwise throws.

### `function fin`

Links: [source](fpx.mjs#L139); [test/example](test/test.mjs#L1178).

Similar to `val ?? 0` but `val` must be [#nil](#function-isnil) or a [#finite number](#function-isfin), otherwise throws.

### `function int`

Links: [source](fpx.mjs#L140); [test/example](test/test.mjs#L1194).

Similar to `val ?? 0` but `val` must be [#nil](#function-isnil) or an [#integer](#function-isint), otherwise throws.

### `function nat`

Links: [source](fpx.mjs#L141); [test/example](test/test.mjs#L1213).

Similar to `val ?? 0` but `val` must be [#nil](#function-isnil) or a [#natural number](#function-isnat), otherwise throws.

### `function intPos`

Links: [source](fpx.mjs#L142); [test/example](test/test.mjs#L1233).

Similar to `val ?? 0` but `val` must be [#nil](#function-isnil) or a [#positive integer](#function-isintpos), otherwise throws.

### `function str`

Links: [source](fpx.mjs#L143); [test/example](test/test.mjs#L1253).

Similar to `val ?? ''` but `val` must be [#nil](#function-isnil) or a [#string](#function-isstr), otherwise throws.

### `function dict`

Links: [source](fpx.mjs#L144); [test/example](test/test.mjs#L1266).

Similar to `val ?? Object.create(null)` but `val` must be [#nil](#function-isnil) or a [#dict](#function-isdict), otherwise throws.

### `function struct`

Links: [source](fpx.mjs#L145); [test/example](test/test.mjs#L1284).

Similar to `val ?? Object.create(null)` but `val` must be [#nil](#function-isnil) or a [#struct](#function-isstruct), otherwise throws.

Most Fpx functions that operate on data structures, such as [#`filter`](#function-filter), support structs, treating them similarly to maps. A struct is considered a collection of its [#`values`](#function-values). Iterating over [#`keys`](#function-keys) or [#`entries`](#function-entries) is opt-in.

### `function scalar`

Links: [source](fpx.mjs#L146); [test/example](test/test.mjs#L1301).

Type checking shortcut. Asserts that the input [#is scalar](#function-isscalar), returning it as-is.

### `function inst`

Links: [source](fpx.mjs#L147); [test/example](test/test.mjs#L1314).

Signature: `(any, typeof A) => A`.

Idempotently converts an arbitrary input to a given class:

* If `isInst(val, cls)`, returns `val` as-is.
* Otherwise returns `new cls(val)`.

```js
const newInst = f.inst([10, 20, 30], Set)
// Set{10, 20, 30}

const oldInst = f.inst(newInst, Set)
// Set{10, 20, 30}

newInst === oldInst
// true
```

### `function add`

Links: [source](fpx.mjs#L155); [test/example](test/test.mjs#L1347).

Same as `+`.

### `function sub`

Links: [source](fpx.mjs#L156); [test/example](test/test.mjs#L1353).

Same as `-`.

### `function mul`

Links: [source](fpx.mjs#L157); [test/example](test/test.mjs#L1359).

Same as `*`.

### `function div`

Links: [source](fpx.mjs#L158); [test/example](test/test.mjs#L1365).

Same as `/`.

### `function rem`

Links: [source](fpx.mjs#L159); [test/example](test/test.mjs#L1371).

Same as `%`.

### `function lt`

Links: [source](fpx.mjs#L160); [test/example](test/test.mjs#L1379).

Same as `<`.

### `function gt`

Links: [source](fpx.mjs#L161); [test/example](test/test.mjs#L1390).

Same as `>`.

### `function lte`

Links: [source](fpx.mjs#L162); [test/example](test/test.mjs#L1401).

Same as `<=`.

### `function gte`

Links: [source](fpx.mjs#L163); [test/example](test/test.mjs#L1412).

Same as `>=`.

### `function neg`

Links: [source](fpx.mjs#L164); [test/example](test/test.mjs#L1423).

Arithmetic negation. Same as unary `-`.

### `function inc`

Links: [source](fpx.mjs#L165); [test/example](test/test.mjs#L1435).

Increments by `1`.

### `function dec`

Links: [source](fpx.mjs#L166); [test/example](test/test.mjs#L1443).

Decrements by `1`.

### `function nop`

Links: [source](fpx.mjs#L170); [test/example](test/test.mjs#L1451).

Empty function. Functional equivalent of `;` or `undefined`. Sometimes useful with higher-order functions.

### `function True`

Links: [source](fpx.mjs#L171); [test/example](test/test.mjs#L1457).

Always returns `true`. Sometimes useful with higher order functions.

### `function False`

Links: [source](fpx.mjs#L172); [test/example](test/test.mjs#L1465).

Always returns `false`. Sometimes useful with higher order functions.

### `function id`

Links: [source](fpx.mjs#L173); [test/example](test/test.mjs#L1473).

Identity function: returns its first argument unchanged. Sometimes useful with higher-order functions.

### `function di`

Links: [source](fpx.mjs#L174); [test/example](test/test.mjs#L1480).

Returns its _second_ argument unchanged. Sometimes useful with higher-order functions.

### `function val`

Links: [source](fpx.mjs#L175); [test/example](test/test.mjs#L1487).

Takes a value and creates a function that always returns that value. Sometimes useful with higher order functions.

```js
const constant = f.val(1)

constant()
// 1

constant(`this input is ignored`)
// 1
```

### `function panic`

Links: [source](fpx.mjs#L176); [test/example](test/test.mjs#L1501).

Same as `throw` but an expression rather than a statement. Also sometimes useful with higher-order functions.

```js
const x = someTest ? someValue : f.panic(Error(`unreachable`))
```

### `function render`

Links: [source](fpx.mjs#L178); [test/example](test/test.mjs#L95).

Renders a value for user display. Counterpart to [#`show`](#function-show), which renders a value for debug purposes. Intended only for [#scalar](#function-isscalar) values. Rules:

* [#Nil](#function-isnil) → `''`.
* [#Scalar](#function-isscalar) → default JS stringification.
* All other inputs → `TypeError` exception.

### `function show`

Links: [source](fpx.mjs#L184); [test/example](test/test.mjs#L42).

Renders a value for debug purposes. Counterpart to [#`render`](#function-render), which renders a value for user display. Convenient for interpolating things into error messages. Used internally in assertion functions such as [#`req`](#function-req). Approximate rules:

* String → use `JSON.stringify`.
* Function → `[function ${val.name || val}]`.
* For named functions, this shorter representation is usually preferable to printing the entire source code.
* Object →
* Plain `{}` or `[]` → use `JSON.stringify`.
* Otherwise `[object ]`, prioritizing constructor name over `Symbol.toStringTag`.
* Exact opposite of default behavior for `Object.prototype.toString`.
* Otherwise → default JS stringification.

### `function npo`

Links: [source](fpx.mjs#L209); [test/example](test/test.mjs#L1523).

Short for "null-prototype object". Syntactic shortcut for `Object.create(null)`.

### `function hasOwn`

Links: [source](fpx.mjs#L211); [test/example](test/test.mjs#L1529).

Same as [`Object.prototype.hasOwnProperty`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty) but shorter and safe to call on primitives. Always false for primitives.

### `function hasOwnEnum`

Links: [source](fpx.mjs#L216); [test/example](test/test.mjs#L1543).

Same as [`Object.prototype.propertyIsEnumerable`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/propertyIsEnumerable) but shorter and safe to call on primitives. Always false for primitives.

### `function mut`

Links: [source](fpx.mjs#L221); [test/example](test/test.mjs#L1558).

Signature: `(tar, src) => tar`.

Similar to [`Object.assign`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign). Differences:

* Supports only one source argument.
* Much faster.
* Has sanity checks:
* Target must be a [#struct](#function-isstruct). Throws if target is a function or iterable.
* Source must be nil or a struct. Throws if source is an iterable, non-nil primitive, etc.
* Does not override inherited properties.
* Does not override own non-enumerable properties.

The refusal to override inherited and non-enumerable properties is good for some use cases, and bad for others. This is not just a faster sanity-checking substitute for `Object.assign`. It has different behaviors. Pick the right one for your use case.

### `function mapDict`

Links: [source](fpx.mjs#L229); [test/example](test/test.mjs#L1681).

Signature: `({[Key: A]}, A => B) => {[Key: B]}`.

Similar to [#`map`](#function-map) but for dicts. Creates a version of the given dict where values have been replaced by calling the given function for each value. Returns an empty dict if the input is [#nil](#function-isnil).

### `function pick`

Links: [source](fpx.mjs#L236); [test/example](test/test.mjs#L1696).

Signature: `({[Key: A]}, A => bool) => {[Key: A]}`.

Similar to [#`filter`](#function-filter) but for dicts. Returns a version of the given dict with only the properties for which `fun` returned something truthy. Returns an empty dict if the input is [#nil](#function-isnil).

### `function omit`

Links: [source](fpx.mjs#L246); [test/example](test/test.mjs#L1706).

Signature: `({[Key: A]}, A => bool) => {[Key: A]}`.

Similar to [#`reject`](#function-reject) but for dicts. Returns a version of the given dict without properties for which `fun` returned something truthy. Returns an empty dict if the input is [#nil](#function-isnil).

### `function pickKeys`

Links: [source](fpx.mjs#L248); [test/example](test/test.mjs#L1716).

Signature: `({[Key: A]}, keys) => {[Key: A]}`.

Returns a version of the given dict, keeping only the given properties. Keys can be either a `Set` or an arbitrary [#sequence](#function-arr). Each key must satisfy [#`isKey`](#function-iskey). Existence is not required: missing properties are silently ignored. Returns an empty dict if the input is [#nil](#function-isnil).

### `function omitKeys`

Links: [source](fpx.mjs#L255); [test/example](test/test.mjs#L1734).

Signature: `({[Key: A]}, keys) => {[Key: A]}`.

Returns a version of the given dict without the given properties. Keys must be an arbitrary sequence convertible to a `Set`. Returns an empty dict if the input is [#nil](#function-isnil).

### `function more`

Links: [source](fpx.mjs#L265); [test/example](test/test.mjs#L1752).

Takes an [#iterator](#function-isiterator), consumes one value, and returns true if the iterator is not yet finished. Shortcut for `val.next().done === false`.

### `function alloc`

Links: [source](fpx.mjs#L266); [test/example](test/test.mjs#L1762).

Shortcut for allocating an array with a sanity check. Same as `Array(N)` but ensures that the input is a [#natural number](#function-nat) suitable for array length. Avoids unintentionally passing any non-natural input such as `Array(-1)`. Allows [#nil](#function-isnil), replacing it with `0`.

### `function arr`

Links: [source](fpx.mjs#L267); [test/example](test/test.mjs#L1771).

Converts an arbitrary [#sequence](#function-isseq) to an array. Allows the following inputs:

* [#Nil](#function-isnil): return `[]`.
* [#Array](#function-isarr): return as-is.
* [#List](#function-islist): convert via `Array.prototype.slice`.
* [#Set](#function-isset) or arbitrary [#iterator](#function-isiterator): convert to array by iterating.

Unlike [#`values`](#function-values), `arr` rejects other inputs such as non-nil primitives, dicts, maps, arbitrary iterables, ensuring that the input is always a sequence.

### `function arrCopy`

Links: [source](fpx.mjs#L268); [test/example](test/test.mjs#L1803).

Like [#`arr`](#function-arr), converts an arbitrary sequence to an array. Unlike `arr,` always makes a copy. Mutating the output doesn't affect the original.

### `function slice`

Links: [source](fpx.mjs#L273); [test/example](test/test.mjs#L1817).

Like [`Array.prototype.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice) but allows arbitrary [#sequences](#function-isseq) compatible with [#`arr`](#function-arr).

### `function keys`

Links: [source](fpx.mjs#L282); [test/example](test/test.mjs#L1849).

Takes an arbitrary input and returns an array of its keys:

* For non-objects: always `[]`.
* For [#iterables](#function-isiter) with `.keys()`: equivalent to converting the output of `.keys()` to an array. Implementation varies for performance.
* Examples: `Array`, `Set`, `Map`, and more.
* For [#lists](#function-islist): equivalent to above for arrays.
* For [#iterators](#function-iterator): exhausts the iterator, returning an array of indexes equivalent to `f.span(f.len(iterator))`. See [#`span`](#function-span) and [#`len`](#function-len).
* For [#structs](#function-isstruct): equivalent to [`Object.keys`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys).

### `function values`

Links: [source](fpx.mjs#L299); [test/example](test/test.mjs#L1872).

Takes an arbitrary input and returns an array of its values:

* For non-objects: always `[]`.
* For [#arrays](#function-isarr): **returns as-is without copying**.
* For [#lists](#function-islist): slice to array.
* For [#iterables](#function-isiter) with `.values()`: equivalent to converting the output of `.values()` to an array. Implementation varies for performance.
* Examples: `Set`, `Map`, and more.
* For [#iterators](#function-iterator): equivalent to `[...iterator]`.
* For [#structs](#function-isstruct): equivalent to [`Object.values`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/values).

### `function valuesCopy`

Links: [source](fpx.mjs#L322); [test/example](test/test.mjs#L1892).

Variant of [#`values`](#function-values) that always makes a copy. Mutating the output doesn't affect the original.

### `function entries`

Links: [source](fpx.mjs#L324); [test/example](test/test.mjs#L1914).

Takes an arbitrary input and returns an array of its entries (key-value tuples):

* For non-objects: always `[]`.
* For [#iterables](#function-isiter) with `.entries()`: equivalent to converting the output of `.entries()` to an array. Implementation varies for performance.
* Examples: `Set`, `Map`, and more.
* For [#lists](#function-islist): equivalent to above for arrays.
* For [#iterators](#function-iterator): exhausts the iterator, returning an array of entries where keys are indexes starting with 0.
* For [#structs](#function-isstruct): equivalent to [`Object.entries`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries).

### `function reify`

Links: [source](fpx.mjs#L350); [test/example](test/test.mjs#L1933).

Takes an arbitrary value and attempts to deeply materialize it. Any [#iterators](#function-iterator), or [#lists](#function-islist) that contain iterators, or lists that contain lists that contain iterators, etc., are converted to arrays. Does not inspect other data structures such as [#sets](#function-isset) or [#dicts](#function-isdict).

### `function vac`

Links: [source](fpx.mjs#L354); [test/example](test/test.mjs#L1958).

Complements [#`isVac`](#function-isvac). Returns `undefined` if the input is vacuous, otherwise returns the input as-is.

### `function indexOf`

Links: [source](fpx.mjs#L356); [test/example](test/test.mjs#L1965).

Like [`Array.prototype.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf). Differences:

* Uses [#`is`](#function-is) rather than `===`, therefore able to detect `NaN`.
* Input may be [#nil](#function-isnil) or any [#list](#function-islist).

### `function includes`

Links: [source](fpx.mjs#L364); [test/example](test/test.mjs#L1986).

Like [`Array.prototype.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes). Differences:

* Supports arbitrary iterables compatible with [#`values`](#function-values).
* Iterable may be [#nil](#function-isnil), equivalent to `[]`.

### `function concat`

Links: [source](fpx.mjs#L365); [test/example](test/test.mjs#L2005).

Like [`Array.prototype.concat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat). Differences:

* Takes two arguments, without rest/spread.
* Supports arbitrary iterables compatible with [#`values`](#function-values).
* Iterables may be [#nil](#function-isnil), equivalent to `[]`.

Note: for individual elements, use [#`append`](#function-append) and
[#`prepend`](#function-prepend).

### `function append`

Links: [source](fpx.mjs#L366); [test/example](test/test.mjs#L2023).

Takes an arbitrary iterable compatible with [#`values`](#function-values) and appends an arbitrary value, returning the resulting array.

### `function prepend`

Links: [source](fpx.mjs#L367); [test/example](test/test.mjs#L2038).

Takes an arbitrary iterable compatible with [#`values`](#function-values) and prepends an arbitrary value, returning the resulting array.

### `function len`

Links: [source](fpx.mjs#L369); [test/example](test/test.mjs#L2073).

Universal length measurement:

* For non-objects: always 0.
* For iterables:
* For [#lists](#function-islist): same as `.length`.
* For ES2015 collections such as `Set`: same as `.size`.
* For iterators: exhausts the iterator, returning element count.
* For [#structs](#function-isstruct): equivalent to `Object.keys(val).length`.

### `function hasLen`

Links: [source](fpx.mjs#L393); [test/example](test/test.mjs#L2077).

Shortcut for [#`len`](#function-len) > 0.

### `function each`

Links: [source](fpx.mjs#L395); [test/example](test/test.mjs#L2109).

Similar to `Array.prototype.forEach`, `Set.prototype.forEach`, `Map.prototype.forEach`, and so on. Differences:

* Takes an arbitrary iterable compatible with [#`values`](#function-values).
* Iterable may be [#nil](#function-isnil), equivalent to `[]`.
* Doesn't support `this` or additional arguments.

### `function map`

Links: [source](fpx.mjs#L400); [test/example](test/test.mjs#L2130).

Similar to [`Array.prototype.map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map). Differences:

* Takes an arbitrary iterable compatible with [#`values`](#function-values).
* Iterable may be [#nil](#function-isnil), equivalent to `[]`.
* Doesn't support `this` or additional arguments.

### `function mapMut`

Links: [source](fpx.mjs#L402); [test/example](test/test.mjs#L2163).

Similar to [`Array.prototype.map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map). Differences:

* Mutates the input (which must be an array).
* Doesn't support `this` or additional arguments.

For a non-mutating version, see [#`map`](#function-map).

### `function mapCompact`

Links: [source](fpx.mjs#L410); [test/example](test/test.mjs#L2179).

Equivalent to `f.compact(f.map(val, fun))`. See [#`map`](#function-map) and [#`compact`](#function-compact).

### `function filter`

Links: [source](fpx.mjs#L412); [test/example](test/test.mjs#L2192).

Similar to [`Array.prototype.filter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter). Differences:

* Takes an arbitrary iterable compatible with [#`values`](#function-values).
* Iterable may be [#nil](#function-isnil), equivalent to `[]`.
* Doesn't support `this` or additional arguments.

### `function reject`

Links: [source](fpx.mjs#L419); [test/example](test/test.mjs#L2208).

Opposite of [#`filter`](#function-filter). Equivalent to `f.filter(val, f.not(fun))`.

### `function compact`

Links: [source](fpx.mjs#L421); [test/example](test/test.mjs#L2224).

Equivalent to `f.filter(val, f.id)`. Takes an arbitrary iterable and returns an array of its truthy [#`values`](#function-values), discarding falsy values.

### `function remove`

Links: [source](fpx.mjs#L427); [test/example](test/test.mjs#L2236).

Takes an arbitrary iterable and an element to remove. Returns an array of the iterable's [#`values`](#function-values), discarding each occurrence of this element, comparing via [#`is`](#function-is).

### `function fold`

Links: [source](fpx.mjs#L431); [test/example](test/test.mjs#L2253).

Similar to [`Array.prototype.reduce`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce). Differences:

* Takes an arbitrary iterable compatible with [#`values`](#function-values).
* Iterable may be [#nil](#function-isnil), equivalent to `[]`.
* Arguments are `(src, acc, fun)` rather than `(fun, acc)`.
* Accumulator argument is mandatory.
* Doesn't support `this`.
* Iterator function receives exactly two arguments: accumulator and next value.

### `function find`

Links: [source](fpx.mjs#L437); [test/example](test/test.mjs#L2269).

Similar to [`Array.prototype.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find). Differences:

* Takes an arbitrary iterable compatible with [#`values`](#function-values).
* Iterable may be [#nil](#function-isnil), equivalent to `[]`.
* Doesn't support `this` or additional arguments.

### `function procure`

Links: [source](fpx.mjs#L443); [test/example](test/test.mjs#L2284).

Similar to [#`find`](#function-find), but returns the first truthy result of calling the iterator function, rather than the corresponding element. Equivalent to `f.find(f.map(src, fun), f.id)` but more efficient.

### `function every`

Links: [source](fpx.mjs#L449); [test/example](test/test.mjs#L2301).

Similar to [`Array.prototype.every`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every). Differences:

* Takes an arbitrary iterable compatible with [#`values`](#function-values).
* Iterable may be [#nil](#function-isnil), equivalent to `[]`.
* Doesn't support `this` or additional arguments.

### `function some`

Links: [source](fpx.mjs#L455); [test/example](test/test.mjs#L2320).

Similar to [`Array.prototype.some`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some). Differences:

* Takes an arbitrary iterable compatible with [#`values`](#function-values).
* Iterable may be [#nil](#function-isnil), equivalent to `[]`.
* Doesn't support `this` or additional arguments.

### `function head`

Links: [source](fpx.mjs#L461); [test/example](test/test.mjs#L2339).

Takes an arbitrary iterable compatible with [#`values`](#function-values) and returns its first element or `undefined`.

### `function last`

Links: [source](fpx.mjs#L470); [test/example](test/test.mjs#L2349).

Takes an arbitrary iterable compatible with [#`values`](#function-values) and returns its last element or `undefined`.

### `function init`

Links: [source](fpx.mjs#L471); [test/example](test/test.mjs#L2359).

Short for "initial". Takes an arbitrary iterable compatible with [#`values`](#function-values) and returns an array of all its values except last.

### `function tail`

Links: [source](fpx.mjs#L472); [test/example](test/test.mjs#L2369).

Takes an arbitrary iterable compatible with [#`values`](#function-values) and returns an array of all its values except first.

### `function take`

Links: [source](fpx.mjs#L473); [test/example](test/test.mjs#L2379).

Takes an arbitrary iterable compatible with [#`values`](#function-values) and returns N values from the start.

### `function count`

Links: [source](fpx.mjs#L475); [test/example](test/test.mjs#L2411).

Takes an arbitrary iterable compatible with [#`values`](#function-values), calls the given function for each value, and returns the count of truthy results. The count is between 0 and iterable length.

### `function compare`

Links: [source](fpx.mjs#L483); [test/example](test/test.mjs#L2426).

Signature: `(a, b) => -1 | 0 | 1`.

Equivalent to the [default JS sort comparison algorithm](https://tc39.github.io/ecma262/#sec-sortcompare). Sometimes useful for sorting via [`Array.prototype.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) or [#`sort`](#function-sort), as a fallback.

### `function compareFin`

Links: [source](fpx.mjs#L494); [test/example](test/test.mjs#L2436).

Signature: `(a, b) => -1 | 0 | 1` where arguments are [#nil](#function-isnil) or [#finite](#function-isfin).

Sort comparison for finite numbers. Usable for [`Array.prototype.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) or [#`sort`](#function-sort). Throws on non-nil, non-finite arguments.

### `function sort`

Links: [source](fpx.mjs#L502); [test/example](test/test.mjs#L2448).

Similar to [`Array.prototype.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort). Differences:

* Takes an arbitrary iterable compatible with [#`values`](#function-values).
* Iterable may be [#nil](#function-isnil), equivalent to `[]`.
* Always creates a new array. Does not mutate the input.

The comparison function is optional. If omitted, default JS sorting is used.

### `function reverse`

Links: [source](fpx.mjs#L503); [test/example](test/test.mjs#L2480).

Similar to [`Array.prototype.reverse`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse). Differences:

* Takes an arbitrary iterable compatible with [#`values`](#function-values).
* Iterable may be [#nil](#function-isnil), equivalent to `[]`.
* Always creates a new array. Does not mutate the input.

### `function index`

Links: [source](fpx.mjs#L505); [test/example](test/test.mjs#L2498).

Takes an arbitrary iterable compatible with [#`values`](#function-values) and returns an index where its values are _keyed_ by the given function, hence the name. The function is called for each value. If the function returns a [#valid key](#function-iskey), the key-value pair is added to the index. Invalid keys are ignored. If the function returns the same key for multiple values, previous values are lost.

Similar to Lodash's `_.keyBy`. Compare [#`group`](#function-group) which keeps all values for each group, rather than only the last.

### `function group`

Links: [source](fpx.mjs#L515); [test/example](test/test.mjs#L2543).

Takes an arbitrary iterable compatible with [#`values`](#function-values) and groups its values by keys generated by the given function. The function is called for each value. If the function returns a [#valid key](#function-iskey), the value is added to the index under that key. Invalid keys are ignored.

Compare [#`index`](#function-index), which keeps only the last value for each group.

### `function partition`

Links: [source](fpx.mjs#L525); [test/example](test/test.mjs#L2569).

Partitions the [#`values`](#function-values) of a given iterable, returning a tuple of two groups: values that satisfy the predicate and the remainder.

### `function sum`

Links: [source](fpx.mjs#L533); [test/example](test/test.mjs#L2586).

Sums all finite [#`values`](#function-values) of an arbitrary iterable, ignoring all non-finite values.

### `function zip`

Links: [source](fpx.mjs#L538); [test/example](test/test.mjs#L2597).

Signature: `(Iter<[Key, A]>) => {[Key: A]}`.

Similar to [`Object.fromEntries`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/fromEntries). Differences:

* Takes an arbitrary iterable compatible with [#`values`](#function-values) (more flexible).
* Each value of this iterable must be a key-value pair.
* Ignores entries where the first element is not a [#valid key](#function-iskey).
* Returns a [#null-prototype object](#function-npo).
* Slightly slower.

### `function mapFrom`

Links: [source](fpx.mjs#L544); [test/example](test/test.mjs#L2614).

Syntactic shortcut for creating a `Map` with inline keys and values. Shorter and less noisy than either `new Map` with an array of entries or chained `.set` calls.

### `function range`

Links: [source](fpx.mjs#L551); [test/example](test/test.mjs#L2621).

Signature: `(min: int, max: int) => int[]`.

Returns an array of contiguous integers in the range of `[min, max)`. The first value is `min`, the last value is `max - 1`.

### `function span`

Links: [source](fpx.mjs#L562); [test/example](test/test.mjs#L2636).

Signature: `nat => nat[]`.

Returns an array of the given length, where values are integers from 0. Shortcut for `f.range(0, length)`. Nil length is equivalent to 0.

### `function times`

Links: [source](fpx.mjs#L563); [test/example](test/test.mjs#L2647).

Signature: `(len: nat, fun: nat => A) => A[]`.

Takes an array length and a mapping function. Returns an array of the given length, where each element is the result of calling the given function, passing the element's index, starting with 0. Equivalent to `f.mapMut(f.span(len), fun)`.

### `function repeat`

Links: [source](fpx.mjs#L564); [test/example](test/test.mjs#L2668).

Signature: `(len: nat, val: A) => A[]`.

Returns an array of the given length where each element is the given value. Equivalent to `f.alloc(len).fill(val)`.

### `function set`

Links: [source](fpx.mjs#L565); [test/example](test/test.mjs#L2680).

Converts an arbitrary input to a native [`Set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set). Similar to `new Set`. Differences:

* If input is already a set: **return as-is without copying**.
* Otherwise, create a set of the input's [#`values`](#function-values).
* [#Maps](#function-ismap) and [#structs](#function-isstruct) are treated as collections of their values rather than key-value entries.

### `function setCopy`

Links: [source](fpx.mjs#L566); [test/example](test/test.mjs#L2704).

Similar to [#`set`](#function-set): converts an arbitrary input to a set. Difference: always makes a copy. If the original was a set, it's unaffected by mutations of the output.

## License

https://unlicense.org

## Misc