    {-# LANGUAGE MultiParamTypeClasses
                ,FlexibleInstances #-}
    {-# OPTIONS -Wno-orphans #-}

    module Data.ListLike.Text.Text

    where

    import           Prelude as P
    import qualified Data.Text as T
    import qualified Data.Text.IO as TI
    import qualified Data.Text.Lazy as Lazy (toStrict)
    import           Data.Text.Encoding (decodeUtf8)
    import           Data.ListLike.Base as LL
    import           Data.ListLike.FoldableLL
    import           Data.ListLike.IO
    import           Data.ListLike.String

    import qualified Data.ByteString as BS

    instance FoldableLL T.Text Char where
        foldl :: forall a. (a -> Char -> a) -> a -> Text -> a
    foldl = (a -> Char -> a) -> a -> Text -> a
    forall a. (a -> Char -> a) -> a -> Text -> a
    T.foldl
        foldl' :: forall a. (a -> Char -> a) -> a -> Text -> a
    foldl' = (a -> Char -> a) -> a -> Text -> a
    forall a. (a -> Char -> a) -> a -> Text -> a
    T.foldl'
        foldl1 :: (Char -> Char -> Char) -> Text -> Char
    foldl1 = HasCallStack => (Char -> Char -> Char) -> Text -> Char
    (Char -> Char -> Char) -> Text -> Char
    T.foldl1
        foldr :: forall b. (Char -> b -> b) -> b -> Text -> b
    foldr = (Char -> b -> b) -> b -> Text -> b
    forall b. (Char -> b -> b) -> b -> Text -> b
    T.foldr
        --foldr' = T.foldr'
        foldr1 :: (Char -> Char -> Char) -> Text -> Char
    foldr1 = HasCallStack => (Char -> Char -> Char) -> Text -> Char
    (Char -> Char -> Char) -> Text -> Char
    T.foldr1

    instance ListLike T.Text Char where
        empty :: Text
    empty = Text
    T.empty
        singleton :: Char -> Text
    singleton = Char -> Text
    T.singleton
        cons :: Char -> Text -> Text
    cons = Char -> Text -> Text
    T.cons
        snoc :: Text -> Char -> Text
    snoc = Text -> Char -> Text
    T.snoc
        append :: Text -> Text -> Text
    append = Text -> Text -> Text
    T.append
        head :: Text -> Char
    head = HasCallStack => Text -> Char
    Text -> Char
    T.head
        last :: Text -> Char
    last = HasCallStack => Text -> Char
    Text -> Char
    T.last
        tail :: Text -> Text
    tail = HasCallStack => Text -> Text
    Text -> Text
    T.tail
        init :: Text -> Text
    init = HasCallStack => Text -> Text
    Text -> Text
    T.init
        null :: Text -> Bool
    null = Text -> Bool
    T.null
        length :: Text -> Int
    length = Text -> Int
    T.length
        rigidMap :: (Char -> Char) -> Text -> Text
    rigidMap = (Char -> Char) -> Text -> Text
    T.map
        reverse :: Text -> Text
    reverse = Text -> Text
    T.reverse
        intersperse :: Char -> Text -> Text
    intersperse = Char -> Text -> Text
    T.intersperse
        concat :: forall full'. ListLike full' Text => full' -> Text
    concat = [Text] -> Text
    T.concat ([Text] -> Text) -> (full' -> [Text]) -> full' -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . full' -> [Item full']
    full' -> [Text]
    forall l. IsList l => l -> [Item l]
    toList
        rigidConcatMap :: (Char -> Text) -> Text -> Text
    rigidConcatMap = (Char -> Text) -> Text -> Text
    T.concatMap
        any :: (Char -> Bool) -> Text -> Bool
    any = (Char -> Bool) -> Text -> Bool
    T.any
        all :: (Char -> Bool) -> Text -> Bool
    all = (Char -> Bool) -> Text -> Bool
    T.all
        maximum :: Ord Char => Text -> Char
    maximum = HasCallStack => Text -> Char
    Text -> Char
    T.maximum
        minimum :: Ord Char => Text -> Char
    minimum = HasCallStack => Text -> Char
    Text -> Char
    T.minimum
        replicate :: Int -> Char -> Text
    replicate Int
    n = Int -> Text -> Text
    T.replicate Int
    n (Text -> Text) -> (Char -> Text) -> Char -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Char -> Text
    T.singleton
        take :: Int -> Text -> Text
    take = Int -> Text -> Text
    T.take
        drop :: Int -> Text -> Text
    drop = Int -> Text -> Text
    T.drop
        splitAt :: Int -> Text -> (Text, Text)
    splitAt = Int -> Text -> (Text, Text)
    T.splitAt
        takeWhile :: (Char -> Bool) -> Text -> Text
    takeWhile = (Char -> Bool) -> Text -> Text
    T.takeWhile
        dropWhile :: (Char -> Bool) -> Text -> Text
    dropWhile = (Char -> Bool) -> Text -> Text
    T.dropWhile
        span :: (Char -> Bool) -> Text -> (Text, Text)
    span = (Char -> Bool) -> Text -> (Text, Text)
    T.span
        break :: (Char -> Bool) -> Text -> (Text, Text)
    break = (Char -> Bool) -> Text -> (Text, Text)
    T.break
        group :: forall full'. (ListLike full' Text, Eq Char) => Text -> full'
    group = [Item full'] -> full'
    [Text] -> full'
    forall l. IsList l => [Item l] -> l
    fromList ([Text] -> full') -> (Text -> [Text]) -> Text -> full'
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> [Text]
    T.group
        inits :: forall full'. ListLike full' Text => Text -> full'
    inits = [Item full'] -> full'
    [Text] -> full'
    forall l. IsList l => [Item l] -> l
    fromList ([Text] -> full') -> (Text -> [Text]) -> Text -> full'
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> [Text]
    T.inits
        tails :: forall full'. ListLike full' Text => Text -> full'
    tails = [Item full'] -> full'
    [Text] -> full'
    forall l. IsList l => [Item l] -> l
    fromList ([Text] -> full') -> (Text -> [Text]) -> Text -> full'
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> [Text]
    T.tails
        isPrefixOf :: Eq Char => Text -> Text -> Bool
    isPrefixOf = Text -> Text -> Bool
    T.isPrefixOf
        isSuffixOf :: Eq Char => Text -> Text -> Bool
    isSuffixOf = Text -> Text -> Bool
    T.isSuffixOf
        stripPrefix :: Eq Char => Text -> Text -> Maybe Text
    stripPrefix = Text -> Text -> Maybe Text
    T.stripPrefix
        stripSuffix :: Eq Char => Text -> Text -> Maybe Text
    stripSuffix = Text -> Text -> Maybe Text
    T.stripSuffix
        elem :: Eq Char => Char -> Text -> Bool
    elem = Text -> Text -> Bool
    T.isInfixOf (Text -> Text -> Bool) -> (Char -> Text) -> Char -> Text -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Char -> Text
    T.singleton
        find :: (Char -> Bool) -> Text -> Maybe Char
    find = (Char -> Bool) -> Text -> Maybe Char
    T.find
        filter :: (Char -> Bool) -> Text -> Text
    filter = (Char -> Bool) -> Text -> Text
    T.filter
        index :: Text -> Int -> Char
    index = HasCallStack => Text -> Int -> Char
    Text -> Int -> Char
    T.index
        findIndex :: (Char -> Bool) -> Text -> Maybe Int
    findIndex = (Char -> Bool) -> Text -> Maybe Int
    T.findIndex
        --toList = T.unpack
        --fromList = T.pack
        --fromListLike = fromList . toList
        groupBy :: forall full'.
    (ListLike full' Text, Eq Char) =>
    (Char -> Char -> Bool) -> Text -> full'
    groupBy Char -> Char -> Bool
    f = [Item full'] -> full'
    [Text] -> full'
    forall l. IsList l => [Item l] -> l
    fromList ([Text] -> full') -> (Text -> [Text]) -> Text -> full'
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Char -> Char -> Bool) -> Text -> [Text]
    T.groupBy Char -> Char -> Bool
    f
        genericLength :: forall a. Num a => Text -> a
    genericLength = Integer -> a
    forall a. Num a => Integer -> a
    fromInteger (Integer -> a) -> (Text -> Integer) -> Text -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Integer
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Integer) -> (Text -> Int) -> Text -> Integer
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Int
    T.length
        genericTake :: forall a. Integral a => a -> Text -> Text
    genericTake a
    i = Int -> Text -> Text
    T.take (a -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral a
    i)
        genericDrop :: forall a. Integral a => a -> Text -> Text
    genericDrop a
    i = Int -> Text -> Text
    T.drop (a -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral a
    i)
        genericSplitAt :: forall a. Integral a => a -> Text -> (Text, Text)
    genericSplitAt a
    i = Int -> Text -> (Text, Text)
    T.splitAt (a -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral a
    i)
        genericReplicate :: forall a. Integral a => a -> Char -> Text
    genericReplicate a
    i = Int -> Char -> Text
    forall full item. ListLike full item => Int -> item -> full
    LL.replicate (a -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral a
    i)

        sequence :: forall (m :: * -> *) fullinp.
    (Applicative m, ListLike fullinp (m Char)) =>
    fullinp -> m Text
    sequence  = ([Char] -> Text) -> m [Char] -> m Text
    forall a b. (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap [Char] -> Text
    [Item Text] -> Text
    forall l. IsList l => [Item l] -> l
    fromList (m [Char] -> m Text) -> (fullinp -> m [Char]) -> fullinp -> m Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [m Char] -> m [Char]
    forall (t :: * -> *) (f :: * -> *) a.
    (Traversable t, Applicative f) =>
    t (f a) -> f (t a)
    forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
    P.sequenceA  ([m Char] -> m [Char])
    -> (fullinp -> [m Char]) -> fullinp -> m [Char]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . fullinp -> [m Char]
    fullinp -> [Item fullinp]
    forall l. IsList l => l -> [Item l]
    toList
        mapM :: forall (m :: * -> *) full' item'.
    (Applicative m, ListLike full' item') =>
    (Char -> m item') -> Text -> m full'
    mapM Char -> m item'
    func = ([item'] -> full') -> m [item'] -> m full'
    forall a b. (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap [item'] -> full'
    [Item full'] -> full'
    forall l. IsList l => [Item l] -> l
    fromList (m [item'] -> m full') -> (Text -> m [item']) -> Text -> m full'
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Char -> m item') -> [Char] -> m [item']
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> [a] -> f [b]
    P.traverse Char -> m item'
    func ([Char] -> m [item']) -> (Text -> [Char]) -> Text -> m [item']
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> [Char]
    Text -> [Item Text]
    forall l. IsList l => l -> [Item l]
    toList

    instance ListLikeIO T.Text Char where
        hGetLine :: Handle -> IO Text
    hGetLine = Handle -> IO Text
    TI.hGetLine
        hGetContents :: Handle -> IO Text
    hGetContents = Handle -> IO Text
    TI.hGetContents
        hGet :: Handle -> Int -> IO Text
    hGet Handle
    h Int
    c = Handle -> Int -> IO ByteString
    BS.hGet Handle
    h Int
    c IO ByteString -> (ByteString -> IO Text) -> IO Text
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= Text -> IO Text
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Text -> IO Text) -> (ByteString -> Text) -> ByteString -> IO Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteString -> Text
    decodeUtf8
        hGetNonBlocking :: Handle -> Int -> IO Text
    hGetNonBlocking Handle
    h Int
    i = Handle -> Int -> IO ByteString
    BS.hGetNonBlocking Handle
    h Int
    i IO ByteString -> (ByteString -> IO Text) -> IO Text
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= Text -> IO Text
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Text -> IO Text) -> (ByteString -> Text) -> ByteString -> IO Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteString -> Text
    decodeUtf8
        hPutStr :: Handle -> Text -> IO ()
    hPutStr = Handle -> Text -> IO ()
    TI.hPutStr
        hPutStrLn :: Handle -> Text -> IO ()
    hPutStrLn = Handle -> Text -> IO ()
    TI.hPutStrLn
        getLine :: IO Text
    getLine = IO Text
    TI.getLine
        getContents :: IO Text
    getContents = IO Text
    TI.getContents
        putStr :: Text -> IO ()
    putStr = Text -> IO ()
    TI.putStr
        putStrLn :: Text -> IO ()
    putStrLn = Text -> IO ()
    TI.putStrLn
        interact :: (Text -> Text) -> IO ()
    interact = (Text -> Text) -> IO ()
    TI.interact
        readFile :: [Char] -> IO Text
    readFile = [Char] -> IO Text
    TI.readFile
        writeFile :: [Char] -> Text -> IO ()
    writeFile = [Char] -> Text -> IO ()
    TI.writeFile
        appendFile :: [Char] -> Text -> IO ()
    appendFile = [Char] -> Text -> IO ()
    TI.appendFile

    instance StringLike T.Text where
        toString :: Text -> [Char]
    toString = Text -> [Char]
    T.unpack
        words :: forall full'. ListLike full' Text => Text -> full'
    words = [Item full] -> full
    [Text] -> full
    forall l. IsList l => [Item l] -> l
    fromList ([Text] -> full) -> (Text -> [Text]) -> Text -> full
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> [Text]
    T.words
        lines :: forall full'. ListLike full' Text => Text -> full'
    lines = [Item full] -> full
    [Text] -> full
    forall l. IsList l => [Item l] -> l
    fromList ([Text] -> full) -> (Text -> [Text]) -> Text -> full
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> [Text]
    T.lines
        unwords :: forall full'. ListLike full' Text => full' -> Text
    unwords = [Text] -> Text
    T.unwords ([Text] -> Text) -> (full -> [Text]) -> full -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . full -> [Item full]
    full -> [Text]
    forall l. IsList l => l -> [Item l]
    toList
        unlines :: forall full'. ListLike full' Text => full' -> Text
    unlines = [Text] -> Text
    T.unlines ([Text] -> Text) -> (full -> [Text]) -> full -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . full -> [Item full]
    full -> [Text]
    forall l. IsList l => l -> [Item l]
    toList

        fromText :: StringLike Text => Text -> Text
    fromText = Text -> Text
    forall a. a -> a
    id
        fromLazyText :: StringLike Text => Text -> Text
    fromLazyText = Text -> Text
    Lazy.toStrict