string¶

Strings in Minilang can contain any sequence of bytes, including 0 bytes. Index and find methods however work on UTF-8 characters, byte sequences that are not valid UTF-8 are handled gracefully but the results are probably not very useful.

Every string is also an address so address methods can also be used to work at the byte level if necessary.

Indexing a string starts at 1, with the last character at String:length. Negative indices are counted form the end, -1 is the last character and -String:length is the first character.

When creating a substring, the first index is inclusive and second index is exclusive. The index 0 refers to just beyond the last character and can be used to take a substring to the end of a string.

fun mlstringbuffercount()

TBD

fun mlstringcheckcache()

TBD

meth (Arg₁: any):sha256

TBD

meth (Buffer: string::buffer):append(Value: any)

Appends a representation of Value to Buffer.

meth (Arg₁: string::buffer):append(Arg₂: any, Arg₃: function, ...)

TBD

meth (Arg₁: buffer):put(Arg₂: string::buffer)

TBD

type byte::order < enum

::LittleEndian
::BigEndian

meth (Arg₁: string::buffer):append(Arg₂: decimal)

TBD

meth (N: integer) * (String: string): string

Returns String concatentated N times.

5 * "abc" :> "abcabcabcabcabc"

meth (Codepoint: integer):char: string

Returns a UTF-8 string containing the character with unicode codepoint Codepoint.

meth (Codepoint: integer):utf8: string

Returns a UTF-8 string containing the character with unicode codepoint Codepoint.

meth (Arg₁: string::buffer):append(Arg₂: rational)

TBD

type regex < function

A regular expression.

fun regex(String: string): regex | error

Compiles String as a regular expression. Returns an error if String is not a valid regular expression.

regex("[0-9]+") :> /[0-9]+/
regex("[0-9") :> error("RegexError", "Missing ']'")

meth (Arg₁: regex) != (Arg₂: regex): regex | nil

Returns Arg₂ if Arg₁ != Arg₂ and nil otherwise.

r"[0-9]+" != r"[A-Za-z0-9_]+" :> /[A-Za-z0-9_]+/
r"[A-Za-z0-9_]+" != r"[0-9]+" :> /[0-9]+/
r"[0-9]+" != r"[0-9]+" :> nil

meth (Arg₁: regex) < (Arg₂: regex): regex | nil

Returns Arg₂ if Arg₁ < Arg₂ and nil otherwise.

r"[0-9]+" < r"[A-Za-z0-9_]+" :> /[A-Za-z0-9_]+/
r"[A-Za-z0-9_]+" < r"[0-9]+" :> nil
r"[0-9]+" < r"[0-9]+" :> nil

meth (Arg₁: regex) <= (Arg₂: regex): regex | nil

Returns Arg₂ if Arg₁ <= Arg₂ and nil otherwise.

r"[0-9]+" <= r"[A-Za-z0-9_]+" :> /[A-Za-z0-9_]+/
r"[A-Za-z0-9_]+" <= r"[0-9]+" :> nil
r"[0-9]+" <= r"[0-9]+" :> /[0-9]+/

meth (A: regex) <> (B: regex): integer

Compares A and B lexicographically and returns -1, 0 or 1 respectively. Mainly for using regular expressions as keys in maps.

r"[0-9]+" <> r"[A-Za-z0-9_]+" :> -1
r"[A-Za-z0-9_]+" <> r"[0-9]+" :> 1
r"[0-9]+" <> r"[0-9]+" :> 0

meth (Arg₁: regex) = (Arg₂: regex): regex | nil

Returns Arg₂ if Arg₁ = Arg₂ and nil otherwise.

r"[0-9]+" = r"[A-Za-z0-9_]+" :> nil
r"[A-Za-z0-9_]+" = r"[0-9]+" :> nil
r"[0-9]+" = r"[0-9]+" :> /[0-9]+/

meth (Arg₁: regex) > (Arg₂: regex): regex | nil

Returns Arg₂ if Arg₁ > Arg₂ and nil otherwise.

r"[0-9]+" > r"[A-Za-z0-9_]+" :> nil
r"[A-Za-z0-9_]+" > r"[0-9]+" :> /[0-9]+/
r"[0-9]+" > r"[0-9]+" :> nil

meth (Arg₁: regex) >= (Arg₂: regex): regex | nil

Returns Arg₂ if Arg₁ >= Arg₂ and nil otherwise.

r"[0-9]+" >= r"[A-Za-z0-9_]+" :> nil
r"[A-Za-z0-9_]+" >= r"[0-9]+" :> /[0-9]+/
r"[0-9]+" >= r"[0-9]+" :> /[0-9]+/

meth (Regex: regex):pattern: string

Returns the pattern used to create Regex.

r"[0-9]+":pattern :> "[0-9]+"

meth (Buffer: string::buffer):append(Value: regex)

Appends a representation of Value to Buffer.

type string < address, sequence

A string of characters in UTF-8 encoding.

fun string(Value: any): string

Returns a representation of Value as a string.

string(100) :> "100"
string(nil) :> "nil"
string("Hello world!\n") :> "Hello world!\n"
string([1, 2, 3]) :> "[1, 2, 3]"

fun regex::escape(String: string): string

Escapes characters in String that are treated specially in regular expressions.

regex::escape("Word (?)\n") :> "Word \\(\\?\\)\\n"

fun string::escape(String: string): string

Escapes characters in String.

string::escape("\'Hello\nworld!\'")
:> "\\\'Hello\\nworld!\\\'"

meth (Arg₁: string) != (Arg₂: string): string | nil

Returns Arg₂ if Arg₁ != Arg₂ and nil otherwise.

"Hello" != "World" :> "World"
"World" != "Hello" :> "Hello"
"Hello" != "Hello" :> nil
"abcd" != "abc" :> "abc"
"abc" != "abcd" :> "abcd"

meth (String: string) !? (Pattern: regex): string | nil

Returns String if it does not match Pattern and nil otherwise.

"2022-03-08" !? r"([0-9]+)[/-]([0-9]+)[/-]([0-9]+)" :> nil
"Not a date" !? r"([0-9]+)[/-]([0-9]+)[/-]([0-9]+)"
:> "Not a date"

meth (String: string) % (Pattern: regex): tuple[string] | nil

Matches String with Pattern returning a tuple of the matched components, or nil if the pattern does not match.

"2022-03-08" % r"([0-9]+)[/-]([0-9]+)[/-]([0-9]+)"
:> (2022-03-08, 2022, 03, 08)
"Not a date" % r"([0-9]+)[/-]([0-9]+)[/-]([0-9]+)" :> nil

meth (String: string) */ (Pattern: regex): tuple[string, string]

Splits String at the last occurence of Pattern and returns the two substrings in a tuple.

"2022/03/08" */ r"[/-]" :> (2022/03, 08)
"2022-03-08" */ r"[/-]" :> (2022-03, 08)

meth (String: string) */ (Pattern: string): tuple[string, string]

Splits String at the last occurence of Pattern and returns the two substrings in a tuple.

"2022/03/08" */ "/" :> (2022/03, 08)

meth (A: string) + (B: string): string

Returns A and B concatentated.

"Hello" + " " + "world" :> "Hello world"

meth (Start: string) .. (Limit: string): string::interval

Returns a interval from the first character of Start to the first character of Limit (inclusive).

meth (String: string) / (Pattern: string): list

Returns a list of substrings from String by splitting around occurences of Pattern. Adjacent occurences of Pattern do not create empty strings.

"The cat snored  as he slept" / " "
:> ["The", "cat", "snored", "as", "he", "slept"]
"2022/03/08" / "/" :> ["2022", "03", "08"]

meth (String: string) /* (Pattern: regex): tuple[string, string]

Splits String at the first occurence of Pattern and returns the two substrings in a tuple.

"2022/03/08" /* r"[/-]" :> (2022, 03/08)
"2022-03-08" /* r"[/-]" :> (2022, 03-08)

meth (String: string) /* (Pattern: string): tuple[string, string]

Splits String at the first occurence of Pattern and returns the two substrings in a tuple.

"2022/03/08" /* "/" :> (2022, 03/08)

meth (Arg₁: string) < (Arg₂: string): string | nil

Returns Arg₂ if Arg₁ < Arg₂ and nil otherwise.

"Hello" < "World" :> "World"
"World" < "Hello" :> nil
"Hello" < "Hello" :> nil
"abcd" < "abc" :> nil
"abc" < "abcd" :> "abcd"

meth (Arg₁: string) <= (Arg₂: string): string | nil

Returns Arg₂ if Arg₁ <= Arg₂ and nil otherwise.

"Hello" <= "World" :> "World"
"World" <= "Hello" :> nil
"Hello" <= "Hello" :> "Hello"
"abcd" <= "abc" :> nil
"abc" <= "abcd" :> "abcd"

meth (A: string) <> (B: string): integer

Compares A and B lexicographically and returns -1, 0 or 1 respectively.

"Hello" <> "World" :> -1
"World" <> "Hello" :> 1
"Hello" <> "Hello" :> 0
"abcd" <> "abc" :> 1
"abc" <> "abcd" :> -1

meth (Arg₁: string) = (Arg₂: string): string | nil

Returns Arg₂ if Arg₁ = Arg₂ and nil otherwise.

"Hello" = "World" :> nil
"World" = "Hello" :> nil
"Hello" = "Hello" :> "Hello"
"abcd" = "abc" :> nil
"abc" = "abcd" :> nil

meth (Arg₁: string) > (Arg₂: string): string | nil

Returns Arg₂ if Arg₁ > Arg₂ and nil otherwise.

"Hello" > "World" :> nil
"World" > "Hello" :> "Hello"
"Hello" > "Hello" :> nil
"abcd" > "abc" :> "abc"
"abc" > "abcd" :> nil

meth (Arg₁: string) >= (Arg₂: string): string | nil

Returns Arg₂ if Arg₁ >= Arg₂ and nil otherwise.

"Hello" >= "World" :> nil
"World" >= "Hello" :> "Hello"
"Hello" >= "Hello" :> "Hello"
"abcd" >= "abc" :> "abc"
"abc" >= "abcd" :> nil

meth (String: string) ? (Pattern: regex): string | nil

Returns String if it matches Pattern and nil otherwise.

"2022-03-08" ? r"([0-9]+)[/-]([0-9]+)[/-]([0-9]+)"
:> "2022-03-08"
"Not a date" ? r"([0-9]+)[/-]([0-9]+)[/-]([0-9]+)" :> nil

meth (String: string)[Interval: integer::interval]: string

Returns the substring of String corresponding to Interval inclusively.

meth (String: string)[Index: integer]: string | nil

Returns the substring of String of length 1 at Index.

let S := "λ:😀 → 😺"
map(-7 .. 7 => (2, 2 -> S[_]))
:> {-7 is "λ", -6 is ":", -5 is "😀", -4 is " ", -3 is "→", -2 is " ", -1 is "😺", 0, 1 is "λ", 2 is ":", 3 is "😀", 4 is " ", 5 is "→", 6 is " ", 7 is "😺"}

meth (String: string)[Start: integer, End: integer]: string | nil

Returns the substring of String from Start to End - 1 inclusively.

meth (String: string):after(Delimiter: string): string | nil

Returns the portion of String after the 1st occurence of Delimiter, or nil if no occurence if found.

"2022/03/08":after("/") :> "03/08"

meth (String: string):after(Delimiter: string, N: integer): string | nil

Returns the portion of String after the N-th occurence of Delimiter, or nil if no N-th occurence if found. If N < 0 then occurences are counted from the end of String.

"2022/03/08":after("/", 2) :> "08"

meth (String: string):before(Delimiter: string): string | nil

Returns the portion of String before the 1st occurence of Delimiter, or nil if no occurence if found.

"2022/03/08":before("/") :> "2022"

meth (String: string):before(Delimiter: string, N: integer): string | nil

Returns the portion of String before the N-th occurence of Delimiter, or nil if no N-th occurence if found. If N < 0 then occurences are counted from the end of String.

"2022/03/08":before("/", 2) :> "2022/03"

meth (Arg₁: string):cname

TBD

meth (String: string):code: integer

Returns the unicode codepoint of the first UTF-8 character of String.

"A":code :> 65
"😀️":code :> 128512

meth (Haystack: string):contains(Pattern: regex): string | nil

Returns the Haystack if it contains Pattern or nil otherwise.

"The cat snored as he slept":contains(r"[a-z]{3}")
:> "The cat snored as he slept"
"The cat snored as he slept":contains(r"[0-9]+") :> nil

meth (Haystack: string):contains(Needle: string): string | nil

Returns the Haystack if it contains Pattern or nil otherwise.

"The cat snored as he slept":contains("cat")
:> "The cat snored as he slept"
"The cat snored as he slept":contains("dog") :> nil

meth (String: string):count: integer

Returns the number of UTF-8 characters in String. Use :size to get the number of bytes.

"Hello world":count :> 11
"Hello world":size :> 11
"λ:😀 → 😺":count :> 7
"λ:😀 → 😺":size :> 16

meth (String: string):ctype: string::ctype

Returns the unicode type of the first character of String.

map("To €2 á\n" => (2, 2 -> :ctype))
:> {"T" is Lu, "o" is Ll, " " is Zs, "€" is Sc, "2" is Nd, "á" is Ll, "\n" is Cc}

meth (String: string):ends(Suffix: string): string | nil

Returns String if it ends with Suffix and nil otherwise.

"Hello world":ends("world") :> "Hello world"
"Hello world":ends("cake") :> nil

meth (String: string):escape: string

Returns String with white space, quotes and backslashes replaced by escape sequences.

"\t\"Text\"\r\n":escape :> "\\t\\\"Text\\\"\\r\\n"

meth (Haystack: string):find(Pattern: regex): integer | nil

Returns the index of the first occurence of Pattern in Haystack, or nil if no occurence is found.

"The cat snored as he slept":find(r"[a-z]{3}") :> 5
"The cat snored as he slept":find(r"[0-9]+") :> nil

meth (Haystack: string):find(Pattern: regex, Start: integer): integer | nil

Returns the index of the first occurence of Pattern in Haystack at or after Start, or nil if no occurence is found.

"The cat snored as he slept":find(r"s[a-z]+", 1) :> 9
"The cat snored as he slept":find(r"s[a-z]+", 10) :> 22
"The cat snored as he slept":find(r"s[a-z]+", -6) :> 22

meth (Haystack: string):find(Needle: string): integer | nil

Returns the index of the first occurence of Needle in Haystack, or nil if no occurence is found.

"The cat snored as he slept":find("cat") :> 5
"The cat snored as he slept":find("dog") :> nil

meth (Haystack: string):find(Needle: string, Start: integer): integer | nil

Returns the index of the first occurence of Needle in Haystack at or after Start, or nil if no occurence is found.

"The cat snored as he slept":find("s", 1) :> 9
"The cat snored as he slept":find("s", 10) :> 17
"The cat snored as he slept":find("s", -6) :> 22

meth (Haystack: string):find2(Pattern: regex): tuple[integer, string] | nil

Returns (Index, Match) where Index is the first occurence of Pattern in Haystack, or nil if no occurence is found.

"The cat snored as he slept":find2(r"[a-z]{3}")
:> (5, cat)
"The cat snored as he slept":find2(r"[0-9]+") :> nil

meth (Haystack: string):find2(Pattern: regex, Start: integer): tuple[integer, string] | nil

Returns (Index, Match) where Index is the first occurence of Pattern in Haystack at or after Start, or nil if no occurence is found.

"The cat snored as he slept":find2(r"s[a-z]+", 1)
:> (9, snored)
"The cat snored as he slept":find2(r"s[a-z]+", 10)
:> (22, slept)
"The cat snored as he slept":find2(r"s[a-z]+", -6)
:> (22, slept)

meth (Haystack: string):find2(Pattern: regex, Start: tuple::integer::string): tuple[integer, string] | nil

Returns (Index, Match) where Index is the first occurence of Pattern in Haystack at or after Start, or nil if no occurence is found.

"The cat snored as he slept":find2(r"s[a-z]+", 1)
:> (9, snored)
"The cat snored as he slept":find2(r"s[a-z]+", 10)
:> (22, slept)
"The cat snored as he slept":find2(r"s[a-z]+", -6)
:> (22, slept)

meth (Haystack: string):find2(Needle: string): tuple[integer, string] | nil

Returns (Index, Needle) where Index is the first occurence of Needle in Haystack, or nil if no occurence is found.

"The cat snored as he slept":find2("cat") :> (5, cat)
"The cat snored as he slept":find2("dog") :> nil

meth (Haystack: string):find2(Needle: string, Start: integer): tuple[integer, string] | nil

Returns (Index, Needle) where Index is the first occurence of Needle in Haystack at or after Start, or nil if no occurence is found.

"The cat snored as he slept":find2("s", 1) :> (9, s)
"The cat snored as he slept":find2("s", 10) :> (17, s)
"The cat snored as he slept":find2("s", -6) :> (22, s)

meth (Haystack: string):find2(Needle: string, Start: tuple::integer::string): tuple[integer, string] | nil

Returns (Index, Needle) where Index is the first occurence of Needle in Haystack at or after Start, or nil if no occurence is found.

"The cat snored as he slept":find2("s", 1) :> (9, s)
"The cat snored as he slept":find2("s", 10) :> (17, s)
"The cat snored as he slept":find2("s", -6) :> (22, s)

meth (String: string):length: integer

Returns the number of UTF-8 characters in String. Use :size to get the number of bytes.

"Hello world":length :> 11
"Hello world":size :> 11
"λ:😀 → 😺":length :> 7
"λ:😀 → 😺":size :> 16

meth (String: string):limit(Length: integer): string

Returns the prefix of String limited to Length.

"Hello world":limit(5) :> "Hello"
"Cake":limit(5) :> "Cake"

meth (String: string):lower: string

Returns String with each character converted to lower case.

"Hello World":lower :> "hello world"

meth (String: string):ltrim: string

Returns a copy of String with characters in Chars removed from the start.

" \t Hello \n":ltrim :> "Hello \n"

meth (String: string):ltrim(Chars: string): string

Returns a copy of String with characters in Chars removed from the start.

" \t Hello \n":trim(" \n") :> "\t Hello"

meth (A: string):max(B: string): integer

Returns max(A, B)

"Hello":max("World") :> "World"
"World":max("Hello") :> "World"
"abcd":max("abc") :> "abcd"
"abc":max("abcd") :> "abcd"

meth (A: string):min(B: string): integer

Returns min(A, B)

"Hello":min("World") :> "Hello"
"World":min("Hello") :> "Hello"
"abcd":min("abc") :> "abc"
"abc":min("abcd") :> "abc"

meth (String: string):normalize(Norm: string::norm): string

Returns a normalized copy of String using the normalizer specified by Norm.

let S := "𝕥𝕖𝕩𝕥" :> "𝕥𝕖𝕩𝕥"
S:normalize(string::norm::NFD) :> "𝕥𝕖𝕩𝕥"

meth (String: string):offset(Index: integer): integer

Returns the byte position of the Index-th character of String.

let S := "λ:😀 → 😺"
list(1 .. S:length, S:offset(_))
:> [0, 2, 3, 7, 8, 11, 12]

meth (String: string):precount: integer

Returns the number of UTF-8 characters in String. Use :size to get the number of bytes.

"Hello world":count :> 11
"Hello world":size :> 11
"λ:😀 → 😺":count :> 7
"λ:😀 → 😺":size :> 16

meth (String: string):replace(I: integer, Fn: function): string

Returns a copy of String with the String[I] is replaced by Fn(String[I]).

"hello world":replace(1, :upper) :> "Hello world"

meth (String: string):replace(I: integer, Fn: integer, Arg₄: function): string

Returns a copy of String with the String[I, J] is replaced by Fn(String[I, J]).

"hello world":replace(1, 6, :upper) :> "HELLO world"

meth (String: string):replace(I: integer, J: integer, Replacement: string): string

Returns a copy of String with the String[I, J] is replaced by Replacement.

"Hello world":replace(1, 6, "Goodbye") :> "Goodbye world"
"Hello world":replace(-6, 0, ", how are you?")
:> "Hello, how are you?"

meth (String: string):replace(I: integer, Replacement: string): string

Returns a copy of String with the String[I] is replaced by Replacement.

"Hello world":replace(6, "_") :> "Hello_world"

meth (String: string):replace(Replacements: map): string

Each key in Replacements can be either a string or a regex. Each value in Replacements can be either a string or a function. Returns a copy of String with each matching string or regex from Replacements replaced with the corresponding value. Functions are called with the matched string or regex subpatterns.

"the dog snored as he slept":replace({
   r" ([a-z])" is fun(Match, A) '-{A:upper}',
   "nor" is "narl"
}) :> "the-Dog-Snarled-As-He-Slept"

meth (String: string):replace(Pattern: regex, Fn: function): string

Returns a copy of String with each occurence of Pattern replaced by Fn(Match, Sub₁, ..., Subₙ) where Match is the actual matched text and Subᵢ are the matched subpatterns.

"the cat snored as he slept":replace(r" ([a-z])", fun(Match, A) '-{A:upper}')
:> "the-Cat-Snored-As-He-Slept"

meth (String: string):replace(Pattern: regex, Replacement: string): string

Returns a copy of String with each occurence of Pattern replaced by Replacement.

"Hello world":replace(r"l+", "bb") :> "Hebbo worbbd"

meth (String: string):replace(Pattern: string, Replacement: string): string

Returns a copy of String with each occurence of Pattern replaced by Replacement.

"Hello world":replace("l", "bb") :> "Hebbbbo worbbd"

meth (String: string):replace2(Replacements: map): string

Each key in Replacements can be either a string or a regex. Each value in Replacements can be either a string or a function. Returns a copy of String with each matching string or regex from Replacements replaced with the corresponding value. Functions are called with the matched string or regex subpatterns.

"the dog snored as he slept":replace2({
   r" ([a-z])" is fun(Match, A) '-{A:upper}',
   "nor" is "narl"
}) :> (the-Dog-Snarled-As-He-Slept, 6)

meth (String: string):replace2(Pattern: regex, Replacement: string): string

Returns a copy of String with each occurence of Pattern replaced by Replacement.

"Hello world":replace2(r"l+", "bb") :> (Hebbo worbbd, 2)

meth (String: string):replace2(Pattern: string, Replacement: string): string

Returns a copy of String with each occurence of Pattern replaced by Replacement.

"Hello world":replace2("l", "bb") :> (Hebbbbo worbbd, 3)

meth (String: string):reverse: string

Returns a string with the characters in String reversed.

"Hello world":reverse :> "dlrow olleH"

meth (String: string):rtrim: string

Returns a copy of String with characters in Chars removed from the end.

" \t Hello \n":rtrim :> " \t Hello"

meth (String: string):rtrim(Chars: string): string

Returns a copy of String with characters in Chars removed from the end.

" \t Hello \n":rtrim(" \n") :> " \t Hello"

meth (String: string):starts(Pattern: regex): string | nil

Returns String if it starts with Pattern and nil otherwise.

"Hello world":starts(r"[A-Z]") :> "Hello world"
"Hello world":starts(r"[0-9]") :> nil

meth (String: string):starts(Prefix: string): string | nil

Returns String if it starts with Prefix and nil otherwise.

"Hello world":starts("Hello") :> "Hello world"
"Hello world":starts("cake") :> nil

meth stringtable(Arg₁: string)

TBD

meth (String: string):title: string

Returns String with the first character and each character after whitespace converted to upper case and each other case converted to lower case.

"hello world":title :> "Hello World"
"HELLO WORLD":title :> "Hello World"

meth (String: string):trim: string

Returns a copy of String with whitespace removed from both ends.

" \t Hello \n":trim :> "Hello"

meth (String: string) / (Pattern: regex, Index: integer): list

Returns a list of substrings from String by splitting around occurences of Pattern. Only the Index subgroup matches are removed from the output substrings.

"<A>-<B>-<C>" / (r">(-)<", 1) :> ["<A>", "<B>", "<C>"]

meth (String: string) / (Pattern: regex): list

Returns a list of substrings from String by splitting around occurences of Pattern. If Pattern contains subgroups then only the subgroup matches are removed from the output substrings.

"2022/03/08" / r"[/-]" :> ["2022", "03", "08"]
"2022-03-08" / r"[/-]" :> ["2022", "03", "08"]

meth (String: string):trim(Chars: string): string

Returns a copy of String with characters in Chars removed from both ends.

" \t Hello \n":trim(" \n") :> "\t Hello"

meth (String: string):upper: string

Returns String with each character converted to upper case.

"Hello World":upper :> "HELLO WORLD"

meth (Arg₁: string):utf8

TBD

meth (A: string) ~ (B: string): integer

Returns the edit distance between A and B.

"cake" ~ "cat" :> 2
"yell" ~ "hello" :> 2
"say" ~ "goodbye" :> 6
"goodbye" ~ "say" :> 6
"λ:😀 → Y" ~ "λ:X → 😺" :> 2

meth (A: string) ~> (B: string): integer

Returns an asymmetric edit distance from A to B.

"cake" ~> "cat" :> 1
"yell" ~> "hello" :> 2
"say" ~> "goodbye" :> 6
"goodbye" ~> "say" :> 3
"λ:😀 → Y" ~> "λ:X → 😺" :> 4

meth (Buffer: string::buffer):append(Value: string)

Appends Value to Buffer.

meth (Arg₁: string::buffer):append(Arg₂: string, Arg₃: string)

TBD

type string::buffer

A string buffer that automatically grows and shrinks as required.

meth string::buffer(): string::buffer

Returns a new string::buffer

meth string::buffer(Arg₁: address): string::buffer

Returns a new string::buffer

meth (Buffer: string::buffer):get: string

Returns the contents of Buffer as a string and clears Buffer. .. deprecated:: 2.5.0

Use Buffer:rest instead.

let B := string::buffer()
B:write("Hello world")
B:get :> "Hello world"
B:get :> ""

meth (Arg₁: string::buffer):grow(Arg₂: sequence)

TBD

meth (Buffer: string::buffer):length: integer

Returns the number of bytes currently available in Buffer.

let B := string::buffer()
B:write("Hello world")
B:length :> 11

meth (Buffer: string::buffer):read16: integer

Reads a signed 16-bit value from Buffer.

let B := string::buffer("Hello world!\n")
:> <string::buffer>
B:read16 :> 25928

meth (Buffer: string::buffer):read16(Arg₂: byte::order): integer

Reads a signed 16-bit value from Buffer.

let B := string::buffer("Hello world!\n")
:> <string::buffer>
B:readu16(address::LE)
:> error("MethodError", "no method found for readu16(string::buffer, address::byteorder)")
B:readu16(address::BE)
:> error("MethodError", "no method found for readu16(string::buffer, address::byteorder)")

meth (Buffer: string::buffer):read16(Arg₂: byte::order): integer

Reads a signed 16-bit value from Buffer.

let B := string::buffer("Hello world!\n")
:> <string::buffer>
B:read16(address::LE) :> 25928
B:read16(address::BE) :> 27756

meth (Buffer: string::buffer):read32: integer

Reads a signed 32-bit value from Buffer.

let B := string::buffer("Hello world!\n")
:> <string::buffer>
B:read32 :> 1819043144

meth (Buffer: string::buffer):read32(Arg₂: byte::order): integer

Reads a signed 32-bit value from Buffer.

let B := string::buffer("Hello world!\n")
:> <string::buffer>
B:read32(address::LE) :> 1819043144
B:read32(address::BE) :> 1864398703

meth (Buffer: string::buffer):read32(Arg₂: byte::order): integer

Reads a signed 32-bit value from Buffer.

let B := string::buffer("Hello world!\n")
:> <string::buffer>
B:readu32(address::LE)
:> error("MethodError", "no method found for readu32(string::buffer, address::byteorder)")
B:readu32(address::BE)
:> error("MethodError", "no method found for readu32(string::buffer, address::byteorder)")

meth (Buffer: string::buffer):read64: integer

Reads a signed 64-bit value from Buffer.

let B := string::buffer("Hello world!\n")
:> <string::buffer>
B:read64 :> 8031924123371070792

meth (Buffer: string::buffer):read64(Arg₂: byte::order): integer

Reads a signed 64-bit value from Buffer.

let B := string::buffer("Hello world!\n")
:> <string::buffer>
B:readu64(address::LE)
:> error("MethodError", "no method found for readu64(string::buffer, address::byteorder)")
B:readu64(address::BE)
:> error("MethodError", "no method found for readu64(string::buffer, address::byteorder)")

meth (Buffer: string::buffer):read64(Arg₂: byte::order): integer

Reads a signed 64-bit value from Buffer.

let B := string::buffer("Hello world!\n")
:> <string::buffer>
B:read64(address::LE) :> 8031924123371070792
B:read64(address::BE) :> nil

meth (Buffer: string::buffer):read8: integer

Reads a signed 8-bit value from Buffer.

let B := string::buffer("\xCC") :> <string::buffer>
B:read8 :> -52

meth (Buffer: string::buffer):readu16: integer

Reads a signed 16-bit value from Buffer.

let B := string::buffer("Hello world!\n")
:> <string::buffer>
B:readu16 :> 25928

meth (Buffer: string::buffer):readu32: integer

Reads a signed 32-bit value from Buffer.

let B := string::buffer("Hello world!\n")
:> <string::buffer>
B:readu32 :> 1819043144

meth (Buffer: string::buffer):readu64: integer

Reads a signed 64-bit value from Buffer.

let B := string::buffer("Hello world!\n")
:> <string::buffer>
B:readu64 :> 8031924123371070792

meth (Buffer: string::buffer):readu8: integer

Reads a signed 8-bit value from Buffer.

let B := string::buffer("\xCC") :> <string::buffer>
B:readu8 :> 204

meth (Buffer: string::buffer):rest: string

Returns the contents of Buffer as a string and clears Buffer.

let B := string::buffer()
B:write("Hello world")
B:rest :> "Hello world"
B:rest :> ""

meth (Buffer: string::buffer):unread(Bytes: address): string::buffer

Inserts the contents of Bytes at the start of Buffer.

meth (Buffer: string::buffer):write(Value₁, : any, ...): integer

Writes each Valueᵢ in turn to Buffer.

let B := string::buffer()
B:write("1 + 1 = ", 1 + 1)
B:rest :> "1 + 1 = 2"

meth (Buffer: string::buffer):write16(Value: integer): buffer

Writes Value to Buffer as an 16-bit signed value. Uses the platform byte order.

let B := string::buffer() :> <string::buffer>
B:write16(12345) :> <string::buffer>
B:rest :> "90"

meth (Buffer: string::buffer):write16(Value: integer, Arg₃: byte::order): buffer

Writes Value to Buffer as an 16-bit signed value. Uses the given byte order.

let B := string::buffer() :> <string::buffer>
B:write16(12345, address::LE) :> <string::buffer>
B:rest :> "90"
B:write16(12345, address::BE) :> <string::buffer>
B:rest :> "09"

meth (Buffer: string::buffer):write32(Value: integer): buffer

Writes Value to Buffer as an 32-bit signed value. Uses the platform byte order.

let B := string::buffer() :> <string::buffer>
B:write32(12345) :> <string::buffer>
B:rest :> "90\0\0"

meth (Buffer: string::buffer):write32(Value: integer, Arg₃: byte::order): buffer

Writes Value to Buffer as an 32-bit signed value. Uses the given byte order.

let B := string::buffer() :> <string::buffer>
B:write32(12345, address::LE) :> <string::buffer>
B:rest :> "90\0\0"
B:write32(12345, address::BE) :> <string::buffer>
B:rest :> "\0\009"

def MLStringProperties: string::properties

TBD

meth (Buffer: string::buffer):write64(Value: integer): buffer

Writes Value to Buffer as an 64-bit signed value. Uses the platform byte order.

let B := string::buffer() :> <string::buffer>
B:write64(12345) :> <string::buffer>
B:rest :> "90\0\0\0\0\0\0"

meth (Buffer: string::buffer):write64(Value: integer, Arg₃: byte::order): buffer

Writes Value to Buffer as an 64-bit signed value. Uses the given byte order.

let B := string::buffer() :> <string::buffer>
B:write64(12345, address::LE) :> <string::buffer>
B:rest :> "90\0\0\0\0\0\0"
B:write64(12345, address::BE) :> <string::buffer>
B:rest :> "\0\0\0\0\0\009"

meth (Buffer: string::buffer):write8(Value: integer): buffer

Write Value to Buffer as an 8-bit signed value.

let B := string::buffer() :> <string::buffer>
B:write8(120) :> <string::buffer>
B:rest :> "x"

meth (Buffer: string::buffer):writeu16(Value: integer): buffer

Writes Value to Buffer as an 16-bit unsigned value. Uses the platform byte order.

let B := string::buffer() :> <string::buffer>
B:writeu16(12345) :> <string::buffer>
B:rest :> "90"

meth (Buffer: string::buffer):writeu16(Value: integer, Arg₃: byte::order): buffer

Writes Value to Buffer as an 16-bit unsigned value. Uses the given byte order.

let B := string::buffer() :> <string::buffer>
B:writeu16(12345, address::LE) :> <string::buffer>
B:rest :> "90"
B:writeu16(12345, address::BE) :> <string::buffer>
B:rest :> "09"

meth (Buffer: string::buffer):writeu32(Value: integer): buffer

Writes Value to Buffer as an 32-bit unsigned value. Uses the platform byte order.

let B := string::buffer() :> <string::buffer>
B:writeu32(12345) :> <string::buffer>
B:rest :> "90\0\0"

meth (Buffer: string::buffer):writeu32(Value: integer, Arg₃: byte::order): buffer

Writes Value to Buffer as an 32-bit unsigned value. Uses the given byte order.

let B := string::buffer() :> <string::buffer>
B:writeu32(12345, address::LE) :> <string::buffer>
B:rest :> "90\0\0"
B:writeu32(12345, address::BE) :> <string::buffer>
B:rest :> "\0\009"

meth (Buffer: string::buffer):writeu64(Value: integer): buffer

Writes Value to Buffer as an 64-bit unsigned value. Uses the platform byte order.

let B := string::buffer() :> <string::buffer>
B:writeu64(12345) :> <string::buffer>
B:rest :> "90\0\0\0\0\0\0"

meth (Buffer: string::buffer):writeu64(Value: integer, Arg₃: byte::order): buffer

Writes Value to Buffer as an 64-bit unsigned value. Uses the given byte order.

let B := string::buffer() :> <string::buffer>
B:writeu64(12345, address::LE) :> <string::buffer>
B:rest :> "90\0\0\0\0\0\0"
B:writeu64(12345, address::BE) :> <string::buffer>
B:rest :> "\0\0\0\0\0\009"

meth (Buffer: string::buffer):writeu8(Value: integer): buffer

Write Value to Buffer as an 8-bit signed value.

let B := string::buffer() :> <string::buffer>
B:writeu8(120) :> <string::buffer>
B:rest :> "x"

type string::charset < sequence

TBD

meth (Arg₁: string::charset)[Arg₂: integer]

TBD

meth (Arg₁: string::charset):count

TBD

type string::ctype < enum

::Cn - General Other Types
::Lu - Uppercase Letter
::Ll - Lowercase Letter
::Lt - Titlecase Letter
::Lm - Modifier Letter
::Lo - Other Letter
::Mn - Non Spacing Mark
::Me - Enclosing Mark
::Mc - Combining Spacing Mark
::Nd - Decimal Digit Number
::Nl - Letter Number
::No - Other Number
::Zs - Space Separator
::Zl - Line Separator
::Zp - Paragraph Separator
::Cc - Control Char
::Cf - Format Char
::Co - Private Use Char
::Cs - Surrogate
::Pd - Dash Punctuation
::Ps - Start Punctuation
::Pe - End Punctuation
::Pc - Connector Punctuation
::Po - Other Punctuation
::Sm - Math Symbol
::Sc - Currency Symbol
::Sk - Modifier Symbol
::So - Other Symbol
::Pi - Initial Punctuation
::Pf - Final Punctuation

type string::interval < integer::interval

TBD

type string::norm < enum

::NFC
::NFD
::NFKC
::NFKD

meth (Arg₁: string::properties) :: (Arg₂: string)

TBD

type string::property < sequence

TBD

meth (Arg₁: string::property) :: (Arg₂: string)

TBD

meth (Arg₁: string::property)[Arg₂: integer]

TBD

meth (Arg₁: string::property)[Arg₂: string]

TBD

meth (Arg₁: string::property):max

TBD

meth (Arg₁: string::property):min

TBD

meth stringcharset(Arg₁: string::property::value)

TBD

meth (Arg₁: string::buffer):append(Arg₂: string::property::value)

TBD

type string::table

TBD

meth (Arg₁: string::table):describe

TBD

meth (Arg₁: string::table):splice(Arg₂: integer, Arg₃: integer, Arg₄: string)

TBD

meth (Arg₁: string::buffer):append(Arg₂: string::table)

TBD

meth stringtable()

TBD

fun string::switch(Cases: string|regex, ...)

Implements switch for string values. Case values must be strings or regular expressions.

for Pet in ["cat", "dog", "mouse", "fox"] do
   switch Pet: string
      case "cat" do
         print("Meow!\n")
      case "dog" do
         print("Woof!\n")
      case "mouse" do
         print("Squeak!\n")
      else
         print("???!")
      end
end :> nil

Meow!
Woof!
Squeak!
???!

meth (Arg₁: visitor):const(Arg₂: buffer)

TBD

meth (Arg₁: visitor):copy(Arg₂: buffer)

TBD