The name of a locale.

A boundary analyser.

A break in a string.

Prefix of the current break.

Text of the current break.

Suffix of the current break.

Status of the current break (only meaningful if Line or Word).

Line break status.

Word break status.

Break a string on character boundaries.

Character boundary analysis identifies the boundaries of "Extended Grapheme Clusters", which are groupings of codepoints that should be treated as character-like units for many text operations. Please see Unicode Standard Annex #29, Unicode Text Segmentation, http://www.unicode.org/reports/tr29/ for additional information on grapheme clusters and guidelines on their use.

Break a string on line boundaries.

Line boundary analysis determines where a text string can be broken when line wrapping. The mechanism correctly handles punctuation and hyphenated words.

Break a string on sentence boundaries.

Sentence boundary analysis allows selection with correct interpretation of periods within numbers and abbreviations, and trailing punctuation marks such as quotation marks and parentheses.

Break a string on word boundaries.

Word boundary analysis is used by search and replace functions, as well as within text editing applications that allow the user to select words with a double click. Word selection provides correct interpretation of punctuation marks within and following words. Characters that are not part of a word, such as symbols or punctuation marks, have word breaks on both sides.

Return a list of all breaks in a string, from left to right.

Return a list of all breaks in a string, from right to left.

Case-fold the characters in a string.

Case folding is locale independent and not context sensitive, but there is an option for treating the letter I specially for Turkic languages. The result may be longer or shorter than the original.

Lowercase the characters in a string.

Casing is locale dependent and context sensitive. The result may be longer or shorter than the original.

Uppercase the characters in a string.

Casing is locale dependent and context sensitive. The result may be longer or shorter than the original.

A type that supports efficient iteration over Unicode characters.

As an example of where this may be useful, a function using this type may be able to iterate over a UTF-8 ByteString directly, rather than first copying and converting it to an intermediate form. This type also allows e.g. comparison between Text and ByteString, with minimal overhead.

Construct a CharIterator from a Unicode string.

Construct a CharIterator from a Unicode string.

Construct a CharIterator from a Unicode string encoded as a UTF-8 ByteString. The validity of the encoded string is *not* checked.

Normalization modes.

Normalize a string according the specified normalization mode.

Perform an efficient check on a string, to quickly determine if the string is in a particular normalization form.

A Nothing result indicates that a definite answer could not be determined quickly, and a more thorough check is required, e.g. with isNormalized. The user may have to convert the string to its normalized form and compare the results.

A result of Just True or Just False indicates that the string definitely is, or is not, in the given normalization form.

Indicate whether a string is in a given normalization form.

Unlike quickCheck, this function returns a definitive result. For NFD, NFKD, and FCD normalization forms, both functions work in exactly the same ways. For NFC and NFKC forms, where quickCheck may return Nothing, this function will perform further tests to arrive at a definitive result.

Options to compare.

Compare two strings for canonical equivalence. Further options include case-insensitive comparison and code point order (as opposed to code unit order).

Canonical equivalence between two strings is defined as their normalized forms (NFD or NFC) being identical. This function compares strings incrementally instead of normalizing (and optionally case-folding) both strings entirely, improving performance significantly.

Bulk normalization is only necessary if the strings do not fulfill the FCD conditions. Only in this case, and only if the strings are relatively long, is memory allocated temporarily. For FCD strings and short non-FCD strings there is no memory allocation.

String collator type.

Create an immutable Collator for comparing strings.

If Root is passed as the locale, UCA collation rules will be used.

Create an immutable Collator with the given Attributes.

Compare two strings.

Compare two CharIterators.

If either iterator was constructed from a ByteString, it does not need to be copied or converted beforehand, so this function can be quite cheap.

Create a key for sorting the Text using the given Collator. The result of comparing two ByteStrings that have been transformed with sortKey will be the same as the result of collate on the two untransformed Texts.

A Collator that uses the Unicode Collation Algorithm (UCA).

Options for controlling matching behaviour.

Detailed information about parsing errors. Used by ICU parsing engines that parse long rules, patterns, or programs, where the text being parsed is long enough that more information than an ICUError is needed to localize the error.

A match for a regular expression.

A compiled regular expression.

Regex values are usually constructed using the regex or regex' functions. This type is also an instance of IsString, so if you have the OverloadedStrings language extension enabled, you can construct a Regex by simply writing the pattern in quotes (though this does not allow you to specify any Options).

A typeclass for functions common to both Match and Regex types.

Compile a regular expression with the given options. This function throws a ParseError if the pattern is invalid, so it is best for use when the pattern is statically known.

Compile a regular expression with the given options. This is safest to use when the pattern is constructed at run time.

Return the source form of the pattern used to construct this regular expression or match.

Find the first match for the regular expression in the given text.

Lazily find all matches for the regular expression in the given text.

Return the number of capturing groups in this regular expression or match's pattern.

A combinator for returning a list of all capturing groups on a Match.

Return the span of text between the end of the previous match and the beginning of the current match.

Return the nth capturing group in a match, or Nothing if n is out of bounds.

Return the prefix of the nth capturing group in a match (the text from the start of the string to the start of the match), or Nothing if n is out of bounds.

Return the suffix of the nth capturing group in a match (the text from the end of the match to the end of the string), or Nothing if n is out of bounds.

Spoof checker type.

Open an immutable Spoof checker with default options (all SpoofChecks except CharLimit).

Open an immutable Spoof checker with specific SpoofParams to control its behavior.

Open a immutable Spoof checker with specific SpoofParams to control its behavior and custom rules given the UTF-8 encoded contents of the confusables.txt and confusablesWholeScript.txt files as described in Unicode UAX #39.

Create an immutable spoof checker with specific SpoofParams to control its behavior and custom rules previously returned by serialize.

Check two strings for confusability.

Check a string for spoofing issues.

Generates re-usable "skeleton" strings which can be used (via Unicode equality) to check if an identifier is confusable with some large set of existing identifiers.

If you cache the returned strings in storage, you must invalidate your cache any time the underlying confusables database changes (i.e., on ICU upgrade).

By default, assumes all input strings have been passed through toCaseFold and are lower-case. To change this, pass SkeletonAnyCase.

By default, builds skeletons which catch visually confusable characters across multiple scripts. Pass SkeletonSingleScript to override that behavior and build skeletons which catch visually confusable characters across single scripts.

Gets the checks currently configured in the spoof checker.

Gets the locales whose scripts are currently allowed by the spoof checker. (We don't use LocaleName since the root and default locales have no meaning here.)

Gets the restriction level currently configured in the spoof checker, if present.

Serializes the rules in this spoof checker to a byte array, suitable for re-use by spoofFromSerialized.

Only includes any data provided to openFromSource. Does not include any other state or configuration.