[RJ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                               GHC experimentalbos@serpentine.com Safe-Inferred None @Detailed information about parsing errors. Used by ICU parsing A engines that parse long rules, patterns, or programs, where the @ text being parsed is long enough that more information than an  " is needed to localize the error. >The line on which the error occured. If the parser uses this A field, it sets it to the line number of the source text line on A which the error appears, which will be be a positive value. If = the parser does not support line numbers, the value will be  . +The character offset to the error. If the  field is  : some value, then this field contains the offset from the ? beginning of the line that contains the error. Otherwise, it ; represents the offset from the start of the text. If the = parser does not support this field, it will have a value of  . ,ICU error type. This is an instance of the  type D class. A value of this type may be thrown as an exception by most  ICU functions. 4Indicate whether the given error code is a success. 4Indicate whether the given error code is a failure. ;Throw an exception if the given code is actually an error. BDeal with ICU functions that report a buffer overflow error if we @ give them an insufficiently large buffer. Our first call will A report a buffer overflow, in which case we allocate a correctly  sized buffer and try again. ?Return a string representing the name of the given error code.  Initial guess at buffer size. Function that retrieves data. -Function that fills destination buffer if no  overflow occurred. !"#$% ! !"#$% GHC experimentalbos@serpentine.comNoneCharacter set converter type. Note: this structure is not  thread safe. It is not safe to use value of this type ' simultaneously from multiple threads. 4Gets the internal, canonical name of the converter. &'() *&') &'() *None{  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~{  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ GHC experimentalbos@serpentine.comNone+,-./+,-./+,-./NoneThe name of a locale.  The program's current locale. A specific locale. 8The root locale. For a description of resource bundles  and the root resource, see   1http://userguide.icu-project.org/locale/resources. BA type that supports efficient iteration over Unicode characters. AAs an example of where this may be useful, a function using this * type may be able to iterate over a UTF-8 0 directly, @ rather than first copying and converting it to an intermediate 6 form. This type also allows e.g. comparison between 1 and  0, with minimal overhead. 2Temporarily allocate a 3 and use it with the - contents of the to-be-iterated-over string. 4563789:2;<=>?@A4563782;<=>4563879:2;<=>?@AGHC experimentalbos@serpentine.comNoneB Compare two s.  Construct a  from a Unicode string.  Construct a  from a Unicode string.  Construct a $ from a Unicode string encoded as a  UTF-8 0. CBDECBDEGHC experimentalbos@serpentine.comNoneNormalization modes. " Fast C or D" form. ?Compatibility decomposition followed by canonical composition. ;Canonical decomposition followed by canonical composition. Compatibility decomposition. Canonical decomposition. No decomposition/ composition.  Options to . )When case folding, exclude the special I ! character. For use with Turkic  (Turkish/Azerbaijani) text data. .Compare strings case-insensitively using case 0 folding, instead of case-sensitively. If set, - then the following case folding options are  used. /The caller knows that both strings fulfill the   conditions. If not set,  will   for  and normalize if  necessary. ?Normalize a string according the specified normalization mode. @Perform an efficient check on a string, to quickly determine if 3 the string is in a particular normalization form. A 6 result indicates that a definite answer could not be < determined quickly, and a more thorough check is required,  e.g. with +. The user may have to convert the string 1 to its normalized form and compare the results.  A result of  F or  G indicates that the C string definitely is, or is not, in the given normalization form. <Indicate whether a string is in a given normalization form. Unlike -, this function returns a definitive result.  For , , and % normalization forms, both functions % work in exactly the same ways. For  and  forms, where   may return , this function will perform 1 further tests to arrive at a definitive result. @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 ( or ") being identical. This function < compares strings incrementally instead of normalizing (and ; optionally case-folding) both strings entirely, improving  performance significantly. CBulk normalization is only necessary if the strings do not fulfill  the 8 conditions. Only in this case, and only if the strings < are relatively long, is memory allocated temporarily. For   strings and short non-( strings there is no memory allocation. HIJKLMNOPHIJKLMNOPGHC experimentalbos@serpentine.comNone&Case-fold the characters in a string. BCase folding is locale independent and not context sensitive, but C there is an option for treating the letter I specially for Turkic D languages. The result may be longer or shorter than the original. &Lowercase the characters in a string. BCasing is locale dependent and context sensitive. The result may ) be longer or shorter than the original. &Uppercase the characters in a string. BCasing is locale dependent and context sensitive. The result may ) be longer or shorter than the original. QRST+Whether to include or exclude mappings for 1 dotted and dotless I and i that are marked with  I in CaseFolding.txt. UQRSTUGHC experimentalbos@serpentine.comNone5Hex digit character class. Printable character class. Graph character class. Blank character class. Alphanumeric character class. See UAX #!31 Identifier and Pattern Syntax   $http://www.unicode.org/reports/tr31/. See UAX #!31 Identifier and Pattern Syntax   $http://www.unicode.org/reports/tr31/. CICU-specific property for characters that are starters in terms of : Unicode normalization and combining character sequences. @ICU-specific property for characters that are inert under NFKC, 5 i.e. they do not interact with adjacent characters. ?ICU-specific property for characters that are inert under NFC, 5 i.e. they do not interact with adjacent characters. EICU-specific property for characters that are inert under NFKD, i.e. 0 they do not interact with adjacent characters. DICU-specific property for characters that are inert under NFD, i.e. E they do not interact with adjacent characters. Used for example in D normalizing transforms in incremental mode to find the boundary of ; safely normalizable text despite possible text additions. 9Indicates all those characters that qualify as Variation A Selectors. For details on the behavior of these characters, see   ;http://unicode.org/Public/UNIDATA/StandardizedVariants.html and 15.6  Variation Selectors. Sentence Terminal. Used in UAX #29: Text Boundaries   $http://www.unicode.org/reports/tr29/. 'Either the source of a case mapping or in the target of a case / mapping. Not the same as the general category  Cased_Letter. : modified to allow closure under normalization forms NFKC  and NFKD. 5 modified to allow closure under normalization forms  NFKC and NFKD. EFor programmatic determination of Ideographic Description Sequences. EPunctuation characters that generally mark the end of textual units. Characters with a soft dot), like i or j. An accent placed on these ) characters causes the dot to disappear. EFor programmatic determination of Ideographic Description Sequences. DCode points that are explicitly defined as illegal for the encoding  of characters. FCharacters that do not use logical order and require special handling  in most processing. 2Format controls for cursive joining and ligation. EFor programmatic determination of Ideographic Description Sequences. CJKV ideographs. )Characters that can start an identifier. ,Characters that can continue an identifier. BDashes used to mark connections between pieces of words, plus the  Katakana middle dot. 2Characters commonly used for hexadecimal numbers. ?For programmatic determination of grapheme cluster boundaries. ?For programmatic determination of grapheme cluster boundaries. ?For programmatic determination of grapheme cluster boundaries. ?Extend the value or shape of a preceding alphabetic character, " e.g. length and iteration marks. =Characters that linguistically modify the meaning of another  character to which they apply. <The usage of deprecated characters is strongly discouraged. Ignorable in most processing. Variations of dashes. 0Characters that may change display in RTL text. EFormat controls which have specific functions in the Bidi Algorithm. 0-9, A-F, a-f  Descriptions of Unicode blocks. u6The language directional property of a character set. <Return the Unicode allocation block that contains the given  character. <Return the bidirectional category value for the code point, ; which is used in the Unicode bidirectional algorithm (UAX #9   #http://www.unicode.org/reports/tr9/). )Determine whether the code point has the  property. This H property is set for characters that are commonly used in Right-To-Left * contexts and need to be displayed with a mirrored glyph. =Return the decimal digit value of a decimal digit character. + Such characters have the general category Nd (decimal digit  numbers) and a  of . ANo digit values are returned for any Han characters, because Han ? number characters are often used with a special Chinese-style E number format (with characters for powers of 10 in between) instead B of in decimal-positional notation. Unicode 4 explicitly assigns  Han number characters a  of  instead of  . DReturn the numeric value for a Unicode code point as defined in the  Unicode Character Database. A V: return type is necessary because some numeric values are J fractions, negative, or too large to fit in a fixed-width integral type. (Return the name of a Unicode character. 2The names of all unassigned characters are empty. The name contains only  invariant" characters like A-Z, 0-9, space,  and '-'. -Return the full name of a Unicode character.  Compared to ., this function gives each Unicode code point E a unique extended name. Extended names are lowercase followed by an 6 uppercase hexadecimal number, within angle brackets. ?Find a Unicode character by its full name, and return its code  point value. ,The name is matched exactly and completely. AA Unicode 1.0 name is matched only if it differs from the modern ) name. Unicode names are all uppercase. BFind a Unicode character by its full or extended name, and return  its code point value. ,The name is matched exactly and completely. AA Unicode 1.0 name is matched only if it differs from the modern  name.  Compared to (, this function gives each Unicode code E point a unique extended name. Extended names are lowercase followed < by an uppercase hexadecimal number, within angle brackets. .Return the ISO 10646 comment for a character. >If a character does not have an associated comment, the empty  string is returned. =The ISO 10646 comment is an informative field in the Unicode  Character Database (UnicodeData.txt field 11) and is from the ISO  10646 names list.  WXYZ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~[\      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~xynoMN  tsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!      u~}|{zyxwvz~}|{pwvutsrqOmlkjihgfedcba`_^]\[ZYXWVUTSRQPLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!    XWXYZ  #     6LKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"! MNOmlkjihgfedcba`_^]\[ZYXWVUTSRQPnopwvutsrqxyz~}|{[\1Ȭtsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!      u~}|{zyxwv]^_`abcdefghijklmnopqrstuvwxyz{|}~GHC experimentalbos@serpentine.comNoneString collator type. s are considered equal if they  will sort strings identically. String collator type. 1s are considered equal if they will sort strings H identically. This means that both the current attributes and the rules  must be equivalent.  GHC experimentalbos@serpentine.comNone #Do a fuzzy compare of two converter/alias names. The comparison = is case-insensitive, ignores leading zeroes if they are not E followed by further digits, and ignores all but letters and digits.  Thus the strings "UTF-8", "utf_8", "u*T@f08" and  "Utf 8"9 are exactly equivalent. See section 1.4, Charset Alias ( Matching in Unicode Technical Standard #22 at   $http://www.unicode.org/reports/tr22/  Create a ( with the name of a coded character set C specified as a string. The actual name will be resolved with the D alias file using a case-insensitive string comparison that ignores @ leading zeroes and all non-alphanumeric characters. E.g., the  names "UTF8", "utf-8", "u*T@f08" and "Utf 8" are  all equivalent (see also ). If an empty string is < passed for the converter name, it will create one with the   return value. DA converter name may contain options like a locale specification to D control the specific behavior of the newly instantiated converter. E The meaning of the options depends on the particular converter. If B an option is not defined for or recognized by a given converter,  then it is ignored. @Options are appended to the converter name string, with a comma A between the name and the first option and also between adjacent  options. AIf the alias is ambiguous, then the preferred converter is used. BThe conversion behavior and names can vary between platforms. ICU 4 may convert some characters differently from other 5 platforms. Details on this topic are in the ICU User' s Guide at   0http://icu-project.org/userguide/conversion.html . Aliases  starting with a "cp", prefix have no specific meaning other than ( its an alias starting with the letters "cp". Please do not ) associate any meaning to these aliases. BConvert the Unicode string into a codepage string using the given  converter. BConvert the codepage string into a Unicode string using the given  converter. @Determines whether the converter uses fallback mappings or not. E This flag has restrictions. Regardless of this flag, the converter D will always use fallbacks from Unicode Private Use code points, as : well as reverse fallbacks (to Unicode). For details see ".ucm  File Format"7 in the Conversion Data chapter of the ICU User Guide:   Chttp://www.icu-project.org/userguide/conversion-data.html#ucmformat ;Returns the current default converter name. If you want to  C a default converter, you do not need to use this function. It is $ faster to pass the empty string to  the default converter. ?Indicates whether the converter contains ambiguous mappings of  the same character or not. @Sets the current default converter name. If this function needs 6 to be called, it should be called during application 4 initialization. Most of the time, the results from   or 6 with an empty string argument is sufficient for your  application. Note$: this function is not thread safe. Do not call this  function when any/ ICU function is being used from more than one  thread! ;A list of the canonical names of all available converters. &The list of supported standard names. 8Return the aliases for a given converter or alias name. Name of the converter to use. !Whether to use fallback mappings  (see  for details).     GHC experimentalbos@serpentine.comNone A compiled regular expression. * values are usually constructed using the  or  regex'. functions. This type is also an instance of IsString,  so if you have the OverloadedStrings language extension enabled,  you can construct a " by simply writing the pattern in 7 quotes (though this does not allow you to specify any Options). ,Options for controlling matching behaviour. >Set the amount of heap storage avaliable for use by the match  backtracking stack. <ICU uses a backtracking regular expression engine, with the A backtrack stack maintained on the heap. This function sets the 9 limit to the amount of memory that can be used for this A purpose. A backtracking stack overflow will result in an error * from the match operation that caused it. <A limit is desirable because a malicious or poorly designed < pattern can use excessive memory, potentially crashing the * process. A limit is enabled by default. -Set a processing limit for match operations. 9Some patterns, when matching certain strings, can run in @ exponential time. For practical purposes, the match operation > may appear to be in an infinite loop. When a limit is set a 9 match operation will fail with an error if the limit is  exceeded. 6The units of the limit are steps of the match engine. > Correspondence with actual processor time will depend on the A speed of the processor and the details of the specific pattern, 5 but will typically be on the order of milliseconds. .By default, the matching time is not limited. ;Throw an error on unrecognized backslash escapes. If set, ? fail with an error on patterns that contain backslash-escaped A ASCII letters without a known special meaning. If this flag is 6 not set, these escaped letters represent themselves. "Unicode word boundaries. If set, '\\b' uses the . Unicode TR 29 definition of word boundaries. Warning3: Unicode word boundaries are quite different from 6 traditional regular expression word boundaries. See   0http://unicode.org/reports/tr29/#Word_Boundaries. <Haskell-only line endings. When this mode is enabled, only  '\n'3 is recognized as a line ending in the behavior of  '.', '^', and '$'. Control behaviour of '$' and '^'. If set, recognize @ line terminators within string, Otherwise, match only at start  and end of input string. 6If set, treat the entire pattern as a literal string. @ Metacharacters or escape sequences in the input sequence will  be given no special meaning.  The option " retains its meanings on matching < when used in conjunction with this option. Other options  become superfluous. If set, '.'% matches line terminators. Otherwise '.'  matching stops at line end. 0Allow comments and white space within patterns. "Enable case insensitive matching. ;Compile a regular expression with the given options. This  function throws a  ParseError if the pattern is invalid. The 3 is initialized with empty text to search against. $  GHC experimentalbos@serpentine.comNone >Compile a regular expression with the given options. This is < safest to use when the pattern is constructed at run time. >Set the subject text string upon which the regular expression C will look for matches. This function may be called any number of A times, allowing the regular expression pattern to be applied to  different strings. <Get the subject text that is currently associated with this  regular expression object. =Return the source form of the pattern used to construct this  regular expression or match. ;Find the first matching substring of the input string that  matches the pattern. If n7 is non-negative, the search for a match begins at the 1 specified index, and any match region is reset. If n< is -1, the search begins at the start of the input region, E or at the start of the full string if no region has been specified. If a match is found, , , and group will provide more " information regarding the match. BFind the next pattern match in the input string. Begin searching C the input at the location following the end of he previous match, C or at the start of the string (or region) if there is no previous  match. If a match is found, , , and group will provide more " information regarding the match. AMake a copy of a compiled regular expression. Cloning a regular E expression is faster than opening a second instance from the source 3 form of the expression, and requires less memory. CNote that the current input string and the position of any matched D text within it are not cloned; only the pattern itself and and the  match mode flags are copied. ACloning can be particularly useful to threaded applications that D perform multiple match operations in parallel. Each concurrent RE * operation requires its own instance of a . 6Return the number of capturing groups in this regular  expression' s pattern. ?Returns the index in the input string of the start of the text B matched by the specified capture group during the previous match  operation. Returns -1* if the capture group was not part of the  last match. =Returns the index in the input string of the end of the text B matched by the specified capture group during the previous match  operation. Returns -1& if the capture group was not part of  the last match. ?Returns the index in the input string of the start of the text B matched by the specified capture group during the previous match  operation. Returns & if the capture group was not part of  the last match. =Returns the index in the input string of the end of the text B matched by the specified capture group during the previous match  operation. Returns & if the capture group was not part of  the last match. GHC experimentalbos@serpentine.comNone)A typeclass for functions common to both  and   types. "A match for a regular expression. A compiled regular expression. * values are usually constructed using the  or  . functions. This type is also an instance of ,  so if you have the OverloadedStrings language extension enabled,  you can construct a " by simply writing the pattern in 7 quotes (though this does not allow you to specify any Options). ;Compile a regular expression with the given options. This  function throws a % if the pattern is invalid, so it is 4 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. CFind the first match for the regular expression in the given text. @Lazily find all matches for the regular expression in the given  text. 6Return 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  .  Return the n"th capturing group in a match, or  if n  is out of bounds. Return the prefix of the n#th capturing group in a match (the B text from the start of the string to the start of the match), or   if n is out of bounds. BReturn the span of text between the end of the previous match and % the beginning of the current match. Return the suffix of the n#th capturing group in a match (the > text from the end of the match to the end of the string), or   if n is out of bounds. GHC experimentalbos@serpentine.comNoneGHC experimentalbos@serpentine.comNone7When enabled, this attribute generates a collation key 9 for the numeric value of substrings of digits. This is  a way to get '100' to sort after '2'. 2When turned on, this attribute positions Hiragana : before all non-ignorables on quaternary level. This is a ' sneaky way to produce JIS sort order. 7Controls whether the normalization check and necessary $ normalizations are performed. When G (default) no : normalization check is performed. The correctness of the 3 result is guaranteed only if the input data is in  so-called FCD( form (see users manual for more info).  When F+, an incremental check is performed to see  whether the input data is in FCD form. If the data is  not in FCD form, incremental NFD normalization is  performed. 1Controls whether an extra case level (positioned 4 before the third level) is generated or not. When  G. (default), case level is not generated; when  F/, the case level is generated. Contents of the - case level are affected by the value of the  9 attribute. A simple way to ignore accent differences in $ a string is to set the strength to  and enable  case level. 6Control the ordering of upper and lower case letters.  + (the default) orders upper and lower case 2 letters in accordance to their tertiary weights. !For handling variable elements.  is  default. 1Direction of secondary weights, used in French. F, : results in secondary weights being considered backwards,  while G* treats secondary weights in the order in  which they appear. DThe strength attribute. The usual strength for most locales (except I Japanese) is tertiary. Quaternary strength is useful when combined with E shifted setting for alternate handling attribute and for JIS x 4061 I collation, when it is used to distinguish between Katakana and Hiragana  (this is achieved by setting  mode to  FA). Otherwise, quaternary level is affected only by the number of G non ignorable code points in the string. Identical strength is rarely , useful, as it amounts to codepoints of the NFD form of the string. 6Control the ordering of upper and lower case letters. (Force lower case letters to sort before  upper case. (Force upper case letters to sort before  lower case. 2Control the handling of variable weight elements. /Cause codepoints with primary weights that are 0 equal to or below the variable top value to be + ignored on primary level and moved to the  quaternary level. 0Treat all codepoints with non-ignorable primary  weights in the same way. Open a  for comparing strings. Set the value of an  attribute. Get the value of an  attribute. -It is safe to provide a dummy argument to an  constructor when 2 using this function, so the following will work: 1 getAttribute mcol (NormalizationMode undefined) Compare two strings.  Compare two s. *If either iterator was constructed from a 0, it does not need E to be copied or converted internally, so this function can be quite  cheap. Create a key for sorting the 1 using the given .  The result of comparing two 0s that have been  transformed with # will be the same as the result of   on the two untransformed 1s. Make a safe copy of a mutable  for use in pure code.  Subsequent changes to the  will not affect the state of  the returned . 14The locale containing the required collation rules.  GHC experimentalbos@serpentine.comNoneCreate an immutable  for comparing strings. If 6 is passed as the locale, UCA collation rules will be  used. Compare two strings.  Compare two s. *If either iterator was constructed from a 0, it does not D need to be copied or converted beforehand, so this function can be  quite cheap. Create a key for sorting the 1 using the given .  The result of comparing two 0s that have been  transformed with # will be the same as the result of   on the two untransformed 1s. A 2 that uses the Unicode Collation Algorithm (UCA). GHC experimentalbos@serpentine.comNoneWord break status. *A word containing ideographic characters. #A word containing kana characters. %A word containing letters, excluding # hiragana, katakana or ideographic  characters. $A word that appears to be a number. A "word" that does not fit into another % category. Includes spaces and most  punctuation. Line break status. #A soft line break is a position at + which a line break is acceptable, but not  required. (Break a string on character boundaries. 9Character boundary analysis identifies the boundaries of " Extended  Grapheme Clusters"3, which are groupings of codepoints that should be G 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 0 grapheme clusters and guidelines on their use. #Break a string on line boundaries. ILine boundary analysis determines where a text string can be broken when K line wrapping. The mechanism correctly handles punctuation and hyphenated  words. 'Break a string on sentence boundaries. HSentence boundary analysis allows selection with correct interpretation G of periods within numbers and abbreviations, and trailing punctuation 0 marks such as quotation marks and parentheses. #Break a string on word boundaries. HWord boundary analysis is used by search and replace functions, as well I as within text editing applications that allow the user to select words H with a double click. Word selection provides correct interpretation of G punctuation marks within and following words. Characters that are not K part of a word, such as symbols or punctuation marks, have word breaks on  both sides.  Create a new % for locating text boundaries in the  specified locale. Point an existing  at a new piece of text. BThread safe cloning operation. This is substantially faster than  creating a new  from scratch. >Reset the breaker to the beginning of the text to be scanned. 8Reset the breaker to the end of the text to be scanned. EAdvance the iterator and break at the text boundary that follows the  current text boundary. FAdvance the iterator and break at the text boundary that precedes the  current text boundary. <Determine the text boundary preceding the specified offset. <Determine the text boundary following the specified offset. 5Return the character index most recently returned by ,  , , or . HReturn the status from the break rule that determined the most recently E returned break position. For rules that do not specify a status, a  default value of () is returned. EReturn statuses from all of the break rules that determined the most # recently returned break position. @Determine whether the specfied position is a boundary position. = As a side effect, leaves the iterator pointing to the first 1 boundary position at or after the given offset. =Locales for which text breaking information is available. A  3 in a locale in this list will perform the correct  text breaking for the locale. -&GHC experimentalbos@serpentine.comNone A break in a string. Prefix of the current break. Text of the current break.  Suffix of the current break.  0Status of the current break (only meaningful if  or ).  A boundary analyser.  (Break a string on character boundaries. 9Character boundary analysis identifies the boundaries of Extended Grapheme Clusters3, which are groupings of codepoints that should be G 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 0 grapheme clusters and guidelines on their use.  #Break a string on line boundaries. ILine boundary analysis determines where a text string can be broken when K line wrapping. The mechanism correctly handles punctuation and hyphenated  words. 'Break a string on sentence boundaries. HSentence boundary analysis allows selection with correct interpretation G of periods within numbers and abbreviations, and trailing punctuation 0 marks such as quotation marks and parentheses. #Break a string on word boundaries. HWord boundary analysis is used by search and replace functions, as well I as within text editing applications that allow the user to select words H with a double click. Word selection provides correct interpretation of G punctuation marks within and following words. Characters that are not K 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.                 GHC experimentalbos@serpentine.comNoneR     V                  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\%]^_`abcdefghijklmnopqrstuvwxyz{|]}~}      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                            ! " # $ %&'()*+,-./0123456789:;<=>?@AB@ACDEFGHIJKLMNOPQ@ARSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~   text-icu-0.6.3.5Data.Text.ICU.ErrorData.Text.ICU.ConvertData.Text.ICU.BreakData.Text.ICU.Types Data.Text.ICUData.Text.ICU.NormalizeData.Text.ICU.CharData.Text.ICU.CollateData.Text.ICU.Regex Data.Text.ICU.Normalize.InternalData.Text.ICU.Error.InternalData.Text.ICU.Convert.InternalData.Text.ICU.Break.TypesData.Text.ICU.InternalData.Text.ICU.IteratorData.Text.ICU.TextData.Text.ICU.Collate.InternalData.Text.ICU.Regex.InternalData.Text.ICU.Regex.PureData.Text.ICU.Collate.PureData.Text.ICU.Break.Pure ParseErrorerrErrorerrLine errOffsetICUError isSuccess isFailure errorName ConvertergetNameu_USING_FALLBACK_WARNINGu_USING_DEFAULT_WARNINGu_SAFECLONE_ALLOCATED_WARNINGu_STATE_OLD_WARNINGu_STRING_NOT_TERMINATED_WARNINGu_SORT_KEY_TOO_SHORT_WARNINGu_AMBIGUOUS_ALIAS_WARNINGu_DIFFERENT_UCA_VERSIONu_ILLEGAL_ARGUMENT_ERRORu_MISSING_RESOURCE_ERRORu_INVALID_FORMAT_ERRORu_FILE_ACCESS_ERRORu_INTERNAL_PROGRAM_ERRORu_MESSAGE_PARSE_ERRORu_MEMORY_ALLOCATION_ERRORu_INDEX_OUTOFBOUNDS_ERROR u_PARSE_ERRORu_INVALID_CHAR_FOUNDu_TRUNCATED_CHAR_FOUNDu_ILLEGAL_CHAR_FOUNDu_INVALID_TABLE_FORMATu_INVALID_TABLE_FILEu_BUFFER_OVERFLOW_ERRORu_UNSUPPORTED_ERRORu_RESOURCE_TYPE_MISMATCHu_ILLEGAL_ESCAPE_SEQUENCEu_UNSUPPORTED_ESCAPE_SEQUENCEu_NO_SPACE_AVAILABLEu_CE_NOT_FOUND_ERRORu_PRIMARY_TOO_LONG_ERRORu_STATE_TOO_OLD_ERRORu_TOO_MANY_ALIASES_ERRORu_ENUM_OUT_OF_SYNC_ERRORu_INVARIANT_CONVERSION_ERRORu_INVALID_STATE_ERRORu_COLLATOR_VERSION_MISMATCHu_USELESS_COLLATOR_ERRORu_NO_WRITE_PERMISSIONu_BAD_VARIABLE_DEFINITIONu_MALFORMED_RULEu_MALFORMED_SETu_MALFORMED_UNICODE_ESCAPEu_MALFORMED_VARIABLE_DEFINITIONu_MALFORMED_VARIABLE_REFERENCEu_MISPLACED_CURSOR_OFFSETu_MISPLACED_QUANTIFIERu_MISSING_OPERATORu_MULTIPLE_ANTE_CONTEXTSu_MULTIPLE_CURSORSu_MULTIPLE_POST_CONTEXTSu_TRAILING_BACKSLASHu_UNDEFINED_SEGMENT_REFERENCEu_UNDEFINED_VARIABLEu_UNQUOTED_SPECIALu_UNTERMINATED_QUOTEu_RULE_MASK_ERRORu_MISPLACED_COMPOUND_FILTERu_MULTIPLE_COMPOUND_FILTERSu_INVALID_RBT_SYNTAXu_MALFORMED_PRAGMAu_UNCLOSED_SEGMENTu_VARIABLE_RANGE_EXHAUSTEDu_VARIABLE_RANGE_OVERLAPu_ILLEGAL_CHARACTERu_INTERNAL_TRANSLITERATOR_ERROR u_INVALID_IDu_INVALID_FUNCTIONu_UNEXPECTED_TOKENu_MULTIPLE_DECIMAL_SEPARATORSu_MULTIPLE_EXPONENTIAL_SYMBOLSu_MALFORMED_EXPONENTIAL_PATTERNu_MULTIPLE_PERCENT_SYMBOLSu_MULTIPLE_PERMILL_SYMBOLSu_MULTIPLE_PAD_SPECIFIERSu_PATTERN_SYNTAX_ERRORu_ILLEGAL_PAD_POSITIONu_UNMATCHED_BRACESu_ARGUMENT_TYPE_MISMATCHu_DUPLICATE_KEYWORDu_UNDEFINED_KEYWORDu_DEFAULT_KEYWORD_MISSINGu_BRK_INTERNAL_ERRORu_BRK_HEX_DIGITS_EXPECTEDu_BRK_SEMICOLON_EXPECTEDu_BRK_RULE_SYNTAXu_BRK_UNCLOSED_SETu_BRK_ASSIGN_ERRORu_BRK_VARIABLE_REDFINITIONu_BRK_MISMATCHED_PARENu_BRK_NEW_LINE_IN_QUOTED_STRINGu_BRK_UNDEFINED_VARIABLEu_BRK_INIT_ERRORu_BRK_RULE_EMPTY_SETu_BRK_UNRECOGNIZED_OPTIONu_BRK_MALFORMED_RULE_TAGu_REGEX_INTERNAL_ERRORu_REGEX_RULE_SYNTAXu_REGEX_INVALID_STATEu_REGEX_BAD_ESCAPE_SEQUENCEu_REGEX_PROPERTY_SYNTAXu_REGEX_UNIMPLEMENTEDu_REGEX_MISMATCHED_PARENu_REGEX_NUMBER_TOO_BIGu_REGEX_BAD_INTERVALu_REGEX_MAX_LT_MINu_REGEX_INVALID_BACK_REFu_REGEX_INVALID_FLAGu_REGEX_SET_CONTAINS_STRINGu_REGEX_OCTAL_TOO_BIGu_REGEX_INVALID_RANGEu_REGEX_STACK_OVERFLOWu_REGEX_TIME_OUTu_REGEX_STOPPED_BY_CALLERu_IDNA_PROHIBITED_ERRORu_IDNA_UNASSIGNED_ERRORu_IDNA_CHECK_BIDI_ERRORu_IDNA_STD3_ASCII_RULES_ERRORu_IDNA_ACE_PREFIX_ERRORu_IDNA_VERIFICATION_ERRORu_IDNA_LABEL_TOO_LONG_ERRORu_IDNA_ZERO_LENGTH_LABEL_ERROR!u_IDNA_DOMAIN_NAME_TOO_LONG_ERROR isRegexError BreakIterator LocaleNameCurrentLocaleRoot CharIterator fromStringfromTextfromUtf8NormalizationModeFCDNFKCNFCNFKDNFDNone CompareOptionFoldCaseExcludeSpecialICompareIgnoreCase InputIsFCD normalize quickCheck isNormalizedcompare toCaseFoldtoLowertoUpper WordBreak WBNewline WBMidNumLetWBLFWBExtendWBCRWBExtendNumLet WBNumericWBMidNum WBMidLetter WBKatakanaWBFormat WBALetter WordBreak_ SentenceBreak SBSContinueSBLFSBExtendSBCRSBUpperSBSTermSBSPSBSep SBOLetter SBNumericSBLowerSBFormatSBCloseSBATermSentenceBreak_GraphemeClusterBreakPrepend SpacingMarkVTLVTLVLFLExtendCRControlGraphemeClusterBreak_ TrailingCanonicalCombiningClass_TrailingCanonicalCombiningClassLeadCanonicalCombiningClass_LeadCanonicalCombiningClassNFKDQuickCheck_NFKDQuickCheckNFKCQuickCheck_NFKCQuickCheckNFDQuickCheck_ NFDQuickCheckNFCQuickCheck_ NFCQuickCheckHangulSyllableType LVTSyllable LVSyllable TrailingJamo VowelJamo LeadingJamoHangulSyllableType_ NumericType NTNumericNTDigit NTDecimal NumericType_ LineBreakJVJTJLH3H2 WordJoinerNextLineZwspace BreakSymbolsSpace LBSurrogateComplexContext Quotation PrefixNumericPostfixNumericOpenPunctuationNumeric NonstarterLineFeed InfixNumeric Inseparable LBIdeographicLBHyphenGlue ExclamationCarriageReturn CombiningMarkClosePunctuationContingentBreakMandatoryBreak BreakBefore BreakAfter BreakBoth LBAlphabetic Ambiguous LineBreak_ JoiningType Transparent RightJoining LeftJoining DualJoining JoinCausing JoiningType_ JoiningGroupBurushaskiYehBarreeZhainKhaphFeZainYudhHeYudh YehWithTail YehBarreeYehWawTeth TehMarbutaTawTah SyriacWawSwashKafShinSemkathSeenSadheSad ReversedPeRehQaphQafPeNunNoonMimMeemLamadhLam KnottedHehKaphKafHethHehGoalHehHeHamzaOnHehGoalHahGamalGaf FinalSemkathFehE DalathRishDalBethBehAlefAlaphAin JoiningGroup_GeneralCategoryFinalPunctuationInitialPunctuation OtherSymbolModifierSymbolCurrencySymbol MathSymbolOtherPunctuationConnectorPunctuationEndPunctuationStartPunctuationDashPunctuation SurrogatePrivateUseChar FormatChar ControlCharParagraphSeparator LineSeparatorSpaceSeparator OtherNumber LetterNumberDecimalDigitNumberCombiningSpacingMark EnclosingMarkNonSpacingMark OtherLetterModifierLetterTitlecaseLetterLowercaseLetterUppercaseLetterGeneralOtherTypeGeneralCategory_EastAsianWidthEACountEAWideEANarrowEAFullEAHalf EAAmbiguous EANeutralEastAsianWidth_ DecompositionCountWideVerticalSuperSubSquareSmallNoBreakNarrowMedialIsolatedInitialFractionFontFinalCircleCompat CanonicalDecomposition_CanonicalCombiningClass_CanonicalCombiningClassBlock_Block BidiClass_ BidiClassPropertyBool_ POSIXXDigit POSIXPrint POSIXGraph POSIXBlank POSIXAlNumPatternWhiteSpace PatternSyntaxSegmentStarter NFKCInertNFCInert NFKDInertNFDInertVariationSelectorSTerm CaseSensitiveXidStart XidContinue WhiteSpace UppercaseUnifiedIdeographTerminalPunctuation SoftDottedRadical QuotationMark NonCharacterMath LowercaseLogicalOrderException JoinControlIDSTrinaryOperatorIDSBinaryOperator IdeographicIDStart IDContinueHyphenHexDigit GraphemeLinkGraphemeExtend GraphemeBaseFullCompositionExclusionExtender Diacritic DeprecatedDefaultIgnorableDash BidiMirrored BidiControl ASCIIHexDigit Alphabetic BlockCode DominoTiles MahjongTilesLydianCarianLycian PhaistosDiscAncientSymbolsChamRejangKayahLi SaurashtraCyrillicExtendedBVaiCyrillicExtendedAOlChikiLepcha SundaneseCountingRodNumeralsCuneiformNumbersAndPunctuation Cuneiform PhoenicianPhagsPaLatinExtendedDLatinExtendedCBalineseN'Ko VerticalFormsTifinagh SylotiNagriSupplementalPunctuationPhoneticExtensionsSupplement OldPersian NewTaiLueModifierToneLetters Kharoshthi GlagoliticGeorgianSupplementEthiopicSupplementEthiopicExtendedCoptic#CombiningDiacriticalMarksSupplement CJKStrokesBugineseArabicSupplementAncientGreekNumbersAncientGreekMusicalNotationVariationSelectorsSupplementTaiXuanJingSymbolsCypriotSyllabaryOsmanyaShavianUgaritic AegeanNumbersLinearBIdeogramsLinearBSyllabaryYijingHexagramSymbolsMiscellaneousSymbolsAndArrowsPhoneticExtensions KhmerSymbolsTaiLeLimbuSupplementaryPrivateUseAreaBSupplementaryPrivateUseAreaAVariationSelectorsKatakanaPhoneticExtensions!SupplementalMathematicalOperators!MiscellaneousMathematicalSymbolsBSupplementalArrowsBSupplementalArrowsA!MiscellaneousMathematicalSymbolsATagbanwaBuhidHanunooTagalogCyrillicSupplementTags$CJKCompatibilityIdeographsSupplementCJKUnifiedIdeographsExtensionBMathematicalAlphanumericSymbolsMusicalSymbolsByzantineMusicalSymbolsDeseretGothic OldItalicHalfwidthAndFullwidthFormsSpecialsArabicPresentationFormsBSmallFormVariantsCJKCompatibilityFormsCombiningHalfMarksArabicPresentationFormsAAlphabeticPresentationFormsCJKCompatibilityIdeographsPrivateUseArea LowSurrogatesHighPrivateUseSurrogatesHighSurrogatesHangulSyllables YiRadicals YiSyllablesCJKUnifiedIdeographsCJKUnifiedIdeographsExtensionACJKCompatibilityEnclosedCJKLettersAndMonthsBopomofoExtendedKanbunHangulCompatibilityJamoBopomofoKatakanaHiraganaCJKSymbolsAndPunctuation IdeographicDescriptionCharactersKangxiRadicalsCJKRadicalsSupplementBraillePatternsDingbatsMiscellaneousSymbolsGeometricShapes BlockElements BoxDrawingEnclosedAlphanumericsOpticalCharacterRecognitionControlPicturesMiscellaneousTechnicalMathematicalOperatorsArrows NumberFormsLetterlikeSymbols#CombiningDiacriticalMarksForSymbolsCurrencySymbolsSuperscriptsAndSubscriptsGeneralPunctuation GreekExtendedLatinExtendedAdditional MongolianKhmerRunicOgham"UnifiedCanadianAboriginalSyllabicsCherokeeEthiopic HangulJamoGeorgianMyanmarTibetanLaoThaiSinhala MalayalamKannadaTeluguTamilOriyaGujaratiGurmukhiBengali DevanagariThaanaSyriacArabicHebrewArmenianCyrillicGreekAndCopticCombiningDiacriticalMarksSpacingModifierLetters IPAExtensionsLatinExtendedBLatinExtendedALatin1Supplement BasicLatinNoBlock DirectionBoundaryNeutralDirNonSpacingMarkPopDirectionalFormatRightToLeftOverrideRightToLeftEmbeddingRightToLeftArabicLeftToRightOverrideLeftToRightEmbedding OtherNeutralWhiteSpaceNeutralSegmentSeparatorBlockSeparatorCommonNumberSeparator ArabicNumberEuropeanNumberTerminatorEuropeanNumberSeparatorEuropeanNumber RightToLeft LeftToRightproperty blockCode direction isMirroredmirrorcombiningClass digitToInt numericValuecharName charFullName charFromNamecharFromFullName isoCommentCollator MCollatorequals compareNamesopen fromUnicode toUnicode usesFallbackgetDefaultName isAmbiguoussetDefaultNameconverterNames standardNamesaliasesRegex MatchOption StackLimit WorkLimitErrorOnUnknownEscapes UnicodeWord HaskellLines MultilineLiteralDotAllCommentsCaseInsensitiveregexregex'setTextgetTextpatternfindfindNextclone groupCountstart_end_startendRegularMatchfindAllunfoldgroupprefixspansuffix AttributeHiraganaQuaternaryModeStrength CaseLevel CaseFirstAlternateHandlingFrench Identical QuaternaryTertiary SecondaryPrimary LowerFirst UpperFirstShifted NonIgnorable setAttribute getAttributecollate collateItersortKeyfreezecollatorucaWord IdeographKanaLetterNumber UncategorizedLineHardSoftbreakCharacter breakLine breakSentence breakWordfirstlastnextprevious preceding followingcurrent getStatus getStatuses isBoundary availableBreak brkPrefixbrkBreak brkSuffix brkStatusBreakerbreaks breaksRightUNormalizationCheckResulttoNCRbase Data.MaybeNothingJust GHC.Exception Exception throwOnErrorhandleOverflowError UParseError fromErrorCode UErrorCode u_errorName withError handleErrorhandleParseError$fStorableParseError$fExceptionParseError$fExceptionICUError$fShowICUError UConverter ucnv_getName withConverter$fShowConverterUBreakIteratorBRbrTextbrStatusbrIterbytestring-0.10.0.2Data.ByteString.Internal ByteString text-0.11.2.3Data.Text.InternalTextwithCharIterator UCharIteratorUChar32UCharUBoolCIUTF8CIText uiter_setUTF8uiter_setStringasBool asOrderingwithNamewithLocaleName$fIsStringLocaleName$fStorableUCharIterator$fShowCharIterator compareIteru_strCompareIter$fOrdCharIterator$fEqCharIteratorghc-prim GHC.TypesTrueFalseUNormalizationModeUCompareOptionunorm_normalizeunorm_isNormalizedunorm_quickCheck unorm_comparefromCompareOptionreduceCompareOptionstoNM CaseMapper u_strToUpper u_strToLower u_strFoldCasecaseMapDouble UPropertyUCharNameChoiceUCharDirection UBlockCode fromNative toUPropertyu_getNumericValueu_getIntPropertyValueu_getISOCommentu_charFromName u_charNameu_charDigitValueu_getCombiningClass u_charMirror u_isMirroredu_charDirectionublock_getCode maybeEnum charFromName' charName' fillString$fPropertyWordBreak_Maybe$fPropertySentenceBreak_Maybe$$fPropertyGraphemeClusterBreak_Maybe-$fPropertyTrailingCanonicalCombiningClass_Int)$fPropertyLeadCanonicalCombiningClass_Int$fPropertyNFKDQuickCheck_Maybe$fPropertyNFKCQuickCheck_Maybe$fPropertyNFDQuickCheck_Maybe$fPropertyNFCQuickCheck_Maybe"$fPropertyHangulSyllableType_Maybe$fPropertyNumericType_Maybe$fPropertyLineBreak_Maybe$fPropertyJoiningType_Maybe$fPropertyJoiningGroup_Maybe)$fPropertyGeneralCategory_GeneralCategory$fPropertyBool_Bool'$fPropertyEastAsianWidth_EastAsianWidth$fPropertyDecomposition_Maybe%$fPropertyCanonicalCombiningClass_Int$fPropertyBlock_BlockCode$fPropertyBidiClass_DirectionC UCollator ucol_equals ucol_close withCollatorwrap $fEqCollatorucnv_isAmbiguousucnv_setFallbackucnv_usesFallbackucnv_getStandarducnv_countStandards ucnv_getAliasucnv_countAliasesucnv_getAvailableNameucnv_countAvailableucnv_setDefaultNameucnv_getDefaultNameucnv_compareNamesucnv_fromUChars ucnv_toUCharsmax_bytes_for_string ucnv_close ucnv_open URegexpFlagURegularExpressionreRereTextHaystackHuregex_setStackLimituregex_setTimeLimit uregex_groupuregex_groupCount uregex_end uregex_starturegex_findNext uregex_finduregex_getTexturegex_setTexturegex_pattern uregex_clone uregex_close uregex_openemptyForeignPtr toURegexpOptscheck $fShowRegex Data.StringIsStringregReregFpmatchRe _matchPrevmatchinggrouping$fRegularRegex$fRegularMatch $fShowMatch$fIsStringRegexUCollationResultUColAttributeValue UColAttributeucol_safeCloneucol_strcollIterucol_getSortKey ucol_strcollucol_setAttributeucol_getAttribute ucol_open toUAttributetoOOtoAHtoCFtoSfromOOfromAHfromCFfromSfromUAttribute valueErrorUBreakIteratorTypeubrk_getAvailableubrk_countAvailableubrk_isBoundaryubrk_getRuleStatusVecubrk_getRuleStatusubrk_followingubrk_preceding ubrk_previous ubrk_next ubrk_last ubrk_first ubrk_current ubrk_closeubrk_safeClone ubrk_setText ubrk_openasIndexBnew