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


-- | An efficient packed Unicode text type
--   
--   An efficient packed Unicode text type.
@package text
@version 0.1


-- | Text manipulation functions represented as fusible operations over
--   streams.
module Data.Text.Fusion
data Stream a
Stream :: (s -> Step s a) -> !s -> {-# UNPACK #-} !Int -> Stream a
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 Text.
unstream :: Stream Char -> Text

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

-- | The empty stream.
empty :: 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 and remainder of a 'Stream
--   Char', or <a>Nothing</a> if empty. Subject to array fusion.
uncons :: Stream Char -> Maybe (Char, Stream Char)

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

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

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

-- | <i>O(1)</i> Returns all but the last character of a Stream Char, which
--   must 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 text.
length :: Stream Char -> Int

-- | <i>O(n)</i> Determines if two streams are equal.
eq :: Ord a => Stream a -> Stream a -> Bool

-- | <i>O(n)</i> <a>map</a> <tt>f </tt>xs is the Stream Char obtained by
--   applying <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
--   characters of a 'Stream Char'.
intersperse :: Char -> Stream Char -> Stream Char

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

-- | foldl, applied to a binary operator, a starting value (typically the
--   left-identity of the operator), and a Stream, reduces the Stream using
--   the 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
--   thus 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
--   (typically the right-identity of the operator), and a stream, reduces
--   the 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
--   argument, and thus must be applied to non-empty streams. Subject to
--   array 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
--   the results.
concatMap :: (Char -> Stream Char) -> Stream Char -> Stream Char

-- | <i>O(n)</i> any <tt>p </tt>xs determines if any character in the
--   stream <tt>xs</tt> satisifes 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
--   <a>Text</a> <tt>xs</tt> satisify the predicate <tt>p</tt>.
all :: (Char -> Bool) -> Stream Char -> Bool

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

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

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

-- | <i>O(n)</i> Like a combination of <a>map</a> and <a>foldl</a>. Applies
--   a function to each element of a stream, passing an accumulating
--   parameter from left to right, and returns a final stream.
--   
--   <i>Note</i>: Unlike the version over lists, this function does not
--   return a final value for the accumulator, because the nature of
--   streams precludes it.
mapAccumL :: (a -> b -> (a, b)) -> a -> Stream b -> Stream b
replicate :: Int -> Char -> Stream Char

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

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

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

-- | <i>O(n)</i> drop n, applied to a stream, returns the suffix of the
--   stream of length <tt>n</tt>, or the empty stream if <tt>n</tt> is
--   greater than the length of the stream.
drop :: Int -> Stream Char -> Stream Char

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

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

-- | <i>O(n)</i> The <a>isPrefixOf</a> function takes two <a>Stream</a>s
--   and 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> elem is the stream membership predicate.
elem :: Char -> Stream Char -> Bool

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

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

-- | <i>O(1)</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
--   returns the index of the first element in the stream satisfying the
--   predicate.
findIndex :: (Char -> Bool) -> Stream Char -> Maybe Int

-- | The <a>findIndices</a> function takes a predicate and a stream and
--   returns all indices of the elements in the stream satisfying the
--   predicate.
findIndices :: (Char -> Bool) -> Stream Char -> [Int]

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

-- | <i>O(n)</i> The <a>elemIndex</a> function returns the index of the
--   first element in the given stream which is equal to the query element,
--   or <a>Nothing</a> if there is no such element.
elemIndex :: Char -> Stream Char -> Maybe Int

-- | <i>O(n)</i> The <a>elemIndices</a> function returns the index of every
--   element in the given stream which is equal to the query element.
elemIndices :: Char -> Stream Char -> [Int]

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

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


-- | Fusible <a>Stream</a>-oriented functions for converting between
--   <tt>Text</tt> and several common encodings.
module Data.Text.Encoding.Fusion
streamASCII :: ByteString -> Stream Char

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

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

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

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

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

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

-- | <i>O(n)</i> Convert a Stream Char into a UTF-8 encoded Stream Word8.
restreamUtf8 :: Stream Char -> Stream Word8
restreamUtf16LE :: Stream Char -> Stream Word8
restreamUtf16BE :: Stream Char -> Stream Word8
restreamUtf32LE :: Stream Char -> Stream Word8
restreamUtf32BE :: Stream Char -> Stream Word8
instance Eq M
instance Ord M
instance Show M


-- | Functions for converting <a>Text</a> values to and from
--   <a>ByteString</a>, using several standard encodings.
--   
--   To make use of a much larger variety of encodings, use the
--   <tt>text-icu</tt> package.
module Data.Text.Encoding

-- | Decode a <a>ByteString</a> containing 7-bit ASCII encoded text.
decodeASCII :: ByteString -> Text

-- | Decode a <a>ByteString</a> containing UTF-8 encoded text.
decodeUtf8 :: ByteString -> Text

-- | Decode text from little endian UTF-16 encoding.
decodeUtf16LE :: ByteString -> Text

-- | Decode text from big endian UTF-16 encoding.
decodeUtf16BE :: ByteString -> Text

-- | Decode text from little endian UTF-32 encoding.
decodeUtf32LE :: ByteString -> Text

-- | Decode text from big endian UTF-32 encoding.
decodeUtf32BE :: ByteString -> Text

-- | Encode text using UTF-8 encoding.
encodeUtf8 :: Text -> ByteString

-- | Encode text using little endian UTF-16 encoding.
encodeUtf16LE :: Text -> ByteString

-- | Encode text using big endian UTF-16 encoding.
encodeUtf16BE :: Text -> ByteString

-- | Encode text using little endian UTF-32 encoding.
encodeUtf32LE :: Text -> ByteString

-- | Encode text using big endian UTF-32 encoding.
encodeUtf32BE :: Text -> ByteString


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

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

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

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

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


-- | A time and space-efficient implementation of Unicode text using packed
--   Word16 arrays. Suitable for performance critical use, both in terms of
--   large data quantities and high speed.
--   
--   This module is intended to be imported <tt>qualified</tt>, to avoid
--   name clashes with <a>Prelude</a> functions, e.g.
--   
--   <pre>
--   import qualified Data.Text as T
--   </pre>
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>.
--   
--   This function is subject to array fusion.
pack :: String -> Text

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

-- | <i>O(1)</i> Convert a character into a Text. Subject to array fusion.
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
--   function is more costly than its <tt>List</tt> counterpart because it
--   requires copying a new array. Subject to array fusion.
cons :: Char -> Text -> Text

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

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

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

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

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

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

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

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

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

-- | <i>O(n)</i> <a>map</a> <tt>f </tt>xs is the <a>Text</a> obtained by
--   applying <tt>f</tt> to each element of <tt>xs</tt>. Subject to array
--   fusion.
map :: (Char -> Char) -> Text -> Text

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

-- | <i>O(n)</i> The <a>intersperse</a> function takes a character and
--   places it between the characters of a <a>Text</a>. Subject to array
--   fusion.
intersperse :: Char -> Text -> Text

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

-- | <i>O(n)</i> Reverse the characters of a string. Subject to array
--   fusion.
reverse :: Text -> Text

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

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

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

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

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

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

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

-- | <i>O(n)</i> Map a function over a <a>Text</a> that results in a
--   <a>Text</a>, and concatenate the results. This function is subject to
--   array fusion.
--   
--   Note: if in <a>concatMap</a> <tt>f</tt> <tt>t</tt>, <tt>f</tt> is
--   defined in terms of fusible functions, it will also be fusible.
concatMap :: (Char -> Text) -> Text -> Text

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

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

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

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

-- | <i>O(n)</i> <a>scanl</a> is similar to <a>foldl</a>, but returns a
--   list of successive reduced values from the left. This function is
--   subject to array fusion.
--   
--   <pre>
--   scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]
--   </pre>
--   
--   Note that
--   
--   <pre>
--   last (scanl f z xs) == foldl f z xs.
--   </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
--   starting value argument. This function is subject to array fusion.
--   
--   <pre>
--   scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]
--   </pre>
scanl1 :: (Char -> Char -> Char) -> Text -> Text

-- | <i>O(n)</i> <a>scanr</a> is the right-to-left dual of <a>scanl</a>.
--   
--   <pre>
--   scanr f v t == reverse (scanl (flip f) v t)
--   </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
--   starting value argument. This function is subject to array fusion.
scanr1 :: (Char -> Char -> Char) -> Text -> Text

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

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

-- | <i>O(n)</i> <a>replicate</a> <tt>n</tt> <tt>c</tt> is a <a>Text</a> of
--   length <tt>n</tt> with <tt>c</tt> the value of every element.
replicate :: Int -> Char -> Text

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

-- | <i>O(n)</i> Like <a>unfoldr</a>, <a>unfoldrN</a> builds a <a>Text</a>
--   from a seed value. However, the length of the result should be limited
--   by the first argument to <a>unfoldrN</a>. This function is more
--   efficient than <a>unfoldr</a> when the maximum length of the result is
--   known and correct, otherwise its performance is similar to
--   <a>unfoldr</a>.
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
--   the prefix of the <a>Text</a> of length <tt>n</tt>, or the <a>Text</a>
--   itself if <tt>n</tt> is greater than the length of the Text.
take :: Int -> Text -> Text

-- | <i>O(n)</i> <a>drop</a> <tt>n</tt>, applied to a <a>Text</a>, returns
--   the suffix of the <a>Text</a> of length <tt>n</tt>, or the empty
--   <a>Text</a> if <tt>n</tt> is greater than the length of the
--   <a>Text</a>.
drop :: Int -> Text -> Text

-- | <i>O(n)</i> <a>takeWhile</a>, applied to a predicate <tt>p</tt> and a
--   <a>Text</a>, returns the longest prefix (possibly empty) of elements
--   that satisfy <tt>p</tt>. This function is subject to array fusion.
takeWhile :: (Char -> Bool) -> Text -> Text

-- | <i>O(n)</i> <a>dropWhile</a> <tt>p</tt> <tt>xs</tt> returns the suffix
--   remaining after <a>takeWhile</a> <tt>p</tt> <tt>xs</tt>. This function
--   is subject to array fusion.
dropWhile :: (Char -> Bool) -> Text -> Text

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

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

-- | <i>O(n)</i> <a>break</a> is like <a>span</a>, but the prefix returned
--   is over elements that fail the predicate <tt>p</tt>.
break :: (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>,
--   shortest first.
inits :: Text -> [Text]

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

-- | <i>O(n)</i> Break a <a>Text</a> into pieces separated by the
--   <a>Char</a> argument, consuming the delimiter. I.e.
--   
--   <pre>
--   split '\n' "a\nb\nd\ne" == ["a","b","d","e"]
--   split 'a'  "aXaXaXa"    == ["","X","X","X",""]
--   split 'x'  "x"          == ["",""]
--   </pre>
--   
--   and
--   
--   <pre>
--   intercalate (singleton c) . split c == id
--   split == splitWith . (==)
--   </pre>
--   
--   As for all splitting functions in this library, this function does not
--   copy the substrings, it just constructs new <a>Text</a>s that are
--   slices of the original.
split :: Char -> Text -> [Text]

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

-- | <i>O(n)</i> Break a string on a substring, returning a pair of the
--   part of the string prior to the match, and the rest of the string.
--   
--   The following relationship holds:
--   
--   <pre>
--   break (==c) l == breakSubstring (singleton c) l
--   </pre>
--   
--   For example, to tokenise a string, dropping delimiters:
--   
--   <pre>
--   tokenise x y = h : if null t then [] else tokenise x (drop (length x) t)
--       where (h,t) = breakSubstring x y
--   </pre>
--   
--   To skip to the first occurence of a string:
--   
--   <pre>
--   snd (breakSubstring x y)
--   </pre>
--   
--   To take the parts of a string before a delimiter:
--   
--   <pre>
--   fst (breakSubstring x y)
--   </pre>
breakSubstring :: Text -> Text -> (Text, Text)

-- | <i>O(n)</i> Breaks a <a>Text</a> up into a list of <a>Text</a>s at
--   newline <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
--   <a>Char</a>s representing white space.
words :: Text -> [Text]

-- | <i>O(n)</i> Portably breaks a <a>Text</a> up into a list of
--   <a>Text</a>s at line boundaries.
--   
--   A line boundary is considered to be either a line feed, a carriage
--   return immediately followed by a line feed, or a carriage return. This
--   accounts for both Unix and Windows line ending conventions, and for
--   the old convention used on Mac OS 9 and earlier.
--   
--   <i>O(n)</i> Joins lines, after appending a terminating newline to
--   each.
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
--   returns <a>True</a> iff the first is a prefix of the second. This
--   function is subject to fusion.
isPrefixOf :: Text -> Text -> Bool

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

-- | <i>O(n)</i> The <a>isInfixOf</a> function takes two <a>Text</a>s and
--   returns <a>True</a> iff the first is contained, wholly and intact,
--   anywhere within the second.
isInfixOf :: Text -> Text -> Bool

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

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

-- | <i>O(n)</i> The <a>find</a> function takes a predicate and a
--   <a>Text</a>, and returns the first element in matching the predicate,
--   or <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
--   <a>Text</a>, and returns the pair of <a>Text</a>s with elements which
--   do and do not satisfy the predicate, respectively; i.e.
--   
--   <pre>
--   partition p t == (filter p t, filter (not . p) t)
--   </pre>
partition :: (Char -> Bool) -> Text -> (Text, Text)

-- | <i>O(1)</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
--   <a>Text</a> and returns the index of the first element in the
--   <a>Text</a> satisfying the predicate. This function is subject to
--   fusion.
findIndex :: (Char -> Bool) -> Text -> Maybe Int

-- | The <a>findIndices</a> function extends <a>findIndex</a>, by returning
--   the indices of all elements satisfying the predicate, in ascending
--   order. This function is subject to fusion.
findIndices :: (Char -> Bool) -> Text -> [Int]

-- | <i>O(n)</i> The <a>elemIndex</a> function returns the index of the
--   first element in the given <a>Text</a> which is equal to the query
--   element, or <a>Nothing</a> if there is no such element. This function
--   is subject to fusion.
elemIndex :: Char -> Text -> Maybe Int

-- | <i>O(n)</i> The <a>elemIndices</a> function returns the index of every
--   element in the given <a>Text</a> which is equal to the query element.
--   This function is subject to fusion.
elemIndices :: Char -> Text -> [Int]

-- | <i>O(n)</i> The <a>count</a> function returns the number of times the
--   query element appears in the given <a>Text</a>. This function is
--   subject to fusion.
count :: Char -> Text -> Int

-- | <i>O(n)</i> <a>zipWith</a> generalises <tt>zip</tt> by zipping with
--   the function given as the first argument, instead of a tupling
--   function.
zipWith :: (Char -> Char -> Char) -> Text -> Text -> Text
instance IsString Text
instance Monoid Text
instance Read Text
instance Show Text
instance Eq Text