std/text/lib

Whether the character is a decimal digit: 0 to 9, and nothing else.

Whether the character is a letter: its general category in the Unicode Character Database is Lu, Ll, Lt, Lm or Lo. Digits, marks, symbols and punctuation are not letters, and neither is a code point nothing is assigned to.

Whether the character has the Unicode property White_Space: the ASCII ones, the line and paragraph separators, the no-break space and the spaces of every width, the ideographic space included. The zero width space is not one.

The number of bytes of the character in UTF-8 (1 to 4): what it adds to an offset into a String.

The same character in upper case, or itself where there is no single upper-case code point for it.

This is the simple case mapping of UnicodeData.txt: one code point in, one code point out, for every script that has a case (Latin, Greek, Cyrillic, Armenian, Georgian, Deseret and the rest). So ß is answered unchanged - its upper case is SS, which is two code points and does not fit a Char - and so is every code point that has no upper case. A titlecase letter such as Dž goes to its capital DŽ.

Upper-casing a text character by character is therefore not the same as the full conversion String.toUpperCase does: ß becomes SS there, and a capital sigma lower-cases to ς or σ by the word it stands in.

The same character in lower case, or itself where there is none: the simple mapping, the mirror of Char.toUpperCase.

'A': inside of another value a character is written in single quotes, with escapes.

The order of two positions in one text: the earlier one first.

The byte offset, which is what a position is and what a message about one names.

String.from(characters), characters.to<String>().

Ordinary TorbScript, and it cannot be a function of the runtime for the same reason ArrayList.from cannot be one: value is a trait-typed Iterate of the program, so reading it means calling iterate and next through a witness table, which C code cannot do. So it collects the characters and hands them to concatenated: a String is a value, so appending to one in a loop copies everything that is already in it, which is O(n²) in the bytes.

The characters, decoded one at a time: for character in text.chars(). Ordinary TorbScript, see Characters.

The bytes of the UTF-8, in order, as a list of their own: Bytes, which is what a sink, a socket, a file and a digest take. One allocation and one copy of the storage, never a byte at a time; changing the list changes nothing of the text.

It is a list and not a lazy view like String.chars, because almost every caller wants the list. A loop that only reads and must not allocate walks String.byteAt up to String.byteLength instead.

const bytes = "hé".bytes()
print bytes

The character that begins at at, or None at the end. A position is never inside of a character.

The character that begins at this byte offset, or None at and past the end: the byte-level form of String.charAt for a format that counts bytes. An offset inside a character panics like every other bad offset.

The position before the first character.

The position after the last character.

The position after the character that begins at at, or None at the end. O(1).

The position before the character that ends at at, or None at the start. O(1): at most four bytes back.

The position at a byte offset, or None where the offset is past the end or inside of a character: how a number from outside - a file format, an editor, a span of a lexer - becomes a position, checked.

The byte offset of a position: for arithmetic on lines and columns, and for a format that counts bytes.

Every character with the position it begins at: what a scanner walks.

The byte at this offset, or None at and past the end. A byte is never inside anything, so this never panics.

How many bytes the text takes up in UTF-8. There is no shortcut for the number of characters: that means decoding.

Whether the text has no bytes at all. String.isBlank also treats pure whitespace as empty.

"a\nb": inside of another value a string is quoted, with escapes. show() is the text itself.

text[from..to] between two positions of this text. A position of another text that is past the end of this one or inside one of its characters panics, and so does a start after the end.

What an open end means is the receiver's decision (std/core's Bounds says so), and for a text it is its start and its end. An inclusive range (from..=to) takes the character that begins at to as well.

The text the range covers, or None where it would panic - a position past the end or inside of a character, which only a position of another text can be, or a start after the end: the total twin of text[from..to].

const text = "Grüße"
const at = text.indexOf("ß") ?? text.end()
print text.part(text.start()..at)

The bytes from one offset to another. The one form the runtime has, and what slice decides its offsets for.

Whether part occurs anywhere in the text.

Whether the text begins with prefix.

Whether the text ends with suffix.

Where the first occurrence of part begins, or None if it does not occur. An empty part is at the start.

const path = "a/b/c"
if const Some(at) = path.indexOf("/") {
  print path[..at]
}

Where the last occurrence of part begins, or None if it does not occur. An empty part is at the end of the text, which is where a search backwards finds it first.

• String.indexOf - the same search from the front.

The byte offset of the first occurrence of part: String.indexOf for a format that counts bytes.

The byte offset of the last occurrence of part: String.lastIndexOf for a format that counts bytes.

Everything before the first occurrence of part, or None if it does not occur.

Everything after the first occurrence of part, or None if it does not occur.

The text without part at its start, or None where it does not start with it. It cannot panic: what it cuts off is a whole text, so the cut is at a character boundary whatever the text holds.

print("--verbose".withoutPrefix("--") ?? "not an option")

• String.withoutSuffix - the same at the end.
• String.dropping - a number of characters instead of a text.

The text without part at its end, or None where it does not end with it.

print("main.trb".withoutSuffix(".trb") ?? "main")

The text before and after the first occurrence of separator, which is dropped, or None where it does not occur. One search, and no offset to get wrong - Go's strings.Cut.

match "name: Ada".splitOnce(": ") {
  Some(parts) => print "{parts.before} is {parts.after}"
  None => print "no field"
}

• String.split - at every occurrence.
• String.substringBefore, String.substringAfter - one of the two halves.

The text without its first characters characters. Total: a text with fewer characters answers the empty text, and a count of zero or less the whole one, as skip of an Iterate does. O(n) in the count, not in the text.

A character is a Unicode scalar value, a Char of chars().

print "Grüße".dropping(characters: 3)

• String.prefix - the characters this drops.
• String.droppingLast - the same at the end.

The text without its last characters characters: the empty text where it has fewer, the whole one for a count of zero or less. O(n) in the count.

print "Grüße".droppingLast(characters: 2)

The first characters characters of the text: the whole text where it has fewer, the empty one for a count of zero or less, as take of an Iterate does. O(n) in the count.

print "Grüße".prefix(characters: 3)

• String.suffix - the last ones.

The last characters characters of the text: the whole text where it has fewer, the empty one for a count of zero or less. O(n) in the count.

print "Grüße".suffix(characters: 2)

The text with leading and trailing whitespace removed.

The text in upper case, by the full default case conversion of the Unicode standard (section 3.13): the simple mapping of Char.toUpperCase, except where SpecialCasing.txt gives a character more than one code point. So ß becomes SS, ʼn becomes ʼN and ffi becomes FFI, and the result can be longer than the text.

The conversion does not look at a language: there is no Turkish or Lithuanian tailoring, because a String has no locale. Bytes the text has that are no character are copied as they are.

The text in lower case, by the same full default conversion. A capital sigma becomes ς at the end of a word - after a cased letter, and not before another one - and σ everywhere else; İ becomes an i and a combining dot above.

Every occurrence of part, replaced with replacement.

The text cut apart at every occurrence of separator, which is dropped.

The text, written after itself times times: "ab".repeat(3) is "ababab".

When times is negative, and with a text longer than 4 GiB is not supported when the result would be longer than a text can be.

Whether the text is empty or holds nothing but whitespace.

The text cut apart at every \n.