std/text/lib

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

Whether the character is a letter. Exact for ASCII, and by the division Latin-1 itself makes above it.

Whether the character is whitespace: the ASCII ones, plus the White_Space code points a text really carries.

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: one code point in, one code point out, over ASCII, over the letters of Latin-1 and over the one pair that reaches out of it (ÿ to Ÿ). 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 the mapping does not cover.

Upper-casing a text character by character is therefore not the same as a full Unicode mapping, and is what String.toUpperCase does today.

The same character in lower case, or itself where there is none. 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.

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: Char.toUpperCase for every character, and nothing more.

Every pair of that mapping needs as many bytes as the character it came from, so the result is exactly as long as the text. A full Unicode mapping may make a text longer (ß becomes SS), and this one therefore leaves such a character alone.

The text in lower case: Char.toLowerCase for every character. The mirror of String.toUpperCase.

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.