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.
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.
Make an array. All of the elements are initialzed to null
.
number is a nonnegative integer, the intended length of the new array.
Make an array. All of the elements are initialized to initial_value.
number is a nonnegative 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.
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.
Concat. Produce a new array that concatenates the array and another_array.
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.
Split into composite characters. A composite character is a Unicode character and its succeeding combining characters, if any.
Split the text into an array of subtexts. The separator can be a text or pattern.
Dice the text into an array of subtexts of a given length.
Make a new empty blob.
Make a new empty blob with a specific initial capacity in bits.
Make a new blob of a given length whose content is random. The random parameter is a random generator function.
Make a copy of all or part of a blob. The default of from is 0
. The default of to is the length(blob).
if value = 0 \/ value = false \/ value = "false" return false if value = 1 \/ value = true \/ value = "true" return true fail
The result will be 1
or 0
.
number(number)
The number is returned.
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 160o  base 80b  base 2otherwise 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
Copy.
Select. Make a new record containing only the fields that are named by the array_of_keys.
Set. Make a record using the array as the source of the keys. Each field value is true
.
Value Set. Make a record using the array as the source of the keys. Each field value is value.
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.
Convert an array of codepoints into a text.
Join an array of texts into a single text. The separator text is inserted between each piece. The default is empty text.
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 zerofill (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  
s 
space  3  space 

u 
underbar  _ underbar 

d 
decimal  2  , comma 

v 
comma  , 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 bye
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.
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 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"
Return the text.
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)
.
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)
.
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
The sensory functions end with ?
question mark. They always return a logical.
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
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
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
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
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
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.
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
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
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
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
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
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
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
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
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
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
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
Is this a worker?
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
If the value is a text, it returns the first character. If the value is a nonnegative 32bit integer, it returns the character from that codeunit. Otherwise, it returns the empty string.
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("" ©2009"") # result is «" ©2009"»
fraction(number
)
The fraction
function returns the fractional part of a number It returns null
for nonnumbers.
integer(number
)
The integer
function returns the integer part. It returns null
for nonnumbers.
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
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"
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)
.
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. 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
:
length(
array)
is 0
, then it returns null
. length(
array)
is 1, then it returns array[0]
.length(
array)
is 2, it returns function(
array[0],
array[1])
. length(
array)
is 3, it returns function(
function(
array[0],
array[1])
, array[2])
. If initial is not null
:
length(
array)
is 0
, then it returns initial. length(
array)
is 1, then it returns function(intial, array[0])
.length(
array)
is 2, it returns function(function(initial,
array[0]),
array[1])
. length(
array)
is 3, it returns function(
function(function(intial,
array[0]),
array[1]),
array[2])
. 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
, 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.
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 leftmost 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"} # ]
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"
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.
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 nonnegative
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 caseinsensitive.
Example:
def a: "vorpal" def b: "VORPAL" set result: ƒ=(a, b) # result is false set result: ƒ=(a, b, true) # result is true
≠
not equalsThe 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.
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
.
ƒ~
concatsThe concats function can take two or three arguments. The optional third argument is the character to be inserted between the first and second.