DA.Text

Documentation Index

Fetch the complete documentation index at: https://docs.canton.network/llms.txt Use this file to discover all available pages before exploring further.

DA.Text

Reference documentation for Daml module DA.Text.

DA.Text

Functions for working with Text.

Module Snapshot

Stable. Status: `active` Introduced in: `3.4.9` Removed in: `-` Warnings: `0` Deprecations: `0` Deprecated since: `-`

Functions

`explode`

explode : Text -> [Text]

`implode`

implode : [Text] -> Text

`isEmpty`

isEmpty : Text -> Bool

Test for emptiness.

`isNotEmpty`

isNotEmpty : Text -> Bool

Test for non-emptiness.

`length`

length : Text -> Int

Compute the number of symbols in the text.

`trim`

trim : Text -> Text

Remove spaces from either side of the given text.

`replace`

replace : Text -> Text -> Text -> Text

Replace a subsequence everywhere it occurs. The first argument must not be empty.

`lines`

lines : Text -> [Text]

Breaks a Text value up into a list of Text’s at newline symbols. The resulting texts do not contain newline symbols.

`unlines`

unlines : [Text] -> Text

Joins lines, after appending a terminating newline to each.

`words`

words : Text -> [Text]

Breaks a ‘Text’ up into a list of words, delimited by symbols representing white space.

`unwords`

unwords : [Text] -> Text

Joins words using single space symbols.

`linesBy`

linesBy : (Text -> Bool) -> Text -> [Text]

A variant of lines with a custom test. In particular, if there is a trailing separator it will be discarded.

`wordsBy`

wordsBy : (Text -> Bool) -> Text -> [Text]

A variant of words with a custom test. In particular, adjacent separators are discarded, as are leading or trailing separators.

`intercalate`

intercalate : Text -> [Text] -> Text

intercalate inserts the text argument t in between the items in ts and concatenates the result.

`dropPrefix`

dropPrefix : Text -> Text -> Text

dropPrefix drops the given prefix from the argument. It returns the original text if the text doesn’t start with the given prefix.

`dropSuffix`

dropSuffix : Text -> Text -> Text

Drops the given suffix from the argument. It returns the original text if the text doesn’t end with the given suffix. Examples:

  dropSuffix "!" "Hello World!"  == "Hello World"
  dropSuffix "!" "Hello World!!" == "Hello World!"
  dropSuffix "!" "Hello World."  == "Hello World."

`stripSuffix`

stripSuffix : Text -> Text -> Optional Text

Return the prefix of the second text if its suffix matches the entire first text. Examples:

  stripSuffix "bar" "foobar" == Some "foo"
  stripSuffix ""    "baz"    == Some "baz"
  stripSuffix "foo" "quux"   == None

`stripPrefix`

stripPrefix : Text -> Text -> Optional Text

The stripPrefix function drops the given prefix from the argument text. It returns None if the text did not start with the prefix.

`isPrefixOf`

isPrefixOf : Text -> Text -> Bool

The isPrefixOf function takes two text arguments and returns True if and only if the first is a prefix of the second.

`isSuffixOf`

isSuffixOf : Text -> Text -> Bool

The isSuffixOf function takes two text arguments and returns True if and only if the first is a suffix of the second.

`isInfixOf`

isInfixOf : Text -> Text -> Bool

The isInfixOf function takes two text arguments and returns True if and only if the first is contained, wholly and intact, anywhere within the second.

`takeWhile`

takeWhile : (Text -> Bool) -> Text -> Text

The function takeWhile, applied to a predicate p and a text, returns the longest prefix (possibly empty) of symbols that satisfy p.

`takeWhileEnd`

takeWhileEnd : (Text -> Bool) -> Text -> Text

The function ‘takeWhileEnd’, applied to a predicate p and a ‘Text’, returns the longest suffix (possibly empty) of elements that satisfy p.

`dropWhile`

dropWhile : (Text -> Bool) -> Text -> Text

dropWhile p t returns the suffix remaining after takeWhile p t.

`dropWhileEnd`

dropWhileEnd : (Text -> Bool) -> Text -> Text

dropWhileEnd p t returns the prefix remaining after dropping symbols that satisfy the predicate p from the end of t.

`splitOn`

splitOn : Text -> Text -> [Text]

Break a text into pieces separated by the first text argument (which cannot be empty), consuming the delimiter.

`splitAt`

splitAt : Int -> Text -> (Text, Text)

Split a text before a given position so that for 0 <= n <= length t, length (fst (splitAt n t)) == n.

`take`

take : Int -> Text -> Text

take n, applied to a text t, returns the prefix of t of length n, or t itself if n is greater than the length of t.

`drop`

drop : Int -> Text -> Text

drop n, applied to a text t, returns the suffix of t after the first n characters, or the empty Text if n is greater than the length of t.

`substring`

substring : Int -> Int -> Text -> Text

Compute the sequence of symbols of length l in the argument text starting at s.

`isPred`

isPred : (Text -> Bool) -> Text -> Bool

isPred f t returns True if t is not empty and f is True for all symbols in t.

`isSpace`

isSpace : Text -> Bool

isSpace t is True if t is not empty and consists only of spaces.

`isNewLine`

isNewLine : Text -> Bool

isSpace t is True if t is not empty and consists only of newlines.

`isUpper`

isUpper : Text -> Bool

isUpper t is True if t is not empty and consists only of uppercase symbols.

`isLower`

isLower : Text -> Bool

isLower t is True if t is not empty and consists only of lowercase symbols.

`isDigit`

isDigit : Text -> Bool

isDigit t is True if t is not empty and consists only of digit symbols.

`isAlpha`

isAlpha : Text -> Bool

isAlpha t is True if t is not empty and consists only of alphabet symbols.

`isAlphaNum`

isAlphaNum : Text -> Bool

isAlphaNum t is True if t is not empty and consists only of alphanumeric symbols.

`parseInt`

parseInt : Text -> Optional Int

Attempt to parse an Int value from a given Text.

`parseNumeric`

parseNumeric : NumericScale n => Text -> Optional (Numeric n)

Attempt to parse a Numeric value from a given Text. To get Some value, the text must follow the regex (-|\+)?[0-9]+(\.[0-9]+)? In particular, the shorthands ".12" and "12." do not work, but the value can be prefixed with +. Leading and trailing zeros are fine, however spaces are not. Examples:

  parseNumeric "3.14" == Some 3.14
  parseNumeric "+12.0" == Some 12

`parseDecimal`

parseDecimal : Text -> Optional Decimal

Attempt to parse a Decimal value from a given Text. To get Some value, the text must follow the regex (-|\+)?[0-9]+(\.[0-9]+)? In particular, the shorthands ".12" and "12." do not work, but the value can be prefixed with +. Leading and trailing zeros are fine, however spaces are not. Examples:

  parseDecimal "3.14" == Some 3.14
  parseDecimal "+12.0" == Some 12

`sha256`

sha256 : Text -> Text

Computes the SHA256 hash of the UTF8 bytes of the Text, and returns it in its hex-encoded form. The hex encoding uses lowercase letters.

This function will crash at runtime if you compile Daml to Daml-LF < 1.2.

`reverse`

reverse : Text -> Text

Reverse some Text.

  reverse "Daml" == "lmaD"

`toCodePoints`

toCodePoints : Text -> [Int]

Convert a Text into a sequence of unicode code points.

`fromCodePoints`

fromCodePoints : [Int] -> Text

Convert a sequence of unicode code points into a Text. Raises an exception if any of the code points is invalid.

`asciiToLower`

asciiToLower : Text -> Text

Convert the uppercase ASCII characters of a Text to lowercase; all other characters remain unchanged.

`asciiToUpper`

asciiToUpper : Text -> Text

Convert the lowercase ASCII characters of a Text to uppercase; all other characters remain unchanged.

Mirrored from Canton Network official documentation (CC-BY-4.0) by CC Privacy Club for learning purposes.