std/unicode (original) (raw)
proc $(runes: seq[Rune]): string {....raises: [], tags: [], forbids: [].}
Converts a sequence of Runes to a string.
See also:
- toRunes for a reverse operation
Example:
let someString = "öÑ" someRunes = toRunes(someString) doAssert $someRunes == someString
proc <%(a, b: Rune): bool {....raises: [], tags: [], forbids: [].}
Checks if code point of a is smaller than code point of b.
Example:
let a = "ú".runeAt(0) b = "ü".runeAt(0) doAssert a <% b
proc <=%(a, b: Rune): bool {....raises: [], tags: [], forbids: [].}
Checks if code point of a is smaller or equal to code point of b.
Example:
let a = "ú".runeAt(0) b = "ü".runeAt(0) doAssert a <=% b
proc ==(a, b: Rune): bool {....raises: [], tags: [], forbids: [].}
Checks if two runes are equal.Source Edit
proc add(s: var string; c: Rune) {....raises: [], tags: [], forbids: [].}
Adds a rune c to a string s.
Example:
var s = "abc" let c = "ä".runeAt(0) s.add(c) doAssert s == "abcä"
proc align(s: openArray[char]; count: Natural; padding = ' '.Rune): string {. noSideEffect, ...gcsafe, extern: "nucAlignString", raises: [], tags: [], forbids: [].}
Aligns a unicode string s with padding, so that it has a rune-length of count.
padding characters (by default spaces) are added before s resulting in right alignment. If s.runelen >= count, no spaces are added and s is returned unchanged. If you need to left align a string use the alignLeft proc.
Example:
assert align("abc", 4) == " abc" assert align("a", 0) == "a" assert align("1232", 6) == " 1232" assert align("1232", 6, '#'.Rune) == "##1232" assert align("Åge", 5) == " Åge" assert align("×", 4, '_'.Rune) == "___×"
proc align(s: string; count: Natural; padding = ' '.Rune): string {. noSideEffect, inline, ...raises: [], tags: [], forbids: [].}
Aligns a unicode string s with padding, so that it has a rune-length of count.
padding characters (by default spaces) are added before s resulting in right alignment. If s.runelen >= count, no spaces are added and s is returned unchanged. If you need to left align a string use the alignLeft proc.
Example:
assert align("abc", 4) == " abc" assert align("a", 0) == "a" assert align("1232", 6) == " 1232" assert align("1232", 6, '#'.Rune) == "##1232" assert align("Åge", 5) == " Åge" assert align("×", 4, '_'.Rune) == "___×"
proc alignLeft(s: openArray[char]; count: Natural; padding = ' '.Rune): string {. noSideEffect, ...raises: [], tags: [], forbids: [].}
Left-aligns a unicode string s with padding, so that it has a rune-length of count.
padding characters (by default spaces) are added after s resulting in left alignment. If s.runelen >= count, no spaces are added and s is returned unchanged. If you need to right align a string use the align proc.
Example:
assert alignLeft("abc", 4) == "abc " assert alignLeft("a", 0) == "a" assert alignLeft("1232", 6) == "1232 " assert alignLeft("1232", 6, '#'.Rune) == "1232##" assert alignLeft("Åge", 5) == "Åge " assert alignLeft("×", 4, ''.Rune) == "×__"
proc alignLeft(s: string; count: Natural; padding = ' '.Rune): string {. noSideEffect, inline, ...raises: [], tags: [], forbids: [].}
Left-aligns a unicode string s with padding, so that it has a rune-length of count.
padding characters (by default spaces) are added after s resulting in left alignment. If s.runelen >= count, no spaces are added and s is returned unchanged. If you need to right align a string use the align proc.
Example:
assert alignLeft("abc", 4) == "abc " assert alignLeft("a", 0) == "a" assert alignLeft("1232", 6) == "1232 " assert alignLeft("1232", 6, '#'.Rune) == "1232##" assert alignLeft("Åge", 5) == "Åge " assert alignLeft("×", 4, ''.Rune) == "×__"
proc capitalize(s: openArray[char]): string {.noSideEffect, ...gcsafe, extern: "nuc$1", raises: [], tags: [], forbids: [].}
Converts the first character of s into an upper-case rune.
Example:
doAssert capitalize("βeta") == "Βeta"
proc capitalize(s: string): string {.noSideEffect, ...raises: [], tags: [], forbids: [].}
Converts the first character of s into an upper-case rune.
Example:
doAssert capitalize("βeta") == "Βeta"
proc cmpRunesIgnoreCase(a, b: openArray[char]): int {....gcsafe, extern: "nuc$1", raises: [], tags: [], forbids: [].}
Compares two UTF-8 strings and ignores the case. Returns:
0 if a == b
< 0 if a < b
> 0 if a > b
proc cmpRunesIgnoreCase(a, b: string): int {.inline, ...raises: [], tags: [], forbids: [].}
Compares two UTF-8 strings and ignores the case. Returns:
0 if a == b
< 0 if a < b
> 0 if a > b
proc graphemeLen(s: openArray[char]; i: Natural): Natural {....raises: [], tags: [], forbids: [].}
The number of bytes belonging to byte index s[i], including following combining code units.
Example:
let a = "añyóng" doAssert a.graphemeLen(1) == 2 doAssert a.graphemeLen(2) == 1 doAssert a.graphemeLen(4) == 2
proc graphemeLen(s: string; i: Natural): Natural {.inline, ...raises: [], tags: [], forbids: [].}
The number of bytes belonging to byte index s[i], including following combining code unit.
Example:
let a = "añyóng" doAssert a.graphemeLen(1) == 2 doAssert a.graphemeLen(2) == 1 doAssert a.graphemeLen(4) == 2
proc isAlpha(c: Rune): bool {....gcsafe, extern: "nuc$1", raises: [], tags: [], forbids: [].}
Returns true if c is an alpha rune (i.e., a letter).
See also:
proc isAlpha(s: openArray[char]): bool {.noSideEffect, ...gcsafe, extern: "nuc$1Str", raises: [], tags: [], forbids: [].}
Returns true if s contains all alphabetic runes.
Example:
let a = "añyóng" doAssert a.isAlpha
proc isAlpha(s: string): bool {.noSideEffect, inline, ...raises: [], tags: [], forbids: [].}
Returns true if s contains all alphabetic runes.
Example:
let a = "añyóng" doAssert a.isAlpha
proc isCombining(c: Rune): bool {....gcsafe, extern: "nuc$1", raises: [], tags: [], forbids: [].}
Returns true if c is a Unicode combining code unit.
See also:
proc isLower(c: Rune): bool {....gcsafe, extern: "nuc$1", raises: [], tags: [], forbids: [].}
Returns true if c is a lower case rune.
If possible, prefer isLower over isUpper.
See also:
proc isSpace(s: openArray[char]): bool {.noSideEffect, ...gcsafe, extern: "nuc$1Str", raises: [], tags: [], forbids: [].}
Returns true if s contains all whitespace runes.
Example:
let a = "\t\l \v\r\f" doAssert a.isSpace
proc isSpace(s: string): bool {.noSideEffect, inline, ...raises: [], tags: [], forbids: [].}
Returns true if s contains all whitespace runes.
Example:
let a = "\t\l \v\r\f" doAssert a.isSpace
proc isTitle(c: Rune): bool {....gcsafe, extern: "nuc$1", raises: [], tags: [], forbids: [].}
Returns true if c is a Unicode titlecase code point.
See also:
proc isUpper(c: Rune): bool {....gcsafe, extern: "nuc$1", raises: [], tags: [], forbids: [].}
Returns true if c is a upper case rune.
If possible, prefer isLower over isUpper.
See also:
proc isWhiteSpace(c: Rune): bool {....gcsafe, extern: "nuc$1", raises: [], tags: [], forbids: [].}
Returns true if c is a Unicode whitespace code point.
See also:
proc lastRune(s: openArray[char]; last: int): (Rune, int) {....raises: [], tags: [], forbids: [].}
Length of the last rune in s[0..last]. Returns the rune and its length in bytes.Source Edit
proc lastRune(s: string; last: int): (Rune, int) {.inline, ...raises: [], tags: [], forbids: [].}
Length of the last rune in s[0..last]. Returns the rune and its length in bytes.Source Edit
proc repeat(c: Rune; count: Natural): string {.noSideEffect, ...gcsafe, extern: "nucRepeatRune", raises: [], tags: [], forbids: [].}
Returns a string of count Runes c.
The returned string will have a rune-length of count.
Example:
let a = "ñ".runeAt(0) doAssert a.repeat(5) == "ñññññ"
proc reversed(s: openArray[char]): string {....raises: [], tags: [], forbids: [].}
Returns the reverse of s, interpreting it as runes.
Unicode combining characters are correctly interpreted as well.
Example:
assert reversed("Reverse this!") == "!siht esreveR" assert reversed("先秦兩漢") == "漢兩秦先" assert reversed("as⃝df̅") == "f̅ds⃝a" assert reversed("a⃞b⃞c⃞") == "c⃞b⃞a⃞"
proc reversed(s: string): string {.inline, ...raises: [], tags: [], forbids: [].}
Returns the reverse of s, interpreting it as runes.
Unicode combining characters are correctly interpreted as well.
Example:
assert reversed("Reverse this!") == "!siht esreveR" assert reversed("先秦兩漢") == "漢兩秦先" assert reversed("as⃝df̅") == "f̅ds⃝a" assert reversed("a⃞b⃞c⃞") == "c⃞b⃞a⃞"
proc runeAt(s: openArray[char]; i: Natural): Rune {....raises: [], tags: [], forbids: [].}
Returns the rune in s at byte index i.
See also:
Example:
let a = "añyóng" doAssert a.runeAt(1) == "ñ".runeAt(0) doAssert a.runeAt(2) == "ñ".runeAt(1) doAssert a.runeAt(3) == "y".runeAt(0)
proc runeAt(s: string; i: Natural): Rune {.inline, ...raises: [], tags: [], forbids: [].}
Returns the rune in s at byte index i.
See also:
Example:
let a = "añyóng" doAssert a.runeAt(1) == "ñ".runeAt(0) doAssert a.runeAt(2) == "ñ".runeAt(1) doAssert a.runeAt(3) == "y".runeAt(0)
proc runeAtPos(s: openArray[char]; pos: int): Rune {....raises: [], tags: [], forbids: [].}
Returns the rune at position pos.
Beware: This can lead to unoptimized code and slow execution! Most problems can be solved more efficiently by using an iterator or conversion to a seq of Rune.
See also:
proc runeAtPos(s: string; pos: int): Rune {.inline, ...raises: [], tags: [], forbids: [].}
Returns the rune at position pos.
Beware: This can lead to unoptimized code and slow execution! Most problems can be solved more efficiently by using an iterator or conversion to a seq of Rune.
See also:
proc runeLen(s: openArray[char]): int {....gcsafe, extern: "nuc$1", raises: [], tags: [], forbids: [].}
Returns the number of runes of the string s.
Example:
let a = "añyóng" doAssert a.runeLen == 6
proc runeLen(s: string): int {.inline, ...raises: [], tags: [], forbids: [].}
Returns the number of runes of the string s.
Example:
let a = "añyóng" doAssert a.runeLen == 6
proc runeLenAt(s: openArray[char]; i: Natural): int {....raises: [], tags: [], forbids: [].}
Returns the number of bytes the rune starting at s[i] takes.
See also:
Example:
let a = "añyóng" doAssert a.runeLenAt(0) == 1 doAssert a.runeLenAt(1) == 2
proc runeLenAt(s: string; i: Natural): int {.inline, ...raises: [], tags: [], forbids: [].}
Returns the number of bytes the rune starting at s[i] takes.
See also:
Example:
let a = "añyóng" doAssert a.runeLenAt(0) == 1 doAssert a.runeLenAt(1) == 2
proc runeOffset(s: openArray[char]; pos: Natural; start: Natural = 0): int {. ...raises: [], tags: [], forbids: [].}
Returns the byte position of rune at position pos in s with an optional start byte position. Returns the special value -1 if it runs out of the string.
Beware: This can lead to unoptimized code and slow execution! Most problems can be solved more efficiently by using an iterator or conversion to a seq of Rune.
See also:
Example:
let a = "añyóng" doAssert a.runeOffset(1) == 1 doAssert a.runeOffset(3) == 4 doAssert a.runeOffset(4) == 6
proc runeOffset(s: string; pos: Natural; start: Natural = 0): int {.inline, ...raises: [], tags: [], forbids: [].}
Returns the byte position of rune at position pos in s with an optional start byte position. Returns the special value -1 if it runs out of the string.
Beware: This can lead to unoptimized code and slow execution! Most problems can be solved more efficiently by using an iterator or conversion to a seq of Rune.
See also:
Example:
let a = "añyóng" doAssert a.runeOffset(1) == 1 doAssert a.runeOffset(3) == 4 doAssert a.runeOffset(4) == 6
proc runeReverseOffset(s: openArray[char]; rev: Positive): (int, int) {. ...raises: [], tags: [], forbids: [].}
Returns a tuple with the byte offset of the rune at position rev in s, counting from the end (starting with 1) and the total number of runes in the string.
Returns a negative value for offset if there are too few runes in the string to satisfy the request.
Beware: This can lead to unoptimized code and slow execution! Most problems can be solved more efficiently by using an iterator or conversion to a seq of Rune.
See also:
proc runeReverseOffset(s: string; rev: Positive): (int, int) {.inline, ...raises: [], tags: [], forbids: [].}
Returns a tuple with the byte offset of the rune at position rev in s, counting from the end (starting with 1) and the total number of runes in the string.
Returns a negative value for offset if there are too few runes in the string to satisfy the request.
Beware: This can lead to unoptimized code and slow execution! Most problems can be solved more efficiently by using an iterator or conversion to a seq of Rune.
See also:
proc runeStrAtPos(s: openArray[char]; pos: Natural): string {....raises: [], tags: [], forbids: [].}
Returns the rune at position pos as UTF8 String.
Beware: This can lead to unoptimized code and slow execution! Most problems can be solved more efficiently by using an iterator or conversion to a seq of Rune.
See also:
proc runeStrAtPos(s: string; pos: Natural): string {.inline, ...raises: [], tags: [], forbids: [].}
Returns the rune at position pos as UTF8 String.
Beware: This can lead to unoptimized code and slow execution! Most problems can be solved more efficiently by using an iterator or conversion to a seq of Rune.
See also:
proc runeSubStr(s: openArray[char]; pos: int; len: int = int.high): string {. ...raises: [], tags: [], forbids: [].}
Returns the UTF-8 substring starting at code point pos with len code points.
If pos or len is negative they count from the end of the string. If len is not given it means the longest possible string.
Example:
let s = "Hänsel ««: 10,00€" doAssert(runeSubStr(s, 0, 2) == "Hä") doAssert(runeSubStr(s, 10, 1) == ":") doAssert(runeSubStr(s, -6) == "10,00€") doAssert(runeSubStr(s, 10) == ": 10,00€") doAssert(runeSubStr(s, 12, 5) == "10,00") doAssert(runeSubStr(s, -6, 3) == "10,")
proc runeSubStr(s: string; pos: int; len: int = int.high): string {.inline, ...raises: [], tags: [], forbids: [].}
Returns the UTF-8 substring starting at code point pos with len code points.
If pos or len is negative they count from the end of the string. If len is not given it means the longest possible string.
Example:
let s = "Hänsel ««: 10,00€" doAssert(runeSubStr(s, 0, 2) == "Hä") doAssert(runeSubStr(s, 10, 1) == ":") doAssert(runeSubStr(s, -6) == "10,00€") doAssert(runeSubStr(s, 10) == ": 10,00€") doAssert(runeSubStr(s, 12, 5) == "10,00") doAssert(runeSubStr(s, -6, 3) == "10,")
proc size(r: Rune): int {.noSideEffect, ...raises: [], tags: [], forbids: [].}
Returns the number of bytes the rune r takes.
Example:
let a = toRunes "aá" doAssert size(a[0]) == 1 doAssert size(a[1]) == 2
proc split(s: openArray[char]; sep: Rune; maxsplit: int = -1): seq[string] {. noSideEffect, ...gcsafe, extern: "nucSplitRune", raises: [], tags: [], forbids: [].}
The same as the split iterator, but is a proc that returns a sequence of substrings.Source Edit
proc split(s: openArray[char]; seps: openArray[Rune] = unicodeSpaces; maxsplit: int = -1): seq[string] {.noSideEffect, ...gcsafe, extern: "nucSplitRunes", raises: [], tags: [], forbids: [].}
The same as the split iterator, but is a proc that returns a sequence of substrings.Source Edit
proc split(s: string; sep: Rune; maxsplit: int = -1): seq[string] {. noSideEffect, inline, ...raises: [], tags: [], forbids: [].}
The same as the split iterator, but is a proc that returns a sequence of substrings.Source Edit
proc split(s: string; seps: openArray[Rune] = unicodeSpaces; maxsplit: int = -1): seq[ string] {.noSideEffect, inline, ...raises: [], tags: [], forbids: [].}
The same as the split iterator, but is a proc that returns a sequence of substrings.Source Edit
proc splitWhitespace(s: openArray[char]): seq[string] {.noSideEffect, ...gcsafe, extern: "ncuSplitWhitespace", raises: [], tags: [], forbids: [].}
The same as the splitWhitespace iterator, but is a proc that returns a sequence of substrings.Source Edit
proc splitWhitespace(s: string): seq[string] {.noSideEffect, inline, ...raises: [], tags: [], forbids: [].}
The same as the splitWhitespace iterator, but is a proc that returns a sequence of substrings.Source Edit
proc strip(s: openArray[char]; leading = true; trailing = true; runes: openArray[Rune] = unicodeSpaces): string {.noSideEffect, ...gcsafe, extern: "nucStrip", raises: [], tags: [], forbids: [].}
Strips leading or trailing runes from s and returns the resulting string.
If leading is true (default), leading runes are stripped. If trailing is true (default), trailing runes are stripped. If both are false, the string is returned unchanged.
Example:
let a = "\táñyóng " doAssert a.strip == "áñyóng" doAssert a.strip(leading = false) == "\táñyóng" doAssert a.strip(trailing = false) == "áñyóng "
proc strip(s: string; leading = true; trailing = true; runes: openArray[Rune] = unicodeSpaces): string {.noSideEffect, inline, ...raises: [], tags: [], forbids: [].}
Strips leading or trailing runes from s and returns the resulting string.
If leading is true (default), leading runes are stripped. If trailing is true (default), trailing runes are stripped. If both are false, the string is returned unchanged.
Example:
let a = "\táñyóng " doAssert a.strip == "áñyóng" doAssert a.strip(leading = false) == "\táñyóng" doAssert a.strip(trailing = false) == "áñyóng "
proc swapCase(s: openArray[char]): string {.noSideEffect, ...gcsafe, extern: "nuc$1", raises: [], tags: [], forbids: [].}
Swaps the case of runes in s.
Returns a new string such that the cases of all runes are swapped if possible.
Example:
doAssert swapCase("Αlpha Βeta Γamma") == "αLPHA βETA γAMMA"
proc swapCase(s: string): string {.noSideEffect, inline, ...raises: [], tags: [], forbids: [].}
Swaps the case of runes in s.
Returns a new string such that the cases of all runes are swapped if possible.
Example:
doAssert swapCase("Αlpha Βeta Γamma") == "αLPHA βETA γAMMA"
proc title(s: openArray[char]): string {.noSideEffect, ...gcsafe, extern: "nuc$1", raises: [], tags: [], forbids: [].}
Converts s to a unicode title.
Returns a new string such that the first character in each word inside s is capitalized.
Example:
doAssert title("αlpha βeta γamma") == "Αlpha Βeta Γamma"
proc title(s: string): string {.noSideEffect, inline, ...raises: [], tags: [], forbids: [].}
Converts s to a unicode title.
Returns a new string such that the first character in each word inside s is capitalized.
Example:
doAssert title("αlpha βeta γamma") == "Αlpha Βeta Γamma"
proc toLower(c: Rune): Rune {....gcsafe, extern: "nuc$1", raises: [], tags: [], forbids: [].}
Converts c into lower case. This works for any rune.
If possible, prefer toLower over toUpper.
See also:
proc toLower(s: openArray[char]): string {.noSideEffect, ...gcsafe, extern: "nuc$1Str", raises: [], tags: [], forbids: [].}
Converts s into lower-case runes.
Example:
doAssert toLower("ABΓ") == "abγ"
proc toLower(s: string): string {.noSideEffect, inline, ...raises: [], tags: [], forbids: [].}
Converts s into lower-case runes.
Example:
doAssert toLower("ABΓ") == "abγ"
proc toRunes(s: openArray[char]): seq[Rune] {....raises: [], tags: [], forbids: [].}
Obtains a sequence containing the Runes in s.
See also:
- $ proc for a reverse operation
Example:
let a = toRunes("aáä") doAssert a == @["a".runeAt(0), "á".runeAt(0), "ä".runeAt(0)]
proc toRunes(s: string): seq[Rune] {.inline, ...raises: [], tags: [], forbids: [].}
Obtains a sequence containing the Runes in s.
See also:
- $ proc for a reverse operation
Example:
let a = toRunes("aáä") doAssert a == @["a".runeAt(0), "á".runeAt(0), "ä".runeAt(0)]
proc toTitle(c: Rune): Rune {....gcsafe, extern: "nuc$1", raises: [], tags: [], forbids: [].}
Converts c to title case.
See also:
proc toUpper(c: Rune): Rune {....gcsafe, extern: "nuc$1", raises: [], tags: [], forbids: [].}
Converts c into upper case. This works for any rune.
If possible, prefer toLower over toUpper.
See also:
proc toUpper(s: openArray[char]): string {.noSideEffect, ...gcsafe, extern: "nuc$1Str", raises: [], tags: [], forbids: [].}
Converts s into upper-case runes.
Example:
doAssert toUpper("abγ") == "ABΓ"
proc toUpper(s: string): string {.noSideEffect, inline, ...raises: [], tags: [], forbids: [].}
Converts s into upper-case runes.
Example:
doAssert toUpper("abγ") == "ABΓ"
proc toUTF8(c: Rune): string {....gcsafe, extern: "nuc$1", raises: [], tags: [], forbids: [].}
Converts a rune into its UTF-8 representation.
See also:
- validateUtf8 proc
- $ proc alias for toUTF8
- utf8 iterator
- fastToUTF8Copy template
Example:
let a = "añyóng" doAssert a.runeAt(1).toUTF8 == "ñ"
proc translate(s: openArray[char]; replacements: proc (key: string): string): string {. ...gcsafe, extern: "nuc$1", effectsOf: replacements, ...raises: [], tags: [], forbids: [].}
Translates words in a string using the replacements proc to substitute words inside s with their replacements.
replacements is any proc that takes a word and returns a new word to fill it's place.
Example:
proc wordToNumber(s: string): string = case s of "one": "1" of "two": "2" else: s let a = "one two three four" doAssert a.translate(wordToNumber) == "1 2 three four"
proc translate(s: string; replacements: proc (key: string): string): string {. effectsOf: replacements, inline, ...raises: [], tags: [], forbids: [].}
Translates words in a string using the replacements proc to substitute words inside s with their replacements.
replacements is any proc that takes a word and returns a new word to fill it's place.
Example:
proc wordToNumber(s: string): string = case s of "one": "1" of "two": "2" else: s let a = "one two three four" doAssert a.translate(wordToNumber) == "1 2 three four"
proc validateUtf8(s: openArray[char]): int {....raises: [], tags: [], forbids: [].}
Returns the position of the invalid byte in s if the string s does not hold valid UTF-8 data. Otherwise -1 is returned.
See also:
- toUTF8 proc
- $ proc alias for toUTF8
- fastToUTF8Copy template Source Edit
proc validateUtf8(s: string): int {.inline, ...raises: [], tags: [], forbids: [].}
Returns the position of the invalid byte in s if the string s does not hold valid UTF-8 data. Otherwise -1 is returned.
See also:
- toUTF8 proc
- $ proc alias for toUTF8
- fastToUTF8Copy template Source Edit