The name of a locale.

Get the available default locales, i.e. locales that return data when passed to ICU APIs, but not including legacy or alias locales.

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.

Create an NFC normalizer and apply this to the given text.

Let's have a look at a concrete example that contains the letter a with an acute accent twice. First as a combination of two codepoints and second as a canonical composite or precomposed character. Both look exactly the same but one character consists of two and one of only one codepoint. A bytewise comparison does not give equality of these.

>>> import Data.Text
>>> let t = pack "a\x301á"
>>> t
"a\769\225"
>>> putStr t
áá
pack "a\x301" == pack "á"
False

But now lets apply some normalization functions and see how these characters coincide afterwards in two different ways:

>>> nfc t
"\225\225"
>>> nfd t
"a\769a\769"

That is exactly what compareUnicode' does:

>>> pack "a\x301" `compareUnicode'` pack "á"

Create an NFD normalizer and apply this to the given text.

Create an NFKC normalizer and apply this to the given text.

Create an NFC normalizer and apply this to the given text.

Create an NFKCCasefold normalizer and apply this to the given text.

Options to compare.

Compare two strings for canonical equivalence. Further options include case-insensitive comparison and codepoint 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.

Create an immutable Collator from the given collation rules.

Create an immutable Collator from the given collation rules 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.

All the fields that comprise a Calendar.

Open a Calendar.

A Calendar may be used to convert a millisecond value to a year, month, and day.

Note: When unknown TimeZone ID is specified or if the TimeZone ID specified is "Etc/Unknown", the Calendar returned by the function is initialized with GMT zone with TimeZone ID UCAL_UNKNOWN_ZONE_ID ("EtcUnknown") without any errorswarnings. If you want to check if a TimeZone ID is valid prior to this function, use ucal_getCanonicalTimeZoneID.

>>> import qualified Data.Text as T
>>> c <- calendar (T.pack "CET") (Locale "de_DE") TraditionalCalendarType
>>> show c
2021-10-12 17:37:43

Add a specified signed amount to a particular field in a Calendar.

See rollField for further details.

>>> import qualified Data.Text as T
>>> c1 <- calendar (T.pack "CET") (Locale "de_DE") TraditionalCalendarType
>>> show c1
2021-10-12 17:53:26
>>> let c2 = roll c1 [(Hour, 2)]
>>> show c2
2021-10-12 19:53:26
>>> let c3 = roll c1 [(Hour, 12)]
>>> show c3
2021-10-12 17:53:26
>>> let c4 = add c1 [(Hour, 12)]
>>> show c4
2021-10-13 5:53:26

Add a specified signed amount to a particular field in a Calendar.

See addField for further details and see rollField for examples and differences compared to rolling.

Set the value of one field of a calendar to a certain value. All fields are represented as 32-bit integers.

Set the value of a list of fields of a calendar to certain values. All fields are represented as 32-bit integers.

Get the value of a specific field in the calendar.

Create a new NumberFormatter.

See https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html for how to specify the number skeletons. And use availableLocales in order to find the allowed locale names. These usuallly look like "en", "de", "de_AT" etc. See formatIntegral and formatDouble for some examples.

Format an integral number.

See https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html for how to specify the number skeletons.

>>> import Data.Text
>>> nf <- numberFormatter (pack "precision-integer") (Locale "de")
>>> formatIntegral nf 12345
"12.345"
>>> nf2 <- numberFormatter (pack "precision-integer") (Locale "fr")
>>> formatIntegral nf2 12345
"12\8239\&345"

Create a number formatter and apply it to an integral number.

Format a Double.

See https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html for how to specify the number skeletons.

>>> import Data.Text
>>> nf3 <- numberFormatter (pack "precision-currency-cash") (Locale "it")
>>> formatDouble nf3 12345.6789
"12.345,68"

Create a number formatter and apply it to a Double.

This is an abstract data type holding a reference to the ICU date format object. Create a DateFormatter with either standardDateFormatter or patternDateFormatter and use it in order to format Calendar objects with the function formatCalendar.

The possible date/time format styles.

The possible types of date format symbols.

Create a new DateFormatter from the standard styles.

>>> import Data.Text
>>> dfDe <- standardDateFormatter LongFormatStyle LongFormatStyle (Locale "de_DE") (pack "CET")

Create a new DateFormatter using a custom pattern as described at https://unicode-org.github.io/icu/userguide/format_parse/datetime/#datetime-format-syntax. For examples the pattern "yyyy.MM.dd G at HH:mm:ss zzz" produces “1996.07.10 AD at 15:08:56 PDT” in English for the PDT time zone.

A date pattern is a string of characters, where specific strings of characters are replaced with date and time data from a calendar when formatting or used to generate data for a calendar when parsing.

The Date Field Symbol Table contains the characters used in patterns to show the appropriate formats for a given locale, such as yyyy for the year. Characters may be used multiple times. For example, if y is used for the year, "yy" might produce “99”, whereas "yyyy" produces “1999”. For most numerical fields, the number of characters specifies the field width. For example, if h is the hour, "h" might produce “5”, but "hh" produces “05”. For some characters, the count specifies whether an abbreviated or full form should be used, but may have other choices, as given below.

Two single quotes represents a literal single quote, either inside or outside single quotes. Text within single quotes is not interpreted in any way (except for two adjacent single quotes). Otherwise all ASCII letter from a to z and A to Z are reserved as syntax characters, and require quoting if they are to represent literal characters. In addition, certain ASCII punctuation characters may become variable in the future (eg : being interpreted as the time separator and / as a date separator, and replaced by respective locale-sensitive characters in display).

“Stand-alone” values refer to those designed to stand on their own independently, as opposed to being with other formatted values. “2nd quarter” would use the wide stand-alone format "qqqq", whereas “2nd quarter 2007” would use the regular format "QQQQ yyyy". For more information about format and stand-alone forms, see CLDR Calendar Elements.

The pattern characters used in the Date Field Symbol Table are defined by CLDR; for more information see CLDR Date Field Symbol Table.

👉 Note that the examples may not reflect current CLDR data.

Get relevant date related symbols, e.g. month and weekday names.

>>> import Data.Text
>>> dfDe <- standardDateFormatter LongFormatStyle LongFormatStyle (Locale "de_DE") (pack "CET")
>>> dateSymbols dfDe Months
["Januar","Februar","M\228rz","April","Mai","Juni","Juli","August","September","Oktober","November","Dezember"]
>>> dfAt <- standardDateFormatter LongFormatStyle LongFormatStyle (Locale "de_AT") (pack "CET")
>>> dateSymbols dfAt Months
["J\228nner","Februar","M\228rz","April","Mai","Juni","Juli","August","September","Oktober","November","Dezember"]

Format a Calendar using a DateFormatter.

>>> import Data.Text
>>> dfDe <- standardDateFormatter LongFormatStyle LongFormatStyle (Locale "de_DE") (pack "CET")
>>> c <- calendar (pack "CET") (Locale "de_DE") TraditionalCalendarType
>>> formatCalendar dfDe c
"13. Oktober 2021 um 12:44:09 GMT+2"