Primordial Functions

These are functions that are predefined in the language that are available to all modules and workers. The names of the functions are not reserved.

Creator Functions

The creator functions are used to make new objects. Some of them can take various types. All of these functions can fail if their inputs are not suitable.

Array

array(`number`)

Make an array. All of the elements are initialzed to null.

number is a non-negative integer, the intended length of the new array.

array(`number`, `initial_value`)

Make an array. All of the elements are initialized to initial_value.

number is a non-negative integer, the intended length of the new array.

If initial_value is a function, then the function is called for each element to produce initialization values. If the function has an arity of 1 or more, it will be passed the element number.

array(`array`, `function`)

Map. Call the function with each element of a the array, collecting the return values in a new array. The function is passed each original element. If the arity is 2 or more, it will also be passed the element number.

array(`array`, `another_array`)

Concat. Produce a new array that concatenates the array and another_array.

array(`array`, `from`, `to`)

Make a mutable copy of all or part of an array.

array: the array to copy

from: the position at which to start copying. Default: 0, the beginning. If negative, add length(array).

to: the position at which to stop copying. Default: length(array), the end. If negative, add length(array).

If, after adjustment, from and to are not valid integers in the proper range, then it fails. from must be positive and less than or equal to to. to must be less than or equal to length(array).

`array(record)`

Make an array containing all of the text keys in the record. The keys are not guaranteed to be in any particular order. Stone record keys are not included.

array(`text`)

Split into composite characters. A composite character is a Unicode character and its succeeding combining characters, if any.

array(`text`, `separator`)

Split the text into an array of subtexts. The separator can be a text or pattern.

array(`text`, `length`)

Dice the text into an array of subtexts of a given length.

Blob

blob()

Make a new empty blob.

blob(`capacity`)

Make a new empty blob with a specific initial capacity in bits.

blob(`length`, `random`)

Make a new blob of a given length whose content is random. The random parameter is a random generator function.

blob(`blob`, `from`, `to`)

Make a copy of all or part of a blob. The default of from is 0. The default of to is the length(blob).

Logical

logical(`value`)

if value = 0 \/ value = false \/ value = "false"
    return false
if value = 1 \/ value = true \/ value = "true"
    return true
fail

Number

number(`logical`)

The result will be 1 or 0.

`number(number)`

The number is returned.

number(`text`, `radix`)

Convert a text to a number. The optional radix is an integer 2 and 37. (See Base 32.) The default radix is 10.

`number`(`text`, `format`)

`format`	radix	separator	decimal point
`""`	10		`.`period
`"n"`
`"u"`		`_`underbar
`"d"`		`,`comma
`"s"`		space
`"v"`		`.`period	`,`comma
`"l"`		dependent on locale
`"i"`		`_`underbar
`"b"`	2
`"o"`	8
`"h"`	16
`"t"`	32
`"j"`	`0x`- base 16 `0o`- base 8 `0b`- base 2 otherwise base 10

The number function converts a text into a number.

If it is unable to (possibly because of a formatting error), it returns null. The format character determines how the text is interpreted. If the format is not one of those listed, then null is returned.

Examples:

set result: number("123,456,789.10", "d")    # result is 123456789.1
set result: number("123.456.789,10", "v")    # result is 123456789.1
set result: number("123.456.789,10", "d")    # result is null
set result: number("123 456 789.10", "s")    # result is 123456789.1
set result: number("12.350")                 # result is 12.35
set result: number("12.350", "v")            # result is 12350
set result: number("12.350", "i")            # result is null
set result: number("666")                    # result is 666
set result: number("666", "o")               # result is 438
set result: number("666", "h")               # result is 1638
set result: number("666", "t")               # result is 6342
set result: number("0666")                   # result is 666

Record

record(`record`)

Copy.

record(`record`, `array_of_keys`)

Select. Make a new record containing only the fields that are named by the array_of_keys.

record(`array_of_keys`)

Set. Make a record using the array as the source of the keys. Each field value is true.

record(`array_of_keys`, `value`)

Value Set. Make a record using the array as the source of the keys. Each field value is value.

Text

record(`array_of_keys`, `function`)

Functional value Set. Make a record using the array as the source of the keys. The function is called for each key, yielding the field values.

Text

text(`array`)

Convert an array of codepoints into a text.

text(`array`, `separator`)

Join an array of texts into a single text. The separator text is inserted between each piece. The default is empty text.

text(`number`, `radix`)

Convert a number to text. The optional radix is an integer 2 and 37. (See Base 32.) The default radix is 10.

`text(number,` `format)`

The text method converts a number to a text. It takes a format text parameter. The format of the format text is

format_text format_separation format_style format_places

format_separation "" digit

format_style 'b' 'e' 'h' 'i' 'j' 'n' 'l' 'o' 's' 't' 'u' 'v'

format_places digit digit digit

A format text contains a style letter that controls how a text is produced from the number. It is optionally preceded by a separation digit, and optionally followed by a places digit. There are real styles and integer styles. If the format parameter is not a proper format text, then null will be returned.

Separation is a character that is placed between digits to improve readability. If separation is 0, then there is no separation. If separation is 3, then a character will be inserted before the quadrillions, trillions, billions, millions, and thousands.

Places is the number of places to display after the decimal point (in real styles) or the minimum number of digits to display with zero-fill (in integer styles). If places is 0, then as many digits as necessary are displayed. Places can be zero or one or two digits.

real `style`		default separation	default places	decimal point	separator
`e`	exponential	0	0	`.`period
`n`	number	0
`s`	space	3			space
`u`	underbar				`_`underbar
`d`	decimal		2		`,`comma
`v`	comma		2	`,`comma	`.`period
`l`	locale	determined by the locale

The real format options are

"e" uses scientific notation. One digit will be placed before the decimal point, and all of the remaining digits after, followed by e and the exponent.

"n" uses .period as the decimal point and no separator. It is the format used for numbers in Misty source programs and JSON. Scientific notation will be used if the number value is extreme.

"s" uses .period as the decimal point and a space as the separator.

"u" uses .period as the decimal point and _underbar as the separator.

"d" uses .period as the decimal point and ,comma as the separator.

"c" uses ,comma as the decimal point and .period as the separator.

"l" depends on the locale to determine the characters to use as the decimal point and the separator.

The optional places determines the number of digits after the decimal point. The default is determined by the format, as seen in the table. If the places is 0, then the number of decimal places will be the fewest to exactly display the number without truncating. If the places is larger, then the field will be padded if necessary with trailing 0.

The optional separation determines the spacing of the separator character. For example, to place a separator between billions, millions, and thousands (that is, every 3 digits) then separation should be 3. If separation is zero, then there is no separation. The default is determined by the style.

integer style		base	default separation	minimum places	separator
`i`	integer	10	0	1	`_`underbar
`b`	binary	2
`o`	octal	8
`h`	hexadecimal	16
`t`	Base32	32

The integer styles first trunc the number. The fractional part of the number is ignored. The separation character is _underbar.

The optional places determines the minimum number of digits to show. More leading 0 may be shown if necessary. The default is determined by the format, as seen in the table.

Examples:

def n: 0123456789.1
set result: text(n)               # result is "123456789.1"
set result: text(n, "n")          # result is "123456789.1"
set result: text(n, "3s4")        # result is "123 456 789.1000"
set result: text(n, "s")          # result is "123 456 789.1"
set result: text(n, "d2")         # result is "123,456,789.10"
set result: text(n, "4d0")        # result is "1,2345,6789.1"
set result: text(n, "v2")         # result is "123.456.789,10"
set result: text(n, "e")          # result is "1.234567891e8"
set result: text(n, "e4")         # result is "1.2345e8"
set result: text(n, "i")          # result is "123456789"
set result: text(n, "8b")         # result is "111_01011011_11001101_00010101"
set result: text(n, "o")          # result is "726746425"
set result: text(n, "h")          # result is "75BCD15"
set result: text(n, "t")          # result is "3NQK8N"
set result: text(12)              # result is "12"
set result: text(12, 8)           # result is "14"
set result: text(12, 32)          # result is "C"
set result: text(12, "4b8")       # result is "0000_1100"
set result: text(12, "o3")        # result is "014"
set result: text(12, "h4")        # result is "000C"
set result: text(12, "t2")        # result is "0C"

text(`text`)

Return the text.

text(`text`, `from`, `to`)

Make a copy of part of a text.

text: the text to copy.

from: the position at which to start copying. Default: 0, the beginning. If negative, add length(text).

to: the position at which to stop copying. Default: length(array), the end. If negative, add length(text).

set my_text: "miskatonic"
text(my_text, 0, 3)        # "mis"        # the first 3
text(my_text, 3, 6)        # "kat"        # from 3 to 6
text(my_text, 5)           # "tonic"      # exclude the first 5
text(my_text, 0, -4)       # "miskat"     # exclude the last 4
text(my_text, -3)          # "nic"        # the last 3
text(my_text, 0, 0)        # ""
text(my_text, 10)          # ""
text(my_text, 11)          # fail
text(my_text, 2, 1)        # fail

Sensory Functions

The sensory functions end with ?question mark. They always return a logical.

array?(`value`)

Is this an array? If the operand is an array, the result is true. Otherwise, the result is false.

array?(0)             # false
array?({})            # false
array?([])            # true
not(array?([]))       # false
array?(pattern [])    # false
array?(null)          # false
array?("array")       # false

blob?(`value`)

Is this a blob? If the operand is a blob, the result is true. Otherwise, the result is false.

blob?(0)        # false
blob?("blob")   # false
blob?(blob())   # true

character?(`value`)

Is this a character? If the operand is a text with a length of 1, then the result is true. Otherwise, the result is false.

character?(1)            # false
character?("1")          # true
character?("character")  # false
character?("")           # false
character?("\u{FFFE}")   # true
character?()             # false
character?(«"»)          # true
character?(null)         # false

data?(`value`)

Is this data? If the operand is a text, number, logical, array, blob, or record, then the result is true. If the operand is a function, pattern, or null, the result is false.

data?(0)           # true
data?("")          # true
data?(["0"])       # true
data?({})          # true
data?(null)        # false

digit?(`value`)

Is this a digit? If the operand is a text with a length of 1 and is one of the 10 digit characters, then the result is true. Otherwise, the result is false.

digit?(0)           # false
digit?("0")         # true
digit?("9")         # true
digit?("09")        # false
digit?("digit")     # false
digit?("")          # false
digit?(1)           # false
digit?(["0"])       # false
digit?("Z")         # false

fit?(`number`)

Is the number a fit number? A number is a fit number if it is an integer that fits in 56 bits. All fit numbers are integers in the range -36028797018963968 thru 36028797018963967. Only fit numbers can be given to the fit functions. Misty has additional integers that are too big to fit.

function?(`value`)

Is this a function? If the operand is a function, then the result is true. Otherwise, the result is false.

function?(0)                # false
function?(ƒ(x)(x))          # true
function?("function")       # false
function?(null)             # false
function?(function?)        # true

integer?(`value`)

Is this an integer? If the operand is a number and if its fraction part is zero, then the result is true. Otherwise, the result is false.

integer?(0)                    # true
integer?(13 / 4)               # false
integer?(16 / 4)               # true
integer?(65.0000000)           # true
integer?(65.0000001)           # false
integer?(null)                 # false
integer?(true)                 # false
integer?(1)                    # true
integer?(36028797018963968)    # true
integer?(1.00001e100)          # true

letter?(`value`)

Is this a letter? If the operand is a text with a length of 1 and is a letter, then the result is true. Otherwise, the result is false.

letter?(0)          # false
letter?("0")        # false
letter?("letter")   # false
letter?("l")        # true
letter?("L")        # true
letter?("")         # false
letter?(null)       # false

logical?(`value`)

Is this a logical? A logical is either a false or a true. All other values are not logical.

logical?(false)    # true
logical?(true)     # true
logical?(0)        # false
logical?()         # false
logical?(null)     # false

lower?(`value`)

Is this a lower case letter? If the operand is a text with a length of 1 and is a lower case letter, then the result is true. Otherwise, the result is false.

lower?(0)         # false
lower?("0")       # false
lower?("lower")   # false
lower?("l")       # true
lower?("L")       # false
lower?("")        # false

number?(`value`)

Is this a number? If the operand is a number, then the result is true. Otherwise, the result is false.

number?(0)           # true
number?((13 / 4))    # true
number?((13 / 0))    # false
number?(98.6)        # true
number?("0")         # false
number?(1)           # true

record?(`value`)

Is this a record? If the operand is a record, then the result is true. Otherwise, the result is false.

record?(0)                 # false
record?({})                # true
record?([])                # false
record?("record")          # false
record?("{}")              # false
record?(ƒ ({}))            # false
record?(pattern [])        # true

stone?(`value`)

Is this stone? If the value is immutable, then the result is true. Otherwise, the result is false. All logicals, numbers, texts, functions, and patterns are immutable. Objects, blobs, and arrays are initially mutable, but can be made immutable with the stone function.

stone?(0)             # true
stone?("0")           # true
stone?([])            # false
stone?({})            # false
stone?(stone([]))     # true
stone?(stone({}))     # true
stone?(null)          # true

text?(`value`)

Is this a text? If the operand is a text, then the result is true. Otherwise, the result is false.

text?(0)           # 0
text?("0")         # true
text?("number")    # true
text?("")          # true
text?(null)        # false

upper?(`value`)

Is this an upper case letter? If the operand is a text with a length of 1 and is an upper case letter, then the result is true. Otherwise, the result is false.

upper?(0)          # false
upper?("0")        # false
upper?("UPPER")    # false
upper?("u")        # false
upper?("U")        # true
upper?("")         # false

whitespace?(`value`)

Is this whitespace? If the operand is a nonempty text containing only whitespace characters, then the result is true. Otherwise, the result is false.

whitespace?(0)          # false
whitespace?(32)         # false
whitespace?(char(32))   # true
whitespace?("0")        # false
whitespace?(" ")        # true
whitespace?("\t")       # true
whitespace?("\r")       # true
whitespace?("\r\n")     # true
whitespace?("space")    # false
whitespace?("     ")    # true
whitespace?(" L")       # false
whitespace?("")         # false

worker?(`value`)

Is this a worker?

Standard Functions

abs(`number`)

Absolute value. Return the positive form of the number. If the argument is not a number, the result is null.

`ceiling(number,` `place)`

If place is 0 or null, the number is rounded up to the smallest integer that is greater than or equal to the number. If place is a small positive integer, then the number is rounded up to that decimal place.

Examples:

set result: ceiling(12.3775, 0)      # result is 13
set result: ceiling(12.3775, -2)     # result is 12.38
set result: ceiling(-12.3775)        # result is -12
set result: ceiling(-12.3775, -2)    # result is -12.37
set result: ceiling(-12.3775)        # result is -13

character(`value`)

If the value is a text, it returns the first character. If the value is a non-negative 32-bit integer, it returns the character from that codeunit. Otherwise, it returns the empty string.

codepoint(`text`)

The codepoint function returns the first codepoint in a text as a number. If the argument is not a text, or if it is the empty text, then it returns null.

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

The text is matched to the pattern. If it does not match, the result is null. If the pattern does match, then the result is a record containing the saved fields.

`filter(array,` `function`)

The filter function calls a function for every element in the array, passing each element as the argument. When the function's return value is true, then the element is copied into a new array. If the function's return value is false, then the element is not copied into the new array. If the return value is not a logical, then the filter fails.

It returns a new array. The length of the new array is between 0 and the length of this array. It fails if the function parameter is not a function.

Example:

var a: [0, 1.25, 2, 3.5, 4, 5.75]
var b: filter(a, integer?)   # b is [0, 2, 4]

`floor(number,` `place)`

If place is 0 or null, the number is rounded down to the greatest integer that is less than or equal to the number. If place is a small positive integer, then the number is rounded down to that many decimal place. For positive numbers, this is like discarding decimal place.

Examples:

set result: floor(12.3775)         # result is 12
set result: floor(12.3775, -2)     # result is 12.37
set result: floor(-12.3775, 0)     # result is -13
set result: floor(-12.3775, -2)    # result is -12.38

`format(text,` `collection,` `transformer,` `begin,` `end)`

The format function makes a new text with substitutions in an original text. A collection is either an array of texts or a record of texts. The optional begin and end are texts; the defaults are "{" and "}".

A search is made for the begin and end in the text. If they are found, the middle text between them is examined. If the collection is an array, the middle text is used as a number, and then the matched begin and middle and end are replaced with the text at that subscript in the array. If the collection is a record, and if the middle text is the key of a member of the collection with a text value, then the value of the member is used in the substitution. Unmatched text is not altered.

The text between begin and end will be broken on the :colon character. The left text will be used as a number or name to select a value from the collection. (The value need not be a text.)

If a transformer parameter is a function, then it will be called with the collection[left text] and right text as parameters. If it returns a text, then the substitution is made.

If a transformer parameter is a record, then the right text will be used to select a function from the transformer. That function will be passed the value from the collection. If the return value is a text, that text will substitute. If there is no colon, then the empty text will be used to select the function from the transformer. If the transformer does not produce a function, or if the function does not return a text, then no replacement occurs. If transformer[right text](collection[left text]) produces a text, then the substituation will be made.

If the substitution is not made, and if collection[left text] is a number, then the right text is used as a format parameter in calling collection[left text].text(right text). If it returns a text, then the substitution is made.

Examples:

var result: format("{0} in {1}!", ["Malmborg", "Plano"])
    # result is "Malmborg in Plano!"

def deentityify: ƒ table (
    return ƒ text (format(text, table, null, "&", ";"))
}({
    amp: "&",
    lt : "<",
    gt : ">",
    quot: «"»
})
set result: deentityify("&quot; &copy;2009&quot;")
    # result is «" &copy;2009"»

`fraction(number)`

The fraction function returns the fractional part of a number It returns null for non-numbers.

`integer(number)`

The integer function returns the integer part. It returns null for non-numbers.

`last(array,` `value,` `from,` `to`)

The last method searches for the last occurrence of the value in the array, starting at at. If the at parameter is null, the default is 0, the first element. If the at parameter is negative, then it counts from the end of the array, -1 being the last element.

It returns the index of the element matching the value, or null if it is not found.

Example:

a: [1, 2, 3]
i: a.find(2)   # i is 1

length(`value`)

type	result
array	number of elements
blob	number of bits
logical	`null`
function	number of named parameters
number	`null`
record	`null`
text	number of codepoints

Length. Find the length of an array, a blob, or a text in elements, bits, or characters. For functions, it is the maximum number of arguments. All other values produce null.

`lower(text)`

The lower function returns a text in which all uppercase characters are converted to lowercase.

Example:

set result: lower("Carl Hollywood")    # result is "carl hollywood"

modulo(`dividend`, `divisor`)

The result has the sign of the divisor. If both arguments are integers, and if the divisor is positive power of two, then it is the same as and(dividend, divisor - 1).

neg(`number`)

Negate. Reverse the sign of a number. If the argument is not a number, the result is null. Note that the -minus sign is not used as a prefix negation operator.

not(`logical`)

Not. Return the opposite logical. If the argument is not a logical, it fails.

`remainder(dividend, divisor)`

For fit integers, the remainder is dividend -((dividend ÷ divisor) * divisor).

`reduce(array,` `function,` `initial)`

The reduce function takes a function that takes two arguments and returns a value. The function will be called for each element of the array, passing the result of the previous iteration to the next iteration.

The inital value is optional. If present, the function will be called for every element of the array.

If initial is null:

If length(array) is 0, then it returns null.
If length(array) is 1, then it returns array[0].
If length(array) is 2, it returns function(array[0], array[1]).
If length(array) is 3, it returns function(function(array[0], array[1]), array[2]).
And so on.

If initial is not null:

If length(array) is 0, then it returns initial.
If length(array) is 1, then it returns function(intial, array[0]).
If length(array) is 2, it returns function(function(initial, array[0]), array[1]).
If length(array) is 3, it returns function(function(function(intial, array[0]), array[1]), array[2]).
And so on.

Example:

def a: [1, 2, 3, 4, 5, 6, 7, 8, 9]
def total: reduce(a, ƒ+)      # total is 45
def product: reduce(a, ƒ*)    # product is 362880

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

Return a new text in which the target is replaced by the replacement.

text: the source text.

target: a text or pattern that should be replaced in the source.

replacement: text to replace the matched text, or a function that takes the matched text and the starting position, and returns the replacement text or null if it should be left alone.

limit: The maximum number of replacements. The default is all possible replacements. The limit includes null matches.

resolve(`first`, `second`)

The resolve function can take two arguments. If the first argument is not a function, it returns the first argument. Otherwise, it returns the result of calling the first argument. If the second argument is an array, then its elements will be passed to the function as its arguments.

`reverse(array)`

The reverse method makes a new array with the elements in the opposite order.

It returns a new, reversed array.

Example:

def a: ["I", "am", "Sam"]
def result: reverse(a)   # the result is ["Sam", "am", "I"]

`round(number,place)`

If place is 0 or null, the number is rounded to the nearest integer. If place is a small integer, then the number is rounded to that many decimal place.

Examples:

set result: round(12.3775)         # result is 12
set result: round(12.3775, -2)     # result is 12.38
set result: round(-12.3775, 0)     # result is -12
set result: round(-12.3775, -2)    # result is -12.38

`search(text, target,` `from)`

Search the text for the target. If the target is found, return the character position of the left-most part of the match. If the search fails, return null.

text: the source text.

target: a text or pattern that should be found in the source.

from: The starting position for the seach. The default is 0, the beginning of the text. If from is negative, it is added to length(text).

`sort(array,` `select)`

The sort function produces a new array in which the values are sorted. Sort keys must be either all numbers or all texts. Any other type of key or any error in the key calculation will cause the sort to fail, returning null. The sort is ascending. The sort is stable, so the relative order of equal keys is preserved.

The optional select parameter determines how the sort key for each element is selected.

`select` type	Sort key for `array[index]`	Description
`null`	`array[index]`	The sort key is the element itself. This is useful for sorting simple arrays of numbers or texts.
text	`array[index][select]`	The sort key is the `select` field of element record. This is useful for sorting arrays of records.
number	`array[index][select]`	The sort key is the `select` element of the array element, or the `select` field of the record element. This is useful for sorting arrays of arrays.
array	`select[index]`	`select` is a parallel array containing the sort keys.

It returns a new, sorted array.

Examples:

def a: ["oats", "peas", "beans", "barley"]
def b: sort(a)    # b is ["barley", "beans", "oats", "peas"]

var stooges: [
    {first: "Moe",   last: "Howard"},
    {first: "Joe",   last: "DeRita"},
    {first: "Shemp", last: "Howard"},
    {first: "Larry", last: "Fine"},
    {first: "Joe",   last: "Besser"},
    {first: "Curly", last: "Howard"}
]
set stooges: sort(sort(stooges, "first"), "last")
    # stooges is now [
    #     {first: "Joe",   last: "Besser"},
    #     {first: "Joe",   last: "DeRita"},
    #     {first: "Larry", last: "Fine"},
    #     {first: "Curly", last: "Howard"},
    #     {first: "Moe",   last: "Howard"},
    #     {first: "Shemp", last: "Howard"}
    # ]
set stooges: sort(stooges, [50, 60, 20, 40, 10, 30])
    # stooges is now [
    #     {first: "Moe", last: "Howard"},
    #     {first: "Larry", last: "Fine"},
    #     {first: "Shemp", last: "Howard"},
    #     {first: "Curly", last: "Howard"},
    #     {first: "Joe", last: "Besser"},
    #     {first: "Joe", last: "DeRita"}
    # ]

stone(`value`)

Turn an object to stone. Make the value immutable. It returns the immutable object.

The stone function makes an value (such as a blob, array, or record) immutable. If a value contains other objects, then they will also be turned to stone. Objects that are already stone are not changed. It returns the value.

`trim(text,` `reject)`

The trim function removes selected characters from the ends of a text. The default is to remove control characters and spaces.

set result: "  Hello   there   ".trim()    # result is "Hello   there"

`trunc(number,` `place)`

The number will be truncated toward zero. If the number is positive, the result is the same as floor(place). If the number is negative, the result is the same as ceiling(place).

If place is a small integer, then the number is rounded down to that many decimal place. This is like discarding decimal places.

Examples:

set result: trunc(12.3775, 0)     # result is 12
set result: trunc(12.3775, 2)     # result is 12.37
set result: trunc(-12.3775)       # result is -12
set result: trunc(-12.3775, 2)    # result is -12.37

`turkish_lower(text)`

Similar to lower, except that I goes to ıdotless i.

`turkish_upper(text)`

Similar to upper, except that i goes to İI dot.

`upper(text)`

The upper function returns a text in which all lowercase characters are converted to uppercase.

Example:

set result: upper("Carl Hollywood")    # result is "CARL HOLLYWOOD"

Functinos

Most operators can be used as functions by prefixing the operators with the ƒflorin operator.

So ƒ+ makes a binary add function that can be passed to the reduce function to make sums. ƒ+(3, 4) returns 7.

ƒ/\and ƒ\/or ƒ=equals ƒ≠not equals ƒ<less than ƒ≥greater than or equal ƒ>greater than ƒ≤less than or equal ƒ~concatenate ƒ+add ƒ-subtract ƒ>>>max ƒ<<<min ƒ*multiply ƒ/divide ƒ÷integer divide ƒ[]get ƒ()resolve ƒ|default

Three of them are short circuiting in their operator form, but not in their functino form: ƒ/\and ƒ\/or ƒ|default.

ƒ=equals

The equals function returns true if the first and second arguments are equal. A tolerance parameter is optional. If all of the parameters are numbers, the tolerance must be a non-negative number. The result is true if the absolute value of the difference between the two numbers is less than or equal to the tolerance.

Example:

def a: 12.3775
def b: 12.38
set result: ƒ=(a, b)          # result is false
set result: ƒ=(a, b, 0.01)    # result is true

If the arguments are texts, and if the tolerance is true, then the comparison is case-insensitive.

Example:

def a: "vorpal"
def b: "VORPAL"
set result: ƒ=(a, b)          # result is false
set result: ƒ=(a, b, true)    # result is true

ƒ`≠`not equals

The not equal function can take two or three arguments. The first two arguments are vaules to be compared. The optional third argument is a tolerance. When comparing numbers, the tolerance is a number that indicates the allowable difference. When comparing texts, the tolerance is a logical that if true ignores case.

ƒ[]get

The get function takes two arguments. The first argument is an array, record, or text. The second argument is an element number or key. It returns an element, a property, or a character or empty text, or null.

`ƒ~`concats

The concats function can take two or three arguments. The optional third argument is the character to be inserted between the first and second.

Primordial Functions

Creator Functions

Array

array(number)

array(number, initial_value)

array(array, function)

array(array, another_array)

array(array, from, to)

array(record)

array(text)

array(text, separator)

array(text, length)

Blob

blob()

blob(capacity)

blob(length, random)

blob(blob, from, to)

Logical

logical(value)

Number

number(logical)

number(number)

number(text, radix)

number(text, format)

Record

record(record)

record(record, array_of_keys)

record(array_of_keys)

record(array_of_keys, value)

Text

record(array_of_keys, function)

Text

text(array)

text(array, separator)

text(number, radix)

text(number, format)

text(text)

text(text, from, to)

Sensory Functions

array?(value)

blob?(value)

character?(value)

data?(value)

digit?(value)

fit?(number)

function?(value)

integer?(value)

letter?(value)

logical?(value)

lower?(value)

number?(value)

record?(value)

stone?(value)

text?(value)

upper?(value)

whitespace?(value)

worker?(value)

Standard Functions

abs(number)

ceiling(number, place)

character(value)

codepoint(text)

extract(text, pattern, from, to)

filter(array, function)

floor(number, place)

format(text, collection, transformer, begin, end)

fraction(number)

integer(number)

last(array, value, from, to)

length(value)

lower(text)

modulo(dividend, divisor)

neg(number)

not(logical)

remainder(dividend, divisor)

reduce(array, function, initial)

replace(text, target, replacement, limit)

resolve(first, second)

reverse(array)

round(number,place)

array(`number`)

array(`number`, `initial_value`)

array(`array`, `function`)

array(`array`, `another_array`)

array(`array`, `from`, `to`)

`array(record)`

array(`text`)

array(`text`, `separator`)

array(`text`, `length`)

blob(`capacity`)

blob(`length`, `random`)

blob(`blob`, `from`, `to`)

logical(`value`)

number(`logical`)

`number(number)`

number(`text`, `radix`)

`number`(`text`, `format`)

record(`record`)

record(`record`, `array_of_keys`)

record(`array_of_keys`)

record(`array_of_keys`, `value`)

record(`array_of_keys`, `function`)

text(`array`)

text(`array`, `separator`)

text(`number`, `radix`)

`text(number,` `format)`

text(`text`)

text(`text`, `from`, `to`)

array?(`value`)

blob?(`value`)

character?(`value`)

data?(`value`)

digit?(`value`)

fit?(`number`)

function?(`value`)

integer?(`value`)

letter?(`value`)

logical?(`value`)

lower?(`value`)

number?(`value`)

record?(`value`)

stone?(`value`)

text?(`value`)

upper?(`value`)

whitespace?(`value`)

worker?(`value`)

abs(`number`)

`ceiling(number,` `place)`

character(`value`)

codepoint(`text`)

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

`filter(array,` `function`)

`floor(number,` `place)`

`format(text,` `collection,` `transformer,` `begin,` `end)`

`fraction(number)`

`integer(number)`

`last(array,` `value,` `from,` `to`)

length(`value`)

`lower(text)`

modulo(`dividend`, `divisor`)

neg(`number`)

not(`logical`)

`remainder(dividend, divisor)`

`reduce(array,` `function,` `initial)`

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

resolve(`first`, `second`)

`reverse(array)`

`round(number,place)`

`search(text, target,` `from)`

`sort(array,` `select)`

stone(`value`)

`trim(text,` `reject)`

`trunc(number,` `place)`

`turkish_lower(text)`

`turkish_upper(text)`

`upper(text)`

ƒ`≠`not equals

`ƒ~`concats