Std.Text

66 public declarations

• allCharsStr -> fn(Char) -> Bool -> Bool

  Whether every character satisfies the predicate. True for empty text.

  fn
• anyCharStr -> fn(Char) -> Bool -> Bool

  Whether any character satisfies the predicate. False for empty text.

  fn
• atStr -> Int -> Option[Char]

  The character at a position, or `None` when there is none.

  fn
• beforeStr -> Str -> Bool

  Whether one text sorts before another.

  fn
• breakOnStr -> Str -> (Str, Str)

  The text before the first occurrence of a needle, and the rest including it.

  fn
• breakOnEndStr -> Str -> (Str, Str)

  The text after the last occurrence of a needle, and everything before it.

  fn
• capitalizeStr -> Str

  Text with its first character in upper case and the rest unchanged.

  fn
• centerStr -> Int -> Str -> Str

  Text padded on both sides to at least `width` characters.

  fn
• chunksOfStr -> Int -> Array[Str]

  The text in pieces of at most `size` characters.

  fn
• commonPrefixStr -> Str -> (Str, Str, Str)

  The longest text both begin with, and what remains of each after it.

  fn
• compareStr -> Str -> Int

  Two texts compared without materialising the comparison as a number.

  fn
• consChar -> Str -> Str

  A character placed before some text.

  fn
• countCharsStr -> fn(Char) -> Bool -> Int

  How many characters satisfy the predicate.

  fn
• countOccurrencesStr -> Str -> Int

  How many times a needle occurs, without overlapping.

  fn
• countOfStr -> Option[Int]

  The count this text spells, or nothing.

  fn
• dropStr -> Int -> Str

  Every character after the first `skipped`.

  fn
• dropAroundStr -> fn(Char) -> Bool -> Str

  Leading and trailing characters the predicate accepts removed.

  fn
• dropEndStr -> Int -> Str

  Every character but the last `skipped`.

  fn
• dropWhileStr -> fn(Char) -> Bool -> Str

  Everything after the longest leading run the predicate accepts.

  fn
• dropWhileEndStr -> fn(Char) -> Bool -> Str

  Trailing characters the predicate accepts removed.

  fn
• equalsIgnoreCaseStr -> Str -> Bool

  Whether two texts are equal ignoring case.

  fn
• filterCharsStr -> fn(Char) -> Bool -> Str

  Only the characters the predicate accepts.

  fn
• findStr -> Str -> Option[Int]

  The position of the first occurrence, or `None` when there is none.

  fn
• findCharStr -> fn(Char) -> Bool -> Option[Char]

  The first character the predicate accepts, or `None`.

  fn
• findIndexStr -> fn(Char) -> Bool -> Option[Int]

  The position of the first character the predicate accepts, or `None`.

  fn
• flatMapCharsStr -> fn(Char) -> Str -> Str

  Every character transformed into text, and that text joined.

  fn
• foldCharsStr -> fn(A, Char) -> A -> A -> A

  Every character folded into one value, left to right.

  fn
• foldCharsRightStr -> fn(Char, A) -> A -> A -> A

  Every character folded into one value, right to left.

  fn
• fromChars&Array[Char] -> Str

  Text rebuilt from characters.

  fn
• fromLines&Array[Str] -> Str

  Lines joined with newlines between them.

  fn
• fromWords&Array[Str] -> Str

  Words joined with single spaces between them.

  fn
• groupCharsStr -> Array[Str]

  Runs of adjacent equal characters, as text.

  fn
• headStr -> Option[Char]

  The first character, or `None` for empty text.

  fn
• initialStr -> Str

  Everything but the last character.

  fn
• isBlankStr -> Bool

  Whether text contains only whitespace, or nothing at all.

  fn
• join&Array[Str] -> Str -> Str

  Every piece joined with a separator between them.

  fn
• lastStr -> Option[Char]

  The last character, or `None` for empty text.

  fn
• mapCharsStr -> fn(Char) -> Char -> Str

  Every character transformed.

  fn
• padLeftStr -> Int -> Str -> Str

  Text padded on the left to at least `width` characters.

  fn
• padRightStr -> Int -> Str -> Str

  Text padded on the right to at least `width` characters.

  fn
• partitionStr -> fn(Char) -> Bool -> (Str, Str)

  The characters the predicate accepts, and the characters it rejects.

  fn
• prefixesStr -> Array[Str]

  Every prefix, shortest first.

  fn
• restStr -> Str

  Everything but the first character. Empty text answers empty text.

  fn
• scanCharsStr -> fn(A, Char) -> A -> A -> Array[A]

  Every running result of folding the characters.

  fn
• singletonChar -> Str

  Text of exactly one character.

  fn
• snocStr -> Char -> Str

  A character placed after some text.

  fn
• spanStr -> fn(Char) -> Bool -> (Str, Str)

  The longest leading run the predicate accepts, and the rest.

  fn
• splitAtStr -> Int -> (Str, Str)

  The text split at a position.

  fn
• splitNonEmptyStr -> Str -> Array[Str]

  The pieces of text separated by a separator, with empty pieces removed.

  fn
• stripPrefixStr -> Str -> Str

  Text with a prefix removed, or unchanged when it is not there.

  fn
• stripSuffixStr -> Str -> Str

  Text with a suffix removed, or unchanged when it is not there.

  fn
• suffixesStr -> Array[Str]

  Every suffix, longest first.

  fn
• takeStr -> Int -> Str

  The first `wanted` characters, or the whole text when it is shorter.

  fn
• takeEndStr -> Int -> Str

  The last `wanted` characters, or the whole text when it is shorter.

  fn
• takeWhileStr -> fn(Char) -> Bool -> Str

  The longest leading run of characters the predicate accepts.

  fn
• toCharsStr -> Array[Char]

  Every character, as an array.

  fn
• toLinesStr -> Array[Str]

  Every line, with a trailing newline producing no final empty line.

  fn
• toTitleStr -> Str

  The title-case form: the first character of each word in upper case.

  fn
• trimEndStr -> Str

  Whitespace removed from the end.

  fn
• trimStartStr -> Str

  Whitespace removed from the start.

  fn
• unconsStr -> Option[(Char, Str)]

  The first character and the rest, or `None` for empty text.

  fn
• unfoldInt -> S -> fn(S) -> Option[(Char, S)] -> Str

  Text grown from a seed until the step answers `None`.

  fn
• unsnocStr -> Option[(Str, Char)]

  Everything but the last character and that character, or `None` when empty.

  fn
• wholeOfStr -> Option[Int]

  The whole number this text spells, or nothing.

  fn
• wordsStr -> Array[Str]

  Every word, splitting on single spaces and discarding empty pieces.

  fn
• zipCharsStr -> Str -> Array[(Char, Char)]

  The characters of two texts paired, stopping at the shorter.

  fn