-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | An efficient packed Unicode text type.
gr
grAn efficient packed, immutable Unicode text type (both strict and
grlazy), with a powerful loop fusion optimization framework.
gr
grThe <a>Text</a> type represents Unicode character strings, in a time
grand space-efficient manner. This package provides text processing
grcapabilities that are optimized for performance critical use, both in
grterms of large data quantities and high speed.
gr
grThe <a>Text</a> type provides character-encoding, type-safe case
grconversion via whole-string case conversion functions (see
gr<a>Data.Text</a>). It also provides a range of functions for
grconverting <a>Text</a> values to and from <a>ByteStrings</a>, using
grseveral standard encodings (see <a>Data.Text.Encoding</a>).
gr
grEfficient locale-sensitive support for text IO is also supported (see
gr<a>Data.Text.IO</a>).
gr
grThese modules are intended to be imported qualified, to avoid name
grclashes with Prelude functions, e.g.
gr
gr<pre>
grimport qualified Data.Text as T
gr</pre>
gr
grTo use an extended and very rich family of functions for working with
grUnicode text (including normalization, regular expressions,
grnon-standard encodings, text breaking, and locales), see the
gr<a>text-icu package</a> based on the well-respected and liberally
grlicensed <a>ICU library</a>.
@package text
@version 1.2.3.0


-- | Types and functions for dealing with encoding and decoding errors in
grUnicode text.
gr
grThe standard functions for encoding and decoding text are strict,
grwhich is to say that they throw exceptions on invalid input. This is
groften unhelpful on real world input, so alternative functions exist
grthat accept custom handlers for dealing with invalid inputs. These
gr<a>OnError</a> handlers are normal Haskell functions. You can use one
grof the presupplied functions in this module, or you can write a custom
grhandler 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
grgiven 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
grgiven encoding, or ran out of input in mid-encode.

-- | <i>Deprecated: This constructor is never used, and will be
grremoved.</i>
EncodeError :: String -> (Maybe Char) -> UnicodeException

-- | Function type for handling a coding error. It is supplied with two
grinputs:
gr
gr<ul>
gr<li>A <a>String</a> that describes the error.</li>
gr<li>The input value that caused the error. If the error arose because
grthe end of input was reached or could not be identified precisely,
grthis value will be <a>Nothing</a>.</li>
gr</ul>
gr
grIf the handler returns a value wrapped with <a>Just</a>, that value
grwill be used in the output as the replacement for the invalid input.
grIf it returns <a>Nothing</a>, no value will be used in the output.
gr
grShould the handler need to abort processing, it should use
gr<a>error</a> or <a>throw</a> an exception (preferably a
gr<a>UnicodeException</a>). It may use the description provided to
grconstruct a more helpful error report.
type OnError a b = String -> Maybe a -> Maybe b

-- | A handler for a decoding error.
type OnDecodeError = OnError Word8 Char

-- | A handler for an encoding error.

-- | <i>Deprecated: This exception is never used in practice, and will be
grremoved.</i>
type OnEncodeError = OnError Char Word8

-- | Replace an invalid input byte with the Unicode replacement character
grU+FFFD.
lenientDecode :: OnDecodeError

-- | Throw a <a>UnicodeException</a> if decoding fails.
strictDecode :: OnDecodeError

-- | Throw a <a>UnicodeException</a> if encoding fails.

-- | <i>Deprecated: This function always throws an exception, and will be
grremoved.</i>
strictEncode :: OnEncodeError

-- | 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 GHC.Classes.Eq Data.Text.Encoding.Error.UnicodeException
instance GHC.Show.Show Data.Text.Encoding.Error.UnicodeException
instance GHC.Exception.Exception Data.Text.Encoding.Error.UnicodeException
instance Control.DeepSeq.NFData Data.Text.Encoding.Error.UnicodeException

module Data.Text.Internal.Builder.Int.Digits
digits :: ByteString


-- | <i>Warning</i>: this is an internal module, and does not have a stable
grAPI or name. Functions in this module may not check or enforce
grpreconditions expected by public modules. Use at your own risk!
module Data.Text.Internal.Builder.RealFloat.Functions
roundTo :: Int -> [Int] -> (Int, [Int])


-- | <i>Warning</i>: this is an internal module, and does not have a stable
grAPI or name. Functions in this module may not check or enforce
grpreconditions expected by public modules. Use at your own risk!
gr
grBasic UTF-16 validation and character manipulation.
module Data.Text.Internal.Encoding.Utf16
chr2 :: Word16 -> Word16 -> Char
validate1 :: Word16 -> Bool
validate2 :: Word16 -> Word16 -> Bool


-- | <i>Warning</i>: this is an internal module, and does not have a stable
grAPI or name. Functions in this module may not check or enforce
grpreconditions expected by public modules. Use at your own risk!
gr
grBasic UTF-32 validation.
module Data.Text.Internal.Encoding.Utf32
validate :: Word32 -> Bool


-- | <i>Warning</i>: this is an internal module, and does not have a stable
grAPI or name. Functions in this module may not check or enforce
grpreconditions expected by public modules. Use at your own risk!
gr
grUseful functions.
module Data.Text.Internal.Functions

-- | A lazier version of Data.List.intersperse. The other version causes
grspace leaks!
intersperse :: a -> [a] -> [a]


-- | Common internal functions for reading textual data.
module Data.Text.Internal.Read
type IReader t a = t -> Either String (a, t)
newtype IParser t a
P :: IReader t a -> IParser t a
[runP] :: IParser t a -> IReader t a
data T
T :: !Integer -> !Int -> T
digitToInt :: Char -> Int
hexDigitToInt :: Char -> Int
perhaps :: a -> IParser t a -> IParser t a
instance GHC.Base.Functor (Data.Text.Internal.Read.IParser t)
instance GHC.Base.Applicative (Data.Text.Internal.Read.IParser t)
instance GHC.Base.Monad (Data.Text.Internal.Read.IParser t)


-- | <i>Warning</i>: this is an internal module, and does not have a stable
grAPI or name. Functions in this module may not check or enforce
grpreconditions expected by public modules. Use at your own risk!
gr
grA module containing <i>unsafe</i> operations, for <i>very very
grcareful</i> use in <i>heavily tested</i> code.
module Data.Text.Internal.Unsafe

-- | Allow an <a>ST</a> computation to be deferred lazily. When passed an
graction of type <a>ST</a> <tt>s</tt> <tt>a</tt>, the action will only
grbe performed when the value of <tt>a</tt> is demanded.
gr
grThis function is identical to the normal unsafeInterleaveST, but is
grinlined and hence faster.
gr
gr<i>Note</i>: This operation is highly unsafe, as it can introduce
grexternally visible non-determinism into an <a>ST</a> action.
inlineInterleaveST :: ST s a -> ST s a

-- | Just like unsafePerformIO, but we inline it. Big performance gains as
grit exposes lots of things to further inlining. <i>Very unsafe</i>. In
grparticular, you should do no memory allocation inside an
gr<a>inlinePerformIO</a> block. On Hugs this is just
gr<tt>unsafePerformIO</tt>.
inlinePerformIO :: IO a -> a


-- | <i>Warning</i>: this is an internal module, and does not have a stable
grAPI or name. Functions in this module may not check or enforce
grpreconditions expected by public modules. Use at your own risk!
gr
grFast, unchecked bit shifting functions.
module Data.Text.Internal.Unsafe.Shift

-- | This is a workaround for poor optimisation in GHC 6.8.2. It fails to
grnotice constant-width shifts, and adds a test and branch to every
grshift. This imposes about a 10% performance hit.
gr
grThese functions are undefined when the amount being shifted by is
grgreater than the size in bits of a machine Int#.
class UnsafeShift a
shiftL :: UnsafeShift a => a -> Int -> a
shiftR :: UnsafeShift a => a -> Int -> a
instance Data.Text.Internal.Unsafe.Shift.UnsafeShift GHC.Word.Word16
instance Data.Text.Internal.Unsafe.Shift.UnsafeShift GHC.Word.Word32
instance Data.Text.Internal.Unsafe.Shift.UnsafeShift GHC.Word.Word64
instance Data.Text.Internal.Unsafe.Shift.UnsafeShift GHC.Types.Int


-- | Packed, unboxed, heap-resident arrays. Suitable for performance
grcritical use, both in terms of large data quantities and high speed.
gr
grThis module is intended to be imported <tt>qualified</tt>, to avoid
grname clashes with <a>Prelude</a> functions, e.g.
gr
gr<pre>
grimport qualified Data.Text.Array as A
gr</pre>
gr
grThe names in this module resemble those in the <a>Array</a> family of
grmodules, but are shorter due to the assumption of qualified naming.
module Data.Text.Array

-- | Immutable array type.
gr
grThe <a>Array</a> constructor is exposed since <tt>text-1.1.1.3</tt>
data Array
Array :: ByteArray# -> Array
[aBA] :: Array -> ByteArray#

-- | Mutable array type, for use in the ST monad.
gr
grThe <a>MArray</a> constructor is exposed since <tt>text-1.1.1.3</tt>
data MArray s
MArray :: MutableByteArray# s -> MArray s
[maBA] :: MArray s -> MutableByteArray# s

-- | Copy some elements of a mutable array.
copyM :: MArray s -> Int -> MArray s -> Int -> Int -> ST s ()

-- | Copy some elements of an immutable array.
copyI :: MArray s -> Int -> Array -> Int -> Int -> ST s ()

-- | An empty immutable array.
empty :: Array

-- | Compare portions of two arrays for equality. No bounds checking is
grperformed.
equal :: Array -> Int -> Array -> Int -> Int -> Bool

-- | Run an action in the ST monad and return an immutable array of its
grresult.
run :: (forall s. ST s (MArray s)) -> Array

-- | Run an action in the ST monad and return an immutable array of its
grresult paired with whatever else the action returns.
run2 :: (forall s. ST s (MArray s, a)) -> (Array, a)

-- | Convert an immutable array to a list.
toList :: Array -> Int -> Int -> [Word16]

-- | Freeze a mutable array. Do not mutate the <a>MArray</a> afterwards!
unsafeFreeze :: MArray s -> ST s Array

-- | Unchecked read of an immutable array. May return garbage or crash on
gran out-of-bounds access.
unsafeIndex :: Array -> Int -> Word16

-- | Create an uninitialized mutable array.
new :: forall s. Int -> ST s (MArray s)

-- | Unchecked write of a mutable array. May return garbage or crash on an
grout-of-bounds access.
unsafeWrite :: MArray s -> Int -> Word16 -> ST s ()


-- | <i>Warning</i>: this is an internal module, and does not have a stable
grAPI or name. Functions in this module may not check or enforce
grpreconditions expected by public modules. Use at your own risk!
gr
grFast character manipulation functions.
module Data.Text.Internal.Unsafe.Char
ord :: Char -> Int
unsafeChr :: Word16 -> Char
unsafeChr8 :: Word8 -> Char
unsafeChr32 :: Word32 -> Char

-- | Write a character into the array at the given offset. Returns the
grnumber of <a>Word16</a>s written.
unsafeWrite :: MArray s -> Int -> Char -> ST s Int


-- | <i>Warning</i>: this is an internal module, and does not have a stable
grAPI or name. Functions in this module may not check or enforce
grpreconditions expected by public modules. Use at your own risk!
gr
grBasic UTF-8 validation and character manipulation.
module Data.Text.Internal.Encoding.Utf8
ord2 :: Char -> (Word8, Word8)
ord3 :: Char -> (Word8, Word8, Word8)
ord4 :: Char -> (Word8, Word8, Word8, Word8)
chr2 :: Word8 -> Word8 -> Char
chr3 :: Word8 -> Word8 -> Word8 -> Char
chr4 :: Word8 -> Word8 -> Word8 -> Word8 -> Char
validate1 :: Word8 -> Bool
validate2 :: Word8 -> Word8 -> Bool
validate3 :: Word8 -> Word8 -> Word8 -> Bool
validate4 :: Word8 -> Word8 -> Word8 -> Word8 -> Bool


-- | A module containing private <a>Text</a> internals. This exposes the
gr<a>Text</a> representation and low level construction functions.
grModules which extend the <a>Text</a> system may need to use this
grmodule.
gr
grYou should not use this module unless you are determined to monkey
grwith the internals, as the functions here do just about nothing to
grpreserve data invariants. You have been warned!
module Data.Text.Internal

-- | A space efficient, packed, unboxed Unicode text type.
data Text
Text :: {-# UNPACK #-} !Array -> {-# UNPACK #-} !Int -> {-# UNPACK #-} !Int -> Text

-- | Construct a <a>Text</a> without invisibly pinning its byte array in
grmemory if its length has dwindled to zero.
text :: Array -> Int -> Int -> Text

-- | <i>Deprecated: Use text instead</i>
textP :: Array -> Int -> Int -> Text

-- | Map a <a>Char</a> to a <a>Text</a>-safe value.
gr
grUTF-16 surrogate code points are not included in the set of Unicode
grscalar values, but are unfortunately admitted as valid <a>Char</a>
grvalues by Haskell. They cannot be represented in a <a>Text</a>. This
grfunction remaps those code points to the Unicode replacement character
gr(U+FFFD, '�'), and leaves other code points unchanged.
safe :: Char -> Char

-- | <i>O(1)</i> The empty <a>Text</a>.
empty :: Text

-- | A non-inlined version of <a>empty</a>.
empty_ :: Text

-- | Apply a function to the first element of an optional pair.
firstf :: (a -> c) -> Maybe (a, b) -> Maybe (c, b)

-- | Checked multiplication. Calls <a>error</a> if the result would
groverflow.
mul :: Int -> Int -> Int
infixl 7 `mul`

-- | Checked multiplication. Calls <a>error</a> if the result would
groverflow.
mul32 :: Int32 -> Int32 -> Int32
infixl 7 `mul32`

-- | Checked multiplication. Calls <a>error</a> if the result would
groverflow.
mul64 :: Int64 -> Int64 -> Int64
infixl 7 `mul64`

-- | A useful <a>show</a>-like function for debugging purposes.
showText :: Text -> String


-- | Fast substring search for <a>Text</a>, based on work by Boyer, Moore,
grHorspool, Sunday, and Lundh.
gr
grReferences:
gr
gr<ul>
gr<li>R. S. Boyer, J. S. Moore: A Fast String Searching Algorithm.
grCommunications of the ACM, 20, 10, 762-772 (1977)</li>
gr<li>R. N. Horspool: Practical Fast Searching in Strings. Software -
grPractice and Experience 10, 501-506 (1980)</li>
gr<li>D. M. Sunday: A Very Fast Substring Search Algorithm.
grCommunications of the ACM, 33, 8, 132-142 (1990)</li>
gr<li>F. Lundh: The Fast Search Algorithm.
gr<a>http://effbot.org/zone/stringlib.htm</a> (2006)</li>
gr</ul>
module Data.Text.Internal.Search

-- | <i>O(n+m)</i> Find the offsets of all non-overlapping indices of
gr<tt>needle</tt> within <tt>haystack</tt>. The offsets returned
grrepresent uncorrected indices in the low-level "needle" array, to
grwhich its offset must be added.
gr
grIn (unlikely) bad cases, this algorithm's complexity degrades towards
gr<i>O(n*m)</i>.
indices :: Text -> Text -> [Int]


-- | <i>Warning</i>: this is an internal module, and does not have a stable
grAPI or name. Functions in this module may not check or enforce
grpreconditions expected by public modules. Use at your own risk!
gr
grSize hints.
module Data.Text.Internal.Fusion.Size

-- | A size in UTF-16 code units.
data Size
exactSize :: Int -> Size
maxSize :: Int -> Size
betweenSize :: Int -> Int -> Size
unknownSize :: Size
unionSize :: Size -> Size -> Size

-- | The <a>Size</a> of the given code point.
charSize :: Char -> Size

-- | The <a>Size</a> of <tt>n</tt> code points.
codePointsSize :: Int -> Size
exactly :: Size -> Maybe Int

-- | Minimum of two size hints.
smaller :: Size -> Size -> Size

-- | Maximum of two size hints.
larger :: Size -> Size -> Size

-- | Compute the maximum size from a size hint, if possible.
upperBound :: Int -> Size -> Int

-- | Compute the maximum size from a size hint, if possible.
lowerBound :: Int -> Size -> Int

-- | Determine the ordering relationship between two <a>Size</a>s, or
gr<a>Nothing</a> in the indeterminate case.
compareSize :: Size -> Size -> Maybe Ordering
isEmpty :: Size -> Bool
instance GHC.Show.Show Data.Text.Internal.Fusion.Size.Size
instance GHC.Classes.Eq Data.Text.Internal.Fusion.Size.Size
instance GHC.Num.Num Data.Text.Internal.Fusion.Size.Size


-- | <i>Warning</i>: this is an internal module, and does not have a stable
grAPI or name. Functions in this module may not check or enforce
grpreconditions expected by public modules. Use at your own risk!
gr
grCore stream fusion functionality for text.
module Data.Text.Internal.Fusion.Types

-- | Specialised tuple for case conversion.
data CC s
CC :: !s -> {-# UNPACK #-} !Char -> {-# UNPACK #-} !Char -> CC s

-- | Strict pair.
data PairS a b
(:*:) :: !a -> !b -> PairS a b

-- | An intermediate result in a scan.
data Scan s
Scan1 :: {-# UNPACK #-} !Char -> !s -> Scan s
Scan2 :: {-# UNPACK #-} !Char -> !s -> Scan s

-- | Restreaming state.
data RS s
RS0 :: !s -> RS s
RS1 :: !s -> {-# UNPACK #-} !Word8 -> RS s
RS2 :: !s -> {-# UNPACK #-} !Word8 -> {-# UNPACK #-} !Word8 -> RS s
RS3 :: !s -> {-# UNPACK #-} !Word8 -> {-# UNPACK #-} !Word8 -> {-# UNPACK #-} !Word8 -> RS s

-- | Intermediate result in a processing pipeline.
data Step s a
Done :: Step s a
Skip :: !s -> Step s a
Yield :: !a -> !s -> Step s a
data Stream a
Stream :: (s -> Step s a) -> !s -> !Size -> Stream a

-- | The empty stream.
empty :: Stream a
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Text.Internal.Fusion.Types.Stream a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Text.Internal.Fusion.Types.Stream a)

module Data.Text.Internal.Fusion.CaseMapping
upperMapping :: forall s. Char -> s -> Step (CC s) Char
lowerMapping :: forall s. Char -> s -> Step (CC s) Char
titleMapping :: forall s. Char -> s -> Step (CC s) Char
foldMapping :: forall s. Char -> s -> Step (CC s) Char


-- | <i>Warning</i>: this is an internal module, and does not have a stable
grAPI or name. Functions in this module may not check or enforce
grpreconditions expected by public modules. Use at your own risk!
gr
grCommon stream fusion functionality for text.
module Data.Text.Internal.Fusion.Common
singleton :: Char -> Stream Char
streamList :: [a] -> Stream a
unstreamList :: Stream a -> [a]

-- | Stream the UTF-8-like packed encoding used by GHC to represent
grconstant strings in generated code.
gr
grThis encoding uses the byte sequence "xc0x80" to represent NUL, and
grthe string is NUL-terminated.
streamCString# :: Addr# -> Stream Char

-- | <i>O(n)</i> Adds a character to the front of a Stream Char.
cons :: Char -> Stream Char -> Stream Char

-- | <i>O(n)</i> Adds a character to the end of a stream.
snoc :: Stream Char -> Char -> Stream Char

-- | <i>O(n)</i> Appends one Stream to the other.
append :: Stream Char -> Stream Char -> Stream Char

-- | <i>O(1)</i> Returns the first character of a Text, which must be
grnon-empty. Subject to array fusion.
head :: Stream Char -> Char

-- | <i>O(1)</i> Returns the first character and remainder of a 'Stream
grChar', or <a>Nothing</a> if empty. Subject to array fusion.
uncons :: Stream Char -> Maybe (Char, Stream Char)

-- | <i>O(n)</i> Returns the last character of a 'Stream Char', which must
grbe non-empty.
last :: Stream Char -> Char

-- | <i>O(1)</i> Returns all characters after the head of a Stream Char,
grwhich must be non-empty.
tail :: Stream Char -> Stream Char

-- | <i>O(1)</i> Returns all but the last character of a Stream Char, which
grmust be non-empty.
init :: Stream Char -> Stream Char

-- | <i>O(1)</i> Tests whether a Stream Char is empty or not.
null :: Stream Char -> Bool

-- | <i>O(n)</i> Returns the number of characters in a string.
lengthI :: Integral a => Stream Char -> a

-- | <i>O(n)</i> Compares the count of characters in a string to a number.
grSubject to fusion.
gr
grThis function gives the same answer as comparing against the result of
gr<a>lengthI</a>, but can short circuit if the count of characters is
grgreater than the number or if the stream can't possibly be as long as
grthe number supplied, and hence be more efficient.
compareLengthI :: Integral a => Stream Char -> a -> Ordering

-- | <i>O(n)</i> Indicate whether a string contains exactly one element.
isSingleton :: Stream Char -> Bool

-- | <i>O(n)</i> <a>map</a> <tt>f </tt>xs is the Stream Char obtained by
grapplying <tt>f</tt> to each element of <tt>xs</tt>.
map :: (Char -> Char) -> Stream Char -> Stream Char
intercalate :: Stream Char -> [Stream Char] -> Stream Char

-- | <i>O(n)</i> Take a character and place it between each of the
grcharacters of a 'Stream Char'.
intersperse :: Char -> Stream Char -> Stream Char

-- | <i>O(n)</i> Convert a string to folded case. This function is mainly
gruseful for performing caseless (or case insensitive) string
grcomparisons.
gr
grA string <tt>x</tt> is a caseless match for a string <tt>y</tt> if and
gronly if:
gr
gr<pre>
grtoCaseFold x == toCaseFold y
gr</pre>
gr
grThe result string may be longer than the input string, and may differ
grfrom applying <a>toLower</a> to the input string. For instance, the
grArmenian small ligature men now (U+FB13) is case folded to the bigram
grmen now (U+0574 U+0576), while the micro sign (U+00B5) is case folded
grto the Greek small letter letter mu (U+03BC) instead of itself.
toCaseFold :: Stream Char -> Stream Char

-- | <i>O(n)</i> Convert a string to lower case, using simple case
grconversion. The result string may be longer than the input string. For
grinstance, the Latin capital letter I with dot above (U+0130) maps to
grthe sequence Latin small letter i (U+0069) followed by combining dot
grabove (U+0307).
toLower :: Stream Char -> Stream Char

-- | <i>O(n)</i> Convert a string to title case, using simple case
grconversion.
gr
grThe first letter of the input is converted to title case, as is every
grsubsequent letter that immediately follows a non-letter. Every letter
grthat immediately follows another letter is converted to lower case.
gr
grThe result string may be longer than the input string. For example,
grthe Latin small ligature ﬂ (U+FB02) is converted to the sequence Latin
grcapital letter F (U+0046) followed by Latin small letter l (U+006C).
gr
gr<i>Note</i>: this function does not take language or culture specific
grrules into account. For instance, in English, different style guides
grdisagree on whether the book name "The Hill of the Red Fox" is
grcorrectly title cased—but this function will capitalize <i>every</i>
grword.
toTitle :: Stream Char -> Stream Char

-- | <i>O(n)</i> Convert a string to upper case, using simple case
grconversion. The result string may be longer than the input string. For
grinstance, the German eszett (U+00DF) maps to the two-letter sequence
grSS.
toUpper :: Stream Char -> Stream Char
justifyLeftI :: Integral a => a -> Char -> Stream Char -> Stream Char

-- | foldl, applied to a binary operator, a starting value (typically the
grleft-identity of the operator), and a Stream, reduces the Stream using
grthe binary operator, from left to right.
foldl :: (b -> Char -> b) -> b -> Stream Char -> b

-- | A strict version of foldl.
foldl' :: (b -> Char -> b) -> b -> Stream Char -> b

-- | foldl1 is a variant of foldl that has no starting value argument, and
grthus must be applied to non-empty Streams.
foldl1 :: (Char -> Char -> Char) -> Stream Char -> Char

-- | A strict version of foldl1.
foldl1' :: (Char -> Char -> Char) -> Stream Char -> Char

-- | <a>foldr</a>, applied to a binary operator, a starting value
gr(typically the right-identity of the operator), and a stream, reduces
grthe stream using the binary operator, from right to left.
foldr :: (Char -> b -> b) -> b -> Stream Char -> b

-- | foldr1 is a variant of <a>foldr</a> that has no starting value
grargument, and thus must be applied to non-empty streams. Subject to
grarray fusion.
foldr1 :: (Char -> Char -> Char) -> Stream Char -> Char

-- | <i>O(n)</i> Concatenate a list of streams. Subject to array fusion.
concat :: [Stream Char] -> Stream Char

-- | Map a function over a stream that results in a stream and concatenate
grthe results.
concatMap :: (Char -> Stream Char) -> Stream Char -> Stream Char

-- | <i>O(n)</i> any <tt>p </tt>xs determines if any character in the
grstream <tt>xs</tt> satisfies the predicate <tt>p</tt>.
any :: (Char -> Bool) -> Stream Char -> Bool

-- | <i>O(n)</i> all <tt>p </tt>xs determines if all characters in the
gr<tt>Text</tt> <tt>xs</tt> satisfy the predicate <tt>p</tt>.
all :: (Char -> Bool) -> Stream Char -> Bool

-- | <i>O(n)</i> maximum returns the maximum value from a stream, which
grmust be non-empty.
maximum :: Stream Char -> Char

-- | <i>O(n)</i> minimum returns the minimum value from a <tt>Text</tt>,
grwhich must be non-empty.
minimum :: Stream Char -> Char
scanl :: (Char -> Char -> Char) -> Char -> Stream Char -> Stream Char
replicateCharI :: Integral a => a -> Char -> Stream Char
replicateI :: Int64 -> Stream Char -> Stream Char

-- | <i>O(n)</i>, where <tt>n</tt> is the length of the result. The unfoldr
grfunction is analogous to the List <a>unfoldr</a>. unfoldr builds a
grstream from a seed value. The function takes the element and returns
grNothing if it is done producing the stream or returns Just (a,b), in
grwhich case, a is the next Char in the string, and b is the seed value
grfor further production.
unfoldr :: (a -> Maybe (Char, a)) -> a -> Stream Char

-- | <i>O(n)</i> Like <a>unfoldr</a>, <a>unfoldrNI</a> builds a stream from
gra seed value. However, the length of the result is limited by the
grfirst argument to <a>unfoldrNI</a>. This function is more efficient
grthan <a>unfoldr</a> when the length of the result is known.
unfoldrNI :: Integral a => a -> (b -> Maybe (Char, b)) -> b -> Stream Char

-- | <i>O(n)</i> <tt><a>take</a> n</tt>, applied to a stream, returns the
grprefix of the stream of length <tt>n</tt>, or the stream itself if
gr<tt>n</tt> is greater than the length of the stream.
take :: Integral a => a -> Stream Char -> Stream Char

-- | <i>O(n)</i> <tt><a>drop</a> n</tt>, applied to a stream, returns the
grsuffix of the stream after the first <tt>n</tt> characters, or the
grempty stream if <tt>n</tt> is greater than the length of the stream.
drop :: Integral a => a -> Stream Char -> Stream Char

-- | <a>takeWhile</a>, applied to a predicate <tt>p</tt> and a stream,
grreturns the longest prefix (possibly empty) of elements that satisfy
gr<tt>p</tt>.
takeWhile :: (Char -> Bool) -> Stream Char -> Stream Char

-- | <tt><a>dropWhile</a> p xs</tt> returns the suffix remaining after
gr<tt><a>takeWhile</a> p xs</tt>.
dropWhile :: (Char -> Bool) -> Stream Char -> Stream Char

-- | <i>O(n)</i> The <a>isPrefixOf</a> function takes two <a>Stream</a>s
grand returns <a>True</a> iff the first is a prefix of the second.
isPrefixOf :: (Eq a) => Stream a -> Stream a -> Bool

-- | <i>O(n)</i> <a>elem</a> is the stream membership predicate.
elem :: Char -> Stream Char -> Bool

-- | <i>O(n)</i> <a>filter</a>, applied to a predicate and a stream,
grreturns a stream containing those characters that satisfy the
grpredicate.
filter :: (Char -> Bool) -> Stream Char -> Stream Char

-- | <i>O(n)</i> The <a>findBy</a> function takes a predicate and a stream,
grand returns the first element in matching the predicate, or
gr<a>Nothing</a> if there is no such element.
findBy :: (Char -> Bool) -> Stream Char -> Maybe Char

-- | <i>O(n)</i> Stream index (subscript) operator, starting from 0.
indexI :: Integral a => Stream Char -> a -> Char

-- | The <a>findIndexI</a> function takes a predicate and a stream and
grreturns the index of the first element in the stream satisfying the
grpredicate.
findIndexI :: Integral a => (Char -> Bool) -> Stream Char -> Maybe a

-- | <i>O(n)</i> The <a>countCharI</a> function returns the number of times
grthe query element appears in the given stream.
countCharI :: Integral a => Char -> Stream Char -> a

-- | zipWith generalises <tt>zip</tt> by zipping with the function given as
grthe first argument, instead of a tupling function.
zipWith :: (a -> a -> b) -> Stream a -> Stream a -> Stream b


-- | A module containing unsafe <a>Text</a> operations, for very very
grcareful use in heavily tested code.
module Data.Text.Unsafe

-- | Allow an <a>ST</a> computation to be deferred lazily. When passed an
graction of type <a>ST</a> <tt>s</tt> <tt>a</tt>, the action will only
grbe performed when the value of <tt>a</tt> is demanded.
gr
grThis function is identical to the normal unsafeInterleaveST, but is
grinlined and hence faster.
gr
gr<i>Note</i>: This operation is highly unsafe, as it can introduce
grexternally visible non-determinism into an <a>ST</a> action.
inlineInterleaveST :: ST s a -> ST s a

-- | Just like unsafePerformIO, but we inline it. Big performance gains as
grit exposes lots of things to further inlining. <i>Very unsafe</i>. In
grparticular, you should do no memory allocation inside an
gr<a>inlinePerformIO</a> block. On Hugs this is just
gr<tt>unsafePerformIO</tt>.
inlinePerformIO :: IO a -> a

-- | This version of <a>unsafePerformIO</a> is more efficient because it
gromits the check that the IO is only being performed by a single
grthread. Hence, when you use <a>unsafeDupablePerformIO</a>, there is a
grpossibility that the IO action may be performed multiple times (on a
grmultiprocessor), and you should therefore ensure that it gives the
grsame results each time. It may even happen that one of the duplicated
grIO actions is only run partially, and then interrupted in the middle
grwithout an exception being raised. Therefore, functions like
gr<tt>bracket</tt> cannot be used safely within
gr<a>unsafeDupablePerformIO</a>.
unsafeDupablePerformIO :: () => IO a -> a
data Iter
Iter :: {-# UNPACK #-} !Char -> {-# UNPACK #-} !Int -> Iter

-- | <i>O(1)</i> Iterate (unsafely) one step forwards through a UTF-16
grarray, returning the current character and the delta to add to give
grthe next offset to iterate at.
iter :: Text -> Int -> Iter

-- | <i>O(1)</i> Iterate one step through a UTF-16 array, returning the
grdelta to add to give the next offset to iterate at.
iter_ :: Text -> Int -> Int

-- | <i>O(1)</i> Iterate one step backwards through a UTF-16 array,
grreturning the current character and the delta to add (i.e. a negative
grnumber) to give the next offset to iterate at.
reverseIter :: Text -> Int -> (Char, Int)

-- | <i>O(1)</i> Iterate one step backwards through a UTF-16 array,
grreturning the delta to add (i.e. a negative number) to give the next
groffset to iterate at.
reverseIter_ :: Text -> Int -> Int

-- | <i>O(1)</i> A variant of <a>head</a> for non-empty <a>Text</a>.
gr<a>unsafeHead</a> omits the check for the empty case, so there is an
grobligation on the programmer to provide a proof that the <a>Text</a>
gris non-empty.
unsafeHead :: Text -> Char

-- | <i>O(1)</i> A variant of <a>tail</a> for non-empty <a>Text</a>.
gr<a>unsafeTail</a> omits the check for the empty case, so there is an
grobligation on the programmer to provide a proof that the <a>Text</a>
gris non-empty.
unsafeTail :: Text -> Text

-- | <i>O(1)</i> Return the length of a <a>Text</a> in units of
gr<tt>Word16</tt>. This is useful for sizing a target array
grappropriately before using <tt>unsafeCopyToPtr</tt>.
lengthWord16 :: Text -> Int

-- | <i>O(1)</i> Unchecked take of <tt>k</tt> <tt>Word16</tt>s from the
grfront of a <a>Text</a>.
takeWord16 :: Int -> Text -> Text

-- | <i>O(1)</i> Unchecked drop of <tt>k</tt> <tt>Word16</tt>s from the
grfront of a <a>Text</a>.
dropWord16 :: Int -> Text -> Text


module Data.Text.Internal.Private
runText :: (forall s. (MArray s -> Int -> ST s Text) -> ST s Text) -> Text
span_ :: (Char -> Bool) -> Text -> (# Text, Text #)


-- | <i>Warning</i>: this is an internal module, and does not have a stable
grAPI or name. Functions in this module may not check or enforce
grpreconditions expected by public modules. Use at your own risk!
gr
grText manipulation functions represented as fusible operations over
grstreams.
module Data.Text.Internal.Fusion
data Stream a
Stream :: (s -> Step s a) -> !s -> !Size -> Stream a

-- | Intermediate result in a processing pipeline.
data Step s a
Done :: Step s a
Skip :: !s -> Step s a
Yield :: !a -> !s -> Step s a

-- | <i>O(n)</i> Convert a <a>Text</a> into a 'Stream Char'.
stream :: Text -> Stream Char

-- | <i>O(n)</i> Convert a 'Stream Char' into a <a>Text</a>.
unstream :: Stream Char -> Text

-- | <i>O(n)</i> Convert a <a>Text</a> into a 'Stream Char', but iterate
grbackwards.
reverseStream :: Text -> Stream Char
length :: Stream Char -> Int

-- | <i>O(n)</i> Reverse the characters of a string.
reverse :: Stream Char -> Text

-- | <i>O(n)</i> Perform the equivalent of <tt>scanr</tt> over a list, only
grwith the input and result reversed.
reverseScanr :: (Char -> Char -> Char) -> Char -> Stream Char -> Stream Char

-- | <i>O(n)</i> Like a combination of <tt>map</tt> and <tt>foldl'</tt>.
grApplies a function to each element of a <a>Text</a>, passing an
graccumulating parameter from left to right, and returns a final
gr<a>Text</a>.
mapAccumL :: (a -> Char -> (a, Char)) -> a -> Stream Char -> (a, Text)

-- | <i>O(n)</i> Like <tt>unfoldr</tt>, <a>unfoldrN</a> builds a stream
grfrom a seed value. However, the length of the result is limited by the
grfirst argument to <a>unfoldrN</a>. This function is more efficient
grthan <tt>unfoldr</tt> when the length of the result is known.
unfoldrN :: Int -> (a -> Maybe (Char, a)) -> a -> Stream Char

-- | <i>O(n)</i> stream index (subscript) operator, starting from 0.
index :: Stream Char -> Int -> Char

-- | The <a>findIndex</a> function takes a predicate and a stream and
grreturns the index of the first element in the stream satisfying the
grpredicate.
findIndex :: (Char -> Bool) -> Stream Char -> Maybe Int

-- | <i>O(n)</i> The <tt>count</tt> function returns the number of times
grthe query element appears in the given stream.
countChar :: Char -> Stream Char -> Int


-- | <i>Warning</i>: this is an internal module, and does not have a stable
grAPI or name. Use at your own risk!
gr
grFusible <a>Stream</a>-oriented functions for converting between
gr<tt>Text</tt> and several common encodings.
module Data.Text.Internal.Encoding.Fusion.Common
restreamUtf16LE :: Stream Char -> Stream Word8
restreamUtf16BE :: Stream Char -> Stream Word8
restreamUtf32LE :: Stream Char -> Stream Word8
restreamUtf32BE :: Stream Char -> Stream Word8


-- | <i>Warning</i>: this is an internal module, and does not have a stable
grAPI or name. Functions in this module may not check or enforce
grpreconditions expected by public modules. Use at your own risk!
gr
grFusible <a>Stream</a>-oriented functions for converting between lazy
gr<tt>Text</tt> and several common encodings.
module Data.Text.Internal.Lazy.Encoding.Fusion

-- | <i>O(n)</i> Convert a lazy <a>ByteString</a> into a 'Stream Char',
grusing UTF-8 encoding.
streamUtf8 :: OnDecodeError -> ByteString -> Stream Char

-- | <i>O(n)</i> Convert a <a>ByteString</a> into a 'Stream Char', using
grlittle endian UTF-16 encoding.
streamUtf16LE :: OnDecodeError -> ByteString -> Stream Char

-- | <i>O(n)</i> Convert a <a>ByteString</a> into a 'Stream Char', using
grbig endian UTF-16 encoding.
streamUtf16BE :: OnDecodeError -> ByteString -> Stream Char

-- | <i>O(n)</i> Convert a <a>ByteString</a> into a 'Stream Char', using
grlittle endian UTF-32 encoding.
streamUtf32LE :: OnDecodeError -> ByteString -> Stream Char

-- | <i>O(n)</i> Convert a <a>ByteString</a> into a 'Stream Char', using
grbig endian UTF-32 encoding.
streamUtf32BE :: OnDecodeError -> ByteString -> Stream Char

-- | <i>O(n)</i> Convert a <a>Stream</a> <a>Word8</a> to a lazy
gr<a>ByteString</a>.
unstream :: Stream Word8 -> ByteString


-- | <i>Warning</i>: this is an internal module, and does not have a stable
grAPI or name. Functions in this module may not check or enforce
grpreconditions expected by public modules. Use at your own risk!
gr
grFusible <a>Stream</a>-oriented functions for converting between
gr<tt>Text</tt> and several common encodings.
module Data.Text.Internal.Encoding.Fusion

-- | <i>Deprecated: Do not use this function</i>
streamASCII :: ByteString -> Stream Char

-- | <i>O(n)</i> Convert a <a>ByteString</a> into a 'Stream Char', using
grUTF-8 encoding.
streamUtf8 :: OnDecodeError -> ByteString -> Stream Char

-- | <i>O(n)</i> Convert a <a>ByteString</a> into a 'Stream Char', using
grlittle endian UTF-16 encoding.
streamUtf16LE :: OnDecodeError -> ByteString -> Stream Char

-- | <i>O(n)</i> Convert a <a>ByteString</a> into a 'Stream Char', using
grbig endian UTF-16 encoding.
streamUtf16BE :: OnDecodeError -> ByteString -> Stream Char

-- | <i>O(n)</i> Convert a <a>ByteString</a> into a 'Stream Char', using
grlittle endian UTF-32 encoding.
streamUtf32LE :: OnDecodeError -> ByteString -> Stream Char

-- | <i>O(n)</i> Convert a <a>ByteString</a> into a 'Stream Char', using
grbig endian UTF-32 encoding.
streamUtf32BE :: OnDecodeError -> ByteString -> Stream Char

-- | <i>O(n)</i> Convert a <a>Stream</a> <a>Word8</a> to a
gr<a>ByteString</a>.
unstream :: Stream Word8 -> ByteString


-- | Functions for converting <a>Text</a> values to and from
gr<a>ByteString</a>, using several standard encodings.
gr
grTo gain access to a much larger family of encodings, use the
gr<a>text-icu package</a>.
module Data.Text.Encoding

-- | <i>Deprecated</i>. Decode a <a>ByteString</a> containing 7-bit ASCII
grencoded text.

-- | <i>Deprecated: Use decodeUtf8 instead</i>
decodeASCII :: ByteString -> Text

-- | Decode a <a>ByteString</a> containing Latin-1 (aka ISO-8859-1) encoded
grtext.
gr
gr<a>decodeLatin1</a> is semantically equivalent to <tt>Data.Text.pack .
grData.ByteString.Char8.unpack</tt>
decodeLatin1 :: ByteString -> Text

-- | Decode a <a>ByteString</a> containing UTF-8 encoded text that is known
grto be valid.
gr
grIf the input contains any invalid UTF-8 data, an exception will be
grthrown that cannot be caught in pure code. For more control over the
grhandling of invalid data, use <a>decodeUtf8'</a> or
gr<a>decodeUtf8With</a>.
decodeUtf8 :: ByteString -> Text

-- | Decode text from little endian UTF-16 encoding.
gr
grIf the input contains any invalid little endian UTF-16 data, an
grexception will be thrown. For more control over the handling of
grinvalid data, use <a>decodeUtf16LEWith</a>.
decodeUtf16LE :: ByteString -> Text

-- | Decode text from big endian UTF-16 encoding.
gr
grIf the input contains any invalid big endian UTF-16 data, an exception
grwill be thrown. For more control over the handling of invalid data,
gruse <a>decodeUtf16BEWith</a>.
decodeUtf16BE :: ByteString -> Text

-- | Decode text from little endian UTF-32 encoding.
gr
grIf the input contains any invalid little endian UTF-32 data, an
grexception will be thrown. For more control over the handling of
grinvalid data, use <a>decodeUtf32LEWith</a>.
decodeUtf32LE :: ByteString -> Text

-- | Decode text from big endian UTF-32 encoding.
gr
grIf the input contains any invalid big endian UTF-32 data, an exception
grwill be thrown. For more control over the handling of invalid data,
gruse <a>decodeUtf32BEWith</a>.
decodeUtf32BE :: ByteString -> Text

-- | Decode a <a>ByteString</a> containing UTF-8 encoded text.
gr
grIf the input contains any invalid UTF-8 data, the relevant exception
grwill be returned, otherwise the decoded text.
decodeUtf8' :: ByteString -> Either UnicodeException Text

-- | Decode a <a>ByteString</a> 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

-- | Decode, in a stream oriented way, a <a>ByteString</a> containing UTF-8
grencoded text that is known to be valid.
gr
grIf the input contains any invalid UTF-8 data, an exception will be
grthrown (either by this function or a continuation) that cannot be
grcaught in pure code. For more control over the handling of invalid
grdata, use <a>streamDecodeUtf8With</a>.
streamDecodeUtf8 :: ByteString -> Decoding

-- | Decode, in a stream oriented way, a <a>ByteString</a> containing UTF-8
grencoded text.
streamDecodeUtf8With :: OnDecodeError -> ByteString -> Decoding

-- | A stream oriented decoding result.
data Decoding
Some :: Text -> ByteString -> (ByteString -> Decoding) -> Decoding

-- | 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

-- | Encode text to a ByteString <a>Builder</a> using UTF-8 encoding.
encodeUtf8Builder :: Text -> Builder

-- | Encode text using UTF-8 encoding and escape the ASCII characters using
gra <a>BoundedPrim</a>.
gr
grUse this function is to implement efficient encoders for text-based
grformats like JSON or HTML.
encodeUtf8BuilderEscaped :: BoundedPrim Word8 -> Text -> Builder
instance Foreign.Storable.Storable Data.Text.Encoding.DecoderState
instance GHC.Num.Num Data.Text.Encoding.DecoderState
instance GHC.Show.Show Data.Text.Encoding.DecoderState
instance GHC.Classes.Eq Data.Text.Encoding.DecoderState
instance Foreign.Storable.Storable Data.Text.Encoding.CodePoint
instance GHC.Num.Num Data.Text.Encoding.CodePoint
instance GHC.Show.Show Data.Text.Encoding.CodePoint
instance GHC.Classes.Eq Data.Text.Encoding.CodePoint
instance GHC.Show.Show Data.Text.Encoding.Decoding


-- | Support for using <a>Text</a> data with native code via the Haskell
grforeign function interface.
module Data.Text.Foreign

-- | A type representing a number of UTF-16 code units.
data I16

-- | <i>O(n)</i> Create a new <a>Text</a> from a <a>Ptr</a> <a>Word16</a>
grby copying the contents of the array.
fromPtr :: Ptr Word16 -> I16 -> IO Text

-- | <i>O(n)</i> Perform an action on a temporary, mutable copy of a
gr<a>Text</a>. The copy is freed as soon as the action returns.
useAsPtr :: Text -> (Ptr Word16 -> I16 -> IO a) -> IO a

-- | <i>O(n)</i> Make a mutable copy of a <a>Text</a>.
asForeignPtr :: Text -> IO (ForeignPtr Word16, I16)

-- | <i>O(n)</i> Decode a C string with explicit length, which is assumed
grto have been encoded as UTF-8. If decoding fails, a
gr<tt>UnicodeException</tt> is thrown.
peekCStringLen :: CStringLen -> IO Text

-- | Marshal a <a>Text</a> into a C string encoded as UTF-8 in temporary
grstorage, with explicit length information. The encoded string may
grcontain NUL bytes, and is not followed by a trailing NUL byte.
gr
grThe temporary storage is freed when the subcomputation terminates
gr(either normally or via an exception), so the pointer to the temporary
grstorage must <i>not</i> be used after this function returns.
withCStringLen :: Text -> (CStringLen -> IO a) -> IO a

-- | <i>O(1)</i> Return the length of a <a>Text</a> in units of
gr<tt>Word16</tt>. This is useful for sizing a target array
grappropriately before using <tt>unsafeCopyToPtr</tt>.
lengthWord16 :: Text -> Int

-- | <i>O(n)</i> Copy a <a>Text</a> to an array. The array is assumed to be
grbig enough to hold the contents of the entire <a>Text</a>.
unsafeCopyToPtr :: Text -> Ptr Word16 -> IO ()

-- | <i>O(1)</i> Return the suffix of the <a>Text</a>, with <tt>n</tt>
gr<a>Word16</a> units dropped from its beginning.
gr
grIf <tt>n</tt> would cause the <a>Text</a> to begin inside a surrogate
grpair, the beginning of the suffix will be advanced by one additional
gr<a>Word16</a> unit to maintain its validity.
dropWord16 :: I16 -> Text -> Text

-- | <i>O(1)</i> Return the prefix of the <a>Text</a> of <tt>n</tt>
gr<a>Word16</a> units in length.
gr
grIf <tt>n</tt> would cause the <a>Text</a> to end inside a surrogate
grpair, the end of the prefix will be advanced by one additional
gr<a>Word16</a> unit to maintain its validity.
takeWord16 :: I16 -> Text -> Text
instance GHC.Show.Show Data.Text.Foreign.I16
instance GHC.Real.Real Data.Text.Foreign.I16
instance GHC.Read.Read Data.Text.Foreign.I16
instance GHC.Classes.Ord Data.Text.Foreign.I16
instance GHC.Num.Num Data.Text.Foreign.I16
instance GHC.Real.Integral Data.Text.Foreign.I16
instance GHC.Classes.Eq Data.Text.Foreign.I16
instance GHC.Enum.Enum Data.Text.Foreign.I16
instance GHC.Enum.Bounded Data.Text.Foreign.I16


-- | A time and space-efficient implementation of Unicode text. Suitable
grfor performance critical use, both in terms of large data quantities
grand high speed.
gr
gr<i>Note</i>: Read below the synopsis for important notes on the use of
grthis module.
gr
grThis module is intended to be imported <tt>qualified</tt>, to avoid
grname clashes with <a>Prelude</a> functions, e.g.
gr
gr<pre>
grimport qualified Data.Text as T
gr</pre>
gr
grTo use an extended and very rich family of functions for working with
grUnicode text (including normalization, regular expressions,
grnon-standard encodings, text breaking, and locales), see the
gr<a>text-icu package</a>.
module Data.Text

-- | A space efficient, packed, unboxed Unicode text type.
data Text

-- | <i>O(n)</i> Convert a <a>String</a> into a <a>Text</a>. Subject to
grfusion. Performs replacement on invalid scalar values.
pack :: String -> Text

-- | <i>O(n)</i> Convert a <a>Text</a> into a <a>String</a>. Subject to
grfusion.
unpack :: Text -> String

-- | <i>O(1)</i> Convert a character into a Text. Subject to fusion.
grPerforms replacement on invalid scalar values.
singleton :: Char -> Text

-- | <i>O(1)</i> The empty <a>Text</a>.
empty :: Text

-- | <i>O(n)</i> Adds a character to the front of a <a>Text</a>. This
grfunction is more costly than its <tt>List</tt> counterpart because it
grrequires copying a new array. Subject to fusion. Performs replacement
gron invalid scalar values.
cons :: Char -> Text -> Text
infixr 5 `cons`

-- | <i>O(n)</i> Adds a character to the end of a <a>Text</a>. This copies
grthe entire array in the process, unless fused. Subject to fusion.
grPerforms replacement on invalid scalar values.
snoc :: Text -> Char -> Text

-- | <i>O(n)</i> Appends one <a>Text</a> to the other by copying both of
grthem into a new <a>Text</a>. Subject to fusion.
append :: Text -> Text -> Text

-- | <i>O(1)</i> Returns the first character and rest of a <a>Text</a>, or
gr<a>Nothing</a> if empty. Subject to fusion.
uncons :: Text -> Maybe (Char, Text)

-- | <i>O(1)</i> Returns all but the last character and the last character
grof a <a>Text</a>, or <a>Nothing</a> if empty.
unsnoc :: Text -> Maybe (Text, Char)

-- | <i>O(1)</i> Returns the first character of a <a>Text</a>, which must
grbe non-empty. Subject to fusion.
head :: Text -> Char

-- | <i>O(1)</i> Returns the last character of a <a>Text</a>, which must be
grnon-empty. Subject to fusion.
last :: Text -> Char

-- | <i>O(1)</i> Returns all characters after the head of a <a>Text</a>,
grwhich must be non-empty. Subject to fusion.
tail :: Text -> Text

-- | <i>O(1)</i> Returns all but the last character of a <a>Text</a>, which
grmust be non-empty. Subject to fusion.
init :: Text -> Text

-- | <i>O(1)</i> Tests whether a <a>Text</a> is empty or not. Subject to
grfusion.
null :: Text -> Bool

-- | <i>O(n)</i> Returns the number of characters in a <a>Text</a>. Subject
grto fusion.
length :: Text -> Int

-- | <i>O(n)</i> Compare the count of characters in a <a>Text</a> to a
grnumber. Subject to fusion.
gr
grThis function gives the same answer as comparing against the result of
gr<a>length</a>, but can short circuit if the count of characters is
grgreater than the number, and hence be more efficient.
compareLength :: Text -> Int -> Ordering

-- | <i>O(n)</i> <a>map</a> <tt>f</tt> <tt>t</tt> is the <a>Text</a>
grobtained by applying <tt>f</tt> to each element of <tt>t</tt>.
gr
grExample:
gr
gr<pre>
gr&gt;&gt;&gt; let message = pack "I am not angry. Not at all."
gr
gr&gt;&gt;&gt; T.map (\c -&gt; if c == '.' then '!' else c) message
gr"I am not angry! Not at all!"
gr</pre>
gr
grSubject to fusion. Performs replacement on invalid scalar values.
map :: (Char -> Char) -> Text -> Text

-- | <i>O(n)</i> The <a>intercalate</a> function takes a <a>Text</a> and a
grlist of <a>Text</a>s and concatenates the list after interspersing the
grfirst argument between each element of the list.
gr
grExample:
gr
gr<pre>
gr&gt;&gt;&gt; T.intercalate "NI!" ["We", "seek", "the", "Holy", "Grail"]
gr"WeNI!seekNI!theNI!HolyNI!Grail"
gr</pre>
intercalate :: Text -> [Text] -> Text

-- | <i>O(n)</i> The <a>intersperse</a> function takes a character and
grplaces it between the characters of a <a>Text</a>.
gr
grExample:
gr
gr<pre>
gr&gt;&gt;&gt; T.intersperse '.' "SHIELD"
gr"S.H.I.E.L.D"
gr</pre>
gr
grSubject to fusion. Performs replacement on invalid scalar values.
intersperse :: Char -> Text -> Text

-- | <i>O(n)</i> The <a>transpose</a> function transposes the rows and
grcolumns of its <a>Text</a> argument. Note that this function uses
gr<a>pack</a>, <a>unpack</a>, and the list version of transpose, and is
grthus not very efficient.
gr
grExamples:
gr
gr<pre>
gr&gt;&gt;&gt; transpose ["green","orange"]
gr["go","rr","ea","en","ng","e"]
gr</pre>
gr
gr<pre>
gr&gt;&gt;&gt; transpose ["blue","red"]
gr["br","le","ud","e"]
gr</pre>
transpose :: [Text] -> [Text]

-- | <i>O(n)</i> Reverse the characters of a string.
gr
grExample:
gr
gr<pre>
gr&gt;&gt;&gt; T.reverse "desrever"
gr"reversed"
gr</pre>
gr
grSubject to fusion.
reverse :: Text -> Text

-- | <i>O(m+n)</i> Replace every non-overlapping occurrence of
gr<tt>needle</tt> in <tt>haystack</tt> with <tt>replacement</tt>.
gr
grThis function behaves as though it was defined as follows:
gr
gr<pre>
grreplace needle replacement haystack =
gr  <a>intercalate</a> replacement (<a>splitOn</a> needle haystack)
gr</pre>
gr
grAs this suggests, each occurrence is replaced exactly once. So if
gr<tt>needle</tt> occurs in <tt>replacement</tt>, that occurrence will
gr<i>not</i> itself be replaced recursively:
gr
gr<pre>
gr&gt;&gt;&gt; replace "oo" "foo" "oo"
gr"foo"
gr</pre>
gr
grIn cases where several instances of <tt>needle</tt> overlap, only the
grfirst one will be replaced:
gr
gr<pre>
gr&gt;&gt;&gt; replace "ofo" "bar" "ofofo"
gr"barfo"
gr</pre>
gr
grIn (unlikely) bad cases, this function's time complexity degrades
grtowards <i>O(n*m)</i>.
replace :: Text -> Text -> Text -> Text

-- | <i>O(n)</i> Convert a string to folded case. Subject to fusion.
gr
grThis function is mainly useful for performing caseless (also known as
grcase insensitive) string comparisons.
gr
grA string <tt>x</tt> is a caseless match for a string <tt>y</tt> if and
gronly if:
gr
gr<pre>
grtoCaseFold x == toCaseFold y
gr</pre>
gr
grThe result string may be longer than the input string, and may differ
grfrom applying <a>toLower</a> to the input string. For instance, the
grArmenian small ligature "ﬓ" (men now, U+FB13) is case folded to the
grsequence "մ" (men, U+0574) followed by "ն" (now, U+0576), while the
grGreek "µ" (micro sign, U+00B5) is case folded to "μ" (small letter mu,
grU+03BC) instead of itself.
toCaseFold :: Text -> Text

-- | <i>O(n)</i> Convert a string to lower case, using simple case
grconversion. Subject to fusion.
gr
grThe result string may be longer than the input string. For instance,
gr"İ" (Latin capital letter I with dot above, U+0130) maps to the
grsequence "i" (Latin small letter i, U+0069) followed by " ̇"
gr(combining dot above, U+0307).
toLower :: Text -> Text

-- | <i>O(n)</i> Convert a string to upper case, using simple case
grconversion. Subject to fusion.
gr
grThe result string may be longer than the input string. For instance,
grthe German "ß" (eszett, U+00DF) maps to the two-letter sequence "SS".
toUpper :: Text -> Text

-- | <i>O(n)</i> Convert a string to title case, using simple case
grconversion. Subject to fusion.
gr
grThe first letter of the input is converted to title case, as is every
grsubsequent letter that immediately follows a non-letter. Every letter
grthat immediately follows another letter is converted to lower case.
gr
grThe result string may be longer than the input string. For example,
grthe Latin small ligature ﬂ (U+FB02) is converted to the sequence Latin
grcapital letter F (U+0046) followed by Latin small letter l (U+006C).
gr
gr<i>Note</i>: this function does not take language or culture specific
grrules into account. For instance, in English, different style guides
grdisagree on whether the book name "The Hill of the Red Fox" is
grcorrectly title cased—but this function will capitalize <i>every</i>
grword.
toTitle :: Text -> Text

-- | <i>O(n)</i> Left-justify a string to the given length, using the
grspecified fill character on the right. Subject to fusion. Performs
grreplacement on invalid scalar values.
gr
grExamples:
gr
gr<pre>
gr&gt;&gt;&gt; justifyLeft 7 'x' "foo"
gr"fooxxxx"
gr</pre>
gr
gr<pre>
gr&gt;&gt;&gt; justifyLeft 3 'x' "foobar"
gr"foobar"
gr</pre>
justifyLeft :: Int -> Char -> Text -> Text

-- | <i>O(n)</i> Right-justify a string to the given length, using the
grspecified fill character on the left. Performs replacement on invalid
grscalar values.
gr
grExamples:
gr
gr<pre>
gr&gt;&gt;&gt; justifyRight 7 'x' "bar"
gr"xxxxbar"
gr</pre>
gr
gr<pre>
gr&gt;&gt;&gt; justifyRight 3 'x' "foobar"
gr"foobar"
gr</pre>
justifyRight :: Int -> Char -> Text -> Text

-- | <i>O(n)</i> Center a string to the given length, using the specified
grfill character on either side. Performs replacement on invalid scalar
grvalues.
gr
grExamples:
gr
gr<pre>
gr&gt;&gt;&gt; center 8 'x' "HS"
gr"xxxHSxxx"
gr</pre>
center :: Int -> Char -> Text -> Text

-- | <i>O(n)</i> <a>foldl</a>, applied to a binary operator, a starting
grvalue (typically the left-identity of the operator), and a
gr<a>Text</a>, reduces the <a>Text</a> using the binary operator, from
grleft to right. Subject to fusion.
foldl :: (a -> Char -> a) -> a -> Text -> a

-- | <i>O(n)</i> A strict version of <a>foldl</a>. Subject to fusion.
foldl' :: (a -> Char -> a) -> a -> Text -> a

-- | <i>O(n)</i> A variant of <a>foldl</a> that has no starting value
grargument, and thus must be applied to a non-empty <a>Text</a>. Subject
grto fusion.
foldl1 :: (Char -> Char -> Char) -> Text -> Char

-- | <i>O(n)</i> A strict version of <a>foldl1</a>. Subject to fusion.
foldl1' :: (Char -> Char -> Char) -> Text -> Char

-- | <i>O(n)</i> <a>foldr</a>, applied to a binary operator, a starting
grvalue (typically the right-identity of the operator), and a
gr<a>Text</a>, reduces the <a>Text</a> using the binary operator, from
grright to left. Subject to fusion.
foldr :: (Char -> a -> a) -> a -> Text -> a

-- | <i>O(n)</i> A variant of <a>foldr</a> that has no starting value
grargument, and thus must be applied to a non-empty <a>Text</a>. Subject
grto fusion.
foldr1 :: (Char -> Char -> Char) -> Text -> Char

-- | <i>O(n)</i> Concatenate a list of <a>Text</a>s.
concat :: [Text] -> Text

-- | <i>O(n)</i> Map a function over a <a>Text</a> that results in a
gr<a>Text</a>, and concatenate the results.
concatMap :: (Char -> Text) -> Text -> Text

-- | <i>O(n)</i> <a>any</a> <tt>p</tt> <tt>t</tt> determines whether any
grcharacter in the <a>Text</a> <tt>t</tt> satisfies the predicate
gr<tt>p</tt>. Subject to fusion.
any :: (Char -> Bool) -> Text -> Bool

-- | <i>O(n)</i> <a>all</a> <tt>p</tt> <tt>t</tt> determines whether all
grcharacters in the <a>Text</a> <tt>t</tt> satisfy the predicate
gr<tt>p</tt>. Subject to fusion.
all :: (Char -> Bool) -> Text -> Bool

-- | <i>O(n)</i> <a>maximum</a> returns the maximum value from a
gr<a>Text</a>, which must be non-empty. Subject to fusion.
maximum :: Text -> Char

-- | <i>O(n)</i> <a>minimum</a> returns the minimum value from a
gr<a>Text</a>, which must be non-empty. Subject to fusion.
minimum :: Text -> Char

-- | <i>O(n)</i> <a>scanl</a> is similar to <a>foldl</a>, but returns a
grlist of successive reduced values from the left. Subject to fusion.
grPerforms replacement on invalid scalar values.
gr
gr<pre>
grscanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]
gr</pre>
gr
grNote that
gr
gr<pre>
grlast (scanl f z xs) == foldl f z xs.
gr</pre>
scanl :: (Char -> Char -> Char) -> Char -> Text -> Text

-- | <i>O(n)</i> <a>scanl1</a> is a variant of <a>scanl</a> that has no
grstarting value argument. Subject to fusion. Performs replacement on
grinvalid scalar values.
gr
gr<pre>
grscanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]
gr</pre>
scanl1 :: (Char -> Char -> Char) -> Text -> Text

-- | <i>O(n)</i> <a>scanr</a> is the right-to-left dual of <a>scanl</a>.
grPerforms replacement on invalid scalar values.
gr
gr<pre>
grscanr f v == reverse . scanl (flip f) v . reverse
gr</pre>
scanr :: (Char -> Char -> Char) -> Char -> Text -> Text

-- | <i>O(n)</i> <a>scanr1</a> is a variant of <a>scanr</a> that has no
grstarting value argument. Subject to fusion. Performs replacement on
grinvalid scalar values.
scanr1 :: (Char -> Char -> Char) -> Text -> Text

-- | <i>O(n)</i> Like a combination of <a>map</a> and <a>foldl'</a>.
grApplies a function to each element of a <a>Text</a>, passing an
graccumulating parameter from left to right, and returns a final
gr<a>Text</a>. Performs replacement on invalid scalar values.
mapAccumL :: (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)

-- | The <a>mapAccumR</a> function behaves like a combination of <a>map</a>
grand a strict <a>foldr</a>; it applies a function to each element of a
gr<a>Text</a>, passing an accumulating parameter from right to left, and
grreturning a final value of this accumulator together with the new
gr<a>Text</a>. Performs replacement on invalid scalar values.
mapAccumR :: (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)

-- | <i>O(n*m)</i> <a>replicate</a> <tt>n</tt> <tt>t</tt> is a <a>Text</a>
grconsisting of the input <tt>t</tt> repeated <tt>n</tt> times.
replicate :: Int -> Text -> Text

-- | <i>O(n)</i>, where <tt>n</tt> is the length of the result. The
gr<a>unfoldr</a> function is analogous to the List <a>unfoldr</a>.
gr<a>unfoldr</a> builds a <a>Text</a> from a seed value. The function
grtakes the element and returns <a>Nothing</a> if it is done producing
grthe <a>Text</a>, otherwise <a>Just</a> <tt>(a,b)</tt>. In this case,
gr<tt>a</tt> is the next <a>Char</a> in the string, and <tt>b</tt> is
grthe seed value for further production. Subject to fusion. Performs
grreplacement on invalid scalar values.
unfoldr :: (a -> Maybe (Char, a)) -> a -> Text

-- | <i>O(n)</i> Like <a>unfoldr</a>, <a>unfoldrN</a> builds a <a>Text</a>
grfrom a seed value. However, the length of the result should be limited
grby the first argument to <a>unfoldrN</a>. This function is more
grefficient than <a>unfoldr</a> when the maximum length of the result is
grknown and correct, otherwise its performance is similar to
gr<a>unfoldr</a>. Subject to fusion. Performs replacement on invalid
grscalar values.
unfoldrN :: Int -> (a -> Maybe (Char, a)) -> a -> Text

-- | <i>O(n)</i> <a>take</a> <tt>n</tt>, applied to a <a>Text</a>, returns
grthe prefix of the <a>Text</a> of length <tt>n</tt>, or the <a>Text</a>
gritself if <tt>n</tt> is greater than the length of the Text. Subject
grto fusion.
take :: Int -> Text -> Text

-- | <i>O(n)</i> <a>takeEnd</a> <tt>n</tt> <tt>t</tt> returns the suffix
grremaining after taking <tt>n</tt> characters from the end of
gr<tt>t</tt>.
gr
grExamples:
gr
gr<pre>
gr&gt;&gt;&gt; takeEnd 3 "foobar"
gr"bar"
gr</pre>
takeEnd :: Int -> Text -> Text

-- | <i>O(n)</i> <a>drop</a> <tt>n</tt>, applied to a <a>Text</a>, returns
grthe suffix of the <a>Text</a> after the first <tt>n</tt> characters,
gror the empty <a>Text</a> if <tt>n</tt> is greater than the length of
grthe <a>Text</a>. Subject to fusion.
drop :: Int -> Text -> Text

-- | <i>O(n)</i> <a>dropEnd</a> <tt>n</tt> <tt>t</tt> returns the prefix
grremaining after dropping <tt>n</tt> characters from the end of
gr<tt>t</tt>.
gr
grExamples:
gr
gr<pre>
gr&gt;&gt;&gt; dropEnd 3 "foobar"
gr"foo"
gr</pre>
dropEnd :: Int -> Text -> Text

-- | <i>O(n)</i> <a>takeWhile</a>, applied to a predicate <tt>p</tt> and a
gr<a>Text</a>, returns the longest prefix (possibly empty) of elements
grthat satisfy <tt>p</tt>. Subject to fusion.
takeWhile :: (Char -> Bool) -> Text -> Text

-- | <i>O(n)</i> <a>takeWhileEnd</a>, applied to a predicate <tt>p</tt> and
gra <a>Text</a>, returns the longest suffix (possibly empty) of elements
grthat satisfy <tt>p</tt>. Subject to fusion. Examples:
gr
gr<pre>
gr&gt;&gt;&gt; takeWhileEnd (=='o') "foo"
gr"oo"
gr</pre>
takeWhileEnd :: (Char -> Bool) -> Text -> Text

-- | <i>O(n)</i> <a>dropWhile</a> <tt>p</tt> <tt>t</tt> returns the suffix
grremaining after <a>takeWhile</a> <tt>p</tt> <tt>t</tt>. Subject to
grfusion.
dropWhile :: (Char -> Bool) -> Text -> Text

-- | <i>O(n)</i> <a>dropWhileEnd</a> <tt>p</tt> <tt>t</tt> returns the
grprefix remaining after dropping characters that satisfy the predicate
gr<tt>p</tt> from the end of <tt>t</tt>. Subject to fusion.
gr
grExamples:
gr
gr<pre>
gr&gt;&gt;&gt; dropWhileEnd (=='.') "foo..."
gr"foo"
gr</pre>
dropWhileEnd :: (Char -> Bool) -> Text -> Text

-- | <i>O(n)</i> <a>dropAround</a> <tt>p</tt> <tt>t</tt> returns the
grsubstring remaining after dropping characters that satisfy the
grpredicate <tt>p</tt> from both the beginning and end of <tt>t</tt>.
grSubject to fusion.
dropAround :: (Char -> Bool) -> Text -> Text

-- | <i>O(n)</i> Remove leading and trailing white space from a string.
grEquivalent to:
gr
gr<pre>
grdropAround isSpace
gr</pre>
strip :: Text -> Text

-- | <i>O(n)</i> Remove leading white space from a string. Equivalent to:
gr
gr<pre>
grdropWhile isSpace
gr</pre>
stripStart :: Text -> Text

-- | <i>O(n)</i> Remove trailing white space from a string. Equivalent to:
gr
gr<pre>
grdropWhileEnd isSpace
gr</pre>
stripEnd :: Text -> Text

-- | <i>O(n)</i> <a>splitAt</a> <tt>n t</tt> returns a pair whose first
grelement is a prefix of <tt>t</tt> of length <tt>n</tt>, and whose
grsecond is the remainder of the string. It is equivalent to
gr<tt>(<a>take</a> n t, <a>drop</a> n t)</tt>.
splitAt :: Int -> Text -> (Text, Text)

-- | <i>O(n+m)</i> Find the first instance of <tt>needle</tt> (which must
grbe non-<a>null</a>) in <tt>haystack</tt>. The first element of the
grreturned tuple is the prefix of <tt>haystack</tt> before
gr<tt>needle</tt> is matched. The second is the remainder of
gr<tt>haystack</tt>, starting with the match.
gr
grExamples:
gr
gr<pre>
gr&gt;&gt;&gt; breakOn "::" "a::b::c"
gr("a","::b::c")
gr</pre>
gr
gr<pre>
gr&gt;&gt;&gt; breakOn "/" "foobar"
gr("foobar","")
gr</pre>
gr
grLaws:
gr
gr<pre>
grappend prefix match == haystack
gr  where (prefix, match) = breakOn needle haystack
gr</pre>
gr
grIf you need to break a string by a substring repeatedly (e.g. you want
grto break on every instance of a substring), use <a>breakOnAll</a>
grinstead, as it has lower startup overhead.
gr
grIn (unlikely) bad cases, this function's time complexity degrades
grtowards <i>O(n*m)</i>.
breakOn :: Text -> Text -> (Text, Text)

-- | <i>O(n+m)</i> Similar to <a>breakOn</a>, but searches from the end of
grthe string.
gr
grThe first element of the returned tuple is the prefix of
gr<tt>haystack</tt> up to and including the last match of
gr<tt>needle</tt>. The second is the remainder of <tt>haystack</tt>,
grfollowing the match.
gr
gr<pre>
gr&gt;&gt;&gt; breakOnEnd "::" "a::b::c"
gr("a::b::","c")
gr</pre>
breakOnEnd :: Text -> Text -> (Text, Text)

-- | <i>O(n)</i> <a>break</a> is like <a>span</a>, but the prefix returned
gris over elements that fail the predicate <tt>p</tt>.
break :: (Char -> Bool) -> Text -> (Text, Text)

-- | <i>O(n)</i> <a>span</a>, applied to a predicate <tt>p</tt> and text
gr<tt>t</tt>, returns a pair whose first element is the longest prefix
gr(possibly empty) of <tt>t</tt> of elements that satisfy <tt>p</tt>,
grand whose second is the remainder of the list.
span :: (Char -> Bool) -> Text -> (Text, Text)

-- | <i>O(n)</i> Group characters in a string by equality.
group :: Text -> [Text]

-- | <i>O(n)</i> Group characters in a string according to a predicate.
groupBy :: (Char -> Char -> Bool) -> Text -> [Text]

-- | <i>O(n)</i> Return all initial segments of the given <a>Text</a>,
grshortest first.
inits :: Text -> [Text]

-- | <i>O(n)</i> Return all final segments of the given <a>Text</a>,
grlongest first.
tails :: Text -> [Text]

-- | <i>O(m+n)</i> Break a <a>Text</a> into pieces separated by the first
gr<a>Text</a> argument (which cannot be empty), consuming the delimiter.
grAn empty delimiter is invalid, and will cause an error to be raised.
gr
grExamples:
gr
gr<pre>
gr&gt;&gt;&gt; splitOn "\r\n" "a\r\nb\r\nd\r\ne"
gr["a","b","d","e"]
gr</pre>
gr
gr<pre>
gr&gt;&gt;&gt; splitOn "aaa"  "aaaXaaaXaaaXaaa"
gr["","X","X","X",""]
gr</pre>
gr
gr<pre>
gr&gt;&gt;&gt; splitOn "x"    "x"
gr["",""]
gr</pre>
gr
grand
gr
gr<pre>
grintercalate s . splitOn s         == id
grsplitOn (singleton c)             == split (==c)
gr</pre>
gr
gr(Note: the string <tt>s</tt> to split on above cannot be empty.)
gr
grIn (unlikely) bad cases, this function's time complexity degrades
grtowards <i>O(n*m)</i>.
splitOn :: Text -> Text -> [Text]

-- | <i>O(n)</i> Splits a <a>Text</a> into components delimited by
grseparators, where the predicate returns True for a separator element.
grThe resulting components do not contain the separators. Two adjacent
grseparators result in an empty component in the output. eg.
gr
gr<pre>
gr&gt;&gt;&gt; split (=='a') "aabbaca"
gr["","","bb","c",""]
gr</pre>
gr
gr<pre>
gr&gt;&gt;&gt; split (=='a') ""
gr[""]
gr</pre>
split :: (Char -> Bool) -> Text -> [Text]

-- | <i>O(n)</i> Splits a <a>Text</a> into components of length <tt>k</tt>.
grThe last element may be shorter than the other chunks, depending on
grthe length of the input. Examples:
gr
gr<pre>
gr&gt;&gt;&gt; chunksOf 3 "foobarbaz"
gr["foo","bar","baz"]
gr</pre>
gr
gr<pre>
gr&gt;&gt;&gt; chunksOf 4 "haskell.org"
gr["hask","ell.","org"]
gr</pre>
chunksOf :: Int -> Text -> [Text]

-- | <i>O(n)</i> Breaks a <a>Text</a> up into a list of <a>Text</a>s at
grnewline <a>Char</a>s. The resulting strings do not contain newlines.
lines :: Text -> [Text]

-- | <i>O(n)</i> Breaks a <a>Text</a> up into a list of words, delimited by
gr<a>Char</a>s representing white space.
words :: Text -> [Text]

-- | <i>O(n)</i> Joins lines, after appending a terminating newline to
greach.
unlines :: [Text] -> Text

-- | <i>O(n)</i> Joins words using single space characters.
unwords :: [Text] -> Text

-- | <i>O(n)</i> The <a>isPrefixOf</a> function takes two <a>Text</a>s and
grreturns <a>True</a> iff the first is a prefix of the second. Subject
grto fusion.
isPrefixOf :: Text -> Text -> Bool

-- | <i>O(n)</i> The <a>isSuffixOf</a> function takes two <a>Text</a>s and
grreturns <a>True</a> iff the first is a suffix of the second.
isSuffixOf :: Text -> Text -> Bool

-- | <i>O(n+m)</i> The <a>isInfixOf</a> function takes two <a>Text</a>s and
grreturns <a>True</a> iff the first is contained, wholly and intact,
granywhere within the second.
gr
grIn (unlikely) bad cases, this function's time complexity degrades
grtowards <i>O(n*m)</i>.
isInfixOf :: Text -> Text -> Bool

-- | <i>O(n)</i> Return the suffix of the second string if its prefix
grmatches the entire first string.
gr
grExamples:
gr
gr<pre>
gr&gt;&gt;&gt; stripPrefix "foo" "foobar"
grJust "bar"
gr</pre>
gr
gr<pre>
gr&gt;&gt;&gt; stripPrefix ""    "baz"
grJust "baz"
gr</pre>
gr
gr<pre>
gr&gt;&gt;&gt; stripPrefix "foo" "quux"
grNothing
gr</pre>
gr
grThis is particularly useful with the <tt>ViewPatterns</tt> extension
grto GHC, as follows:
gr
gr<pre>
gr{-# LANGUAGE ViewPatterns #-}
grimport Data.Text as T
gr
grfnordLength :: Text -&gt; Int
grfnordLength (stripPrefix "fnord" -&gt; Just suf) = T.length suf
grfnordLength _                                 = -1
gr</pre>
stripPrefix :: Text -> Text -> Maybe Text

-- | <i>O(n)</i> Return the prefix of the second string if its suffix
grmatches the entire first string.
gr
grExamples:
gr
gr<pre>
gr&gt;&gt;&gt; stripSuffix "bar" "foobar"
grJust "foo"
gr</pre>
gr
gr<pre>
gr&gt;&gt;&gt; stripSuffix ""    "baz"
grJust "baz"
gr</pre>
gr
gr<pre>
gr&gt;&gt;&gt; stripSuffix "foo" "quux"
grNothing
gr</pre>
gr
grThis is particularly useful with the <tt>ViewPatterns</tt> extension
grto GHC, as follows:
gr
gr<pre>
gr{-# LANGUAGE ViewPatterns #-}
grimport Data.Text as T
gr
grquuxLength :: Text -&gt; Int
grquuxLength (stripSuffix "quux" -&gt; Just pre) = T.length pre
grquuxLength _                                = -1
gr</pre>
stripSuffix :: Text -> Text -> Maybe Text

-- | <i>O(n)</i> Find the longest non-empty common prefix of two strings
grand return it, along with the suffixes of each string at which they no
grlonger match.
gr
grIf the strings do not have a common prefix or either one is empty,
grthis function returns <a>Nothing</a>.
gr
grExamples:
gr
gr<pre>
gr&gt;&gt;&gt; commonPrefixes "foobar" "fooquux"
grJust ("foo","bar","quux")
gr</pre>
gr
gr<pre>
gr&gt;&gt;&gt; commonPrefixes "veeble" "fetzer"
grNothing
gr</pre>
gr
gr<pre>
gr&gt;&gt;&gt; commonPrefixes "" "baz"
grNothing
gr</pre>
commonPrefixes :: Text -> Text -> Maybe (Text, Text, Text)

-- | <i>O(n)</i> <a>filter</a>, applied to a predicate and a <a>Text</a>,
grreturns a <a>Text</a> containing those characters that satisfy the
grpredicate.
filter :: (Char -> Bool) -> Text -> Text

-- | <i>O(n+m)</i> Find all non-overlapping instances of <tt>needle</tt> in
gr<tt>haystack</tt>. Each element of the returned list consists of a
grpair:
gr
gr<ul>
gr<li>The entire string prior to the <i>k</i>th match (i.e. the
grprefix)</li>
gr<li>The <i>k</i>th match, followed by the remainder of the string</li>
gr</ul>
gr
grExamples:
gr
gr<pre>
gr&gt;&gt;&gt; breakOnAll "::" ""
gr[]
gr</pre>
gr
gr<pre>
gr&gt;&gt;&gt; breakOnAll "/" "a/b/c/"
gr[("a","/b/c/"),("a/b","/c/"),("a/b/c","/")]
gr</pre>
gr
grIn (unlikely) bad cases, this function's time complexity degrades
grtowards <i>O(n*m)</i>.
gr
grThe <tt>needle</tt> parameter may not be empty.
breakOnAll :: Text -> Text -> [(Text, Text)]

-- | <i>O(n)</i> The <a>find</a> function takes a predicate and a
gr<a>Text</a>, and returns the first element matching the predicate, or
gr<a>Nothing</a> if there is no such element.
find :: (Char -> Bool) -> Text -> Maybe Char

-- | <i>O(n)</i> The <a>partition</a> function takes a predicate and a
gr<a>Text</a>, and returns the pair of <a>Text</a>s with elements which
grdo and do not satisfy the predicate, respectively; i.e.
gr
gr<pre>
grpartition p t == (filter p t, filter (not . p) t)
gr</pre>
partition :: (Char -> Bool) -> Text -> (Text, Text)

-- | <i>O(n)</i> <a>Text</a> index (subscript) operator, starting from 0.
index :: Text -> Int -> Char

-- | <i>O(n)</i> The <a>findIndex</a> function takes a predicate and a
gr<a>Text</a> and returns the index of the first element in the
gr<a>Text</a> satisfying the predicate. Subject to fusion.
findIndex :: (Char -> Bool) -> Text -> Maybe Int

-- | <i>O(n+m)</i> The <a>count</a> function returns the number of times
grthe query string appears in the given <a>Text</a>. An empty query
grstring is invalid, and will cause an error to be raised.
gr
grIn (unlikely) bad cases, this function's time complexity degrades
grtowards <i>O(n*m)</i>.
count :: Text -> Text -> Int

-- | <i>O(n)</i> <a>zip</a> takes two <a>Text</a>s and returns a list of
grcorresponding pairs of bytes. If one input <a>Text</a> is short,
grexcess elements of the longer <a>Text</a> are discarded. This is
grequivalent to a pair of <a>unpack</a> operations.
zip :: Text -> Text -> [(Char, Char)]

-- | <i>O(n)</i> <a>zipWith</a> generalises <a>zip</a> by zipping with the
grfunction given as the first argument, instead of a tupling function.
grPerforms replacement on invalid scalar values.
zipWith :: (Char -> Char -> Char) -> Text -> Text -> Text

-- | <i>O(n)</i> Make a distinct copy of the given string, sharing no
grstorage with the original string.
gr
grAs an example, suppose you read a large string, of which you need only
gra small portion. If you do not use <a>copy</a>, the entire original
grarray will be kept alive in memory by the smaller string. Making a
grcopy "breaks the link" to the original array, allowing it to be
grgarbage collected if there are no other live references to it.
copy :: Text -> Text

-- | <i>O(n)</i> Convert a literal string into a <a>Text</a>. Subject to
grfusion.
gr
grThis is exposed solely for people writing GHC rewrite rules.
unpackCString# :: Addr# -> Text
instance GHC.Classes.Eq Data.Text.Internal.Text
instance GHC.Classes.Ord Data.Text.Internal.Text
instance GHC.Read.Read Data.Text.Internal.Text
instance GHC.Base.Semigroup Data.Text.Internal.Text
instance GHC.Base.Monoid Data.Text.Internal.Text
instance Data.String.IsString Data.Text.Internal.Text
instance GHC.Exts.IsList Data.Text.Internal.Text
instance Control.DeepSeq.NFData Data.Text.Internal.Text
instance Data.Binary.Class.Binary Data.Text.Internal.Text
instance Data.Data.Data Data.Text.Internal.Text
instance Text.Printf.PrintfArg Data.Text.Internal.Text


-- | Functions used frequently when reading textual data.
module Data.Text.Read

-- | Read some text. If the read succeeds, return its value and the
grremaining text, otherwise an error message.
type Reader a = IReader Text a

-- | Read a decimal integer. The input must begin with at least one decimal
grdigit, and is consumed until a non-digit or end of string is reached.
gr
grThis function does not handle leading sign characters. If you need to
grhandle signed input, use <tt><a>signed</a> <a>decimal</a></tt>.
gr
gr<i>Note</i>: For fixed-width integer types, this function does not
grattempt to detect overflow, so a sufficiently long input may give
grincorrect results. If you are worried about overflow, use
gr<a>Integer</a> for your result type.
decimal :: Integral a => Reader a

-- | Read a hexadecimal integer, consisting of an optional leading
gr<tt>"0x"</tt> followed by at least one hexadecimal digit. Input is
grconsumed until a non-hex-digit or end of string is reached. This
grfunction is case insensitive.
gr
grThis function does not handle leading sign characters. If you need to
grhandle signed input, use <tt><a>signed</a> <a>hexadecimal</a></tt>.
gr
gr<i>Note</i>: For fixed-width integer types, this function does not
grattempt to detect overflow, so a sufficiently long input may give
grincorrect results. If you are worried about overflow, use
gr<a>Integer</a> for your result type.
hexadecimal :: Integral a => Reader a

-- | Read an optional leading sign character (<tt>'-'</tt> or <tt>'+'</tt>)
grand apply it to the result of applying the given reader.
signed :: Num a => Reader a -> Reader a

-- | Read a rational number.
gr
grThis function accepts an optional leading sign character, followed by
grat least one decimal digit. The syntax similar to that accepted by the
gr<a>read</a> function, with the exception that a trailing <tt>'.'</tt>
gror <tt>'e'</tt> <i>not</i> followed by a number is not consumed.
gr
grExamples (with behaviour identical to <a>read</a>):
gr
gr<pre>
grrational "3"     == Right (3.0, "")
grrational "3.1"   == Right (3.1, "")
grrational "3e4"   == Right (30000.0, "")
grrational "3.1e4" == Right (31000.0, "")
grrational ".3"    == Left "input does not start with a digit"
grrational "e3"    == Left "input does not start with a digit"
gr</pre>
gr
grExamples of differences from <a>read</a>:
gr
gr<pre>
grrational "3.foo" == Right (3.0, ".foo")
grrational "3e"    == Right (3.0, "e")
gr</pre>
rational :: Fractional a => Reader a

-- | Read a rational number.
gr
grThe syntax accepted by this function is the same as for
gr<a>rational</a>.
gr
gr<i>Note</i>: This function is almost ten times faster than
gr<a>rational</a>, but is slightly less accurate.
gr
grThe <a>Double</a> type supports about 16 decimal places of accuracy.
grFor 94.2% of numbers, this function and <a>rational</a> give identical
grresults, but for the remaining 5.8%, this function loses precision
graround the 15th decimal place. For 0.001% of numbers, this function
grwill lose precision at the 13th or 14th decimal place.
double :: Reader Double


-- | <i>Warning</i>: this is an internal module, and does not have a stable
grAPI or name. Functions in this module may not check or enforce
grpreconditions expected by public modules. Use at your own risk!
gr
grA module containing private <a>Text</a> internals. This exposes the
gr<a>Text</a> representation and low level construction functions.
grModules which extend the <a>Text</a> system may need to use this
grmodule.
module Data.Text.Internal.Lazy
data Text
Empty :: Text
Chunk :: {-# UNPACK #-} !Text -> Text -> Text

-- | Smart constructor for <a>Chunk</a>. Guarantees the data type
grinvariant.
chunk :: Text -> Text -> Text

-- | Smart constructor for <a>Empty</a>.
empty :: Text

-- | Consume the chunks of a lazy <a>Text</a> with a natural right fold.
foldrChunks :: (Text -> a -> a) -> a -> Text -> a

-- | Consume the chunks of a lazy <a>Text</a> with a strict,
grtail-recursive, accumulating left fold.
foldlChunks :: (a -> Text -> a) -> a -> Text -> a

-- | Check the invariant strictly.
strictInvariant :: Text -> Bool

-- | Check the invariant lazily.
lazyInvariant :: Text -> Text

-- | Display the internal structure of a lazy <a>Text</a>.
showStructure :: Text -> String

-- | Currently set to 16 KiB, less the memory management overhead.
defaultChunkSize :: Int

-- | Currently set to 128 bytes, less the memory management overhead.
smallChunkSize :: Int

-- | The memory management overhead. Currently this is tuned for GHC only.
chunkOverhead :: Int


-- | This module has been renamed to <a>Lazy</a>. This name for the module
grwill be removed in the next major release.

-- | <i>Deprecated: Use Data.Text.Internal.Lazy instead</i>
module Data.Text.Lazy.Internal


-- | <i>Warning</i>: this is an internal module, and does not have a stable
grAPI or name. Functions in this module may not check or enforce
grpreconditions expected by public modules. Use at your own risk!
gr
grFast substring search for lazy <a>Text</a>, based on work by Boyer,
grMoore, Horspool, Sunday, and Lundh. Adapted from the strict
grimplementation.
module Data.Text.Internal.Lazy.Search

-- | <i>O(n+m)</i> Find the offsets of all non-overlapping indices of
gr<tt>needle</tt> within <tt>haystack</tt>.
gr
grThis function is strict in <tt>needle</tt>, and lazy (as far as
grpossible) in the chunks of <tt>haystack</tt>.
gr
grIn (unlikely) bad cases, this algorithm's complexity degrades towards
gr<i>O(n*m)</i>.
indices :: Text -> Text -> [Int64]


-- | <i>Warning</i>: this is an internal module, and does not have a stable
grAPI or name. Functions in this module may not check or enforce
grpreconditions expected by public modules. Use at your own risk!
gr
grCore stream fusion functionality for text.
module Data.Text.Internal.Lazy.Fusion

-- | <i>O(n)</i> Convert a <a>Text</a> into a 'Stream Char'.
stream :: Text -> Stream Char

-- | <i>O(n)</i> Convert a 'Stream Char' into a <a>Text</a>, using
gr<a>defaultChunkSize</a>.
unstream :: Stream Char -> Text

-- | <i>O(n)</i> Convert a 'Stream Char' into a <a>Text</a>, using the
grgiven chunk size.
unstreamChunks :: Int -> Stream Char -> Text

-- | <i>O(n)</i> Returns the number of characters in a text.
length :: Stream Char -> Int64

-- | <i>O(n)</i> Like <tt>unfoldr</tt>, <a>unfoldrN</a> builds a stream
grfrom a seed value. However, the length of the result is limited by the
grfirst argument to <a>unfoldrN</a>. This function is more efficient
grthan <tt>unfoldr</tt> when the length of the result is known.
unfoldrN :: Int64 -> (a -> Maybe (Char, a)) -> a -> Stream Char

-- | <i>O(n)</i> stream index (subscript) operator, starting from 0.
index :: Stream Char -> Int64 -> Char

-- | <i>O(n)</i> The <tt>count</tt> function returns the number of times
grthe query element appears in the given stream.
countChar :: Char -> Stream Char -> Int64


-- | Functions for converting lazy <a>Text</a> values to and from lazy
gr<tt>ByteString</tt>, using several standard encodings.
gr
grTo gain access to a much larger family of encodings, use the
gr<a>text-icu package</a>.
module Data.Text.Lazy.Encoding

-- | <i>Deprecated</i>. Decode a <tt>ByteString</tt> containing 7-bit ASCII
grencoded text.

-- | <i>Deprecated: Use decodeUtf8 instead</i>
decodeASCII :: ByteString -> Text

-- | Decode a <tt>ByteString</tt> containing Latin-1 (aka ISO-8859-1)
grencoded text.
decodeLatin1 :: ByteString -> Text

-- | Decode a <tt>ByteString</tt> containing UTF-8 encoded text that is
grknown to be valid.
gr
grIf the input contains any invalid UTF-8 data, an exception will be
grthrown that cannot be caught in pure code. For more control over the
grhandling of invalid data, use <a>decodeUtf8'</a> or
gr<a>decodeUtf8With</a>.
decodeUtf8 :: ByteString -> Text

-- | Decode text from little endian UTF-16 encoding.
gr
grIf the input contains any invalid little endian UTF-16 data, an
grexception will be thrown. For more control over the handling of
grinvalid data, use <a>decodeUtf16LEWith</a>.
decodeUtf16LE :: ByteString -> Text

-- | Decode text from big endian UTF-16 encoding.
gr
grIf the input contains any invalid big endian UTF-16 data, an exception
grwill be thrown. For more control over the handling of invalid data,
gruse <a>decodeUtf16BEWith</a>.
decodeUtf16BE :: ByteString -> Text

-- | Decode text from little endian UTF-32 encoding.
gr
grIf the input contains any invalid little endian UTF-32 data, an
grexception will be thrown. For more control over the handling of
grinvalid data, use <a>decodeUtf32LEWith</a>.
decodeUtf32LE :: ByteString -> Text

-- | Decode text from big endian UTF-32 encoding.
gr
grIf the input contains any invalid big endian UTF-32 data, an exception
grwill be thrown. For more control over the handling of invalid data,
gruse <a>decodeUtf32BEWith</a>.
decodeUtf32BE :: ByteString -> Text

-- | Decode a <tt>ByteString</tt> containing UTF-8 encoded text..
gr
grIf the input contains any invalid UTF-8 data, the relevant exception
grwill be returned, otherwise the decoded text.
gr
gr<i>Note</i>: this function is <i>not</i> lazy, as it must decode its
grentire input before it can return a result. If you need lazy
gr(streaming) decoding, use <a>decodeUtf8With</a> in lenient mode.
decodeUtf8' :: ByteString -> Either UnicodeException Text

-- | Decode a <tt>ByteString</tt> 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

-- | Encode text to a ByteString <a>Builder</a> using UTF-8 encoding.
encodeUtf8Builder :: Text -> Builder

-- | Encode text using UTF-8 encoding and escape the ASCII characters using
gra <a>BoundedPrim</a>.
gr
grUse this function is to implement efficient encoders for text-based
grformats like JSON or HTML.
encodeUtf8BuilderEscaped :: BoundedPrim Word8 -> Text -> Builder


-- | A time and space-efficient implementation of Unicode text using lists
grof packed arrays.
gr
gr<i>Note</i>: Read below the synopsis for important notes on the use of
grthis module.
gr
grThe representation used by this module is suitable for high
grperformance use and for streaming large quantities of data. It
grprovides a means to manipulate a large body of text without requiring
grthat the entire content be resident in memory.
gr
grSome operations, such as <a>concat</a>, <a>append</a>, <a>reverse</a>
grand <a>cons</a>, have better time complexity than their
gr<a>Data.Text</a> equivalents, due to the underlying representation
grbeing a list of chunks. For other operations, lazy <a>Text</a>s are
grusually within a few percent of strict ones, but often with better
grheap usage if used in a streaming fashion. For data larger than
gravailable memory, or if you have tight memory constraints, this module
grwill be the only option.
gr
grThis module is intended to be imported <tt>qualified</tt>, to avoid
grname clashes with <a>Prelude</a> functions. eg.
gr
gr<pre>
grimport qualified Data.Text.Lazy as L
gr</pre>
module Data.Text.Lazy
data Text

-- | <i>O(n)</i> Convert a <a>String</a> into a <a>Text</a>.
gr
grSubject to fusion. Performs replacement on invalid scalar values.
pack :: String -> Text

-- | <i>O(n)</i> Convert a <a>Text</a> into a <a>String</a>. Subject to
grfusion.
unpack :: Text -> String

-- | <i>O(1)</i> Convert a character into a Text. Subject to fusion.
grPerforms replacement on invalid scalar values.
singleton :: Char -> Text

-- | Smart constructor for <a>Empty</a>.
empty :: Text

-- | <i>O(c)</i> Convert a list of strict <a>Text</a>s into a lazy
gr<a>Text</a>.
fromChunks :: [Text] -> Text

-- | <i>O(n)</i> Convert a lazy <a>Text</a> into a list of strict
gr<a>Text</a>s.
toChunks :: Text -> [Text]

-- | <i>O(n)</i> Convert a lazy <a>Text</a> into a strict <a>Text</a>.
toStrict :: Text -> Text

-- | <i>O(c)</i> Convert a strict <a>Text</a> into a lazy <a>Text</a>.
fromStrict :: Text -> Text

-- | Consume the chunks of a lazy <a>Text</a> with a natural right fold.
foldrChunks :: (Text -> a -> a) -> a -> Text -> a

-- | Consume the chunks of a lazy <a>Text</a> with a strict,
grtail-recursive, accumulating left fold.
foldlChunks :: (a -> Text -> a) -> a -> Text -> a

-- | <i>O(1)</i> Adds a character to the front of a <a>Text</a>. Subject to
grfusion.
cons :: Char -> Text -> Text
infixr 5 `cons`

-- | <i>O(n)</i> Adds a character to the end of a <a>Text</a>. This copies
grthe entire array in the process, unless fused. Subject to fusion.
snoc :: Text -> Char -> Text

-- | <i>O(n/c)</i> Appends one <a>Text</a> to another. Subject to fusion.
append :: Text -> Text -> Text

-- | <i>O(1)</i> Returns the first character and rest of a <a>Text</a>, or
gr<a>Nothing</a> if empty. Subject to fusion.
uncons :: Text -> Maybe (Char, Text)

-- | <i>O(n/c)</i> Returns the <a>init</a> and <a>last</a> of a
gr<a>Text</a>, or <a>Nothing</a> if empty.
gr
gr<ul>
gr<li>It is no faster than using <a>init</a> and <a>last</a>.</li>
gr</ul>
unsnoc :: Text -> Maybe (Text, Char)

-- | <i>O(1)</i> Returns the first character of a <a>Text</a>, which must
grbe non-empty. Subject to fusion.
head :: Text -> Char

-- | <i>O(n/c)</i> Returns the last character of a <a>Text</a>, which must
grbe non-empty. Subject to fusion.
last :: Text -> Char

-- | <i>O(1)</i> Returns all characters after the head of a <a>Text</a>,
grwhich must be non-empty. Subject to fusion.
tail :: Text -> Text

-- | <i>O(n/c)</i> Returns all but the last character of a <a>Text</a>,
grwhich must be non-empty. Subject to fusion.
init :: Text -> Text

-- | <i>O(1)</i> Tests whether a <a>Text</a> is empty or not. Subject to
grfusion.
null :: Text -> Bool

-- | <i>O(n)</i> Returns the number of characters in a <a>Text</a>. Subject
grto fusion.
length :: Text -> Int64

-- | <i>O(n)</i> Compare the count of characters in a <a>Text</a> to a
grnumber. Subject to fusion.
gr
grThis function gives the same answer as comparing against the result of
gr<a>length</a>, but can short circuit if the count of characters is
grgreater than the number, and hence be more efficient.
compareLength :: Text -> Int64 -> Ordering

-- | <i>O(n)</i> <a>map</a> <tt>f</tt> <tt>t</tt> is the <a>Text</a>
grobtained by applying <tt>f</tt> to each element of <tt>t</tt>. Subject
grto fusion. Performs replacement on invalid scalar values.
map :: (Char -> Char) -> Text -> Text

-- | <i>O(n)</i> The <a>intercalate</a> function takes a <a>Text</a> and a
grlist of <a>Text</a>s and concatenates the list after interspersing the
grfirst argument between each element of the list.
intercalate :: Text -> [Text] -> Text

-- | <i>O(n)</i> The <a>intersperse</a> function takes a character and
grplaces it between the characters of a <a>Text</a>. Subject to fusion.
grPerforms replacement on invalid scalar values.
intersperse :: Char -> Text -> Text

-- | <i>O(n)</i> The <a>transpose</a> function transposes the rows and
grcolumns of its <a>Text</a> argument. Note that this function uses
gr<a>pack</a>, <a>unpack</a>, and the list version of transpose, and is
grthus not very efficient.
transpose :: [Text] -> [Text]

-- | <i>O(n)</i> <a>reverse</a> <tt>t</tt> returns the elements of
gr<tt>t</tt> in reverse order.
reverse :: Text -> Text

-- | <i>O(m+n)</i> Replace every non-overlapping occurrence of
gr<tt>needle</tt> in <tt>haystack</tt> with <tt>replacement</tt>.
gr
grThis function behaves as though it was defined as follows:
gr
gr<pre>
grreplace needle replacement haystack =
gr  <a>intercalate</a> replacement (<a>splitOn</a> needle haystack)
gr</pre>
gr
grAs this suggests, each occurrence is replaced exactly once. So if
gr<tt>needle</tt> occurs in <tt>replacement</tt>, that occurrence will
gr<i>not</i> itself be replaced recursively:
gr
gr<pre>
grreplace "oo" "foo" "oo" == "foo"
gr</pre>
gr
grIn cases where several instances of <tt>needle</tt> overlap, only the
grfirst one will be replaced:
gr
gr<pre>
grreplace "ofo" "bar" "ofofo" == "barfo"
gr</pre>
gr
grIn (unlikely) bad cases, this function's time complexity degrades
grtowards <i>O(n*m)</i>.
replace :: Text -> Text -> Text -> Text

-- | <i>O(n)</i> Convert a string to folded case. Subject to fusion.
gr
grThis function is mainly useful for performing caseless (or case
grinsensitive) string comparisons.
gr
grA string <tt>x</tt> is a caseless match for a string <tt>y</tt> if and
gronly if:
gr
gr<pre>
grtoCaseFold x == toCaseFold y
gr</pre>
gr
grThe result string may be longer than the input string, and may differ
grfrom applying <a>toLower</a> to the input string. For instance, the
grArmenian small ligature men now (U+FB13) is case folded to the bigram
grmen now (U+0574 U+0576), while the micro sign (U+00B5) is case folded
grto the Greek small letter letter mu (U+03BC) instead of itself.
toCaseFold :: Text -> Text

-- | <i>O(n)</i> Convert a string to lower case, using simple case
grconversion. Subject to fusion.
gr
grThe result string may be longer than the input string. For instance,
grthe Latin capital letter I with dot above (U+0130) maps to the
grsequence Latin small letter i (U+0069) followed by combining dot above
gr(U+0307).
toLower :: Text -> Text

-- | <i>O(n)</i> Convert a string to upper case, using simple case
grconversion. Subject to fusion.
gr
grThe result string may be longer than the input string. For instance,
grthe German eszett (U+00DF) maps to the two-letter sequence SS.
toUpper :: Text -> Text

-- | <i>O(n)</i> Convert a string to title case, using simple case
grconversion. Subject to fusion.
gr
grThe first letter of the input is converted to title case, as is every
grsubsequent letter that immediately follows a non-letter. Every letter
grthat immediately follows another letter is converted to lower case.
gr
grThe result string may be longer than the input string. For example,
grthe Latin small ligature ﬂ (U+FB02) is converted to the sequence Latin
grcapital letter F (U+0046) followed by Latin small letter l (U+006C).
gr
gr<i>Note</i>: this function does not take language or culture specific
grrules into account. For instance, in English, different style guides
grdisagree on whether the book name "The Hill of the Red Fox" is
grcorrectly title cased—but this function will capitalize <i>every</i>
grword.
toTitle :: Text -> Text

-- | <i>O(n)</i> Left-justify a string to the given length, using the
grspecified fill character on the right. Subject to fusion. Performs
grreplacement on invalid scalar values.
gr
grExamples:
gr
gr<pre>
grjustifyLeft 7 'x' "foo"    == "fooxxxx"
grjustifyLeft 3 'x' "foobar" == "foobar"
gr</pre>
justifyLeft :: Int64 -> Char -> Text -> Text

-- | <i>O(n)</i> Right-justify a string to the given length, using the
grspecified fill character on the left. Performs replacement on invalid
grscalar values.
gr
grExamples:
gr
gr<pre>
grjustifyRight 7 'x' "bar"    == "xxxxbar"
grjustifyRight 3 'x' "foobar" == "foobar"
gr</pre>
justifyRight :: Int64 -> Char -> Text -> Text

-- | <i>O(n)</i> Center a string to the given length, using the specified
grfill character on either side. Performs replacement on invalid scalar
grvalues.
gr
grExamples:
gr
gr<pre>
grcenter 8 'x' "HS" = "xxxHSxxx"
gr</pre>
center :: Int64 -> Char -> Text -> Text

-- | <i>O(n)</i> <a>foldl</a>, applied to a binary operator, a starting
grvalue (typically the left-identity of the operator), and a
gr<a>Text</a>, reduces the <a>Text</a> using the binary operator, from
grleft to right. Subject to fusion.
foldl :: (a -> Char -> a) -> a -> Text -> a

-- | <i>O(n)</i> A strict version of <a>foldl</a>. Subject to fusion.
foldl' :: (a -> Char -> a) -> a -> Text -> a

-- | <i>O(n)</i> A variant of <a>foldl</a> that has no starting value
grargument, and thus must be applied to a non-empty <a>Text</a>. Subject
grto fusion.
foldl1 :: (Char -> Char -> Char) -> Text -> Char

-- | <i>O(n)</i> A strict version of <a>foldl1</a>. Subject to fusion.
foldl1' :: (Char -> Char -> Char) -> Text -> Char

-- | <i>O(n)</i> <a>foldr</a>, applied to a binary operator, a starting
grvalue (typically the right-identity of the operator), and a
gr<a>Text</a>, reduces the <a>Text</a> using the binary operator, from
grright to left. Subject to fusion.
foldr :: (Char -> a -> a) -> a -> Text -> a

-- | <i>O(n)</i> A variant of <a>foldr</a> that has no starting value
grargument, and thus must be applied to a non-empty <a>Text</a>. Subject
grto fusion.
foldr1 :: (Char -> Char -> Char) -> Text -> Char

-- | <i>O(n)</i> Concatenate a list of <a>Text</a>s.
concat :: [Text] -> Text

-- | <i>O(n)</i> Map a function over a <a>Text</a> that results in a
gr<a>Text</a>, and concatenate the results.
concatMap :: (Char -> Text) -> Text -> Text

-- | <i>O(n)</i> <a>any</a> <tt>p</tt> <tt>t</tt> determines whether any
grcharacter in the <a>Text</a> <tt>t</tt> satisfies the predicate
gr<tt>p</tt>. Subject to fusion.
any :: (Char -> Bool) -> Text -> Bool

-- | <i>O(n)</i> <a>all</a> <tt>p</tt> <tt>t</tt> determines whether all
grcharacters in the <a>Text</a> <tt>t</tt> satisfy the predicate
gr<tt>p</tt>. Subject to fusion.
all :: (Char -> Bool) -> Text -> Bool

-- | <i>O(n)</i> <a>maximum</a> returns the maximum value from a
gr<a>Text</a>, which must be non-empty. Subject to fusion.
maximum :: Text -> Char

-- | <i>O(n)</i> <a>minimum</a> returns the minimum value from a
gr<a>Text</a>, which must be non-empty. Subject to fusion.
minimum :: Text -> Char

-- | <i>O(n)</i> <a>scanl</a> is similar to <a>foldl</a>, but returns a
grlist of successive reduced values from the left. Subject to fusion.
grPerforms replacement on invalid scalar values.
gr
gr<pre>
grscanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]
gr</pre>
gr
grNote that
gr
gr<pre>
grlast (scanl f z xs) == foldl f z xs.
gr</pre>
scanl :: (Char -> Char -> Char) -> Char -> Text -> Text

-- | <i>O(n)</i> <a>scanl1</a> is a variant of <a>scanl</a> that has no
grstarting value argument. Subject to fusion. Performs replacement on
grinvalid scalar values.
gr
gr<pre>
grscanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]
gr</pre>
scanl1 :: (Char -> Char -> Char) -> Text -> Text

-- | <i>O(n)</i> <a>scanr</a> is the right-to-left dual of <a>scanl</a>.
grPerforms replacement on invalid scalar values.
gr
gr<pre>
grscanr f v == reverse . scanl (flip f) v . reverse
gr</pre>
scanr :: (Char -> Char -> Char) -> Char -> Text -> Text

-- | <i>O(n)</i> <a>scanr1</a> is a variant of <a>scanr</a> that has no
grstarting value argument. Performs replacement on invalid scalar
grvalues.
scanr1 :: (Char -> Char -> Char) -> Text -> Text

-- | <i>O(n)</i> Like a combination of <a>map</a> and <a>foldl'</a>.
grApplies a function to each element of a <a>Text</a>, passing an
graccumulating parameter from left to right, and returns a final
gr<a>Text</a>. Performs replacement on invalid scalar values.
mapAccumL :: (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)

-- | The <a>mapAccumR</a> function behaves like a combination of <a>map</a>
grand a strict <a>foldr</a>; it applies a function to each element of a
gr<a>Text</a>, passing an accumulating parameter from right to left, and
grreturning a final value of this accumulator together with the new
gr<a>Text</a>. Performs replacement on invalid scalar values.
mapAccumR :: (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)

-- | <tt><a>repeat</a> x</tt> is an infinite <a>Text</a>, with <tt>x</tt>
grthe value of every element.
repeat :: Char -> Text

-- | <i>O(n*m)</i> <a>replicate</a> <tt>n</tt> <tt>t</tt> is a <a>Text</a>
grconsisting of the input <tt>t</tt> repeated <tt>n</tt> times.
replicate :: Int64 -> Text -> Text

-- | <a>cycle</a> ties a finite, non-empty <a>Text</a> into a circular one,
gror equivalently, the infinite repetition of the original <a>Text</a>.
cycle :: Text -> Text

-- | <tt><a>iterate</a> f x</tt> returns an infinite <a>Text</a> of
grrepeated applications of <tt>f</tt> to <tt>x</tt>:
gr
gr<pre>
griterate f x == [x, f x, f (f x), ...]
gr</pre>
iterate :: (Char -> Char) -> Char -> Text

-- | <i>O(n)</i>, where <tt>n</tt> is the length of the result. The
gr<a>unfoldr</a> function is analogous to the List <a>unfoldr</a>.
gr<a>unfoldr</a> builds a <a>Text</a> from a seed value. The function
grtakes the element and returns <a>Nothing</a> if it is done producing
grthe <a>Text</a>, otherwise <a>Just</a> <tt>(a,b)</tt>. In this case,
gr<tt>a</tt> is the next <a>Char</a> in the string, and <tt>b</tt> is
grthe seed value for further production. Performs replacement on invalid
grscalar values.
unfoldr :: (a -> Maybe (Char, a)) -> a -> Text

-- | <i>O(n)</i> Like <a>unfoldr</a>, <a>unfoldrN</a> builds a <a>Text</a>
grfrom a seed value. However, the length of the result should be limited
grby the first argument to <a>unfoldrN</a>. This function is more
grefficient than <a>unfoldr</a> when the maximum length of the result is
grknown and correct, otherwise its performance is similar to
gr<a>unfoldr</a>. Performs replacement on invalid scalar values.
unfoldrN :: Int64 -> (a -> Maybe (Char, a)) -> a -> Text

-- | <i>O(n)</i> <a>take</a> <tt>n</tt>, applied to a <a>Text</a>, returns
grthe prefix of the <a>Text</a> of length <tt>n</tt>, or the <a>Text</a>
gritself if <tt>n</tt> is greater than the length of the Text. Subject
grto fusion.
take :: Int64 -> Text -> Text

-- | <i>O(n)</i> <a>takeEnd</a> <tt>n</tt> <tt>t</tt> returns the suffix
grremaining after taking <tt>n</tt> characters from the end of
gr<tt>t</tt>.
gr
grExamples:
gr
gr<pre>
grtakeEnd 3 "foobar" == "bar"
gr</pre>
takeEnd :: Int64 -> Text -> Text

-- | <i>O(n)</i> <a>drop</a> <tt>n</tt>, applied to a <a>Text</a>, returns
grthe suffix of the <a>Text</a> after the first <tt>n</tt> characters,
gror the empty <a>Text</a> if <tt>n</tt> is greater than the length of
grthe <a>Text</a>. Subject to fusion.
drop :: Int64 -> Text -> Text

-- | <i>O(n)</i> <a>dropEnd</a> <tt>n</tt> <tt>t</tt> returns the prefix
grremaining after dropping <tt>n</tt> characters from the end of
gr<tt>t</tt>.
gr
grExamples:
gr
gr<pre>
grdropEnd 3 "foobar" == "foo"
gr</pre>
dropEnd :: Int64 -> Text -> Text

-- | <i>O(n)</i> <a>takeWhile</a>, applied to a predicate <tt>p</tt> and a
gr<a>Text</a>, returns the longest prefix (possibly empty) of elements
grthat satisfy <tt>p</tt>. Subject to fusion.
takeWhile :: (Char -> Bool) -> Text -> Text

-- | <i>O(n)</i> <a>takeWhileEnd</a>, applied to a predicate <tt>p</tt> and
gra <a>Text</a>, returns the longest suffix (possibly empty) of elements
grthat satisfy <tt>p</tt>. Examples:
gr
gr<pre>
grtakeWhileEnd (=='o') "foo" == "oo"
gr</pre>
takeWhileEnd :: (Char -> Bool) -> Text -> Text

-- | <i>O(n)</i> <a>dropWhile</a> <tt>p</tt> <tt>t</tt> returns the suffix
grremaining after <a>takeWhile</a> <tt>p</tt> <tt>t</tt>. Subject to
grfusion.
dropWhile :: (Char -> Bool) -> Text -> Text

-- | <i>O(n)</i> <a>dropWhileEnd</a> <tt>p</tt> <tt>t</tt> returns the
grprefix remaining after dropping characters that satisfy the predicate
gr<tt>p</tt> from the end of <tt>t</tt>.
gr
grExamples:
gr
gr<pre>
grdropWhileEnd (=='.') "foo..." == "foo"
gr</pre>
dropWhileEnd :: (Char -> Bool) -> Text -> Text

-- | <i>O(n)</i> <a>dropAround</a> <tt>p</tt> <tt>t</tt> returns the
grsubstring remaining after dropping characters that satisfy the
grpredicate <tt>p</tt> from both the beginning and end of <tt>t</tt>.
grSubject to fusion.
dropAround :: (Char -> Bool) -> Text -> Text

-- | <i>O(n)</i> Remove leading and trailing white space from a string.
grEquivalent to:
gr
gr<pre>
grdropAround isSpace
gr</pre>
strip :: Text -> Text

-- | <i>O(n)</i> Remove leading white space from a string. Equivalent to:
gr
gr<pre>
grdropWhile isSpace
gr</pre>
stripStart :: Text -> Text

-- | <i>O(n)</i> Remove trailing white space from a string. Equivalent to:
gr
gr<pre>
grdropWhileEnd isSpace
gr</pre>
stripEnd :: Text -> Text

-- | <i>O(n)</i> <a>splitAt</a> <tt>n t</tt> returns a pair whose first
grelement is a prefix of <tt>t</tt> of length <tt>n</tt>, and whose
grsecond is the remainder of the string. It is equivalent to
gr<tt>(<a>take</a> n t, <a>drop</a> n t)</tt>.
splitAt :: Int64 -> Text -> (Text, Text)

-- | <i>O(n)</i> <a>span</a>, applied to a predicate <tt>p</tt> and text
gr<tt>t</tt>, returns a pair whose first element is the longest prefix
gr(possibly empty) of <tt>t</tt> of elements that satisfy <tt>p</tt>,
grand whose second is the remainder of the list.
span :: (Char -> Bool) -> Text -> (Text, Text)

-- | <i>O(n+m)</i> Find the first instance of <tt>needle</tt> (which must
grbe non-<a>null</a>) in <tt>haystack</tt>. The first element of the
grreturned tuple is the prefix of <tt>haystack</tt> before
gr<tt>needle</tt> is matched. The second is the remainder of
gr<tt>haystack</tt>, starting with the match.
gr
grExamples:
gr
gr<pre>
grbreakOn "::" "a::b::c" ==&gt; ("a", "::b::c")
grbreakOn "/" "foobar"   ==&gt; ("foobar", "")
gr</pre>
gr
grLaws:
gr
gr<pre>
grappend prefix match == haystack
gr  where (prefix, match) = breakOn needle haystack
gr</pre>
gr
grIf you need to break a string by a substring repeatedly (e.g. you want
grto break on every instance of a substring), use <a>breakOnAll</a>
grinstead, as it has lower startup overhead.
gr
grThis function is strict in its first argument, and lazy in its second.
gr
grIn (unlikely) bad cases, this function's time complexity degrades
grtowards <i>O(n*m)</i>.
breakOn :: Text -> Text -> (Text, Text)

-- | <i>O(n+m)</i> Similar to <a>breakOn</a>, but searches from the end of
grthe string.
gr
grThe first element of the returned tuple is the prefix of
gr<tt>haystack</tt> up to and including the last match of
gr<tt>needle</tt>. The second is the remainder of <tt>haystack</tt>,
grfollowing the match.
gr
gr<pre>
grbreakOnEnd "::" "a::b::c" ==&gt; ("a::b::", "c")
gr</pre>
breakOnEnd :: Text -> Text -> (Text, Text)

-- | <i>O(n)</i> <a>break</a> is like <a>span</a>, but the prefix returned
gris over elements that fail the predicate <tt>p</tt>.
break :: (Char -> Bool) -> Text -> (Text, Text)

-- | The <a>group</a> function takes a <a>Text</a> and returns a list of
gr<a>Text</a>s such that the concatenation of the result is equal to the
grargument. Moreover, each sublist in the result contains only equal
grelements. For example,
gr
gr<pre>
grgroup "Mississippi" = ["M","i","ss","i","ss","i","pp","i"]
gr</pre>
gr
grIt is a special case of <a>groupBy</a>, which allows the programmer to
grsupply their own equality test.
group :: Text -> [Text]

-- | The <a>groupBy</a> function is the non-overloaded version of
gr<a>group</a>.
groupBy :: (Char -> Char -> Bool) -> Text -> [Text]

-- | <i>O(n)</i> Return all initial segments of the given <a>Text</a>,
grshortest first.
inits :: Text -> [Text]

-- | <i>O(n)</i> Return all final segments of the given <a>Text</a>,
grlongest first.
tails :: Text -> [Text]

-- | <i>O(m+n)</i> Break a <a>Text</a> into pieces separated by the first
gr<a>Text</a> argument (which cannot be an empty string), consuming the
grdelimiter. An empty delimiter is invalid, and will cause an error to
grbe raised.
gr
grExamples:
gr
gr<pre>
grsplitOn "\r\n" "a\r\nb\r\nd\r\ne" == ["a","b","d","e"]
grsplitOn "aaa"  "aaaXaaaXaaaXaaa"  == ["","X","X","X",""]
grsplitOn "x"    "x"                == ["",""]
gr</pre>
gr
grand
gr
gr<pre>
grintercalate s . splitOn s         == id
grsplitOn (singleton c)             == split (==c)
gr</pre>
gr
gr(Note: the string <tt>s</tt> to split on above cannot be empty.)
gr
grThis function is strict in its first argument, and lazy in its second.
gr
grIn (unlikely) bad cases, this function's time complexity degrades
grtowards <i>O(n*m)</i>.
splitOn :: Text -> Text -> [Text]

-- | <i>O(n)</i> Splits a <a>Text</a> into components delimited by
grseparators, where the predicate returns True for a separator element.
grThe resulting components do not contain the separators. Two adjacent
grseparators result in an empty component in the output. eg.
gr
gr<pre>
grsplit (=='a') "aabbaca" == ["","","bb","c",""]
grsplit (=='a') []        == [""]
gr</pre>
split :: (Char -> Bool) -> Text -> [Text]

-- | <i>O(n)</i> Splits a <a>Text</a> into components of length <tt>k</tt>.
grThe last element may be shorter than the other chunks, depending on
grthe length of the input. Examples:
gr
gr<pre>
grchunksOf 3 "foobarbaz"   == ["foo","bar","baz"]
grchunksOf 4 "haskell.org" == ["hask","ell.","org"]
gr</pre>
chunksOf :: Int64 -> Text -> [Text]

-- | <i>O(n)</i> Breaks a <a>Text</a> up into a list of <a>Text</a>s at
grnewline <a>Char</a>s. The resulting strings do not contain newlines.
lines :: Text -> [Text]

-- | <i>O(n)</i> Breaks a <a>Text</a> up into a list of words, delimited by
gr<a>Char</a>s representing white space.
words :: Text -> [Text]

-- | <i>O(n)</i> Joins lines, after appending a terminating newline to
greach.
unlines :: [Text] -> Text

-- | <i>O(n)</i> Joins words using single space characters.
unwords :: [Text] -> Text

-- | <i>O(n)</i> The <a>isPrefixOf</a> function takes two <a>Text</a>s and
grreturns <a>True</a> iff the first is a prefix of the second. Subject
grto fusion.
isPrefixOf :: Text -> Text -> Bool

-- | <i>O(n)</i> The <a>isSuffixOf</a> function takes two <a>Text</a>s and
grreturns <a>True</a> iff the first is a suffix of the second.
isSuffixOf :: Text -> Text -> Bool

-- | <i>O(n+m)</i> The <a>isInfixOf</a> function takes two <a>Text</a>s and
grreturns <a>True</a> iff the first is contained, wholly and intact,
granywhere within the second.
gr
grThis function is strict in its first argument, and lazy in its second.
gr
grIn (unlikely) bad cases, this function's time complexity degrades
grtowards <i>O(n*m)</i>.
isInfixOf :: Text -> Text -> Bool

-- | <i>O(n)</i> Return the suffix of the second string if its prefix
grmatches the entire first string.
gr
grExamples:
gr
gr<pre>
grstripPrefix "foo" "foobar" == Just "bar"
grstripPrefix ""    "baz"    == Just "baz"
grstripPrefix "foo" "quux"   == Nothing
gr</pre>
gr
grThis is particularly useful with the <tt>ViewPatterns</tt> extension
grto GHC, as follows:
gr
gr<pre>
gr{-# LANGUAGE ViewPatterns #-}
grimport Data.Text.Lazy as T
gr
grfnordLength :: Text -&gt; Int
grfnordLength (stripPrefix "fnord" -&gt; Just suf) = T.length suf
grfnordLength _                                 = -1
gr</pre>
stripPrefix :: Text -> Text -> Maybe Text

-- | <i>O(n)</i> Return the prefix of the second string if its suffix
grmatches the entire first string.
gr
grExamples:
gr
gr<pre>
grstripSuffix "bar" "foobar" == Just "foo"
grstripSuffix ""    "baz"    == Just "baz"
grstripSuffix "foo" "quux"   == Nothing
gr</pre>
gr
grThis is particularly useful with the <tt>ViewPatterns</tt> extension
grto GHC, as follows:
gr
gr<pre>
gr{-# LANGUAGE ViewPatterns #-}
grimport Data.Text.Lazy as T
gr
grquuxLength :: Text -&gt; Int
grquuxLength (stripSuffix "quux" -&gt; Just pre) = T.length pre
grquuxLength _                                = -1
gr</pre>
stripSuffix :: Text -> Text -> Maybe Text

-- | <i>O(n)</i> Find the longest non-empty common prefix of two strings
grand return it, along with the suffixes of each string at which they no
grlonger match.
gr
grIf the strings do not have a common prefix or either one is empty,
grthis function returns <a>Nothing</a>.
gr
grExamples:
gr
gr<pre>
grcommonPrefixes "foobar" "fooquux" == Just ("foo","bar","quux")
grcommonPrefixes "veeble" "fetzer"  == Nothing
grcommonPrefixes "" "baz"           == Nothing
gr</pre>
commonPrefixes :: Text -> Text -> Maybe (Text, Text, Text)

-- | <i>O(n)</i> <a>filter</a>, applied to a predicate and a <a>Text</a>,
grreturns a <a>Text</a> containing those characters that satisfy the
grpredicate.
filter :: (Char -> Bool) -> Text -> Text

-- | <i>O(n)</i> The <a>find</a> function takes a predicate and a
gr<a>Text</a>, and returns the first element in matching the predicate,
gror <a>Nothing</a> if there is no such element.
find :: (Char -> Bool) -> Text -> Maybe Char

-- | <i>O(n+m)</i> Find all non-overlapping instances of <tt>needle</tt> in
gr<tt>haystack</tt>. Each element of the returned list consists of a
grpair:
gr
gr<ul>
gr<li>The entire string prior to the <i>k</i>th match (i.e. the
grprefix)</li>
gr<li>The <i>k</i>th match, followed by the remainder of the string</li>
gr</ul>
gr
grExamples:
gr
gr<pre>
grbreakOnAll "::" ""
gr==&gt; []
grbreakOnAll "/" "a/b/c/"
gr==&gt; [("a", "/b/c/"), ("a/b", "/c/"), ("a/b/c", "/")]
gr</pre>
gr
grThis function is strict in its first argument, and lazy in its second.
gr
grIn (unlikely) bad cases, this function's time complexity degrades
grtowards <i>O(n*m)</i>.
gr
grThe <tt>needle</tt> parameter may not be empty.
breakOnAll :: Text -> Text -> [(Text, Text)]

-- | <i>O(n)</i> The <a>partition</a> function takes a predicate and a
gr<a>Text</a>, and returns the pair of <a>Text</a>s with elements which
grdo and do not satisfy the predicate, respectively; i.e.
gr
gr<pre>
grpartition p t == (filter p t, filter (not . p) t)
gr</pre>
partition :: (Char -> Bool) -> Text -> (Text, Text)

-- | <i>O(n)</i> <a>Text</a> index (subscript) operator, starting from 0.
index :: Text -> Int64 -> Char

-- | <i>O(n+m)</i> The <a>count</a> function returns the number of times
grthe query string appears in the given <a>Text</a>. An empty query
grstring is invalid, and will cause an error to be raised.
gr
grIn (unlikely) bad cases, this function's time complexity degrades
grtowards <i>O(n*m)</i>.
count :: Text -> Text -> Int64

-- | <i>O(n)</i> <a>zip</a> takes two <a>Text</a>s and returns a list of
grcorresponding pairs of bytes. If one input <a>Text</a> is short,
grexcess elements of the longer <a>Text</a> are discarded. This is
grequivalent to a pair of <a>unpack</a> operations.
zip :: Text -> Text -> [(Char, Char)]

-- | <i>O(n)</i> <a>zipWith</a> generalises <a>zip</a> by zipping with the
grfunction given as the first argument, instead of a tupling function.
grPerforms replacement on invalid scalar values.
zipWith :: (Char -> Char -> Char) -> Text -> Text -> Text
instance GHC.Classes.Eq Data.Text.Internal.Lazy.Text
instance GHC.Classes.Ord Data.Text.Internal.Lazy.Text
instance GHC.Show.Show Data.Text.Internal.Lazy.Text
instance GHC.Read.Read Data.Text.Internal.Lazy.Text
instance GHC.Base.Semigroup Data.Text.Internal.Lazy.Text
instance GHC.Base.Monoid Data.Text.Internal.Lazy.Text
instance Data.String.IsString Data.Text.Internal.Lazy.Text
instance GHC.Exts.IsList Data.Text.Internal.Lazy.Text
instance Control.DeepSeq.NFData Data.Text.Internal.Lazy.Text
instance Data.Binary.Class.Binary Data.Text.Internal.Lazy.Text
instance Data.Data.Data Data.Text.Internal.Lazy.Text
instance Text.Printf.PrintfArg Data.Text.Internal.Lazy.Text


-- | Functions used frequently when reading textual data.
module Data.Text.Lazy.Read

-- | Read some text. If the read succeeds, return its value and the
grremaining text, otherwise an error message.
type Reader a = IReader Text a

-- | Read a decimal integer. The input must begin with at least one decimal
grdigit, and is consumed until a non-digit or end of string is reached.
gr
grThis function does not handle leading sign characters. If you need to
grhandle signed input, use <tt><a>signed</a> <a>decimal</a></tt>.
gr
gr<i>Note</i>: For fixed-width integer types, this function does not
grattempt to detect overflow, so a sufficiently long input may give
grincorrect results. If you are worried about overflow, use
gr<a>Integer</a> for your result type.
decimal :: Integral a => Reader a

-- | Read a hexadecimal integer, consisting of an optional leading
gr<tt>"0x"</tt> followed by at least one hexadecimal digit. Input is
grconsumed until a non-hex-digit or end of string is reached. This
grfunction is case insensitive.
gr
grThis function does not handle leading sign characters. If you need to
grhandle signed input, use <tt><a>signed</a> <a>hexadecimal</a></tt>.
gr
gr<i>Note</i>: For fixed-width integer types, this function does not
grattempt to detect overflow, so a sufficiently long input may give
grincorrect results. If you are worried about overflow, use
gr<a>Integer</a> for your result type.
hexadecimal :: Integral a => Reader a

-- | Read an optional leading sign character (<tt>'-'</tt> or <tt>'+'</tt>)
grand apply it to the result of applying the given reader.
signed :: Num a => Reader a -> Reader a

-- | Read a rational number.
gr
grThis function accepts an optional leading sign character, followed by
grat least one decimal digit. The syntax similar to that accepted by the
gr<a>read</a> function, with the exception that a trailing <tt>'.'</tt>
gror <tt>'e'</tt> <i>not</i> followed by a number is not consumed.
gr
grExamples:
gr
gr<pre>
grrational "3"     == Right (3.0, "")
grrational "3.1"   == Right (3.1, "")
grrational "3e4"   == Right (30000.0, "")
grrational "3.1e4" == Right (31000.0, "")
grrational ".3"    == Left "input does not start with a digit"
grrational "e3"    == Left "input does not start with a digit"
gr</pre>
gr
grExamples of differences from <a>read</a>:
gr
gr<pre>
grrational "3.foo" == Right (3.0, ".foo")
grrational "3e"    == Right (3.0, "e")
gr</pre>
rational :: Fractional a => Reader a

-- | Read a rational number.
gr
grThe syntax accepted by this function is the same as for
gr<a>rational</a>.
gr
gr<i>Note</i>: This function is almost ten times faster than
gr<a>rational</a>, but is slightly less accurate.
gr
grThe <a>Double</a> type supports about 16 decimal places of accuracy.
grFor 94.2% of numbers, this function and <a>rational</a> give identical
grresults, but for the remaining 5.8%, this function loses precision
graround the 15th decimal place. For 0.001% of numbers, this function
grwill lose precision at the 13th or 14th decimal place.
double :: Reader Double


-- | <i>Warning</i>: this is an internal module, and does not have a stable
grAPI or name. Functions in this module may not check or enforce
grpreconditions expected by public modules. Use at your own risk!
gr
grLow-level support for text I/O.
module Data.Text.Internal.IO

-- | Read a single line of input from a handle, constructing a list of
grdecoded chunks as we go. When we're done, transform them into the
grdestination type.
hGetLineWith :: ([Text] -> t) -> Handle -> IO t

-- | Read a single chunk of strict text from a buffer. Used by both the
grstrict and lazy implementations of hGetContents.
readChunk :: Handle__ -> CharBuffer -> IO Text


-- | <i>Warning</i>: this is an internal module, and does not have a stable
grAPI or name. Functions in this module may not check or enforce
grpreconditions expected by public modules. Use at your own risk!
gr
grEfficient construction of lazy <tt>Text</tt> values. The principal
groperations on a <tt>Builder</tt> are <tt>singleton</tt>,
gr<tt>fromText</tt>, and <tt>fromLazyText</tt>, which construct new
grbuilders, and <a>mappend</a>, which concatenates two builders.
gr
grTo get maximum performance when building lazy <tt>Text</tt> values
grusing a builder, associate <tt>mappend</tt> calls to the right. For
grexample, prefer
gr
gr<pre>
grsingleton 'a' `mappend` (singleton 'b' `mappend` singleton 'c')
gr</pre>
gr
grto
gr
gr<pre>
grsingleton 'a' `mappend` singleton 'b' `mappend` singleton 'c'
gr</pre>
gr
gras the latter associates <tt>mappend</tt> to the left.
module Data.Text.Internal.Builder

-- | A <tt>Builder</tt> is an efficient way to build lazy <tt>Text</tt>
grvalues. There are several functions for constructing builders, but
gronly one to inspect them: to extract any data, you have to turn them
grinto lazy <tt>Text</tt> values using <tt>toLazyText</tt>.
gr
grInternally, a builder constructs a lazy <tt>Text</tt> by filling
grarrays piece by piece. As each buffer is filled, it is 'popped' off,
grto become a new chunk of the resulting lazy <tt>Text</tt>. All this is
grhidden from the user of the <tt>Builder</tt>.
data Builder

-- | <i>O(n).</i> Extract a lazy <tt>Text</tt> from a <tt>Builder</tt> with
gra default buffer size. The construction work takes place if and when
grthe relevant part of the lazy <tt>Text</tt> is demanded.
toLazyText :: Builder -> Text

-- | <i>O(n).</i> Extract a lazy <tt>Text</tt> from a <tt>Builder</tt>,
grusing the given size for the initial buffer. The construction work
grtakes place if and when the relevant part of the lazy <tt>Text</tt> is
grdemanded.
gr
grIf the initial buffer is too small to hold all data, subsequent
grbuffers will be the default buffer size.
toLazyTextWith :: Int -> Builder -> Text

-- | <i>O(1).</i> A <tt>Builder</tt> taking a single character, satisfying
gr
gr<ul>
gr<li><pre><a>toLazyText</a> (<a>singleton</a> c) = <a>singleton</a>
grc</pre></li>
gr</ul>
singleton :: Char -> Builder

-- | <i>O(1).</i> A <tt>Builder</tt> taking a <a>Text</a>, satisfying
gr
gr<ul>
gr<li><pre><a>toLazyText</a> (<a>fromText</a> t) = <a>fromChunks</a>
gr[t]</pre></li>
gr</ul>
fromText :: Text -> Builder

-- | <i>O(1).</i> A <tt>Builder</tt> taking a lazy <tt>Text</tt>,
grsatisfying
gr
gr<ul>
gr<li><pre><a>toLazyText</a> (<a>fromLazyText</a> t) = t</pre></li>
gr</ul>
fromLazyText :: Text -> Builder

-- | <i>O(1).</i> A Builder taking a <tt>String</tt>, satisfying
gr
gr<ul>
gr<li><pre><a>toLazyText</a> (<a>fromString</a> s) = <a>fromChunks</a>
gr[S.pack s]</pre></li>
gr</ul>
fromString :: String -> Builder

-- | <i>O(1).</i> Pop the strict <tt>Text</tt> we have constructed so far,
grif any, yielding a new chunk in the result lazy <tt>Text</tt>.
flush :: Builder
append' :: Builder -> Builder -> Builder

-- | Ensure that there are at least <tt>n</tt> many elements available.
ensureFree :: Int -> Builder

-- | Ensure that <tt>n</tt> many elements are available, and then use
gr<tt>f</tt> to write some elements into the memory.
writeN :: Int -> (forall s. MArray s -> Int -> ST s ()) -> Builder
instance GHC.Base.Semigroup Data.Text.Internal.Builder.Builder
instance GHC.Base.Monoid Data.Text.Internal.Builder.Builder
instance Data.String.IsString Data.Text.Internal.Builder.Builder
instance GHC.Show.Show Data.Text.Internal.Builder.Builder
instance GHC.Classes.Eq Data.Text.Internal.Builder.Builder
instance GHC.Classes.Ord Data.Text.Internal.Builder.Builder


-- | Efficient construction of lazy <tt>Text</tt> values. The principal
groperations on a <tt>Builder</tt> are <tt>singleton</tt>,
gr<tt>fromText</tt>, and <tt>fromLazyText</tt>, which construct new
grbuilders, and <a>mappend</a>, which concatenates two builders.
gr
grTo get maximum performance when building lazy <tt>Text</tt> values
grusing a builder, associate <tt>mappend</tt> calls to the right. For
grexample, prefer
gr
gr<pre>
grsingleton 'a' `mappend` (singleton 'b' `mappend` singleton 'c')
gr</pre>
gr
grto
gr
gr<pre>
grsingleton 'a' `mappend` singleton 'b' `mappend` singleton 'c'
gr</pre>
gr
gras the latter associates <tt>mappend</tt> to the left. Or,
grequivalently, prefer
gr
gr<pre>
grsingleton 'a' &lt;&gt; singleton 'b' &lt;&gt; singleton 'c'
gr</pre>
gr
grsince the <a>&lt;&gt;</a> from recent versions of <a>Monoid</a>
grassociates to the right.
module Data.Text.Lazy.Builder

-- | A <tt>Builder</tt> is an efficient way to build lazy <tt>Text</tt>
grvalues. There are several functions for constructing builders, but
gronly one to inspect them: to extract any data, you have to turn them
grinto lazy <tt>Text</tt> values using <tt>toLazyText</tt>.
gr
grInternally, a builder constructs a lazy <tt>Text</tt> by filling
grarrays piece by piece. As each buffer is filled, it is 'popped' off,
grto become a new chunk of the resulting lazy <tt>Text</tt>. All this is
grhidden from the user of the <tt>Builder</tt>.
data Builder

-- | <i>O(n).</i> Extract a lazy <tt>Text</tt> from a <tt>Builder</tt> with
gra default buffer size. The construction work takes place if and when
grthe relevant part of the lazy <tt>Text</tt> is demanded.
toLazyText :: Builder -> Text

-- | <i>O(n).</i> Extract a lazy <tt>Text</tt> from a <tt>Builder</tt>,
grusing the given size for the initial buffer. The construction work
grtakes place if and when the relevant part of the lazy <tt>Text</tt> is
grdemanded.
gr
grIf the initial buffer is too small to hold all data, subsequent
grbuffers will be the default buffer size.
toLazyTextWith :: Int -> Builder -> Text

-- | <i>O(1).</i> A <tt>Builder</tt> taking a single character, satisfying
gr
gr<ul>
gr<li><pre><a>toLazyText</a> (<a>singleton</a> c) = <a>singleton</a>
grc</pre></li>
gr</ul>
singleton :: Char -> Builder

-- | <i>O(1).</i> A <tt>Builder</tt> taking a <a>Text</a>, satisfying
gr
gr<ul>
gr<li><pre><a>toLazyText</a> (<a>fromText</a> t) = <a>fromChunks</a>
gr[t]</pre></li>
gr</ul>
fromText :: Text -> Builder

-- | <i>O(1).</i> A <tt>Builder</tt> taking a lazy <tt>Text</tt>,
grsatisfying
gr
gr<ul>
gr<li><pre><a>toLazyText</a> (<a>fromLazyText</a> t) = t</pre></li>
gr</ul>
fromLazyText :: Text -> Builder

-- | <i>O(1).</i> A Builder taking a <tt>String</tt>, satisfying
gr
gr<ul>
gr<li><pre><a>toLazyText</a> (<a>fromString</a> s) = <a>fromChunks</a>
gr[S.pack s]</pre></li>
gr</ul>
fromString :: String -> Builder

-- | <i>O(1).</i> Pop the strict <tt>Text</tt> we have constructed so far,
grif any, yielding a new chunk in the result lazy <tt>Text</tt>.
flush :: Builder


-- | <i>Warning</i>: this is an internal module, and does not have a stable
grAPI or name. Functions in this module may not check or enforce
grpreconditions expected by public modules. Use at your own risk!
gr
grUseful functions and combinators.
module Data.Text.Internal.Builder.Functions

-- | The normal <a>mappend</a> function with right associativity instead of
grleft.
(<>) :: Builder -> Builder -> Builder
infixr 4 <>

-- | Unsafe conversion for decimal digits.
i2d :: Int -> Char

module Data.Text.Lazy.Builder.Int
decimal :: Integral a => a -> Builder
hexadecimal :: Integral a => a -> Builder


-- | Write a floating point value to a <a>Builder</a>.
module Data.Text.Lazy.Builder.RealFloat

-- | Control the rendering of floating point numbers.
data FPFormat

-- | Scientific notation (e.g. <tt>2.3e123</tt>).
Exponent :: FPFormat

-- | Standard decimal notation.
Fixed :: FPFormat

-- | Use decimal notation for values between <tt>0.1</tt> and
gr<tt>9,999,999</tt>, and scientific notation otherwise.
Generic :: FPFormat

-- | Show a signed <a>RealFloat</a> value to full precision, using standard
grdecimal notation for arguments whose absolute value lies between
gr<tt>0.1</tt> and <tt>9,999,999</tt>, and scientific notation
grotherwise.
realFloat :: (RealFloat a) => a -> Builder
formatRealFloat :: (RealFloat a) => FPFormat -> Maybe Int -> a -> Builder
instance GHC.Show.Show Data.Text.Lazy.Builder.RealFloat.FPFormat
instance GHC.Read.Read Data.Text.Lazy.Builder.RealFloat.FPFormat
instance GHC.Enum.Enum Data.Text.Lazy.Builder.RealFloat.FPFormat


-- | Efficient locale-sensitive support for text I/O.
gr
grSkip past the synopsis for some important notes on performance and
grportability across different versions of GHC.
module Data.Text.IO

-- | The <a>readFile</a> function reads a file and returns the contents of
grthe file as a string. The entire file is read strictly, as with
gr<a>getContents</a>.
readFile :: FilePath -> IO Text

-- | Write a string to a file. The file is truncated to zero length before
grwriting begins.
writeFile :: FilePath -> Text -> IO ()

-- | Write a string the end of a file.
appendFile :: FilePath -> Text -> IO ()

-- | Read the remaining contents of a <a>Handle</a> as a string. The
gr<a>Handle</a> is closed once the contents have been read, or if an
grexception is thrown.
gr
grInternally, this function reads a chunk at a time from the lower-level
grbuffering abstraction, and concatenates the chunks into a single
grstring once the entire file has been read.
gr
grAs a result, it requires approximately twice as much memory as its
grresult to construct its result. For files more than a half of
gravailable RAM in size, this may result in memory exhaustion.
hGetContents :: Handle -> IO Text

-- | <i>Experimental.</i> Read a single chunk of strict text from a
gr<a>Handle</a>. The size of the chunk depends on the amount of input
grcurrently buffered.
gr
grThis function blocks only if there is no data available, and EOF has
grnot yet been reached. Once EOF is reached, this function returns an
grempty string instead of throwing an exception.
hGetChunk :: Handle -> IO Text

-- | Read a single line from a handle.
hGetLine :: Handle -> IO Text

-- | Write a string to a handle.
hPutStr :: Handle -> Text -> IO ()

-- | Write a string to a handle, followed by a newline.
hPutStrLn :: Handle -> Text -> IO ()

-- | The <a>interact</a> function takes a function of type <tt>Text -&gt;
grText</tt> as its argument. The entire input from the standard input
grdevice is passed to this function as its argument, and the resulting
grstring is output on the standard output device.
interact :: (Text -> Text) -> IO ()

-- | Read all user input on <a>stdin</a> as a single string.
getContents :: IO Text

-- | Read a single line of user input from <a>stdin</a>.
getLine :: IO Text

-- | Write a string to <a>stdout</a>.
putStr :: Text -> IO ()

-- | Write a string to <a>stdout</a>, followed by a newline.
putStrLn :: Text -> IO ()


-- | Efficient locale-sensitive support for lazy text I/O.
gr
grSkip past the synopsis for some important notes on performance and
grportability across different versions of GHC.
module Data.Text.Lazy.IO

-- | Read a file and return its contents as a string. The file is read
grlazily, as with <a>getContents</a>.
readFile :: FilePath -> IO Text

-- | Write a string to a file. The file is truncated to zero length before
grwriting begins.
writeFile :: FilePath -> Text -> IO ()

-- | Write a string the end of a file.
appendFile :: FilePath -> Text -> IO ()

-- | Lazily read the remaining contents of a <a>Handle</a>. The
gr<a>Handle</a> will be closed after the read completes, or on error.
hGetContents :: Handle -> IO Text

-- | Read a single line from a handle.
hGetLine :: Handle -> IO Text

-- | Write a string to a handle.
hPutStr :: Handle -> Text -> IO ()

-- | Write a string to a handle, followed by a newline.
hPutStrLn :: Handle -> Text -> IO ()

-- | The <a>interact</a> function takes a function of type <tt>Text -&gt;
grText</tt> as its argument. The entire input from the standard input
grdevice is passed (lazily) to this function as its argument, and the
grresulting string is output on the standard output device.
interact :: (Text -> Text) -> IO ()

-- | Lazily read all user input on <a>stdin</a> as a single string.
getContents :: IO Text

-- | Read a single line of user input from <a>stdin</a>.
getLine :: IO Text

-- | Write a string to <a>stdout</a>.
putStr :: Text -> IO ()

-- | Write a string to <a>stdout</a>, followed by a newline.
putStrLn :: Text -> IO ()
