---
title: "Built-in Functions"
description: "Intrinsic constants and functions"
weight: 60
type: "docs"
---

The intrinsics are constants and functions that are built into the language. The `use` statement is not needed to access them.

A programmer is not obliged to consult the list of intrinsics before naming a new variable or input. New intrinsics may be added to ƿit without breaking existing programs.

## Constants

### false

The value of `1 == 0`. One of the two logical values.

### true

The value of `1 == 1`. One of the two logical values.

### null

The value of `1 / 0`. The null value is an empty immutable object. All attempts to obtain a value from null by refinement will produce null.

Any attempt to modify null will disrupt. Any attempt to call null as a function will disrupt.

null is the value of missing input values, missing fields in records, and invalid numbers.

### pi

An approximation of circumference / diameter: 3.1415926535897932.

## Creator Functions

The creator functions make new objects. Some can take various types. All return null if their inputs are not suitable.

### array

`array(number)` — Make an array. All elements are initialized to null.

`array(number, initial_value)` — Make an array. All elements are initialized to initial_value. If initial_value is a function, it is called for each element. If the function has arity >= 1, it is passed the element number.

```javascript
array(3)              // [null, null, null]
array(3, 0)           // [0, 0, 0]
array(5, i => i * 2)  // [0, 2, 4, 6, 8]
```

`array(array)` — Copy. Make a mutable copy of the array.

`array(array, function, reverse, exit)` — Map. Call the function with each element, collecting return values in a new array. The function is passed each element and its element number.

```javascript
array([1, 2, 3], x => x * 10)  // [10, 20, 30]
```

If reverse is true, starts with the last element and works backwards.

If exit is not null, when the function returns the exit value, array returns early. The exit value is not stored into the new array.

`array(array, another_array)` — Concat. Produce a new array concatenating both.

```javascript
array([1, 2], [3, 4])  // [1, 2, 3, 4]
```

`array(array, from, to)` — Slice. Make a mutable copy of part of an array. If from is negative, add length(array). If to is negative, add length(array).

```javascript
array([1, 2, 3, 4, 5], 1, 4)  // [2, 3, 4]
array([1, 2, 3], -2)          // [2, 3]
```

`array(record)` — Keys. Make an array containing all text keys in the record.

`array(text)` — Split text into grapheme clusters.

```javascript
array("hello")  // ["h", "e", "l", "l", "o"]
```

`array(text, separator)` — Split text into an array of subtexts.

`array(text, length)` — Dice text into an array of subtexts of a given length.

### logical

```javascript
logical(0)        // false
logical(false)    // false
logical("false")  // false
logical(null)     // false
logical(1)        // true
logical(true)     // true
logical("true")   // true
```

All other values return null.

### number

`number(logical)` — Returns 1 or 0.

`number(number)` — Returns the number.

`number(text, radix)` — Convert text to number. Radix is 2 thru 37 (default: 10).

`number(text, format)` — Parse formatted numbers:

| Format | Radix | Separator | Decimal point |
|--------|-------|-----------|---------------|
| `""` | 10 | | .period |
| `"n"` | 10 | | .period |
| `"u"` | 10 | _underbar | .period |
| `"d"` | 10 | ,comma | .period |
| `"s"` | 10 | space | .period |
| `"v"` | 10 | .period | ,comma |
| `"l"` | 10 | locale | locale |
| `"b"` | 2 | | |
| `"o"` | 8 | | |
| `"h"` | 16 | | |
| `"j"` | auto | | |

```javascript
number("123,456,789.10", "d")  // 123456789.1
number("123.456.789,10", "v")  // 123456789.1
number("666", "o")             // 438
number("666", "h")             // 1638
```

### text

`text(array, separator)` — Convert array to text. Elements are concatenated with the separator (default: empty text).

`text(number, radix)` — Convert number to text. Radix is 2 thru 37 (default: 10).

`text(number, format)` — Format a number as text:

**Real styles:**

| Style | Description | Separator | Decimal |
|-------|-------------|-----------|---------|
| `"e"` | Scientific | | .period |
| `"n"` | Number | | .period |
| `"s"` | Space | space | .period |
| `"u"` | Underbar | _underbar | .period |
| `"d"` | Decimal | ,comma | .period |
| `"c"` | Comma | .period | ,comma |
| `"l"` | Locale | locale | locale |

**Integer styles:**

| Style | Base | Separator |
|-------|------|-----------|
| `"i"` | 10 | _underbar |
| `"b"` | 2 | _underbar |
| `"o"` | 8 | _underbar |
| `"h"` | 16 | _underbar |
| `"t"` | 32 | _underbar |

The format text is: `separation_digit` + `style_letter` + `places_digits`

```javascript
var data = 123456789.1
text(data)             // "123456789.1"
text(data, "3s4")      // "123 456 789.1000"
text(data, "d2")       // "123,456,789.10"
text(data, "e")        // "1.234567891e8"
text(data, "i")        // "123456789"
text(data, "8b")       // "111_01011011_11001101_00010101"
text(data, "h")        // "75BCD15"
text(12, "4b8")        // "0000_1100"
```

`text(text, from, to)` — Extract a substring. If from/to are negative, add length(text).

```javascript
var my_text = "miskatonic"
text(my_text, 0, 3)   // "mis"
text(my_text, 5)       // "tonic"
text(my_text, -3)      // "nic"
```

### record

`record(record)` — Copy. Make a mutable copy.

`record(record, another_record)` — Combine. Copy a record, then put all fields of another into the copy.

`record(record, array_of_keys)` — Select. New record with only the named fields.

`record(array_of_keys)` — Set. New record using array as keys, each value is true.

`record(array_of_keys, value)` — Value Set. Each field value is value.

`record(array_of_keys, function)` — Functional Value Set. The function is called for each key to produce field values.

## Sensory Functions

The sensory functions always return a logical value. In ƿit, they use the `is_` prefix:

```javascript
is_array([])         // true
is_blob(blob.make()) // true
is_function(x => x)  // true
is_integer(42)       // true
is_logical(true)     // true
is_null(null)        // true
is_number(3.14)      // true
is_object({})        // true
is_text("hello")     // true
```

Additional type checks: `is_character`, `is_data`, `is_digit`, `is_false`, `is_fit`, `is_letter`, `is_lower`, `is_pattern`, `is_stone`, `is_true`, `is_upper`, `is_whitespace`.

## Standard Functions

### abs(number)

Absolute value. Returns null for non-numbers.

### apply(function, array)

Execute the function, passing the array elements as input values. If the array is longer than the function's arity, it disrupts.

### ceiling(number, place)

Round up. If place is 0 or null, round to the smallest integer >= number.

```javascript
ceiling(12.3775)        // 13
ceiling(12.3775, -2)    // 12.38
ceiling(-12.3775)       // -12
```

### character(value)

If text, returns the first character. If a non-negative 32-bit integer, returns the character from that codepoint.

### codepoint(text)

Returns the codepoint number of the first character.

### extract(text, pattern, from, to)

Match text to pattern. Returns a record of saved fields, or null if no match.

### fallback(requestor_array)

Returns a requestor that tries each requestor in order until one succeeds. Returns a cancel function.

### filter(array, function)

Call function for each element. When it returns true, the element is included in the new array.

```javascript
filter([0, 1.25, 2, 3.5, 4, 5.75], is_integer)  // [0, 2, 4]
```

### find(array, function, reverse, from)

Call function for each element. If it returns true, return the element number. If the second argument is not a function, it is compared directly to elements. Returns null if not found.

```javascript
find([1, 2, 3], x => x > 1)  // 1
find([1, 2, 3], 2)            // 1
```

### floor(number, place)

Round down. If place is 0 or null, round to the greatest integer <= number.

```javascript
floor(12.3775)        // 12
floor(12.3775, -2)    // 12.37
floor(-12.3775)       // -13
```

### for(array, function, reverse, exit)

Call function with each element and its element number. If exit is not null and the function returns the exit value, return early.

### format(text, collection, transformer)

Substitute `{key}` placeholders in text with values from a collection (array or record).

```javascript
format("{0} in {1}!", ["Malmborg", "Plano"])
// "Malmborg in Plano!"
```

### fraction(number)

Returns the fractional part of a number. See also `whole`.

### length(value)

| Value | Result |
|-------|--------|
| array | number of elements |
| blob | number of bits |
| text | number of codepoints |
| function | number of named inputs (arity) |
| record | record.length() |
| other | null |

### lower(text)

Returns text with all uppercase characters converted to lowercase.

### max(number, number)

Returns the larger of two numbers. Returns null if either is not a number.

### min(number, number)

Returns the smaller of two numbers.

### modulo(dividend, divisor)

Result is `dividend - (divisor * floor(dividend / divisor))`. Result has the sign of the divisor.

### neg(number)

Negate. Reverse the sign of a number.

### normalize(text)

Unicode normalize.

### not(logical)

Returns the opposite logical. Returns null for non-logicals.

### parallel(requestor_array, throttle, need)

Returns a requestor that starts all requestors in the array. Results are collected into an array matching the input order. Optional throttle limits concurrent requestors. Optional need specifies the minimum number of successes required.

### race(requestor_array, throttle, need)

Like parallel, but returns as soon as the needed number of results are obtained. Default need is 1. Unfinished requestors are cancelled.

### reduce(array, function, initial, reverse)

Reduce an array to a single value by applying a function to pairs of elements.

```javascript
reduce([1, 2, 3, 4, 5, 6, 7, 8, 9], (a, b) => a + b)  // 45
```

### remainder(dividend, divisor)

For fit integers: `dividend - ((dividend // divisor) * divisor)`.

### replace(text, target, replacement, limit)

Return text with target replaced by replacement. Target can be text or pattern. Replacement can be text or a function.

### reverse(array)

Returns a new array with elements in the opposite order.

### round(number, place)

Round to nearest.

```javascript
round(12.3775)        // 12
round(12.3775, -2)    // 12.38
```

### search(text, target, from)

Search text for target. Returns character position or null.

### sequence(requestor_array)

Returns a requestor that processes each requestor in order. Each result becomes the input to the next. The last result is the final result.

### sign(number)

Returns -1, 0, or 1.

### sort(array, select)

Returns a new sorted array. Sort keys must be all numbers or all texts. Sort is ascending and stable.

| select type | Sort key | Description |
|-------------|----------|-------------|
| null | element itself | Simple sort |
| text | element[select] | Sort by record field |
| number | element[select] | Sort by array index |
| array | select[index] | External sort keys |

```javascript
sort(["oats", "peas", "beans", "barley"])
// ["barley", "beans", "oats", "peas"]

sort([{n: 3}, {n: 1}], "n")
// [{n: 1}, {n: 3}]
```

### stone(value)

Petrify the value, making it permanently immutable. The operation is deep — all nested objects and arrays are also frozen. Returns the value.

### trim(text, reject)

Remove characters from both ends. Default removes whitespace.

### trunc(number, place)

Truncate toward zero.

```javascript
trunc(12.3775)        // 12
trunc(-12.3775)       // -12
```

### upper(text)

Returns text with all lowercase characters converted to uppercase.

### whole(number)

Returns the whole part of a number. See also `fraction`.