-- Hoogle documentation, generated by Haddock -- See Hoogle, http://www.haskell.org/hoogle/ -- | An efficient packed Unicode text type -- -- An efficient packed Unicode text type. @package text @version 0.6 -- | Types and functions for dealing with encoding and decoding errors in -- Unicode text. -- -- The standard functions for encoding and decoding text are strict, -- which is to say that they throw exceptions on invalid input. This is -- often unhelpful on real world input, so alternative functions exist -- that accept custom handlers for dealing with invalid inputs. These -- OnError handlers are normal Haskell functions. You can use one -- of the presupplied functions in this module, or you can write a custom -- handler of your own. module Data.Text.Encoding.Error -- | An exception type for representing Unicode encoding errors. data UnicodeException -- | Could not decode a byte sequence because it was invalid under the -- given encoding, or ran out of input in mid-decode. DecodeError :: String -> (Maybe Word8) -> UnicodeException -- | Tried to encode a character that could not be represented under the -- given encoding, or ran out of input in mid-encode. EncodeError :: String -> (Maybe Char) -> UnicodeException -- | Function type for handling a coding error. It is supplied with two -- inputs: -- -- -- -- If the handler returns a value wrapped with Just, that value -- will be used in the output as the replacement for the invalid input. -- If it returns Nothing, no value will be used in the output. -- -- Should the handler need to abort processing, it should use -- error or throw an exception (preferably a -- UnicodeException). It may use the description provided to -- construct a more helpful error report. type OnError a b = String -> Maybe a -> Maybe b type OnDecodeError = OnError Word8 Char type OnEncodeError = OnError Char Word8 -- | Replace an invalid input byte with the Unicode replacement character -- U+FFFD. lenientDecode :: OnError Word8 Char -- | Throw a UnicodeException if decoding fails. strictDecode :: OnError Word8 Char -- | Throw a UnicodeException if encoding fails. strictEncode :: OnError Char Word8 -- | Ignore an invalid input, substituting nothing in the output. ignore :: OnError a b -- | Replace an invalid input with a valid output. replace :: b -> OnError a b instance Typeable UnicodeException instance Exception UnicodeException instance Show UnicodeException -- | Functions for converting Text values to and from -- ByteString, using several standard encodings. -- -- To make use of a much larger variety of encodings, use the -- text-icu package. module Data.Text.Encoding -- | Decode a ByteString containing 7-bit ASCII encoded text. decodeASCII :: ByteString -> Text -- | Decode a ByteString containing UTF-8 encoded text. decodeUtf8 :: ByteString -> Text -- | Decode text from little endian UTF-16 encoding. decodeUtf16LE :: ByteString -> Text -- | Decode text from big endian UTF-16 encoding. decodeUtf16BE :: ByteString -> Text -- | Decode text from little endian UTF-32 encoding. decodeUtf32LE :: ByteString -> Text -- | Decode text from big endian UTF-32 encoding. decodeUtf32BE :: ByteString -> Text -- | Decode a ByteString containing UTF-8 encoded text. decodeUtf8With :: OnDecodeError -> ByteString -> Text -- | Decode text from little endian UTF-16 encoding. decodeUtf16LEWith :: OnDecodeError -> ByteString -> Text -- | Decode text from big endian UTF-16 encoding. decodeUtf16BEWith :: OnDecodeError -> ByteString -> Text -- | Decode text from little endian UTF-32 encoding. decodeUtf32LEWith :: OnDecodeError -> ByteString -> Text -- | Decode text from big endian UTF-32 encoding. decodeUtf32BEWith :: OnDecodeError -> ByteString -> Text -- | Encode text using UTF-8 encoding. encodeUtf8 :: Text -> ByteString -- | Encode text using little endian UTF-16 encoding. encodeUtf16LE :: Text -> ByteString -- | Encode text using big endian UTF-16 encoding. encodeUtf16BE :: Text -> ByteString -- | Encode text using little endian UTF-32 encoding. encodeUtf32LE :: Text -> ByteString -- | Encode text using big endian UTF-32 encoding. encodeUtf32BE :: Text -> ByteString -- | Support for using Text data with native code via the Haskell -- foreign function interface. module Data.Text.Foreign -- | O(n) Create a new Text from a Ptr Word16 -- by copying the contents of the array. fromPtr :: Ptr Word16 -> Int -> IO Text -- | O(n) Perform an action on a temporary, mutable copy of a -- Text. The copy is freed as soon as the action returns. useAsPtr :: Text -> (Ptr Word16 -> Int -> IO a) -> IO a -- | O(1) Return the length of a Text in units of -- Word16. This is useful for sizing a target array appropriately -- before using unsafeCopyToPtr. lengthWord16 :: Text -> Int -- | O(n) Copy a Text to an array. The array is assumed to be -- big enough to hold the contents of the entire Text. unsafeCopyToPtr :: Text -> Ptr Word16 -> IO () -- | A time and space-efficient implementation of Unicode text using packed -- Word16 arrays. Suitable for performance critical use, both in terms of -- large data quantities and high speed. -- -- This module is intended to be imported qualified, to avoid -- name clashes with Prelude functions, e.g. -- -- 
--   import qualified Data.Text as T
--
module Data.Text -- | A space efficient, packed, unboxed Unicode text type. data Text -- | O(n) Convert a String into a Text. Subject to -- fusion. pack :: String -> Text -- | O(n) Convert a Text into a String. Subject to fusion. unpack :: Text -> String -- | O(1) Convert a character into a Text. Subject to fusion. singleton :: Char -> Text -- | O(1) The empty Text. empty :: Text -- | O(n) Adds a character to the front of a Text. This -- function is more costly than its List counterpart because it -- requires copying a new array. Subject to fusion. cons :: Char -> Text -> Text -- | O(n) Adds a character to the end of a Text. This copies -- the entire array in the process, unless fused. Subject to fusion. snoc :: Text -> Char -> Text -- | O(n) Appends one Text to the other by copying both of -- them into a new Text. Subject to fusion. append :: Text -> Text -> Text -- | O(1) Returns the first character and rest of a Text, or -- Nothing if empty. Subject to fusion. uncons :: Text -> Maybe (Char, Text) -- | O(1) Returns the first character of a Text, which must -- be non-empty. Subject to fusion. head :: Text -> Char -- | O(1) Returns the last character of a Text, which must be -- non-empty. Subject to fusion. last :: Text -> Char -- | O(1) Returns all characters after the head of a Text, -- which must be non-empty. Subject to fusion. tail :: Text -> Text -- | O(1) Returns all but the last character of a Text, which -- must be non-empty. Subject to fusion. init :: Text -> Text -- | O(1) Tests whether a Text is empty or not. Subject to -- fusion. null :: Text -> Bool -- | O(n) Returns the number of characters in a Text. Subject -- to fusion. length :: Text -> Int -- | O(n) map f t is the Text -- obtained by applying f to each element of t. Subject -- to fusion. map :: (Char -> Char) -> Text -> Text -- | O(n) The intercalate function takes a Text and a -- list of Texts and concatenates the list after interspersing the -- first argument between each element of the list. intercalate :: Text -> [Text] -> Text -- | O(n) The intersperse function takes a character and -- places it between the characters of a Text. Subject to fusion. intersperse :: Char -> Text -> Text -- | O(n) The transpose function transposes the rows and -- columns of its Text argument. Note that this function uses -- pack, unpack, and the list version of transpose, and is -- thus not very efficient. transpose :: [Text] -> [Text] -- | O(n) Reverse the characters of a string. Subject to fusion. reverse :: Text -> Text -- | O(m+n) Replace every occurrence of one substring with another. replace :: Text -> Text -> Text -> Text -- | O(n) Convert a string to folded case. This function is mainly -- useful for performing caseless (also known as case insensitive) string -- comparisons. -- -- A string x is a caseless match for a string y if and -- only if: -- -- 
--   toCaseFold x == toCaseFold y
--
-- -- The result string may be longer than the input string, and may differ -- from applying toLower to the input string. For instance, the -- Armenian small ligature "ﬓ" (men now, U+FB13) is case folded to the -- sequence "մ" (men, U+0574) followed by "ն" (now, U+0576), while the -- Greek "µ" (micro sign, U+00B5) is case folded to "μ" (small letter mu, -- U+03BC) instead of itself. toCaseFold :: Text -> Text -- | O(n) Convert a string to lower case, using simple case -- conversion. The result string may be longer than the input string. For -- instance, "İ" (Latin capital letter I with dot above, U+0130) maps to -- the sequence "i" (Latin small letter i, U+0069) followed by " ̇" -- (combining dot above, U+0307). toLower :: Text -> Text -- | O(n) Convert a string to upper case, using simple case -- conversion. The result string may be longer than the input string. For -- instance, the German "ß" (eszett, U+00DF) maps to the two-letter -- sequence "SS". toUpper :: Text -> Text -- | O(n) Left-justify a string to the given length, using the -- specified fill character on the right. Subject to fusion. Examples: -- -- 
--   justifyLeft 7 'x' "foo"    == "fooxxxx"
--   justifyLeft 3 'x' "foobar" == "foobar"
--
justifyLeft :: Int -> Char -> Text -> Text -- | O(n) Right-justify a string to the given length, using the -- specified fill character on the left. Examples: -- -- 
--   justifyRight 7 'x' "bar"    == "xxxxbar"
--   justifyRight 3 'x' "foobar" == "foobar"
--
justifyRight :: Int -> Char -> Text -> Text -- | O(n) Center a string to the given length, using the specified -- fill character on either side. Examples: -- -- 
--   center 8 'x' "HS" = "xxxHSxxx"
--
center :: Int -> Char -> Text -> Text -- | O(n) foldl, applied to a binary operator, a starting -- value (typically the left-identity of the operator), and a -- Text, reduces the Text using the binary operator, from -- left to right. Subject to fusion. foldl :: (b -> Char -> b) -> b -> Text -> b -- | O(n) A strict version of foldl. Subject to fusion. foldl' :: (b -> Char -> b) -> b -> Text -> b -- | O(n) A variant of foldl that has no starting value -- argument, and thus must be applied to a non-empty Text. Subject -- to fusion. foldl1 :: (Char -> Char -> Char) -> Text -> Char -- | O(n) A strict version of foldl1. Subject to fusion. foldl1' :: (Char -> Char -> Char) -> Text -> Char -- | O(n) foldr, applied to a binary operator, a starting -- value (typically the right-identity of the operator), and a -- Text, reduces the Text using the binary operator, from -- right to left. Subject to fusion. foldr :: (Char -> b -> b) -> b -> Text -> b -- | O(n) A variant of foldr that has no starting value -- argument, and thust must be applied to a non-empty Text. -- Subject to fusion. foldr1 :: (Char -> Char -> Char) -> Text -> Char -- | O(n) Concatenate a list of Texts. concat :: [Text] -> Text -- | O(n) Map a function over a Text that results in a -- Text, and concatenate the results. concatMap :: (Char -> Text) -> Text -> Text -- | O(n) any p t determines whether any -- character in the Text t satisifes the predicate -- p. Subject to fusion. any :: (Char -> Bool) -> Text -> Bool -- | O(n) all p t determines whether all -- characters in the Text t satisify the predicate -- p. Subject to fusion. all :: (Char -> Bool) -> Text -> Bool -- | O(n) maximum returns the maximum value from a -- Text, which must be non-empty. Subject to fusion. maximum :: Text -> Char -- | O(n) minimum returns the minimum value from a -- Text, which must be non-empty. Subject to fusion. minimum :: Text -> Char -- | O(n) scanl is similar to foldl, but returns a -- list of successive reduced values from the left. Subject to fusion. -- -- 
--   scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]
--
-- -- Note that -- -- 
--   last (scanl f z xs) == foldl f z xs.
--
scanl :: (Char -> Char -> Char) -> Char -> Text -> Text -- | O(n) scanl1 is a variant of scanl that has no -- starting value argument. Subject to fusion. -- -- 
--   scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]
--
scanl1 :: (Char -> Char -> Char) -> Text -> Text -- | O(n) scanr is the right-to-left dual of scanl. -- -- 
--   scanr f v == reverse . scanl (flip f) v . reverse
--
scanr :: (Char -> Char -> Char) -> Char -> Text -> Text -- | O(n) scanr1 is a variant of scanr that has no -- starting value argument. Subject to fusion. scanr1 :: (Char -> Char -> Char) -> Text -> Text -- | O(n) Like a combination of map and foldl. Applies -- a function to each element of a Text, passing an accumulating -- parameter from left to right, and returns a final Text. mapAccumL :: (a -> Char -> (a, Char)) -> a -> Text -> (a, Text) -- | The mapAccumR function behaves like a combination of map -- and foldr; it applies a function to each element of a -- Text, passing an accumulating parameter from right to left, and -- returning a final value of this accumulator together with the new -- Text. mapAccumR :: (a -> Char -> (a, Char)) -> a -> Text -> (a, Text) -- | O(n*m) replicate n t is a Text -- consisting of the input t repeated n times. replicate :: Int -> Text -> Text -- | O(n), where n is the length of the result. The -- unfoldr function is analogous to the List unfoldr. -- unfoldr builds a Text from a seed value. The function -- takes the element and returns Nothing if it is done producing -- the Text, otherwise Just (a,b). In this case, -- a is the next Char in the string, and b is -- the seed value for further production. Subject to fusion. unfoldr :: (a -> Maybe (Char, a)) -> a -> Text -- | O(n) Like unfoldr, unfoldrN builds a Text -- from a seed value. However, the length of the result should be limited -- by the first argument to unfoldrN. This function is more -- efficient than unfoldr when the maximum length of the result is -- known and correct, otherwise its performance is similar to -- unfoldr. Subject to fusion. unfoldrN :: Int -> (a -> Maybe (Char, a)) -> a -> Text -- | O(n) take n, applied to a Text, returns -- the prefix of the Text of length n, or the Text -- itself if n is greater than the length of the Text. Subject -- to fusion. take :: Int -> Text -> Text -- | O(n) drop n, applied to a Text, returns -- the suffix of the Text of length n, or the empty -- Text if n is greater than the length of the -- Text. Subject to fusion. drop :: Int -> Text -> Text -- | O(n) takeWhile, applied to a predicate p and a -- Text, returns the longest prefix (possibly empty) of elements -- that satisfy p. Subject to fusion. takeWhile :: (Char -> Bool) -> Text -> Text -- | O(n) dropWhile p t returns the suffix -- remaining after takeWhile p t. Subject to -- fusion. dropWhile :: (Char -> Bool) -> Text -> Text -- | O(n) dropWhileEnd p t returns the -- prefix remaining after dropping characters that fail the predicate -- p from the end of t. Subject to fusion. Examples: -- -- 
--   dropWhileEnd (=='.') "foo..." == "foo"
--
dropWhileEnd :: (Char -> Bool) -> Text -> Text -- | O(n) dropAround p t returns the -- substring remaining after dropping characters that fail the predicate -- p from both the beginning and end of t. Subject to -- fusion. dropAround :: (Char -> Bool) -> Text -> Text -- | O(n) Remove leading and trailing white space from a string. -- Equivalent to: -- -- 
--   dropAround isSpace
--
strip :: Text -> Text -- | O(n) Remove leading white space from a string. Equivalent to: -- -- 
--   dropWhile isSpace
--
stripStart :: Text -> Text -- | O(n) Remove trailing white space from a string. Equivalent to: -- -- 
--   dropWhileEnd isSpace
--
stripEnd :: Text -> Text -- | O(n) splitAt n t returns a pair whose first -- element is a prefix of t of length n, and whose -- second is the remainder of the string. It is equivalent to -- (take n t, drop n t). splitAt :: Int -> Text -> (Text, Text) -- | O(n) spanBy, applied to a predicate p and text -- t, returns a pair whose first element is the longest prefix -- (possibly empty) of t of elements that satisfy p, -- and whose second is the remainder of the list. spanBy :: (Char -> Bool) -> Text -> (Text, Text) -- | O(n+m) Find the first instance of needle (which must -- be non-null) in haystack. The first element of the -- returned tuple is the prefix of haystack before -- needle is matched. The second is the remainder of -- haystack, starting with the match. -- -- Examples: -- -- 
--   break "::" "a::b::c" ==> ("a", "::b::c")
--   break "/" "foobar"   ==> ("foobar", "")
--
-- -- Laws: -- -- 
--   append prefix match == haystack
--     where (prefix, match) = break needle haystack
--
-- -- If you need to break a string by a substring repeatedly (e.g. you want -- to break on every instance of a substring), use find instead, -- as it has lower startup overhead. -- -- In (unlikely) bad cases, this function's time complexity degrades -- towards O(n*m). break :: Text -> Text -> (Text, Text) -- | O(n+m) Similar to break, but searches from the end of -- the string. -- -- The first element of the returned tuple is the prefix of -- haystack up to and including the last match of -- needle. The second is the remainder of haystack, -- following the match. -- -- 
--   breakEnd "::" "a::b::c" ==> ("a::b::", "c")
--
breakEnd :: Text -> Text -> (Text, Text) -- | O(n) breakBy is like spanBy, but the prefix -- returned is over elements that fail the predicate p. breakBy :: (Char -> Bool) -> Text -> (Text, Text) -- | O(n) Group characters in a string by equality. group :: Text -> [Text] -- | O(n) Group characters in a string according to a predicate. groupBy :: (Char -> Char -> Bool) -> Text -> [Text] -- | O(n) Return all initial segments of the given Text, -- shortest first. inits :: Text -> [Text] -- | O(n) Return all final segments of the given Text, -- longest first. tails :: Text -> [Text] -- | O(m+n) Break a Text into pieces separated by the first -- Text argument, consuming the delimiter. An empty delimiter is -- invalid, and will cause an error to be raised. -- -- Examples: -- -- 
--   split "\r\n" "a\r\nb\r\nd\r\ne" == ["a","b","d","e"]
--   split "aaa"  "aaaXaaaXaaaXaaa"  == ["","X","X","X",""]
--   split "x"    "x"                == ["",""]
--
-- -- and -- -- 
--   intercalate s . split s         == id
--   split (singleton c)             == splitBy (==c)
--
-- -- In (unlikely) bad cases, this function's time complexity degrades -- towards O(n*m). split :: Text -> Text -> [Text] -- | O(n) Splits a Text into components delimited by -- separators, where the predicate returns True for a separator element. -- The resulting components do not contain the separators. Two adjacent -- separators result in an empty component in the output. eg. -- -- 
--   splitBy (=='a') "aabbaca" == ["","","bb","c",""]
--   splitBy (=='a') ""        == [""]
--
splitBy :: (Char -> Bool) -> Text -> [Text] -- | O(n) Splits a Text into components of length k. -- The last element may be shorter than the other chunks, depending on -- the length of the input. Examples: -- -- 
--   chunksOf 3 "foobarbaz"   == ["foo","bar","baz"]
--   chunksOf 4 "haskell.org" == ["hask","ell.","org"]
--
chunksOf :: Int -> Text -> [Text] -- | O(n) Breaks a Text up into a list of Texts at -- newline Chars. The resulting strings do not contain newlines. lines :: Text -> [Text] -- | O(n) Breaks a Text up into a list of words, delimited by -- Chars representing white space. words :: Text -> [Text] -- | O(n) Joins lines, after appending a terminating newline to -- each. unlines :: [Text] -> Text -- | O(n) Joins words using single space characters. unwords :: [Text] -> Text -- | O(n) The isPrefixOf function takes two Texts and -- returns True iff the first is a prefix of the second. This -- function is subject to fusion. isPrefixOf :: Text -> Text -> Bool -- | O(n) The isSuffixOf function takes two Texts and -- returns True iff the first is a suffix of the second. isSuffixOf :: Text -> Text -> Bool -- | O(n+m) The isInfixOf function takes two Texts and -- returns True iff the first is contained, wholly and intact, -- anywhere within the second. -- -- In (unlikely) bad cases, this function's time complexity degrades -- towards O(n*m). isInfixOf :: Text -> Text -> Bool -- | O(n) filter, applied to a predicate and a Text, -- returns a Text containing those characters that satisfy the -- predicate. filter :: (Char -> Bool) -> Text -> Text -- | O(n+m) Find all non-overlapping instances of needle in -- haystack. The first element of the returned pair is the -- prefix of haystack prior to any matches of needle. -- The second is a list of pairs. -- -- The first element of each pair in the list is a span from the -- beginning of a match to the beginning of the next match, while the -- second is a span from the beginning of the match to the end of the -- input. -- -- Examples: -- -- 
--   find "::" ""
--   ==> ("", [])
--   find "/" "a/b/c/d"
--   ==> ("a", [("/b","/b/c/d"), ("/c","/c/d"), ("/d","/d")])
--
-- -- In (unlikely) bad cases, this function's time complexity degrades -- towards O(n*m). find :: Text -> Text -> (Text, [(Text, Text)]) -- | O(n) The findBy function takes a predicate and a -- Text, and returns the first element in matching the predicate, -- or Nothing if there is no such element. findBy :: (Char -> Bool) -> Text -> Maybe Char -- | O(n) The partitionBy function takes a predicate and a -- Text, and returns the pair of Texts with elements which -- do and do not satisfy the predicate, respectively; i.e. -- -- 
--   partitionBy p t == (filter p t, filter (not . p) t)
--
partitionBy :: (Char -> Bool) -> Text -> (Text, Text) -- | O(n) Text index (subscript) operator, starting from 0. index :: Text -> Int -> Char -- | O(n) The findIndex function takes a predicate and a -- Text and returns the index of the first element in the -- Text satisfying the predicate. Subject to fusion. findIndex :: (Char -> Bool) -> Text -> Maybe Int -- | O(n+m) The count function returns the number of times -- the query string appears in the given Text. An empty query -- string is invalid, and will cause an error to be raised. -- -- In (unlikely) bad cases, this function's time complexity degrades -- towards O(n*m). count :: Text -> Text -> Int -- | O(n) zip takes two Texts and returns a list of -- corresponding pairs of bytes. If one input Text is short, -- excess elements of the longer Text are discarded. This is -- equivalent to a pair of unpack operations. zip :: Text -> Text -> [(Char, Char)] -- | O(n) zipWith generalises zip by zipping with the -- function given as the first argument, instead of a tupling function. zipWith :: (Char -> Char -> Char) -> Text -> Text -> Text instance NFData Text instance IsString Text instance Monoid Text instance Read Text instance Show Text instance Ord Text instance Eq Text -- | A time and space-efficient implementation of Unicode text using lists -- of packed arrays. This representation is suitable for high performance -- use and for streaming large quantities of data. It provides a means to -- manipulate a large body of text without requiring that the entire -- content be resident in memory. -- -- Some operations, such as concat, append, reverse -- and cons, have better complexity than their Data.Text -- equivalents, due to optimisations resulting from the list spine -- structure. And for other operations lazy Texts are usually -- within a few percent of strict ones, but with better heap usage. For -- data larger than available memory, or if you have tight memory -- constraints, this module will be the only option. -- -- This module is intended to be imported qualified, to avoid -- name clashes with Prelude functions. eg. -- -- 
--   import qualified Data.Text.Lazy as B
--
module Data.Text.Lazy data Text -- | O(n) Convert a String into a Text. -- -- This function is subject to array fusion. pack :: String -> Text -- | O(n) Convert a Text into a String. Subject to -- array fusion. unpack :: Text -> String singleton :: Char -> Text -- | Smart constructor for Empty. empty :: Text -- | O(c) Convert a list of strict Texts into a lazy -- Text. fromChunks :: [Text] -> Text -- | O(n) Convert a lazy Text into a list of strict -- Texts. toChunks :: Text -> [Text] cons :: Char -> Text -> Text snoc :: Text -> Char -> Text -- | O(n\c)/ Appends one Text to another. Subject to array -- fusion. append :: Text -> Text -> Text -- | O(1) Returns the first character and rest of a Text, or -- Nothing if empty. Subject to array fusion. uncons :: Text -> Maybe (Char, Text) -- | O(1) Returns the first character of a Text, which must -- be non-empty. Subject to array fusion. head :: Text -> Char -- | O(1) Returns the last character of a Text, which must be -- non-empty. Subject to array fusion. last :: Text -> Char -- | O(1) Returns all characters after the head of a Text, -- which must be non-empty. Subject to array fusion. tail :: Text -> Text -- | O(1) Returns all but the last character of a Text, which -- must be non-empty. Subject to array fusion. init :: Text -> Text -- | O(1) Tests whether a Text is empty or not. Subject to -- array fusion. null :: Text -> Bool length :: Text -> Int64 -- | O(n) map f t is the Text -- obtained by applying f to each element of t. Subject -- to array fusion. map :: (Char -> Char) -> Text -> Text -- | O(n) The intercalate function takes a Text and a -- list of Texts and concatenates the list after interspersing the -- first argument between each element of the list. intercalate :: Text -> [Text] -> Text -- | O(n) The intersperse function takes a character and -- places it between the characters of a Text. Subject to array -- fusion. intersperse :: Char -> Text -> Text -- | O(n) The transpose function transposes the rows and -- columns of its Text argument. Note that this function uses -- pack, unpack, and the list version of transpose, and is -- thus not very efficient. transpose :: [Text] -> [Text] -- | O(n) reverse t returns the elements of -- t in reverse order. reverse :: Text -> Text -- | O(m+n) Replace every occurrence of one substring with another. replace :: Text -> Text -> Text -> Text -- | O(n) Convert a string to folded case. This function is mainly -- useful for performing caseless (or case insensitive) string -- comparisons. -- -- A string x is a caseless match for a string y if and -- only if: -- -- 
--   toCaseFold x == toCaseFold y
--
-- -- The result string may be longer than the input string, and may differ -- from applying toLower to the input string. For instance, the -- Armenian small ligature men now (U+FB13) is case folded to the bigram -- men now (U+0574 U+0576), while the micro sign (U+00B5) is case folded -- to the Greek small letter letter mu (U+03BC) instead of itself. toCaseFold :: Text -> Text -- | O(n) Convert a string to lower case, using simple case -- conversion. The result string may be longer than the input string. For -- instance, the Latin capital letter I with dot above (U+0130) maps to -- the sequence Latin small letter i (U+0069) followed by combining dot -- above (U+0307). toLower :: Text -> Text -- | O(n) Convert a string to upper case, using simple case -- conversion. The result string may be longer than the input string. For -- instance, the German eszett (U+00DF) maps to the two-letter sequence -- SS. toUpper :: Text -> Text -- | O(n) Left-justify a string to the given length, using the -- specified fill character on the right. Subject to fusion. Examples: -- -- 
--   justifyLeft 7 'x' "foo"    == "fooxxxx"
--   justifyLeft 3 'x' "foobar" == "foobar"
--
justifyLeft :: Int64 -> Char -> Text -> Text -- | O(n) Right-justify a string to the given length, using the -- specified fill character on the left. Examples: -- -- 
--   justifyRight 7 'x' "bar"    == "xxxxbar"
--   justifyRight 3 'x' "foobar" == "foobar"
--
justifyRight :: Int64 -> Char -> Text -> Text -- | O(n) Center a string to the given length, using the specified -- fill character on either side. Examples: -- -- 
--   center 8 'x' "HS" = "xxxHSxxx"
--
center :: Int64 -> Char -> Text -> Text -- | O(n) foldl, applied to a binary operator, a starting -- value (typically the left-identity of the operator), and a -- Text, reduces the Text using the binary operator, from -- left to right. Subject to array fusion. foldl :: (b -> Char -> b) -> b -> Text -> b -- | O(n) A strict version of foldl. Subject to array fusion. foldl' :: (b -> Char -> b) -> b -> Text -> b -- | O(n) A variant of foldl that has no starting value -- argument, and thus must be applied to a non-empty Text. Subject -- to array fusion. foldl1 :: (Char -> Char -> Char) -> Text -> Char -- | O(n) A strict version of foldl1. Subject to array -- fusion. foldl1' :: (Char -> Char -> Char) -> Text -> Char -- | O(n) foldr, applied to a binary operator, a starting -- value (typically the right-identity of the operator), and a -- Text, reduces the Text using the binary operator, from -- right to left. Subject to array fusion. foldr :: (Char -> b -> b) -> b -> Text -> b -- | O(n) A variant of foldr that has no starting value -- argument, and thust must be applied to a non-empty Text. -- Subject to array fusion. foldr1 :: (Char -> Char -> Char) -> Text -> Char -- | O(n) Concatenate a list of Texts. concat :: [Text] -> Text -- | O(n) Map a function over a Text that results in a -- Text, and concatenate the results. concatMap :: (Char -> Text) -> Text -> Text -- | O(n) any p t determines whether any -- character in the Text t satisifes the predicate -- p. Subject to array fusion. any :: (Char -> Bool) -> Text -> Bool -- | O(n) all p t determines whether all -- characters in the Text t satisify the predicate -- p. Subject to array fusion. all :: (Char -> Bool) -> Text -> Bool -- | O(n) maximum returns the maximum value from a -- Text, which must be non-empty. Subject to array fusion. maximum :: Text -> Char -- | O(n) minimum returns the minimum value from a -- Text, which must be non-empty. Subject to array fusion. minimum :: Text -> Char -- | O(n) scanl is similar to foldl, but returns a -- list of successive reduced values from the left. This function is -- subject to array fusion. -- -- 
--   scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]
--
-- -- Note that -- -- 
--   last (scanl f z xs) == foldl f z xs.
--
scanl :: (Char -> Char -> Char) -> Char -> Text -> Text -- | O(n) scanl1 is a variant of scanl that has no -- starting value argument. This function is subject to array fusion. -- -- 
--   scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]
--
scanl1 :: (Char -> Char -> Char) -> Text -> Text -- | O(n) scanr is the right-to-left dual of scanl. -- -- 
--   scanr f v == reverse . scanl (flip f) v . reverse
--
scanr :: (Char -> Char -> Char) -> Char -> Text -> Text -- | O(n) scanr1 is a variant of scanr that has no -- starting value argument. scanr1 :: (Char -> Char -> Char) -> Text -> Text -- | O(n) Like a combination of map and foldl. Applies -- a function to each element of a Text, passing an accumulating -- parameter from left to right, and returns a final Text. mapAccumL :: (a -> Char -> (a, Char)) -> a -> Text -> (a, Text) -- | The mapAccumR function behaves like a combination of map -- and foldr; it applies a function to each element of a -- Text, passing an accumulating parameter from right to left, and -- returning a final value of this accumulator together with the new -- Text. mapAccumR :: (a -> Char -> (a, Char)) -> a -> Text -> (a, Text) -- | O(n*m) replicate n t is a Text -- consisting of the input t repeated n times. replicate :: Int64 -> Text -> Text -- | O(n), where n is the length of the result. The -- unfoldr function is analogous to the List unfoldr. -- unfoldr builds a Text from a seed value. The function -- takes the element and returns Nothing if it is done producing -- the Text, otherwise Just (a,b). In this case, -- a is the next Char in the string, and b is -- the seed value for further production. unfoldr :: (a -> Maybe (Char, a)) -> a -> Text -- | O(n) Like unfoldr, unfoldrN builds a Text -- from a seed value. However, the length of the result should be limited -- by the first argument to unfoldrN. This function is more -- efficient than unfoldr when the maximum length of the result is -- known and correct, otherwise its performance is similar to -- unfoldr. unfoldrN :: Int64 -> (a -> Maybe (Char, a)) -> a -> Text -- | O(n) take n, applied to a Text, returns -- the prefix of the Text of length n, or the Text -- itself if n is greater than the length of the Text. Subject -- to fusion. take :: Int64 -> Text -> Text -- | O(n) drop n, applied to a Text, returns -- the suffix of the Text of length n, or the empty -- Text if n is greater than the length of the -- Text. Subject to fusion. drop :: Int64 -> Text -> Text -- | O(n) takeWhile, applied to a predicate p and a -- Text, returns the longest prefix (possibly empty) of elements -- that satisfy p. This function is subject to array fusion. takeWhile :: (Char -> Bool) -> Text -> Text -- | O(n) dropWhile p t returns the suffix -- remaining after takeWhile p t. This function -- is subject to array fusion. dropWhile :: (Char -> Bool) -> Text -> Text -- | O(n) dropWhileEnd p t returns the -- prefix remaining after dropping characters that fail the predicate -- p from the end of t. Examples: -- -- 
--   dropWhileEnd (=='.') "foo..." == "foo"
--
dropWhileEnd :: (Char -> Bool) -> Text -> Text -- | O(n) dropAround p t returns the -- substring remaining after dropping characters that fail the predicate -- p from both the beginning and end of t. Subject to -- fusion. dropAround :: (Char -> Bool) -> Text -> Text -- | O(n) Remove leading and trailing white space from a string. -- Equivalent to: -- -- 
--   dropAround isSpace
--
strip :: Text -> Text -- | O(n) Remove leading white space from a string. Equivalent to: -- -- 
--   dropWhile isSpace
--
stripStart :: Text -> Text -- | O(n) Remove trailing white space from a string. Equivalent to: -- -- 
--   dropWhileEnd isSpace
--
stripEnd :: Text -> Text -- | O(n) splitAt n t returns a pair whose first -- element is a prefix of t of length n, and whose -- second is the remainder of the string. It is equivalent to -- (take n t, drop n t). splitAt :: Int64 -> Text -> (Text, Text) -- | O(n) spanBy, applied to a predicate p and text -- t, returns a pair whose first element is the longest prefix -- (possibly empty) of t of elements that satisfy p, -- and whose second is the remainder of the list. spanBy :: (Char -> Bool) -> Text -> (Text, Text) -- | O(n+m) Find the first instance of needle (which must -- be non-null) in haystack. The first element of the -- returned tuple is the prefix of haystack before -- needle is matched. The second is the remainder of -- haystack, starting with the match. -- -- Examples: -- -- 
--   break "::" "a::b::c" ==> ("a", "::b::c")
--   break "/" "foobar"   ==> ("foobar", "")
--
-- -- Laws: -- -- 
--   append prefix match == haystack
--     where (prefix, match) = break needle haystack
--
-- -- If you need to break a string by a substring repeatedly (e.g. you want -- to break on every instance of a substring), use find instead, -- as it has lower startup overhead. -- -- This function is strict in its first argument, and lazy in its second. -- -- In (unlikely) bad cases, this function's time complexity degrades -- towards O(n*m). break :: Text -> Text -> (Text, Text) -- | O(n+m) Similar to break, but searches from the end of -- the string. -- -- The first element of the returned tuple is the prefix of -- haystack up to and including the last match of -- needle. The second is the remainder of haystack, -- following the match. -- -- 
--   breakEnd "::" "a::b::c" ==> ("a::b::", "c")
--
breakEnd :: Text -> Text -> (Text, Text) -- | O(n) breakBy is like spanBy, but the prefix -- returned is over elements that fail the predicate p. breakBy :: (Char -> Bool) -> Text -> (Text, Text) -- | The group function takes a Text and returns a list of -- Texts such that the concatenation of the result is equal to the -- argument. Moreover, each sublist in the result contains only equal -- elements. For example, -- -- 
--   group "Mississippi" = ["M","i","ss","i","ss","i","pp","i"]
--
-- -- It is a special case of groupBy, which allows the programmer to -- supply their own equality test. group :: Text -> [Text] -- | The groupBy function is the non-overloaded version of -- group. groupBy :: (Char -> Char -> Bool) -> Text -> [Text] -- | O(n) Return all initial segments of the given Text, -- shortest first. inits :: Text -> [Text] -- | O(n) Return all final segments of the given Text, -- longest first. tails :: Text -> [Text] -- | O(m+n) Break a Text into pieces separated by the first -- Text argument, consuming the delimiter. An empty delimiter is -- invalid, and will cause an error to be raised. -- -- Examples: -- -- 
--   split "\r\n" "a\r\nb\r\nd\r\ne" == ["a","b","d","e"]
--   split "aaa"  "aaaXaaaXaaaXaaa"  == ["","X","X","X",""]
--   split "x"    "x"                == ["",""]
--
-- -- and -- -- 
--   intercalate s . split s         == id
--   split (singleton c)             == splitBy (==c)
--
-- -- This function is strict in its first argument, and lazy in its second. -- -- In (unlikely) bad cases, this function's time complexity degrades -- towards O(n*m). split :: Text -> Text -> [Text] -- | O(n) Splits a Text into components delimited by -- separators, where the predicate returns True for a separator element. -- The resulting components do not contain the separators. Two adjacent -- separators result in an empty component in the output. eg. -- -- 
--   splitBy (=='a') "aabbaca" == ["","","bb","c",""]
--   splitBy (=='a') []        == [""]
--
splitBy :: (Char -> Bool) -> Text -> [Text] -- | O(n) Splits a Text into components of length k. -- The last element may be shorter than the other chunks, depending on -- the length of the input. Examples: -- -- 
--   chunksOf 3 "foobarbaz"   == ["foo","bar","baz"]
--   chunksOf 4 "haskell.org" == ["hask","ell.","org"]
--
chunksOf :: Int64 -> Text -> [Text] -- | O(n) Breaks a Text up into a list of Texts at -- newline Chars. The resulting strings do not contain newlines. lines :: Text -> [Text] -- | O(n) Breaks a Text up into a list of words, delimited by -- Chars representing white space. words :: Text -> [Text] -- | O(n) Joins lines, after appending a terminating newline to -- each. unlines :: [Text] -> Text -- | O(n) Joins words using single space characters. unwords :: [Text] -> Text -- | O(n) The isPrefixOf function takes two Texts and -- returns True iff the first is a prefix of the second. This -- function is subject to fusion. isPrefixOf :: Text -> Text -> Bool -- | O(n) The isSuffixOf function takes two Texts and -- returns True iff the first is a suffix of the second. isSuffixOf :: Text -> Text -> Bool -- | O(n+m) The isInfixOf function takes two Texts and -- returns True iff the first is contained, wholly and intact, -- anywhere within the second. -- -- This function is strict in its first argument, and lazy in its second. -- -- In (unlikely) bad cases, this function's time complexity degrades -- towards O(n*m). isInfixOf :: Text -> Text -> Bool -- | O(n) filter, applied to a predicate and a Text, -- returns a Text containing those characters that satisfy the -- predicate. filter :: (Char -> Bool) -> Text -> Text -- | O(n+m) Find all non-overlapping instances of needle in -- haystack. The first element of the returned pair is the -- prefix of haystack prior to any matches of needle. -- The second is a list of pairs. -- -- The first element of each pair in the list is a span from the -- beginning of a match to the beginning of the next match, while the -- second is a span from the beginning of the match to the end of the -- input. -- -- Examples: -- -- 
--   find "::" ""
--   ==> ("", [])
--   find "/" "a/b/c/d"
--   ==> ("a", [("/b","/b/c/d"), ("/c","/c/d"), ("/d","/d")])
--
-- -- This function is strict in its first argument, and lazy in its second. -- -- In (unlikely) bad cases, this function's time complexity degrades -- towards O(n*m). find :: Text -> Text -> (Text, [(Text, Text)]) -- | O(n) The findBy function takes a predicate and a -- Text, and returns the first element in matching the predicate, -- or Nothing if there is no such element. findBy :: (Char -> Bool) -> Text -> Maybe Char -- | O(n) The partitionBy function takes a predicate and a -- Text, and returns the pair of Texts with elements which -- do and do not satisfy the predicate, respectively; i.e. -- -- 
--   partitionBy p t == (filter p t, filter (not . p) t)
--
partitionBy :: (Char -> Bool) -> Text -> (Text, Text) -- | O(n) Text index (subscript) operator, starting from 0. index :: Text -> Int64 -> Char -- | O(n+m) The count function returns the number of times -- the query string appears in the given Text. An empty query -- string is invalid, and will cause an error to be raised. -- -- In (unlikely) bad cases, this function's time complexity degrades -- towards O(n*m). count :: Text -> Text -> Int64 -- | O(n) zip takes two Texts and returns a list of -- corresponding pairs of bytes. If one input Text is short, -- excess elements of the longer Text are discarded. This is -- equivalent to a pair of unpack operations. zip :: Text -> Text -> [(Char, Char)] -- | O(n) zipWith generalises zip by zipping with the -- function given as the first argument, instead of a tupling function. zipWith :: (Char -> Char -> Char) -> Text -> Text -> Text instance NFData Text instance IsString Text instance Monoid Text instance Read Text instance Show Text instance Ord Text instance Eq Text -- | Functions for converting lazy Text values to and from lazy -- ByteString, using several standard encodings. -- -- To make use of a much larger variety of encodings, use the -- text-icu package. module Data.Text.Lazy.Encoding -- | Decode a ByteString containing UTF-8 encoded text. decodeUtf8 :: ByteString -> Text -- | Decode a ByteString containing UTF-8 encoded text. decodeUtf8With :: OnDecodeError -> ByteString -> Text -- | Encode text using UTF-8 encoding. encodeUtf8 :: Text -> ByteString