{-# LANGUAGE CPP
            ,MultiParamTypeClasses
            ,FlexibleInstances
            ,TypeFamilies
            ,TypeSynonymInstances
            ,GeneralizedNewtypeDeriving #-}


{-
Copyright (C) 2007 John Goerzen <jgoerzen@complete.org>

All rights reserved.

For license and copyright information, see the file COPYRIGHT

-}

{- |
   Module     : Data.ListLike.CharString
   Copyright  : Copyright (C) 2007 John Goerzen
   License    : BSD3

   Maintainer : David Fox <dsf@seereason.com>, Andreas Abel
   Stability  : stable
   Portability: portable

Newtype wrapper for ByteString to enable a Char-based interface
Re-exported by "Data.ListLike".

Written by John Lato, jwlato\@gmail.com
-}

module Data.ListLike.CharString (
  CharString (..)
 ,CharStringLazy (..)
)

where

import Prelude hiding (length, head, last, null, tail, map, filter, concat,
                       any, lookup, init, all, foldl, foldr, foldl1, foldr1,
                       maximum, minimum, iterate, span, break, takeWhile,
                       dropWhile, reverse, zip, zipWith, sequence,
                       sequence_, mapM, mapM_, concatMap, and, or, sum,
                       product, repeat, replicate, cycle, take, drop,
                       splitAt, elem, notElem, unzip, lines, words,
                       unlines, unwords)
--import qualified Data.Foldable as F
import           Data.ListLike.Base
import           Data.ListLike.String
import           Data.ListLike.IO
import           Data.ListLike.FoldableLL
import           Data.Int
#if !MIN_VERSION_base(4,11,0)
import           Data.Semigroup (Semigroup(..))
#endif
import           Data.String (IsString(..))
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy.Char8 as BSL
--import qualified System.IO as IO
--import           Data.Word
import           Control.Arrow
import           GHC.Exts (IsList(..))

--------------------------------------------------
-- ByteString

-- | Newtype wrapper around Data.ByteString.Char8.ByteString,
--   this allows for ListLike instances with Char elements.
newtype CharString = CS { CharString -> ByteString
unCS :: BS.ByteString }
  deriving (ReadPrec [CharString]
ReadPrec CharString
Int -> ReadS CharString
ReadS [CharString]
(Int -> ReadS CharString)
-> ReadS [CharString]
-> ReadPrec CharString
-> ReadPrec [CharString]
-> Read CharString
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS CharString
readsPrec :: Int -> ReadS CharString
$creadList :: ReadS [CharString]
readList :: ReadS [CharString]
$creadPrec :: ReadPrec CharString
readPrec :: ReadPrec CharString
$creadListPrec :: ReadPrec [CharString]
readListPrec :: ReadPrec [CharString]
Read, Int -> CharString -> ShowS
[CharString] -> ShowS
CharString -> String
(Int -> CharString -> ShowS)
-> (CharString -> String)
-> ([CharString] -> ShowS)
-> Show CharString
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CharString -> ShowS
showsPrec :: Int -> CharString -> ShowS
$cshow :: CharString -> String
show :: CharString -> String
$cshowList :: [CharString] -> ShowS
showList :: [CharString] -> ShowS
Show, CharString -> CharString -> Bool
(CharString -> CharString -> Bool)
-> (CharString -> CharString -> Bool) -> Eq CharString
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CharString -> CharString -> Bool
== :: CharString -> CharString -> Bool
$c/= :: CharString -> CharString -> Bool
/= :: CharString -> CharString -> Bool
Eq, Eq CharString
Eq CharString =>
(CharString -> CharString -> Ordering)
-> (CharString -> CharString -> Bool)
-> (CharString -> CharString -> Bool)
-> (CharString -> CharString -> Bool)
-> (CharString -> CharString -> Bool)
-> (CharString -> CharString -> CharString)
-> (CharString -> CharString -> CharString)
-> Ord CharString
CharString -> CharString -> Bool
CharString -> CharString -> Ordering
CharString -> CharString -> CharString
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: CharString -> CharString -> Ordering
compare :: CharString -> CharString -> Ordering
$c< :: CharString -> CharString -> Bool
< :: CharString -> CharString -> Bool
$c<= :: CharString -> CharString -> Bool
<= :: CharString -> CharString -> Bool
$c> :: CharString -> CharString -> Bool
> :: CharString -> CharString -> Bool
$c>= :: CharString -> CharString -> Bool
>= :: CharString -> CharString -> Bool
$cmax :: CharString -> CharString -> CharString
max :: CharString -> CharString -> CharString
$cmin :: CharString -> CharString -> CharString
min :: CharString -> CharString -> CharString
Ord, NonEmpty CharString -> CharString
CharString -> CharString -> CharString
(CharString -> CharString -> CharString)
-> (NonEmpty CharString -> CharString)
-> (forall b. Integral b => b -> CharString -> CharString)
-> Semigroup CharString
forall b. Integral b => b -> CharString -> CharString
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: CharString -> CharString -> CharString
<> :: CharString -> CharString -> CharString
$csconcat :: NonEmpty CharString -> CharString
sconcat :: NonEmpty CharString -> CharString
$cstimes :: forall b. Integral b => b -> CharString -> CharString
stimes :: forall b. Integral b => b -> CharString -> CharString
Semigroup, Semigroup CharString
CharString
Semigroup CharString =>
CharString
-> (CharString -> CharString -> CharString)
-> ([CharString] -> CharString)
-> Monoid CharString
[CharString] -> CharString
CharString -> CharString -> CharString
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
$cmempty :: CharString
mempty :: CharString
$cmappend :: CharString -> CharString -> CharString
mappend :: CharString -> CharString -> CharString
$cmconcat :: [CharString] -> CharString
mconcat :: [CharString] -> CharString
Monoid)

instance FoldableLL CharString Char where
    foldl :: forall a. (a -> Char -> a) -> a -> CharString -> a
foldl a -> Char -> a
f a
i0  CharString
ls = (a -> Char -> a) -> a -> ByteString -> a
forall a. (a -> Char -> a) -> a -> ByteString -> a
BS.foldl a -> Char -> a
f a
i0 (CharString -> ByteString
unCS CharString
ls)
    foldl' :: forall a. (a -> Char -> a) -> a -> CharString -> a
foldl' a -> Char -> a
f a
i0 CharString
ls = (a -> Char -> a) -> a -> ByteString -> a
forall a. (a -> Char -> a) -> a -> ByteString -> a
BS.foldl' a -> Char -> a
f a
i0 (CharString -> ByteString
unCS CharString
ls)
    foldl1 :: (Char -> Char -> Char) -> CharString -> Char
foldl1 Char -> Char -> Char
f    CharString
ls = (Char -> Char -> Char) -> ByteString -> Char
BS.foldl1 Char -> Char -> Char
f (CharString -> ByteString
unCS CharString
ls)
    foldr :: forall b. (Char -> b -> b) -> b -> CharString -> b
foldr Char -> b -> b
f b
i0  CharString
ls = (Char -> b -> b) -> b -> ByteString -> b
forall a. (Char -> a -> a) -> a -> ByteString -> a
BS.foldr Char -> b -> b
f b
i0 (CharString -> ByteString
unCS CharString
ls)
    foldr1 :: (Char -> Char -> Char) -> CharString -> Char
foldr1 Char -> Char -> Char
f    CharString
ls = (Char -> Char -> Char) -> ByteString -> Char
BS.foldr1 Char -> Char -> Char
f (CharString -> ByteString
unCS CharString
ls)

instance IsList CharString where
  type Item CharString = Char
  toList :: CharString -> [Item CharString]
toList = ByteString -> String
BS.unpack (ByteString -> String)
-> (CharString -> ByteString) -> CharString -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
  fromList :: [Item CharString] -> CharString
fromList = ByteString -> CharString
CS (ByteString -> CharString)
-> (String -> ByteString) -> String -> CharString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ByteString
BS.pack

instance ListLike CharString Char where
    empty :: CharString
empty = ByteString -> CharString
CS ByteString
BS.empty
    singleton :: Char -> CharString
singleton = ByteString -> CharString
CS (ByteString -> CharString)
-> (Char -> ByteString) -> Char -> CharString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ByteString
BS.singleton
    cons :: Char -> CharString -> CharString
cons Char
x CharString
l = ByteString -> CharString
CS (Char -> ByteString -> ByteString
BS.cons Char
x (CharString -> ByteString
unCS CharString
l))
    snoc :: CharString -> Char -> CharString
snoc CharString
l Char
x = ByteString -> CharString
CS (ByteString -> Char -> ByteString
BS.snoc (CharString -> ByteString
unCS CharString
l) Char
x)
    append :: CharString -> CharString -> CharString
append CharString
l CharString
r = ByteString -> CharString
CS (ByteString -> CharString) -> ByteString -> CharString
forall a b. (a -> b) -> a -> b
$ ByteString -> ByteString -> ByteString
BS.append (CharString -> ByteString
unCS CharString
l) (CharString -> ByteString
unCS CharString
r)
    head :: CharString -> Char
head = ByteString -> Char
BS.head (ByteString -> Char)
-> (CharString -> ByteString) -> CharString -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    last :: CharString -> Char
last = ByteString -> Char
BS.last (ByteString -> Char)
-> (CharString -> ByteString) -> CharString -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    tail :: CharString -> CharString
tail = ByteString -> CharString
CS (ByteString -> CharString)
-> (CharString -> ByteString) -> CharString -> CharString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HasCallStack => ByteString -> ByteString
ByteString -> ByteString
BS.tail (ByteString -> ByteString)
-> (CharString -> ByteString) -> CharString -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    init :: CharString -> CharString
init = ByteString -> CharString
CS (ByteString -> CharString)
-> (CharString -> ByteString) -> CharString -> CharString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HasCallStack => ByteString -> ByteString
ByteString -> ByteString
BS.init (ByteString -> ByteString)
-> (CharString -> ByteString) -> CharString -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    null :: CharString -> Bool
null = ByteString -> Bool
BS.null (ByteString -> Bool)
-> (CharString -> ByteString) -> CharString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    length :: CharString -> Int
length = Int -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int) -> (CharString -> Int) -> CharString -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Int
BS.length (ByteString -> Int)
-> (CharString -> ByteString) -> CharString -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    -- map = BS.map
    rigidMap :: (Char -> Char) -> CharString -> CharString
rigidMap Char -> Char
f = ByteString -> CharString
CS (ByteString -> CharString)
-> (CharString -> ByteString) -> CharString -> CharString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Char) -> ByteString -> ByteString
BS.map Char -> Char
f (ByteString -> ByteString)
-> (CharString -> ByteString) -> CharString -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    reverse :: CharString -> CharString
reverse = ByteString -> CharString
CS (ByteString -> CharString)
-> (CharString -> ByteString) -> CharString -> CharString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
BS.reverse (ByteString -> ByteString)
-> (CharString -> ByteString) -> CharString -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    --intersperse = BS.intersperse
    concat :: forall full'. ListLike full' CharString => full' -> CharString
concat = ByteString -> CharString
CS (ByteString -> CharString)
-> (full' -> ByteString) -> full' -> CharString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [ByteString] -> ByteString
BS.concat ([ByteString] -> ByteString)
-> (full' -> [ByteString]) -> full' -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CharString -> ByteString) -> [CharString] -> [ByteString]
forall full' item'.
ListLike full' item' =>
(CharString -> item') -> [CharString] -> full'
forall full item full' item'.
(ListLike full item, ListLike full' item') =>
(item -> item') -> full -> full'
map CharString -> ByteString
unCS ([CharString] -> [ByteString])
-> (full' -> [CharString]) -> full' -> [ByteString]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. full' -> [Item full']
full' -> [CharString]
forall l. IsList l => l -> [Item l]
toList
    --concatMap = BS.concatMap
    rigidConcatMap :: (Char -> CharString) -> CharString -> CharString
rigidConcatMap Char -> CharString
f = ByteString -> CharString
CS (ByteString -> CharString)
-> (CharString -> ByteString) -> CharString -> CharString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> ByteString) -> ByteString -> ByteString
BS.concatMap (CharString -> ByteString
unCS (CharString -> ByteString)
-> (Char -> CharString) -> Char -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> CharString
f) (ByteString -> ByteString)
-> (CharString -> ByteString) -> CharString -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    any :: (Char -> Bool) -> CharString -> Bool
any Char -> Bool
p = (Char -> Bool) -> ByteString -> Bool
BS.any Char -> Bool
p (ByteString -> Bool)
-> (CharString -> ByteString) -> CharString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    all :: (Char -> Bool) -> CharString -> Bool
all Char -> Bool
p = (Char -> Bool) -> ByteString -> Bool
BS.all Char -> Bool
p (ByteString -> Bool)
-> (CharString -> ByteString) -> CharString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    maximum :: Ord Char => CharString -> Char
maximum = ByteString -> Char
BS.maximum (ByteString -> Char)
-> (CharString -> ByteString) -> CharString -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    minimum :: Ord Char => CharString -> Char
minimum = ByteString -> Char
BS.minimum (ByteString -> Char)
-> (CharString -> ByteString) -> CharString -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    replicate :: Int -> Char -> CharString
replicate Int
i = ByteString -> CharString
CS (ByteString -> CharString)
-> (Char -> ByteString) -> Char -> CharString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Char -> ByteString
BS.replicate (Int -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i)
    take :: Int -> CharString -> CharString
take Int
i = ByteString -> CharString
CS (ByteString -> CharString)
-> (CharString -> ByteString) -> CharString -> CharString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> ByteString -> ByteString
BS.take (Int -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i) (ByteString -> ByteString)
-> (CharString -> ByteString) -> CharString -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    drop :: Int -> CharString -> CharString
drop Int
i = ByteString -> CharString
CS (ByteString -> CharString)
-> (CharString -> ByteString) -> CharString -> CharString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> ByteString -> ByteString
BS.drop (Int -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i) (ByteString -> ByteString)
-> (CharString -> ByteString) -> CharString -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    splitAt :: Int -> CharString -> (CharString, CharString)
splitAt Int
i = (ByteString -> CharString
CS (ByteString -> CharString)
-> (ByteString -> CharString)
-> (ByteString, ByteString)
-> (CharString, CharString)
forall b c b' c'. (b -> c) -> (b' -> c') -> (b, b') -> (c, c')
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** ByteString -> CharString
CS) ((ByteString, ByteString) -> (CharString, CharString))
-> (CharString -> (ByteString, ByteString))
-> CharString
-> (CharString, CharString)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> ByteString -> (ByteString, ByteString)
BS.splitAt (Int -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i) (ByteString -> (ByteString, ByteString))
-> (CharString -> ByteString)
-> CharString
-> (ByteString, ByteString)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    takeWhile :: (Char -> Bool) -> CharString -> CharString
takeWhile Char -> Bool
p = ByteString -> CharString
CS (ByteString -> CharString)
-> (CharString -> ByteString) -> CharString -> CharString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> ByteString -> ByteString
BS.takeWhile Char -> Bool
p (ByteString -> ByteString)
-> (CharString -> ByteString) -> CharString -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    dropWhile :: (Char -> Bool) -> CharString -> CharString
dropWhile Char -> Bool
p = ByteString -> CharString
CS (ByteString -> CharString)
-> (CharString -> ByteString) -> CharString -> CharString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> ByteString -> ByteString
BS.dropWhile Char -> Bool
p (ByteString -> ByteString)
-> (CharString -> ByteString) -> CharString -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    span :: (Char -> Bool) -> CharString -> (CharString, CharString)
span Char -> Bool
p  = (ByteString -> CharString
CS (ByteString -> CharString)
-> (ByteString -> CharString)
-> (ByteString, ByteString)
-> (CharString, CharString)
forall b c b' c'. (b -> c) -> (b' -> c') -> (b, b') -> (c, c')
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** ByteString -> CharString
CS) ((ByteString, ByteString) -> (CharString, CharString))
-> (CharString -> (ByteString, ByteString))
-> CharString
-> (CharString, CharString)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> ByteString -> (ByteString, ByteString)
BS.span Char -> Bool
p (ByteString -> (ByteString, ByteString))
-> (CharString -> ByteString)
-> CharString
-> (ByteString, ByteString)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    break :: (Char -> Bool) -> CharString -> (CharString, CharString)
break Char -> Bool
p = (ByteString -> CharString
CS (ByteString -> CharString)
-> (ByteString -> CharString)
-> (ByteString, ByteString)
-> (CharString, CharString)
forall b c b' c'. (b -> c) -> (b' -> c') -> (b, b') -> (c, c')
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** ByteString -> CharString
CS) ((ByteString, ByteString) -> (CharString, CharString))
-> (CharString -> (ByteString, ByteString))
-> CharString
-> (CharString, CharString)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> ByteString -> (ByteString, ByteString)
BS.break Char -> Bool
p (ByteString -> (ByteString, ByteString))
-> (CharString -> ByteString)
-> CharString
-> (ByteString, ByteString)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    group :: forall full'.
(ListLike full' CharString, Eq Char) =>
CharString -> full'
group = [Item full'] -> full'
[CharString] -> full'
forall l. IsList l => [Item l] -> l
fromList ([CharString] -> full')
-> (CharString -> [CharString]) -> CharString -> full'
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ByteString -> CharString) -> [ByteString] -> [CharString]
forall full' item'.
ListLike full' item' =>
(ByteString -> item') -> [ByteString] -> full'
forall full item full' item'.
(ListLike full item, ListLike full' item') =>
(item -> item') -> full -> full'
map ByteString -> CharString
CS ([ByteString] -> [CharString])
-> (CharString -> [ByteString]) -> CharString -> [CharString]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [ByteString]
BS.group (ByteString -> [ByteString])
-> (CharString -> ByteString) -> CharString -> [ByteString]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    inits :: forall full'. ListLike full' CharString => CharString -> full'
inits = [Item full'] -> full'
[CharString] -> full'
forall l. IsList l => [Item l] -> l
fromList ([CharString] -> full')
-> (CharString -> [CharString]) -> CharString -> full'
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ByteString -> CharString) -> [ByteString] -> [CharString]
forall full' item'.
ListLike full' item' =>
(ByteString -> item') -> [ByteString] -> full'
forall full item full' item'.
(ListLike full item, ListLike full' item') =>
(item -> item') -> full -> full'
map ByteString -> CharString
CS ([ByteString] -> [CharString])
-> (CharString -> [ByteString]) -> CharString -> [CharString]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [ByteString]
BS.inits (ByteString -> [ByteString])
-> (CharString -> ByteString) -> CharString -> [ByteString]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    tails :: forall full'. ListLike full' CharString => CharString -> full'
tails = [Item full'] -> full'
[CharString] -> full'
forall l. IsList l => [Item l] -> l
fromList ([CharString] -> full')
-> (CharString -> [CharString]) -> CharString -> full'
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ByteString -> CharString) -> [ByteString] -> [CharString]
forall full' item'.
ListLike full' item' =>
(ByteString -> item') -> [ByteString] -> full'
forall full item full' item'.
(ListLike full item, ListLike full' item') =>
(item -> item') -> full -> full'
map ByteString -> CharString
CS ([ByteString] -> [CharString])
-> (CharString -> [ByteString]) -> CharString -> [CharString]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [ByteString]
BS.tails (ByteString -> [ByteString])
-> (CharString -> ByteString) -> CharString -> [ByteString]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    isPrefixOf :: Eq Char => CharString -> CharString -> Bool
isPrefixOf CharString
p CharString
f = ByteString -> ByteString -> Bool
BS.isPrefixOf (CharString -> ByteString
unCS CharString
p) (CharString -> ByteString
unCS CharString
f)
    --isSuffixOf = BS.isSuffixOf
    --isInfixOf = BS.isInfixOf
    elem :: Eq Char => Char -> CharString -> Bool
elem Char
x = Char -> ByteString -> Bool
BS.elem Char
x (ByteString -> Bool)
-> (CharString -> ByteString) -> CharString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    notElem :: Eq Char => Char -> CharString -> Bool
notElem Char
x = Char -> ByteString -> Bool
BS.notElem Char
x (ByteString -> Bool)
-> (CharString -> ByteString) -> CharString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    find :: (Char -> Bool) -> CharString -> Maybe Char
find Char -> Bool
p = (Char -> Bool) -> ByteString -> Maybe Char
BS.find Char -> Bool
p (ByteString -> Maybe Char)
-> (CharString -> ByteString) -> CharString -> Maybe Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    filter :: (Char -> Bool) -> CharString -> CharString
filter Char -> Bool
p = ByteString -> CharString
CS (ByteString -> CharString)
-> (CharString -> ByteString) -> CharString -> CharString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> ByteString -> ByteString
BS.filter Char -> Bool
p (ByteString -> ByteString)
-> (CharString -> ByteString) -> CharString -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    --partition = BS.partition
    index :: CharString -> Int -> Char
index CharString
l Int
i = ByteString -> Int -> Char
BS.index (CharString -> ByteString
unCS CharString
l) (Int -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i)
    elemIndex :: Eq Char => Char -> CharString -> Maybe Int
elemIndex Char
i = Char -> ByteString -> Maybe Int
BS.elemIndex Char
i  (ByteString -> Maybe Int)
-> (CharString -> ByteString) -> CharString -> Maybe Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    --elemIndices x = fromList . L.map fromIntegral . BS.elemIndices x
    findIndex :: (Char -> Bool) -> CharString -> Maybe Int
findIndex Char -> Bool
f = (Char -> Bool) -> ByteString -> Maybe Int
BS.findIndex Char -> Bool
f (ByteString -> Maybe Int)
-> (CharString -> ByteString) -> CharString -> Maybe Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    --findIndices x = fromList . L.map fromIntegral . BS.findIndices x
    --sequence = BS.sequence
    --mapM = BS.mapM
    --mapM_ = BS.mapM_
    --nub = BS.nub
    --delete = BS.delete
    --deleteFirsts = BS.deleteFirsts
    --union = BS.union
    --intersect = BS.intersect
    --sort = BS.sort
    --insert = BS.insert
    --toList = BS.unpack . unCS
    --fromList = CS . BS.pack
    --fromListLike = fromList . toList
    --nubBy = BS.nubBy
    --deleteBy = BS.deleteBy
    --deleteFirstsBy = BS.deleteFirstsBy
    --unionBy = BS.unionBy
    --intersectBy = BS.intersectBy
    -- BS.groupBy is broken. groupBy f = fromList . BS.groupBy f
    -- the below works on ghc but generates a type error on hugs
    -- groupBy func = map fromList . L.groupBy func . toList
    --sortBy = BS.sortBy
    --insertBy = BS.insertBy
    genericLength :: forall a. Num a => CharString -> a
genericLength = Integer -> a
forall a. Num a => Integer -> a
fromInteger (Integer -> a) -> (CharString -> Integer) -> CharString -> 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) -> (CharString -> Int) -> CharString -> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Int
BS.length (ByteString -> Int)
-> (CharString -> ByteString) -> CharString -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    genericTake :: forall b. Integral b => b -> CharString -> CharString
genericTake a
i = ByteString -> CharString
CS (ByteString -> CharString)
-> (CharString -> ByteString) -> CharString -> CharString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> ByteString -> ByteString
BS.take (a -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
i) (ByteString -> ByteString)
-> (CharString -> ByteString) -> CharString -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    genericDrop :: forall b. Integral b => b -> CharString -> CharString
genericDrop a
i = ByteString -> CharString
CS (ByteString -> CharString)
-> (CharString -> ByteString) -> CharString -> CharString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> ByteString -> ByteString
BS.drop (a -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
i) (ByteString -> ByteString)
-> (CharString -> ByteString) -> CharString -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    genericSplitAt :: forall a. Integral a => a -> CharString -> (CharString, CharString)
genericSplitAt a
i = (ByteString -> CharString
CS (ByteString -> CharString)
-> (ByteString -> CharString)
-> (ByteString, ByteString)
-> (CharString, CharString)
forall b c b' c'. (b -> c) -> (b' -> c') -> (b, b') -> (c, c')
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** ByteString -> CharString
CS) ((ByteString, ByteString) -> (CharString, CharString))
-> (CharString -> (ByteString, ByteString))
-> CharString
-> (CharString, CharString)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> ByteString -> (ByteString, ByteString)
BS.splitAt (a -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
i) (ByteString -> (ByteString, ByteString))
-> (CharString -> ByteString)
-> CharString
-> (ByteString, ByteString)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    genericReplicate :: forall a. Integral a => a -> Char -> CharString
genericReplicate a
i = ByteString -> CharString
CS (ByteString -> CharString)
-> (Char -> ByteString) -> Char -> CharString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Char -> ByteString
BS.replicate (a -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
i)

instance ListLikeIO CharString Char where
    hGetLine :: Handle -> IO CharString
hGetLine Handle
h = (ByteString -> CharString) -> IO ByteString -> IO CharString
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> CharString
CS (IO ByteString -> IO CharString) -> IO ByteString -> IO CharString
forall a b. (a -> b) -> a -> b
$ Handle -> IO ByteString
BS.hGetLine Handle
h
    hGetContents :: Handle -> IO CharString
hGetContents = (ByteString -> CharString) -> IO ByteString -> IO CharString
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> CharString
CS (IO ByteString -> IO CharString)
-> (Handle -> IO ByteString) -> Handle -> IO CharString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> IO ByteString
BS.hGetContents
    hGet :: Handle -> Int -> IO CharString
hGet Handle
h Int
n = (ByteString -> CharString) -> IO ByteString -> IO CharString
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> CharString
CS (IO ByteString -> IO CharString) -> IO ByteString -> IO CharString
forall a b. (a -> b) -> a -> b
$ Handle -> Int -> IO ByteString
BS.hGet Handle
h Int
n
    hGetNonBlocking :: Handle -> Int -> IO CharString
hGetNonBlocking Handle
h Int
n = (ByteString -> CharString) -> IO ByteString -> IO CharString
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> CharString
CS (IO ByteString -> IO CharString) -> IO ByteString -> IO CharString
forall a b. (a -> b) -> a -> b
$ Handle -> Int -> IO ByteString
BS.hGetNonBlocking Handle
h Int
n
    hPutStr :: Handle -> CharString -> IO ()
hPutStr Handle
h = Handle -> ByteString -> IO ()
BS.hPut Handle
h (ByteString -> IO ())
-> (CharString -> ByteString) -> CharString -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    --hPutStrLn = BS.hPutStrLn
    getLine :: IO CharString
getLine = (ByteString -> CharString) -> IO ByteString -> IO CharString
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> CharString
CS IO ByteString
BS.getLine
    getContents :: IO CharString
getContents = (ByteString -> CharString) -> IO ByteString -> IO CharString
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> CharString
CS IO ByteString
BS.getContents
    putStr :: CharString -> IO ()
putStr = ByteString -> IO ()
BS.putStr (ByteString -> IO ())
-> (CharString -> ByteString) -> CharString -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    putStrLn :: CharString -> IO ()
putStrLn = ByteString -> IO ()
BS.putStrLn (ByteString -> IO ())
-> (CharString -> ByteString) -> CharString -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    interact :: (CharString -> CharString) -> IO ()
interact CharString -> CharString
f = (ByteString -> ByteString) -> IO ()
BS.interact (CharString -> ByteString
unCS (CharString -> ByteString)
-> (ByteString -> CharString) -> ByteString -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> CharString
f (CharString -> CharString)
-> (ByteString -> CharString) -> ByteString -> CharString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> CharString
CS)
    readFile :: String -> IO CharString
readFile = (ByteString -> CharString) -> IO ByteString -> IO CharString
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> CharString
CS (IO ByteString -> IO CharString)
-> (String -> IO ByteString) -> String -> IO CharString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> IO ByteString
BS.readFile
    writeFile :: String -> CharString -> IO ()
writeFile String
fp = String -> ByteString -> IO ()
BS.writeFile String
fp (ByteString -> IO ())
-> (CharString -> ByteString) -> CharString -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS
    appendFile :: String -> CharString -> IO ()
appendFile String
fp = String -> ByteString -> IO ()
BS.appendFile String
fp (ByteString -> IO ())
-> (CharString -> ByteString) -> CharString -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS

instance IsString CharString where
    fromString :: String -> CharString
fromString = ByteString -> CharString
CS (ByteString -> CharString)
-> (String -> ByteString) -> String -> CharString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ByteString
BS.pack

instance StringLike CharString where
    toString :: CharString -> String
toString = ByteString -> String
BS.unpack (ByteString -> String)
-> (CharString -> ByteString) -> CharString -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharString -> ByteString
unCS

--------------------------------------------------
-- ByteString.Lazy

-- | Newtype wrapper around Data.ByteString.Lazy.Char8.ByteString,
--   this allows for ListLike instances with Char elements.
newtype CharStringLazy = CSL { CharStringLazy -> ByteString
unCSL :: BSL.ByteString }
  deriving (ReadPrec [CharStringLazy]
ReadPrec CharStringLazy
Int -> ReadS CharStringLazy
ReadS [CharStringLazy]
(Int -> ReadS CharStringLazy)
-> ReadS [CharStringLazy]
-> ReadPrec CharStringLazy
-> ReadPrec [CharStringLazy]
-> Read CharStringLazy
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS CharStringLazy
readsPrec :: Int -> ReadS CharStringLazy
$creadList :: ReadS [CharStringLazy]
readList :: ReadS [CharStringLazy]
$creadPrec :: ReadPrec CharStringLazy
readPrec :: ReadPrec CharStringLazy
$creadListPrec :: ReadPrec [CharStringLazy]
readListPrec :: ReadPrec [CharStringLazy]
Read, Int -> CharStringLazy -> ShowS
[CharStringLazy] -> ShowS
CharStringLazy -> String
(Int -> CharStringLazy -> ShowS)
-> (CharStringLazy -> String)
-> ([CharStringLazy] -> ShowS)
-> Show CharStringLazy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CharStringLazy -> ShowS
showsPrec :: Int -> CharStringLazy -> ShowS
$cshow :: CharStringLazy -> String
show :: CharStringLazy -> String
$cshowList :: [CharStringLazy] -> ShowS
showList :: [CharStringLazy] -> ShowS
Show, CharStringLazy -> CharStringLazy -> Bool
(CharStringLazy -> CharStringLazy -> Bool)
-> (CharStringLazy -> CharStringLazy -> Bool) -> Eq CharStringLazy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CharStringLazy -> CharStringLazy -> Bool
== :: CharStringLazy -> CharStringLazy -> Bool
$c/= :: CharStringLazy -> CharStringLazy -> Bool
/= :: CharStringLazy -> CharStringLazy -> Bool
Eq, Eq CharStringLazy
Eq CharStringLazy =>
(CharStringLazy -> CharStringLazy -> Ordering)
-> (CharStringLazy -> CharStringLazy -> Bool)
-> (CharStringLazy -> CharStringLazy -> Bool)
-> (CharStringLazy -> CharStringLazy -> Bool)
-> (CharStringLazy -> CharStringLazy -> Bool)
-> (CharStringLazy -> CharStringLazy -> CharStringLazy)
-> (CharStringLazy -> CharStringLazy -> CharStringLazy)
-> Ord CharStringLazy
CharStringLazy -> CharStringLazy -> Bool
CharStringLazy -> CharStringLazy -> Ordering
CharStringLazy -> CharStringLazy -> CharStringLazy
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: CharStringLazy -> CharStringLazy -> Ordering
compare :: CharStringLazy -> CharStringLazy -> Ordering
$c< :: CharStringLazy -> CharStringLazy -> Bool
< :: CharStringLazy -> CharStringLazy -> Bool
$c<= :: CharStringLazy -> CharStringLazy -> Bool
<= :: CharStringLazy -> CharStringLazy -> Bool
$c> :: CharStringLazy -> CharStringLazy -> Bool
> :: CharStringLazy -> CharStringLazy -> Bool
$c>= :: CharStringLazy -> CharStringLazy -> Bool
>= :: CharStringLazy -> CharStringLazy -> Bool
$cmax :: CharStringLazy -> CharStringLazy -> CharStringLazy
max :: CharStringLazy -> CharStringLazy -> CharStringLazy
$cmin :: CharStringLazy -> CharStringLazy -> CharStringLazy
min :: CharStringLazy -> CharStringLazy -> CharStringLazy
Ord, NonEmpty CharStringLazy -> CharStringLazy
CharStringLazy -> CharStringLazy -> CharStringLazy
(CharStringLazy -> CharStringLazy -> CharStringLazy)
-> (NonEmpty CharStringLazy -> CharStringLazy)
-> (forall b. Integral b => b -> CharStringLazy -> CharStringLazy)
-> Semigroup CharStringLazy
forall b. Integral b => b -> CharStringLazy -> CharStringLazy
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: CharStringLazy -> CharStringLazy -> CharStringLazy
<> :: CharStringLazy -> CharStringLazy -> CharStringLazy
$csconcat :: NonEmpty CharStringLazy -> CharStringLazy
sconcat :: NonEmpty CharStringLazy -> CharStringLazy
$cstimes :: forall b. Integral b => b -> CharStringLazy -> CharStringLazy
stimes :: forall b. Integral b => b -> CharStringLazy -> CharStringLazy
Semigroup, Semigroup CharStringLazy
CharStringLazy
Semigroup CharStringLazy =>
CharStringLazy
-> (CharStringLazy -> CharStringLazy -> CharStringLazy)
-> ([CharStringLazy] -> CharStringLazy)
-> Monoid CharStringLazy
[CharStringLazy] -> CharStringLazy
CharStringLazy -> CharStringLazy -> CharStringLazy
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
$cmempty :: CharStringLazy
mempty :: CharStringLazy
$cmappend :: CharStringLazy -> CharStringLazy -> CharStringLazy
mappend :: CharStringLazy -> CharStringLazy -> CharStringLazy
$cmconcat :: [CharStringLazy] -> CharStringLazy
mconcat :: [CharStringLazy] -> CharStringLazy
Monoid)

instance FoldableLL CharStringLazy Char where
    foldl :: forall a. (a -> Char -> a) -> a -> CharStringLazy -> a
foldl a -> Char -> a
f a
i0  CharStringLazy
ls = (a -> Char -> a) -> a -> ByteString -> a
forall a. (a -> Char -> a) -> a -> ByteString -> a
BSL.foldl a -> Char -> a
f a
i0 (CharStringLazy -> ByteString
unCSL CharStringLazy
ls)
    foldl' :: forall a. (a -> Char -> a) -> a -> CharStringLazy -> a
foldl' a -> Char -> a
f a
i0 CharStringLazy
ls = (a -> Char -> a) -> a -> ByteString -> a
forall a. (a -> Char -> a) -> a -> ByteString -> a
BSL.foldl' a -> Char -> a
f a
i0 (CharStringLazy -> ByteString
unCSL CharStringLazy
ls)
    foldl1 :: (Char -> Char -> Char) -> CharStringLazy -> Char
foldl1 Char -> Char -> Char
f    CharStringLazy
ls = (Char -> Char -> Char) -> ByteString -> Char
BSL.foldl1 Char -> Char -> Char
f (CharStringLazy -> ByteString
unCSL CharStringLazy
ls)
    foldr :: forall b. (Char -> b -> b) -> b -> CharStringLazy -> b
foldr Char -> b -> b
f b
i0  CharStringLazy
ls = (Char -> b -> b) -> b -> ByteString -> b
forall a. (Char -> a -> a) -> a -> ByteString -> a
BSL.foldr Char -> b -> b
f b
i0 (CharStringLazy -> ByteString
unCSL CharStringLazy
ls)
    foldr1 :: (Char -> Char -> Char) -> CharStringLazy -> Char
foldr1 Char -> Char -> Char
f    CharStringLazy
ls = (Char -> Char -> Char) -> ByteString -> Char
BSL.foldr1 Char -> Char -> Char
f (CharStringLazy -> ByteString
unCSL CharStringLazy
ls)

mi64toi :: Maybe Int64 -> Maybe Int
mi64toi :: Maybe Int64 -> Maybe Int
mi64toi Maybe Int64
Nothing = Maybe Int
forall a. Maybe a
Nothing
mi64toi (Just Int64
x) = Int -> Maybe Int
forall a. a -> Maybe a
Just (Int64 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
x)

instance IsList CharStringLazy where
  type Item CharStringLazy = Char
  toList :: CharStringLazy -> [Item CharStringLazy]
toList = ByteString -> String
BSL.unpack (ByteString -> String)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
  fromList :: [Item CharStringLazy] -> CharStringLazy
fromList = ByteString -> CharStringLazy
CSL (ByteString -> CharStringLazy)
-> (String -> ByteString) -> String -> CharStringLazy
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ByteString
BSL.pack

instance ListLike CharStringLazy Char where
    empty :: CharStringLazy
empty = ByteString -> CharStringLazy
CSL ByteString
BSL.empty
    singleton :: Char -> CharStringLazy
singleton = ByteString -> CharStringLazy
CSL (ByteString -> CharStringLazy)
-> (Char -> ByteString) -> Char -> CharStringLazy
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ByteString
BSL.singleton
    cons :: Char -> CharStringLazy -> CharStringLazy
cons Char
x CharStringLazy
l = ByteString -> CharStringLazy
CSL (Char -> ByteString -> ByteString
BSL.cons Char
x (CharStringLazy -> ByteString
unCSL CharStringLazy
l))
    snoc :: CharStringLazy -> Char -> CharStringLazy
snoc CharStringLazy
l Char
x = ByteString -> CharStringLazy
CSL (ByteString -> Char -> ByteString
BSL.snoc (CharStringLazy -> ByteString
unCSL CharStringLazy
l) Char
x)
    append :: CharStringLazy -> CharStringLazy -> CharStringLazy
append CharStringLazy
l CharStringLazy
r = ByteString -> CharStringLazy
CSL (ByteString -> CharStringLazy) -> ByteString -> CharStringLazy
forall a b. (a -> b) -> a -> b
$ ByteString -> ByteString -> ByteString
BSL.append (CharStringLazy -> ByteString
unCSL CharStringLazy
l) (CharStringLazy -> ByteString
unCSL CharStringLazy
r)
    head :: CharStringLazy -> Char
head = ByteString -> Char
BSL.head (ByteString -> Char)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    last :: CharStringLazy -> Char
last = ByteString -> Char
BSL.last (ByteString -> Char)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    tail :: CharStringLazy -> CharStringLazy
tail = ByteString -> CharStringLazy
CSL (ByteString -> CharStringLazy)
-> (CharStringLazy -> ByteString)
-> CharStringLazy
-> CharStringLazy
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HasCallStack => ByteString -> ByteString
ByteString -> ByteString
BSL.tail (ByteString -> ByteString)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    init :: CharStringLazy -> CharStringLazy
init = ByteString -> CharStringLazy
CSL (ByteString -> CharStringLazy)
-> (CharStringLazy -> ByteString)
-> CharStringLazy
-> CharStringLazy
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HasCallStack => ByteString -> ByteString
ByteString -> ByteString
BSL.init (ByteString -> ByteString)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    null :: CharStringLazy -> Bool
null = ByteString -> Bool
BSL.null (ByteString -> Bool)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    length :: CharStringLazy -> Int
length = Int64 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int64 -> Int)
-> (CharStringLazy -> Int64) -> CharStringLazy -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Int64
BSL.length (ByteString -> Int64)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> Int64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    -- map = BSL.map
    rigidMap :: (Char -> Char) -> CharStringLazy -> CharStringLazy
rigidMap Char -> Char
f = ByteString -> CharStringLazy
CSL (ByteString -> CharStringLazy)
-> (CharStringLazy -> ByteString)
-> CharStringLazy
-> CharStringLazy
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Char) -> ByteString -> ByteString
BSL.map Char -> Char
f (ByteString -> ByteString)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    reverse :: CharStringLazy -> CharStringLazy
reverse = ByteString -> CharStringLazy
CSL (ByteString -> CharStringLazy)
-> (CharStringLazy -> ByteString)
-> CharStringLazy
-> CharStringLazy
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
BSL.reverse (ByteString -> ByteString)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    --intersperse = BSL.intersperse
    concat :: forall full'.
ListLike full' CharStringLazy =>
full' -> CharStringLazy
concat = ByteString -> CharStringLazy
CSL (ByteString -> CharStringLazy)
-> (full' -> ByteString) -> full' -> CharStringLazy
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [ByteString] -> ByteString
BSL.concat ([ByteString] -> ByteString)
-> (full' -> [ByteString]) -> full' -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CharStringLazy -> ByteString) -> [CharStringLazy] -> [ByteString]
forall full' item'.
ListLike full' item' =>
(CharStringLazy -> item') -> [CharStringLazy] -> full'
forall full item full' item'.
(ListLike full item, ListLike full' item') =>
(item -> item') -> full -> full'
map CharStringLazy -> ByteString
unCSL ([CharStringLazy] -> [ByteString])
-> (full' -> [CharStringLazy]) -> full' -> [ByteString]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. full' -> [Item full']
full' -> [CharStringLazy]
forall l. IsList l => l -> [Item l]
toList
    --concatMap = BSL.concatMap
    rigidConcatMap :: (Char -> CharStringLazy) -> CharStringLazy -> CharStringLazy
rigidConcatMap Char -> CharStringLazy
f = ByteString -> CharStringLazy
CSL (ByteString -> CharStringLazy)
-> (CharStringLazy -> ByteString)
-> CharStringLazy
-> CharStringLazy
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> ByteString) -> ByteString -> ByteString
BSL.concatMap (CharStringLazy -> ByteString
unCSL (CharStringLazy -> ByteString)
-> (Char -> CharStringLazy) -> Char -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> CharStringLazy
f) (ByteString -> ByteString)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    any :: (Char -> Bool) -> CharStringLazy -> Bool
any Char -> Bool
p = (Char -> Bool) -> ByteString -> Bool
BSL.any Char -> Bool
p (ByteString -> Bool)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    all :: (Char -> Bool) -> CharStringLazy -> Bool
all Char -> Bool
p = (Char -> Bool) -> ByteString -> Bool
BSL.all Char -> Bool
p (ByteString -> Bool)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    maximum :: Ord Char => CharStringLazy -> Char
maximum = ByteString -> Char
BSL.maximum (ByteString -> Char)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    minimum :: Ord Char => CharStringLazy -> Char
minimum = ByteString -> Char
BSL.minimum (ByteString -> Char)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    replicate :: Int -> Char -> CharStringLazy
replicate Int
i = ByteString -> CharStringLazy
CSL (ByteString -> CharStringLazy)
-> (Char -> ByteString) -> Char -> CharStringLazy
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> Char -> ByteString
BSL.replicate (Int -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i)
    take :: Int -> CharStringLazy -> CharStringLazy
take Int
i = ByteString -> CharStringLazy
CSL (ByteString -> CharStringLazy)
-> (CharStringLazy -> ByteString)
-> CharStringLazy
-> CharStringLazy
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> ByteString -> ByteString
BSL.take (Int -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i) (ByteString -> ByteString)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    drop :: Int -> CharStringLazy -> CharStringLazy
drop Int
i = ByteString -> CharStringLazy
CSL (ByteString -> CharStringLazy)
-> (CharStringLazy -> ByteString)
-> CharStringLazy
-> CharStringLazy
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> ByteString -> ByteString
BSL.drop (Int -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i) (ByteString -> ByteString)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    splitAt :: Int -> CharStringLazy -> (CharStringLazy, CharStringLazy)
splitAt Int
i = (ByteString -> CharStringLazy
CSL (ByteString -> CharStringLazy)
-> (ByteString -> CharStringLazy)
-> (ByteString, ByteString)
-> (CharStringLazy, CharStringLazy)
forall b c b' c'. (b -> c) -> (b' -> c') -> (b, b') -> (c, c')
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** ByteString -> CharStringLazy
CSL) ((ByteString, ByteString) -> (CharStringLazy, CharStringLazy))
-> (CharStringLazy -> (ByteString, ByteString))
-> CharStringLazy
-> (CharStringLazy, CharStringLazy)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> ByteString -> (ByteString, ByteString)
BSL.splitAt (Int -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i) (ByteString -> (ByteString, ByteString))
-> (CharStringLazy -> ByteString)
-> CharStringLazy
-> (ByteString, ByteString)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    takeWhile :: (Char -> Bool) -> CharStringLazy -> CharStringLazy
takeWhile Char -> Bool
p = ByteString -> CharStringLazy
CSL (ByteString -> CharStringLazy)
-> (CharStringLazy -> ByteString)
-> CharStringLazy
-> CharStringLazy
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> ByteString -> ByteString
BSL.takeWhile Char -> Bool
p (ByteString -> ByteString)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    dropWhile :: (Char -> Bool) -> CharStringLazy -> CharStringLazy
dropWhile Char -> Bool
p = ByteString -> CharStringLazy
CSL (ByteString -> CharStringLazy)
-> (CharStringLazy -> ByteString)
-> CharStringLazy
-> CharStringLazy
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> ByteString -> ByteString
BSL.dropWhile Char -> Bool
p (ByteString -> ByteString)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    span :: (Char -> Bool)
-> CharStringLazy -> (CharStringLazy, CharStringLazy)
span Char -> Bool
p  = (ByteString -> CharStringLazy
CSL (ByteString -> CharStringLazy)
-> (ByteString -> CharStringLazy)
-> (ByteString, ByteString)
-> (CharStringLazy, CharStringLazy)
forall b c b' c'. (b -> c) -> (b' -> c') -> (b, b') -> (c, c')
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** ByteString -> CharStringLazy
CSL) ((ByteString, ByteString) -> (CharStringLazy, CharStringLazy))
-> (CharStringLazy -> (ByteString, ByteString))
-> CharStringLazy
-> (CharStringLazy, CharStringLazy)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> ByteString -> (ByteString, ByteString)
BSL.span Char -> Bool
p (ByteString -> (ByteString, ByteString))
-> (CharStringLazy -> ByteString)
-> CharStringLazy
-> (ByteString, ByteString)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    break :: (Char -> Bool)
-> CharStringLazy -> (CharStringLazy, CharStringLazy)
break Char -> Bool
p = (ByteString -> CharStringLazy
CSL (ByteString -> CharStringLazy)
-> (ByteString -> CharStringLazy)
-> (ByteString, ByteString)
-> (CharStringLazy, CharStringLazy)
forall b c b' c'. (b -> c) -> (b' -> c') -> (b, b') -> (c, c')
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** ByteString -> CharStringLazy
CSL) ((ByteString, ByteString) -> (CharStringLazy, CharStringLazy))
-> (CharStringLazy -> (ByteString, ByteString))
-> CharStringLazy
-> (CharStringLazy, CharStringLazy)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> ByteString -> (ByteString, ByteString)
BSL.break Char -> Bool
p (ByteString -> (ByteString, ByteString))
-> (CharStringLazy -> ByteString)
-> CharStringLazy
-> (ByteString, ByteString)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    group :: forall full'.
(ListLike full' CharStringLazy, Eq Char) =>
CharStringLazy -> full'
group = [Item full'] -> full'
[CharStringLazy] -> full'
forall l. IsList l => [Item l] -> l
fromList ([CharStringLazy] -> full')
-> (CharStringLazy -> [CharStringLazy]) -> CharStringLazy -> full'
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ByteString -> CharStringLazy) -> [ByteString] -> [CharStringLazy]
forall full' item'.
ListLike full' item' =>
(ByteString -> item') -> [ByteString] -> full'
forall full item full' item'.
(ListLike full item, ListLike full' item') =>
(item -> item') -> full -> full'
map ByteString -> CharStringLazy
CSL ([ByteString] -> [CharStringLazy])
-> (CharStringLazy -> [ByteString])
-> CharStringLazy
-> [CharStringLazy]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [ByteString]
BSL.group (ByteString -> [ByteString])
-> (CharStringLazy -> ByteString) -> CharStringLazy -> [ByteString]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    inits :: forall full'.
ListLike full' CharStringLazy =>
CharStringLazy -> full'
inits = [Item full'] -> full'
[CharStringLazy] -> full'
forall l. IsList l => [Item l] -> l
fromList ([CharStringLazy] -> full')
-> (CharStringLazy -> [CharStringLazy]) -> CharStringLazy -> full'
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ByteString -> CharStringLazy) -> [ByteString] -> [CharStringLazy]
forall full' item'.
ListLike full' item' =>
(ByteString -> item') -> [ByteString] -> full'
forall full item full' item'.
(ListLike full item, ListLike full' item') =>
(item -> item') -> full -> full'
map ByteString -> CharStringLazy
CSL ([ByteString] -> [CharStringLazy])
-> (CharStringLazy -> [ByteString])
-> CharStringLazy
-> [CharStringLazy]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [ByteString]
BSL.inits (ByteString -> [ByteString])
-> (CharStringLazy -> ByteString) -> CharStringLazy -> [ByteString]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    tails :: forall full'.
ListLike full' CharStringLazy =>
CharStringLazy -> full'
tails = [Item full'] -> full'
[CharStringLazy] -> full'
forall l. IsList l => [Item l] -> l
fromList ([CharStringLazy] -> full')
-> (CharStringLazy -> [CharStringLazy]) -> CharStringLazy -> full'
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ByteString -> CharStringLazy) -> [ByteString] -> [CharStringLazy]
forall full' item'.
ListLike full' item' =>
(ByteString -> item') -> [ByteString] -> full'
forall full item full' item'.
(ListLike full item, ListLike full' item') =>
(item -> item') -> full -> full'
map ByteString -> CharStringLazy
CSL ([ByteString] -> [CharStringLazy])
-> (CharStringLazy -> [ByteString])
-> CharStringLazy
-> [CharStringLazy]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [ByteString]
BSL.tails (ByteString -> [ByteString])
-> (CharStringLazy -> ByteString) -> CharStringLazy -> [ByteString]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    isPrefixOf :: Eq Char => CharStringLazy -> CharStringLazy -> Bool
isPrefixOf CharStringLazy
p CharStringLazy
f = ByteString -> ByteString -> Bool
BSL.isPrefixOf (CharStringLazy -> ByteString
unCSL CharStringLazy
p) (CharStringLazy -> ByteString
unCSL CharStringLazy
f)
    --isSuffixOf = BSL.isSuffixOf
    --isInfixOf = BSL.isInfixOf
    elem :: Eq Char => Char -> CharStringLazy -> Bool
elem Char
x = Char -> ByteString -> Bool
BSL.elem Char
x (ByteString -> Bool)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    notElem :: Eq Char => Char -> CharStringLazy -> Bool
notElem Char
x = Char -> ByteString -> Bool
BSL.notElem Char
x (ByteString -> Bool)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    find :: (Char -> Bool) -> CharStringLazy -> Maybe Char
find Char -> Bool
p = (Char -> Bool) -> ByteString -> Maybe Char
BSL.find Char -> Bool
p (ByteString -> Maybe Char)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> Maybe Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    filter :: (Char -> Bool) -> CharStringLazy -> CharStringLazy
filter Char -> Bool
p = ByteString -> CharStringLazy
CSL (ByteString -> CharStringLazy)
-> (CharStringLazy -> ByteString)
-> CharStringLazy
-> CharStringLazy
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> ByteString -> ByteString
BSL.filter Char -> Bool
p (ByteString -> ByteString)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    --partition = BSL.partition
    index :: CharStringLazy -> Int -> Char
index CharStringLazy
l Int
i = ByteString -> Int64 -> Char
BSL.index (CharStringLazy -> ByteString
unCSL CharStringLazy
l) (Int -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i)
    elemIndex :: Eq Char => Char -> CharStringLazy -> Maybe Int
elemIndex Char
i = Maybe Int64 -> Maybe Int
mi64toi (Maybe Int64 -> Maybe Int)
-> (CharStringLazy -> Maybe Int64) -> CharStringLazy -> Maybe Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ByteString -> Maybe Int64
BSL.elemIndex Char
i  (ByteString -> Maybe Int64)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> Maybe Int64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    --elemIndices x = fromList . L.map fromIntegral . BSL.elemIndices x
    findIndex :: (Char -> Bool) -> CharStringLazy -> Maybe Int
findIndex Char -> Bool
f = Maybe Int64 -> Maybe Int
mi64toi (Maybe Int64 -> Maybe Int)
-> (CharStringLazy -> Maybe Int64) -> CharStringLazy -> Maybe Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> ByteString -> Maybe Int64
BSL.findIndex Char -> Bool
f (ByteString -> Maybe Int64)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> Maybe Int64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    --findIndices x = fromList . L.map fromIntegral . BSL.findIndices x
    --sequence = BSL.sequence
    --mapM = BSL.mapM
    --mapM_ = BSL.mapM_
    --nub = BSL.nub
    --delete = BSL.delete
    --deleteFirsts = BSL.deleteFirsts
    --union = BSL.union
    --intersect = BSL.intersect
    --sort = BSL.sort
    --insert = BSL.insert
    --toList = BSL.unpack . unCSL
    --fromList = CSL . BSL.pack
    --fromListLike = fromList . toList
    --nubBy = BSL.nubBy
    --deleteBy = BSL.deleteBy
    --deleteFirstsBy = BSL.deleteFirstsBy
    --unionBy = BSL.unionBy
    --intersectBy = BSL.intersectBy
    -- BSL.groupBy is broken. groupBy f = fromList . BSL.groupBy f
    -- the below works on ghc but generates a type error on hugs
    -- groupBy func = map fromList . L.groupBy func . toList
    --sortBy = BSL.sortBy
    --insertBy = BSL.insertBy
    genericLength :: forall a. Num a => CharStringLazy -> a
genericLength = Integer -> a
forall a. Num a => Integer -> a
fromInteger (Integer -> a)
-> (CharStringLazy -> Integer) -> CharStringLazy -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int64 -> Integer)
-> (CharStringLazy -> Int64) -> CharStringLazy -> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Int64
BSL.length (ByteString -> Int64)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> Int64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    genericTake :: forall b. Integral b => b -> CharStringLazy -> CharStringLazy
genericTake a
i = ByteString -> CharStringLazy
CSL (ByteString -> CharStringLazy)
-> (CharStringLazy -> ByteString)
-> CharStringLazy
-> CharStringLazy
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> ByteString -> ByteString
BSL.take (a -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
i) (ByteString -> ByteString)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    genericDrop :: forall b. Integral b => b -> CharStringLazy -> CharStringLazy
genericDrop a
i = ByteString -> CharStringLazy
CSL (ByteString -> CharStringLazy)
-> (CharStringLazy -> ByteString)
-> CharStringLazy
-> CharStringLazy
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> ByteString -> ByteString
BSL.drop (a -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
i) (ByteString -> ByteString)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    genericSplitAt :: forall a.
Integral a =>
a -> CharStringLazy -> (CharStringLazy, CharStringLazy)
genericSplitAt a
i = (ByteString -> CharStringLazy
CSL (ByteString -> CharStringLazy)
-> (ByteString -> CharStringLazy)
-> (ByteString, ByteString)
-> (CharStringLazy, CharStringLazy)
forall b c b' c'. (b -> c) -> (b' -> c') -> (b, b') -> (c, c')
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** ByteString -> CharStringLazy
CSL) ((ByteString, ByteString) -> (CharStringLazy, CharStringLazy))
-> (CharStringLazy -> (ByteString, ByteString))
-> CharStringLazy
-> (CharStringLazy, CharStringLazy)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> ByteString -> (ByteString, ByteString)
BSL.splitAt (a -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
i) (ByteString -> (ByteString, ByteString))
-> (CharStringLazy -> ByteString)
-> CharStringLazy
-> (ByteString, ByteString)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    genericReplicate :: forall a. Integral a => a -> Char -> CharStringLazy
genericReplicate a
i = ByteString -> CharStringLazy
CSL (ByteString -> CharStringLazy)
-> (Char -> ByteString) -> Char -> CharStringLazy
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> Char -> ByteString
BSL.replicate (a -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
i)

strict2lazy :: BS.ByteString -> CharStringLazy
strict2lazy :: ByteString -> CharStringLazy
strict2lazy ByteString
b = ByteString -> CharStringLazy
CSL (ByteString -> CharStringLazy) -> ByteString -> CharStringLazy
forall a b. (a -> b) -> a -> b
$ [ByteString] -> ByteString
BSL.fromChunks [ByteString
b]

instance ListLikeIO CharStringLazy Char where
    hGetLine :: Handle -> IO CharStringLazy
hGetLine Handle
h = (ByteString -> CharStringLazy)
-> IO ByteString -> IO CharStringLazy
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> CharStringLazy
strict2lazy (IO ByteString -> IO CharStringLazy)
-> IO ByteString -> IO CharStringLazy
forall a b. (a -> b) -> a -> b
$ Handle -> IO ByteString
BS.hGetLine Handle
h
    hGetContents :: Handle -> IO CharStringLazy
hGetContents = (ByteString -> CharStringLazy)
-> IO ByteString -> IO CharStringLazy
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> CharStringLazy
CSL (IO ByteString -> IO CharStringLazy)
-> (Handle -> IO ByteString) -> Handle -> IO CharStringLazy
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> IO ByteString
BSL.hGetContents
    hGet :: Handle -> Int -> IO CharStringLazy
hGet Handle
h Int
n = (ByteString -> CharStringLazy)
-> IO ByteString -> IO CharStringLazy
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> CharStringLazy
CSL (IO ByteString -> IO CharStringLazy)
-> IO ByteString -> IO CharStringLazy
forall a b. (a -> b) -> a -> b
$ Handle -> Int -> IO ByteString
BSL.hGet Handle
h Int
n
    hGetNonBlocking :: Handle -> Int -> IO CharStringLazy
hGetNonBlocking Handle
h Int
n = (ByteString -> CharStringLazy)
-> IO ByteString -> IO CharStringLazy
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> CharStringLazy
CSL (IO ByteString -> IO CharStringLazy)
-> IO ByteString -> IO CharStringLazy
forall a b. (a -> b) -> a -> b
$ Handle -> Int -> IO ByteString
BSL.hGetNonBlocking Handle
h Int
n
    hPutStr :: Handle -> CharStringLazy -> IO ()
hPutStr Handle
h = Handle -> ByteString -> IO ()
BSL.hPut Handle
h (ByteString -> IO ())
-> (CharStringLazy -> ByteString) -> CharStringLazy -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    --hPutStrLn = BSL.hPutStrLn
    getLine :: IO CharStringLazy
getLine = (ByteString -> CharStringLazy)
-> IO ByteString -> IO CharStringLazy
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> CharStringLazy
strict2lazy IO ByteString
BS.getLine
    getContents :: IO CharStringLazy
getContents = (ByteString -> CharStringLazy)
-> IO ByteString -> IO CharStringLazy
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> CharStringLazy
CSL IO ByteString
BSL.getContents
    putStr :: CharStringLazy -> IO ()
putStr = ByteString -> IO ()
BSL.putStr (ByteString -> IO ())
-> (CharStringLazy -> ByteString) -> CharStringLazy -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    putStrLn :: CharStringLazy -> IO ()
putStrLn = ByteString -> IO ()
BSL.putStrLn (ByteString -> IO ())
-> (CharStringLazy -> ByteString) -> CharStringLazy -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    interact :: (CharStringLazy -> CharStringLazy) -> IO ()
interact CharStringLazy -> CharStringLazy
f = (ByteString -> ByteString) -> IO ()
BSL.interact (CharStringLazy -> ByteString
unCSL (CharStringLazy -> ByteString)
-> (ByteString -> CharStringLazy) -> ByteString -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> CharStringLazy
f (CharStringLazy -> CharStringLazy)
-> (ByteString -> CharStringLazy) -> ByteString -> CharStringLazy
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> CharStringLazy
CSL)
    readFile :: String -> IO CharStringLazy
readFile = (ByteString -> CharStringLazy)
-> IO ByteString -> IO CharStringLazy
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> CharStringLazy
CSL (IO ByteString -> IO CharStringLazy)
-> (String -> IO ByteString) -> String -> IO CharStringLazy
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> IO ByteString
BSL.readFile
    writeFile :: String -> CharStringLazy -> IO ()
writeFile String
fp = String -> ByteString -> IO ()
BSL.writeFile String
fp (ByteString -> IO ())
-> (CharStringLazy -> ByteString) -> CharStringLazy -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL
    appendFile :: String -> CharStringLazy -> IO ()
appendFile String
fp = String -> ByteString -> IO ()
BSL.appendFile String
fp (ByteString -> IO ())
-> (CharStringLazy -> ByteString) -> CharStringLazy -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL

instance IsString CharStringLazy where
    fromString :: String -> CharStringLazy
fromString = ByteString -> CharStringLazy
CSL (ByteString -> CharStringLazy)
-> (String -> ByteString) -> String -> CharStringLazy
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ByteString
BSL.pack

instance StringLike CharStringLazy where
    toString :: CharStringLazy -> String
toString = ByteString -> String
BSL.unpack (ByteString -> String)
-> (CharStringLazy -> ByteString) -> CharStringLazy -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CharStringLazy -> ByteString
unCSL