{-# LANGUAGE BangPatterns #-}
{-# OPTIONS_GHC -fno-warn-incomplete-patterns #-}
{-# OPTIONS_HADDOCK prune #-}
{-# LANGUAGE Trustworthy #-}
module Data.ByteString.Lazy (
ByteString,
LazyByteString,
empty,
singleton,
pack,
unpack,
fromStrict,
toStrict,
fromChunks,
toChunks,
foldrChunks,
foldlChunks,
cons,
cons',
snoc,
append,
head,
uncons,
unsnoc,
last,
tail,
init,
null,
length,
map,
reverse,
intersperse,
intercalate,
transpose,
foldl,
foldl',
foldl1,
foldl1',
foldr,
foldr',
foldr1,
foldr1',
concat,
concatMap,
any,
all,
maximum,
minimum,
compareLength,
scanl,
scanl1,
scanr,
scanr1,
mapAccumL,
mapAccumR,
repeat,
replicate,
cycle,
iterate,
unfoldr,
take,
takeEnd,
drop,
dropEnd,
splitAt,
takeWhile,
takeWhileEnd,
dropWhile,
dropWhileEnd,
span,
spanEnd,
break,
breakEnd,
group,
groupBy,
inits,
tails,
initsNE,
tailsNE,
stripPrefix,
stripSuffix,
split,
splitWith,
isPrefixOf,
isSuffixOf,
elem,
notElem,
find,
filter,
partition,
index,
indexMaybe,
(!?),
elemIndex,
elemIndexEnd,
elemIndices,
findIndex,
findIndexEnd,
findIndices,
count,
zip,
zipWith,
packZipWith,
unzip,
copy,
getContents,
putStr,
interact,
readFile,
writeFile,
appendFile,
hGetContents,
hGet,
hGetNonBlocking,
hPut,
hPutNonBlocking,
hPutStr,
) where
import Prelude hiding
(reverse,head,tail,last,init,null,length,map,lines,foldl,foldr,unlines
,concat,any,take,drop,splitAt,takeWhile,dropWhile,span,break,elem,filter,maximum
,minimum,all,concatMap,foldl1,foldr1,scanl, scanl1, scanr, scanr1
,repeat, cycle, interact, iterate,readFile,writeFile,appendFile,replicate
,getContents,getLine,putStr,putStrLn ,zip,zipWith,unzip,notElem)
import qualified Data.List as List
import qualified Data.List.NonEmpty as NE
import Data.List.NonEmpty (NonEmpty(..))
import qualified Data.Bifunctor as BF
import qualified Data.ByteString as P (ByteString)
import qualified Data.ByteString as S
import qualified Data.ByteString.Internal.Type as S
import qualified Data.ByteString.Unsafe as S
import qualified Data.ByteString.Lazy.Internal.Deque as D
import Data.ByteString.Lazy.Internal
import Control.Monad (mplus)
import Data.Word (Word8)
import Data.Int (Int64)
import GHC.Stack.Types (HasCallStack)
import System.IO (Handle,openBinaryFile,stdin,stdout,withBinaryFile,IOMode(..)
,hClose)
import System.IO.Error (mkIOError, illegalOperationErrorType)
import System.IO.Unsafe
import Foreign.Ptr
import Foreign.Storable
empty :: ByteString
empty :: ByteString
empty = ByteString
Empty
{-# INLINE empty #-}
singleton :: Word8 -> ByteString
singleton :: Word8 -> ByteString
singleton Word8
w = ByteString -> ByteString -> ByteString
Chunk (Word8 -> ByteString
S.singleton Word8
w) ByteString
Empty
{-# INLINE singleton #-}
pack :: [Word8] -> ByteString
pack :: [Word8] -> ByteString
pack = [Word8] -> ByteString
packBytes
unpack :: ByteString -> [Word8]
unpack :: ByteString -> [Word8]
unpack = ByteString -> [Word8]
unpackBytes
fromChunks :: [P.ByteString] -> ByteString
fromChunks :: [ByteString] -> ByteString
fromChunks = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
List.foldr ByteString -> ByteString -> ByteString
chunk ByteString
Empty
toChunks :: ByteString -> [P.ByteString]
toChunks :: ByteString -> [ByteString]
toChunks = forall a. (ByteString -> a -> a) -> a -> ByteString -> a
foldrChunks (:) []
null :: ByteString -> Bool
null :: ByteString -> Bool
null ByteString
Empty = Bool
True
null ByteString
_ = Bool
False
{-# INLINE null #-}
length :: ByteString -> Int64
length :: ByteString -> Int64
length = forall a. (a -> ByteString -> a) -> a -> ByteString -> a
foldlChunks (\Int64
n ByteString
c -> Int64
n forall a. Num a => a -> a -> a
+ forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
S.length ByteString
c)) Int64
0
{-# INLINE [1] length #-}
infixr 5 `cons`, `cons'`
infixl 5 `snoc`
cons :: Word8 -> ByteString -> ByteString
cons :: Word8 -> ByteString -> ByteString
cons Word8
c = ByteString -> ByteString -> ByteString
Chunk (Word8 -> ByteString
S.singleton Word8
c)
{-# INLINE cons #-}
cons' :: Word8 -> ByteString -> ByteString
cons' :: Word8 -> ByteString -> ByteString
cons' Word8
w (Chunk ByteString
c ByteString
cs) | ByteString -> Int
S.length ByteString
c forall a. Ord a => a -> a -> Bool
< Int
16 = ByteString -> ByteString -> ByteString
Chunk (Word8 -> ByteString -> ByteString
S.cons Word8
w ByteString
c) ByteString
cs
cons' Word8
w ByteString
cs = ByteString -> ByteString -> ByteString
Chunk (Word8 -> ByteString
S.singleton Word8
w) ByteString
cs
{-# INLINE cons' #-}
snoc :: ByteString -> Word8 -> ByteString
snoc :: ByteString -> Word8 -> ByteString
snoc ByteString
cs Word8
w = forall a. (ByteString -> a -> a) -> a -> ByteString -> a
foldrChunks ByteString -> ByteString -> ByteString
Chunk (Word8 -> ByteString
singleton Word8
w) ByteString
cs
{-# INLINE snoc #-}
head :: HasCallStack => ByteString -> Word8
head :: HasCallStack => ByteString -> Word8
head ByteString
Empty = forall a. HasCallStack => String -> a
errorEmptyList String
"head"
head (Chunk ByteString
c ByteString
_) = ByteString -> Word8
S.unsafeHead ByteString
c
{-# INLINE head #-}
uncons :: ByteString -> Maybe (Word8, ByteString)
uncons :: ByteString -> Maybe (Word8, ByteString)
uncons ByteString
Empty = forall a. Maybe a
Nothing
uncons (Chunk ByteString
c ByteString
cs) = case ByteString -> Int
S.length ByteString
c of
Int
1 -> forall a. a -> Maybe a
Just (ByteString -> Word8
S.unsafeHead ByteString
c, ByteString
cs)
Int
_ -> forall a. a -> Maybe a
Just (ByteString -> Word8
S.unsafeHead ByteString
c, ByteString -> ByteString -> ByteString
Chunk (ByteString -> ByteString
S.unsafeTail ByteString
c) ByteString
cs)
{-# INLINE uncons #-}
tail :: HasCallStack => ByteString -> ByteString
tail :: HasCallStack => ByteString -> ByteString
tail ByteString
Empty = forall a. HasCallStack => String -> a
errorEmptyList String
"tail"
tail (Chunk ByteString
c ByteString
cs)
| ByteString -> Int
S.length ByteString
c forall a. Eq a => a -> a -> Bool
== Int
1 = ByteString
cs
| Bool
otherwise = ByteString -> ByteString -> ByteString
Chunk (ByteString -> ByteString
S.unsafeTail ByteString
c) ByteString
cs
{-# INLINE tail #-}
last :: HasCallStack => ByteString -> Word8
last :: HasCallStack => ByteString -> Word8
last ByteString
Empty = forall a. HasCallStack => String -> a
errorEmptyList String
"last"
last (Chunk ByteString
c0 ByteString
cs0) = ByteString -> ByteString -> Word8
go ByteString
c0 ByteString
cs0
where go :: ByteString -> ByteString -> Word8
go ByteString
c ByteString
Empty = ByteString -> Word8
S.unsafeLast ByteString
c
go ByteString
_ (Chunk ByteString
c ByteString
cs) = ByteString -> ByteString -> Word8
go ByteString
c ByteString
cs
init :: HasCallStack => ByteString -> ByteString
init :: HasCallStack => ByteString -> ByteString
init ByteString
Empty = forall a. HasCallStack => String -> a
errorEmptyList String
"init"
init (Chunk ByteString
c0 ByteString
cs0) = ByteString -> ByteString -> ByteString
go ByteString
c0 ByteString
cs0
where go :: ByteString -> ByteString -> ByteString
go ByteString
c ByteString
Empty | ByteString -> Int
S.length ByteString
c forall a. Eq a => a -> a -> Bool
== Int
1 = ByteString
Empty
| Bool
otherwise = ByteString -> ByteString -> ByteString
Chunk (ByteString -> ByteString
S.unsafeInit ByteString
c) ByteString
Empty
go ByteString
c (Chunk ByteString
c' ByteString
cs) = ByteString -> ByteString -> ByteString
Chunk ByteString
c (ByteString -> ByteString -> ByteString
go ByteString
c' ByteString
cs)
unsnoc :: ByteString -> Maybe (ByteString, Word8)
unsnoc :: ByteString -> Maybe (ByteString, Word8)
unsnoc ByteString
Empty = forall a. Maybe a
Nothing
unsnoc (Chunk ByteString
c ByteString
cs) = forall a. a -> Maybe a
Just (HasCallStack => ByteString -> ByteString
init (ByteString -> ByteString -> ByteString
Chunk ByteString
c ByteString
cs), HasCallStack => ByteString -> Word8
last (ByteString -> ByteString -> ByteString
Chunk ByteString
c ByteString
cs))
append :: ByteString -> ByteString -> ByteString
append :: ByteString -> ByteString -> ByteString
append = forall a. Monoid a => a -> a -> a
mappend
{-# INLINE append #-}
map :: (Word8 -> Word8) -> ByteString -> ByteString
map :: (Word8 -> Word8) -> ByteString -> ByteString
map Word8 -> Word8
f = ByteString -> ByteString
go
where
go :: ByteString -> ByteString
go ByteString
Empty = ByteString
Empty
go (Chunk ByteString
x ByteString
xs) = ByteString -> ByteString -> ByteString
Chunk ByteString
y ByteString
ys
where
y :: ByteString
y = (Word8 -> Word8) -> ByteString -> ByteString
S.map Word8 -> Word8
f ByteString
x
ys :: ByteString
ys = ByteString -> ByteString
go ByteString
xs
{-# INLINE map #-}
reverse :: ByteString -> ByteString
reverse :: ByteString -> ByteString
reverse = ByteString -> ByteString -> ByteString
rev ByteString
Empty
where rev :: ByteString -> ByteString -> ByteString
rev ByteString
a ByteString
Empty = ByteString
a
rev ByteString
a (Chunk ByteString
c ByteString
cs) = ByteString -> ByteString -> ByteString
rev (ByteString -> ByteString -> ByteString
Chunk (ByteString -> ByteString
S.reverse ByteString
c) ByteString
a) ByteString
cs
{-# INLINE reverse #-}
intersperse :: Word8 -> ByteString -> ByteString
intersperse :: Word8 -> ByteString -> ByteString
intersperse Word8
_ ByteString
Empty = ByteString
Empty
intersperse Word8
w (Chunk ByteString
c ByteString
cs) = ByteString -> ByteString -> ByteString
Chunk (Word8 -> ByteString -> ByteString
S.intersperse Word8
w ByteString
c)
(forall a. (ByteString -> a -> a) -> a -> ByteString -> a
foldrChunks (ByteString -> ByteString -> ByteString
Chunk forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
intersperse') ByteString
Empty ByteString
cs)
where intersperse' :: P.ByteString -> P.ByteString
intersperse' :: ByteString -> ByteString
intersperse' (S.BS ForeignPtr Word8
fp Int
l) =
Int -> (ForeignPtr Word8 -> IO ()) -> ByteString
S.unsafeCreateFp (Int
2forall a. Num a => a -> a -> a
*Int
l) forall a b. (a -> b) -> a -> b
$ \ForeignPtr Word8
fp' ->
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
S.unsafeWithForeignPtr ForeignPtr Word8
fp' forall a b. (a -> b) -> a -> b
$ \Ptr Word8
p' ->
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
S.unsafeWithForeignPtr ForeignPtr Word8
fp forall a b. (a -> b) -> a -> b
$ \Ptr Word8
p -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr Word8
p' Word8
w
Ptr Word8 -> Ptr Word8 -> CSize -> Word8 -> IO ()
S.c_intersperse (Ptr Word8
p' forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
1) Ptr Word8
p (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
l) Word8
w
transpose :: [ByteString] -> [ByteString]
transpose :: [ByteString] -> [ByteString]
transpose [ByteString]
css = forall a b. (a -> b) -> [a] -> [b]
List.map (\[Word8]
ss -> ByteString -> ByteString -> ByteString
Chunk ([Word8] -> ByteString
S.pack [Word8]
ss) ByteString
Empty)
(forall a. [[a]] -> [[a]]
List.transpose (forall a b. (a -> b) -> [a] -> [b]
List.map ByteString -> [Word8]
unpack [ByteString]
css))
foldl :: (a -> Word8 -> a) -> a -> ByteString -> a
foldl :: forall a. (a -> Word8 -> a) -> a -> ByteString -> a
foldl a -> Word8 -> a
f = a -> ByteString -> a
go
where go :: a -> ByteString -> a
go a
a ByteString
Empty = a
a
go a
a (Chunk ByteString
c ByteString
cs) = a -> ByteString -> a
go (forall a. (a -> Word8 -> a) -> a -> ByteString -> a
S.foldl a -> Word8 -> a
f a
a ByteString
c) ByteString
cs
{-# INLINE foldl #-}
foldl' :: (a -> Word8 -> a) -> a -> ByteString -> a
foldl' :: forall a. (a -> Word8 -> a) -> a -> ByteString -> a
foldl' a -> Word8 -> a
f = a -> ByteString -> a
go
where go :: a -> ByteString -> a
go !a
a ByteString
Empty = a
a
go !a
a (Chunk ByteString
c ByteString
cs) = a -> ByteString -> a
go (forall a. (a -> Word8 -> a) -> a -> ByteString -> a
S.foldl' a -> Word8 -> a
f a
a ByteString
c) ByteString
cs
{-# INLINE foldl' #-}
foldr :: (Word8 -> a -> a) -> a -> ByteString -> a
foldr :: forall a. (Word8 -> a -> a) -> a -> ByteString -> a
foldr Word8 -> a -> a
k = forall a. (ByteString -> a -> a) -> a -> ByteString -> a
foldrChunks (forall a b c. (a -> b -> c) -> b -> a -> c
flip (forall a. (Word8 -> a -> a) -> a -> ByteString -> a
S.foldr Word8 -> a -> a
k))
{-# INLINE foldr #-}
foldr' :: (Word8 -> a -> a) -> a -> ByteString -> a
foldr' :: forall a. (Word8 -> a -> a) -> a -> ByteString -> a
foldr' Word8 -> a -> a
f a
a = ByteString -> a
go
where
go :: ByteString -> a
go ByteString
Empty = a
a
go (Chunk ByteString
c ByteString
cs) = forall a. (Word8 -> a -> a) -> a -> ByteString -> a
S.foldr' Word8 -> a -> a
f (forall a. (Word8 -> a -> a) -> a -> ByteString -> a
foldr' Word8 -> a -> a
f a
a ByteString
cs) ByteString
c
{-# INLINE foldr' #-}
foldl1 :: HasCallStack => (Word8 -> Word8 -> Word8) -> ByteString -> Word8
foldl1 :: HasCallStack => (Word8 -> Word8 -> Word8) -> ByteString -> Word8
foldl1 Word8 -> Word8 -> Word8
_ ByteString
Empty = forall a. HasCallStack => String -> a
errorEmptyList String
"foldl1"
foldl1 Word8 -> Word8 -> Word8
f (Chunk ByteString
c ByteString
cs) = forall a. (a -> Word8 -> a) -> a -> ByteString -> a
foldl Word8 -> Word8 -> Word8
f (ByteString -> Word8
S.unsafeHead ByteString
c) (ByteString -> ByteString -> ByteString
Chunk (ByteString -> ByteString
S.unsafeTail ByteString
c) ByteString
cs)
foldl1' :: HasCallStack => (Word8 -> Word8 -> Word8) -> ByteString -> Word8
foldl1' :: HasCallStack => (Word8 -> Word8 -> Word8) -> ByteString -> Word8
foldl1' Word8 -> Word8 -> Word8
_ ByteString
Empty = forall a. HasCallStack => String -> a
errorEmptyList String
"foldl1'"
foldl1' Word8 -> Word8 -> Word8
f (Chunk ByteString
c ByteString
cs) = forall a. (a -> Word8 -> a) -> a -> ByteString -> a
foldl' Word8 -> Word8 -> Word8
f (ByteString -> Word8
S.unsafeHead ByteString
c) (ByteString -> ByteString -> ByteString
Chunk (ByteString -> ByteString
S.unsafeTail ByteString
c) ByteString
cs)
foldr1 :: HasCallStack => (Word8 -> Word8 -> Word8) -> ByteString -> Word8
foldr1 :: HasCallStack => (Word8 -> Word8 -> Word8) -> ByteString -> Word8
foldr1 Word8 -> Word8 -> Word8
_ ByteString
Empty = forall a. HasCallStack => String -> a
errorEmptyList String
"foldr1"
foldr1 Word8 -> Word8 -> Word8
f (Chunk ByteString
c0 ByteString
cs0) = ByteString -> ByteString -> Word8
go ByteString
c0 ByteString
cs0
where go :: ByteString -> ByteString -> Word8
go ByteString
c ByteString
Empty = HasCallStack => (Word8 -> Word8 -> Word8) -> ByteString -> Word8
S.foldr1 Word8 -> Word8 -> Word8
f ByteString
c
go ByteString
c (Chunk ByteString
c' ByteString
cs) = forall a. (Word8 -> a -> a) -> a -> ByteString -> a
S.foldr Word8 -> Word8 -> Word8
f (ByteString -> ByteString -> Word8
go ByteString
c' ByteString
cs) ByteString
c
foldr1' :: HasCallStack => (Word8 -> Word8 -> Word8) -> ByteString -> Word8
foldr1' :: HasCallStack => (Word8 -> Word8 -> Word8) -> ByteString -> Word8
foldr1' Word8 -> Word8 -> Word8
_ ByteString
Empty = forall a. HasCallStack => String -> a
errorEmptyList String
"foldr1'"
foldr1' Word8 -> Word8 -> Word8
f (Chunk ByteString
c0 ByteString
cs0) = ByteString -> ByteString -> Word8
go ByteString
c0 ByteString
cs0
where go :: ByteString -> ByteString -> Word8
go ByteString
c ByteString
Empty = HasCallStack => (Word8 -> Word8 -> Word8) -> ByteString -> Word8
S.foldr1' Word8 -> Word8 -> Word8
f ByteString
c
go ByteString
c (Chunk ByteString
c' ByteString
cs) = forall a. (Word8 -> a -> a) -> a -> ByteString -> a
S.foldr' Word8 -> Word8 -> Word8
f (ByteString -> ByteString -> Word8
go ByteString
c' ByteString
cs) ByteString
c
concat :: [ByteString] -> ByteString
concat :: [ByteString] -> ByteString
concat = forall a. Monoid a => [a] -> a
mconcat
concatMap :: (Word8 -> ByteString) -> ByteString -> ByteString
concatMap :: (Word8 -> ByteString) -> ByteString -> ByteString
concatMap Word8 -> ByteString
_ ByteString
Empty = ByteString
Empty
concatMap Word8 -> ByteString
f (Chunk ByteString
c0 ByteString
cs0) = ByteString -> ByteString -> ByteString
to ByteString
c0 ByteString
cs0
where
go :: ByteString -> P.ByteString -> ByteString -> ByteString
go :: ByteString -> ByteString -> ByteString -> ByteString
go ByteString
Empty ByteString
c' ByteString
cs' = ByteString -> ByteString -> ByteString
to ByteString
c' ByteString
cs'
go (Chunk ByteString
c ByteString
cs) ByteString
c' ByteString
cs' = ByteString -> ByteString -> ByteString
Chunk ByteString
c (ByteString -> ByteString -> ByteString -> ByteString
go ByteString
cs ByteString
c' ByteString
cs')
to :: P.ByteString -> ByteString -> ByteString
to :: ByteString -> ByteString -> ByteString
to ByteString
c ByteString
cs | ByteString -> Bool
S.null ByteString
c = case ByteString
cs of
ByteString
Empty -> ByteString
Empty
(Chunk ByteString
c' ByteString
cs') -> ByteString -> ByteString -> ByteString
to ByteString
c' ByteString
cs'
| Bool
otherwise = ByteString -> ByteString -> ByteString -> ByteString
go (Word8 -> ByteString
f (ByteString -> Word8
S.unsafeHead ByteString
c)) (ByteString -> ByteString
S.unsafeTail ByteString
c) ByteString
cs
any :: (Word8 -> Bool) -> ByteString -> Bool
any :: (Word8 -> Bool) -> ByteString -> Bool
any Word8 -> Bool
f = forall a. (ByteString -> a -> a) -> a -> ByteString -> a
foldrChunks (\ByteString
c Bool
rest -> (Word8 -> Bool) -> ByteString -> Bool
S.any Word8 -> Bool
f ByteString
c Bool -> Bool -> Bool
|| Bool
rest) Bool
False
{-# INLINE any #-}
all :: (Word8 -> Bool) -> ByteString -> Bool
all :: (Word8 -> Bool) -> ByteString -> Bool
all Word8 -> Bool
f = forall a. (ByteString -> a -> a) -> a -> ByteString -> a
foldrChunks (\ByteString
c Bool
rest -> (Word8 -> Bool) -> ByteString -> Bool
S.all Word8 -> Bool
f ByteString
c Bool -> Bool -> Bool
&& Bool
rest) Bool
True
{-# INLINE all #-}
maximum :: HasCallStack => ByteString -> Word8
maximum :: HasCallStack => ByteString -> Word8
maximum ByteString
Empty = forall a. HasCallStack => String -> a
errorEmptyList String
"maximum"
maximum (Chunk ByteString
c ByteString
cs) = forall a. (a -> ByteString -> a) -> a -> ByteString -> a
foldlChunks (\Word8
n ByteString
c' -> Word8
n forall a. Ord a => a -> a -> a
`max` HasCallStack => ByteString -> Word8
S.maximum ByteString
c')
(HasCallStack => ByteString -> Word8
S.maximum ByteString
c) ByteString
cs
{-# INLINE maximum #-}
minimum :: HasCallStack => ByteString -> Word8
minimum :: HasCallStack => ByteString -> Word8
minimum ByteString
Empty = forall a. HasCallStack => String -> a
errorEmptyList String
"minimum"
minimum (Chunk ByteString
c ByteString
cs) = forall a. (a -> ByteString -> a) -> a -> ByteString -> a
foldlChunks (\Word8
n ByteString
c' -> Word8
n forall a. Ord a => a -> a -> a
`min` HasCallStack => ByteString -> Word8
S.minimum ByteString
c')
(HasCallStack => ByteString -> Word8
S.minimum ByteString
c) ByteString
cs
{-# INLINE minimum #-}
compareLength :: ByteString -> Int64 -> Ordering
compareLength :: ByteString -> Int64 -> Ordering
compareLength ByteString
_ Int64
toCmp | Int64
toCmp forall a. Ord a => a -> a -> Bool
< Int64
0 = Ordering
GT
compareLength ByteString
Empty Int64
toCmp = forall a. Ord a => a -> a -> Ordering
compare Int64
0 Int64
toCmp
compareLength (Chunk ByteString
c ByteString
cs) Int64
toCmp = ByteString -> Int64 -> Ordering
compareLength ByteString
cs (Int64
toCmp forall a. Num a => a -> a -> a
- forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
S.length ByteString
c))
{-# INLINE compareLength #-}
{-# RULES
"ByteString.Lazy length/compareN -> compareLength" [~1] forall t n.
compare (length t) n = compareLength t n
"ByteString.Lazy compareN/length -> compareLength" [~1] forall t n.
-- compare EQ LT = GT and vice versa
compare n (length t) = compare EQ $ compareLength t n
"ByteString.Lazy length/==N -> compareLength/==EQ" [~1] forall t n.
length t == n = compareLength t n == EQ
"ByteString.Lazy N==/length -> compareLength/==EQ" [~1] forall t n.
n == length t = compareLength t n == EQ
"ByteString.Lazy length//=N -> compareLength//=EQ" [~1] forall t n.
length t /= n = compareLength t n /= EQ
"ByteString.Lazy N/=/length -> compareLength//=EQ" [~1] forall t n.
n /= length t = compareLength t n /= EQ
"ByteString.Lazy length/<N -> compareLength/==LT" [~1] forall t n.
length t < n = compareLength t n == LT
"ByteString.Lazy >N/length -> compareLength/==LT" [~1] forall t n.
n > length t = compareLength t n == LT
"ByteString.Lazy length/<=N -> compareLength//=GT" [~1] forall t n.
length t <= n = compareLength t n /= GT
"ByteString.Lazy <=N/length -> compareLength//=GT" [~1] forall t n.
n >= length t = compareLength t n /= GT
"ByteString.Lazy length/>N -> compareLength/==GT" [~1] forall t n.
length t > n = compareLength t n == GT
"ByteString.Lazy <N/length -> compareLength/==GT" [~1] forall t n.
n < length t = compareLength t n == GT
"ByteString.Lazy length/>=N -> compareLength//=LT" [~1] forall t n.
length t >= n = compareLength t n /= LT
"ByteString.Lazy >=N/length -> compareLength//=LT" [~1] forall t n.
n <= length t = compareLength t n /= LT
#-}
mapAccumL :: (acc -> Word8 -> (acc, Word8)) -> acc -> ByteString -> (acc, ByteString)
mapAccumL :: forall acc.
(acc -> Word8 -> (acc, Word8))
-> acc -> ByteString -> (acc, ByteString)
mapAccumL acc -> Word8 -> (acc, Word8)
f = acc -> ByteString -> (acc, ByteString)
go
where
go :: acc -> ByteString -> (acc, ByteString)
go acc
s ByteString
Empty = (acc
s, ByteString
Empty)
go acc
s (Chunk ByteString
c ByteString
cs) = (acc
s'', ByteString -> ByteString -> ByteString
Chunk ByteString
c' ByteString
cs')
where (acc
s', ByteString
c') = forall acc.
(acc -> Word8 -> (acc, Word8))
-> acc -> ByteString -> (acc, ByteString)
S.mapAccumL acc -> Word8 -> (acc, Word8)
f acc
s ByteString
c
(acc
s'', ByteString
cs') = acc -> ByteString -> (acc, ByteString)
go acc
s' ByteString
cs
mapAccumR :: (acc -> Word8 -> (acc, Word8)) -> acc -> ByteString -> (acc, ByteString)
mapAccumR :: forall acc.
(acc -> Word8 -> (acc, Word8))
-> acc -> ByteString -> (acc, ByteString)
mapAccumR acc -> Word8 -> (acc, Word8)
f = acc -> ByteString -> (acc, ByteString)
go
where
go :: acc -> ByteString -> (acc, ByteString)
go acc
s ByteString
Empty = (acc
s, ByteString
Empty)
go acc
s (Chunk ByteString
c ByteString
cs) = (acc
s'', ByteString -> ByteString -> ByteString
Chunk ByteString
c' ByteString
cs')
where (acc
s'', ByteString
c') = forall acc.
(acc -> Word8 -> (acc, Word8))
-> acc -> ByteString -> (acc, ByteString)
S.mapAccumR acc -> Word8 -> (acc, Word8)
f acc
s' ByteString
c
(acc
s', ByteString
cs') = acc -> ByteString -> (acc, ByteString)
go acc
s ByteString
cs
scanl
:: (Word8 -> Word8 -> Word8)
-> Word8
-> ByteString
-> ByteString
scanl :: (Word8 -> Word8 -> Word8) -> Word8 -> ByteString -> ByteString
scanl Word8 -> Word8 -> Word8
function = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (forall a b c. (a -> b -> c) -> b -> a -> c
flip ByteString -> Word8 -> ByteString
snoc)) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall acc.
(acc -> Word8 -> (acc, Word8))
-> acc -> ByteString -> (acc, ByteString)
mapAccumL (\Word8
x Word8
y -> (Word8 -> Word8 -> Word8
function Word8
x Word8
y, Word8
x))
{-# INLINE scanl #-}
scanl1 :: (Word8 -> Word8 -> Word8) -> ByteString -> ByteString
scanl1 :: (Word8 -> Word8 -> Word8) -> ByteString -> ByteString
scanl1 Word8 -> Word8 -> Word8
function ByteString
byteStream = case ByteString -> Maybe (Word8, ByteString)
uncons ByteString
byteStream of
Maybe (Word8, ByteString)
Nothing -> ByteString
Empty
Just (Word8
firstByte, ByteString
remainingBytes) -> (Word8 -> Word8 -> Word8) -> Word8 -> ByteString -> ByteString
scanl Word8 -> Word8 -> Word8
function Word8
firstByte ByteString
remainingBytes
scanr
:: (Word8 -> Word8 -> Word8)
-> Word8
-> ByteString
-> ByteString
scanr :: (Word8 -> Word8 -> Word8) -> Word8 -> ByteString -> ByteString
scanr Word8 -> Word8 -> Word8
function = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Word8 -> ByteString -> ByteString
cons) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall acc.
(acc -> Word8 -> (acc, Word8))
-> acc -> ByteString -> (acc, ByteString)
mapAccumR (\Word8
x Word8
y -> (Word8 -> Word8 -> Word8
function Word8
y Word8
x, Word8
x))
scanr1 :: (Word8 -> Word8 -> Word8) -> ByteString -> ByteString
scanr1 :: (Word8 -> Word8 -> Word8) -> ByteString -> ByteString
scanr1 Word8 -> Word8 -> Word8
function ByteString
byteStream = case ByteString -> Maybe (ByteString, Word8)
unsnoc ByteString
byteStream of
Maybe (ByteString, Word8)
Nothing -> ByteString
Empty
Just (ByteString
initialBytes, Word8
lastByte) -> (Word8 -> Word8 -> Word8) -> Word8 -> ByteString -> ByteString
scanr Word8 -> Word8 -> Word8
function Word8
lastByte ByteString
initialBytes
iterate :: (Word8 -> Word8) -> Word8 -> ByteString
iterate :: (Word8 -> Word8) -> Word8 -> ByteString
iterate Word8 -> Word8
f = forall a. (a -> Maybe (Word8, a)) -> a -> ByteString
unfoldr (\Word8
x -> case Word8 -> Word8
f Word8
x of !Word8
x' -> forall a. a -> Maybe a
Just (Word8
x', Word8
x'))
repeat :: Word8 -> ByteString
repeat :: Word8 -> ByteString
repeat Word8
w = ByteString
cs where cs :: ByteString
cs = ByteString -> ByteString -> ByteString
Chunk (Int -> Word8 -> ByteString
S.replicate Int
smallChunkSize Word8
w) ByteString
cs
replicate :: Int64 -> Word8 -> ByteString
replicate :: Int64 -> Word8 -> ByteString
replicate Int64
n Word8
w
| Int64
n forall a. Ord a => a -> a -> Bool
<= Int64
0 = ByteString
Empty
| Int64
n forall a. Ord a => a -> a -> Bool
< forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
smallChunkSize = ByteString -> ByteString -> ByteString
Chunk (Int -> Word8 -> ByteString
S.replicate (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
n) Word8
w) ByteString
Empty
| Int64
r forall a. Eq a => a -> a -> Bool
== Int64
0 = ByteString
cs
| Bool
otherwise = ByteString -> ByteString -> ByteString
Chunk (Int -> ByteString -> ByteString
S.unsafeTake (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
r) ByteString
c) ByteString
cs
where
c :: ByteString
c = Int -> Word8 -> ByteString
S.replicate Int
smallChunkSize Word8
w
cs :: ByteString
cs = forall {t}. (Eq t, Num t) => t -> ByteString
nChunks Int64
q
(Int64
q, Int64
r) = forall a. Integral a => a -> a -> (a, a)
quotRem Int64
n (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
smallChunkSize)
nChunks :: t -> ByteString
nChunks t
0 = ByteString
Empty
nChunks t
m = ByteString -> ByteString -> ByteString
Chunk ByteString
c (t -> ByteString
nChunks (t
mforall a. Num a => a -> a -> a
-t
1))
cycle :: HasCallStack => ByteString -> ByteString
cycle :: HasCallStack => ByteString -> ByteString
cycle ByteString
Empty = forall a. HasCallStack => String -> a
errorEmptyList String
"cycle"
cycle ByteString
cs = ByteString
cs' where cs' :: ByteString
cs' = forall a. (ByteString -> a -> a) -> a -> ByteString -> a
foldrChunks ByteString -> ByteString -> ByteString
Chunk ByteString
cs' ByteString
cs
unfoldr :: (a -> Maybe (Word8, a)) -> a -> ByteString
unfoldr :: forall a. (a -> Maybe (Word8, a)) -> a -> ByteString
unfoldr a -> Maybe (Word8, a)
f = Int -> a -> ByteString
unfoldChunk Int
32
where unfoldChunk :: Int -> a -> ByteString
unfoldChunk Int
n a
x =
case forall a.
Int -> (a -> Maybe (Word8, a)) -> a -> (ByteString, Maybe a)
S.unfoldrN Int
n a -> Maybe (Word8, a)
f a
x of
(ByteString
c, Maybe a
Nothing)
| ByteString -> Bool
S.null ByteString
c -> ByteString
Empty
| Bool
otherwise -> ByteString -> ByteString -> ByteString
Chunk ByteString
c ByteString
Empty
(ByteString
c, Just a
x') -> ByteString -> ByteString -> ByteString
Chunk ByteString
c (Int -> a -> ByteString
unfoldChunk (Int
nforall a. Num a => a -> a -> a
*Int
2) a
x')
take :: Int64 -> ByteString -> ByteString
take :: Int64 -> ByteString -> ByteString
take Int64
i ByteString
_ | Int64
i forall a. Ord a => a -> a -> Bool
<= Int64
0 = ByteString
Empty
take Int64
i ByteString
cs0 = forall {t}. Integral t => t -> ByteString -> ByteString
take' Int64
i ByteString
cs0
where take' :: t -> ByteString -> ByteString
take' t
0 ByteString
_ = ByteString
Empty
take' t
_ ByteString
Empty = ByteString
Empty
take' t
n (Chunk ByteString
c ByteString
cs) =
if t
n forall a. Ord a => a -> a -> Bool
< forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
S.length ByteString
c)
then ByteString -> ByteString -> ByteString
Chunk (Int -> ByteString -> ByteString
S.take (forall a b. (Integral a, Num b) => a -> b
fromIntegral t
n) ByteString
c) ByteString
Empty
else ByteString -> ByteString -> ByteString
Chunk ByteString
c (t -> ByteString -> ByteString
take' (t
n forall a. Num a => a -> a -> a
- forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
S.length ByteString
c)) ByteString
cs)
takeEnd :: Int64 -> ByteString -> ByteString
takeEnd :: Int64 -> ByteString -> ByteString
takeEnd Int64
i ByteString
_ | Int64
i forall a. Ord a => a -> a -> Bool
<= Int64
0 = ByteString
Empty
takeEnd Int64
i ByteString
cs0 = forall {t}. Integral t => t -> ByteString -> ByteString
takeEnd' Int64
i ByteString
cs0
where takeEnd' :: a -> ByteString -> ByteString
takeEnd' a
0 ByteString
_ = ByteString
Empty
takeEnd' a
n ByteString
cs =
forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall a. (ByteString -> a -> a) -> a -> ByteString -> a
foldrChunks forall {a}.
Integral a =>
ByteString -> (a, ByteString) -> (a, ByteString)
takeTuple (a
n,ByteString
Empty) ByteString
cs
takeTuple :: ByteString -> (a, ByteString) -> (a, ByteString)
takeTuple ByteString
_ (a
0, ByteString
cs) = (a
0, ByteString
cs)
takeTuple ByteString
c (a
n, ByteString
cs)
| a
n forall a. Ord a => a -> a -> Bool
> forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
S.length ByteString
c) = (a
n forall a. Num a => a -> a -> a
- forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
S.length ByteString
c), ByteString -> ByteString -> ByteString
Chunk ByteString
c ByteString
cs)
| Bool
otherwise = (a
0, ByteString -> ByteString -> ByteString
Chunk (Int -> ByteString -> ByteString
S.takeEnd (forall a b. (Integral a, Num b) => a -> b
fromIntegral a
n) ByteString
c) ByteString
cs)
drop :: Int64 -> ByteString -> ByteString
drop :: Int64 -> ByteString -> ByteString
drop Int64
i ByteString
p | Int64
i forall a. Ord a => a -> a -> Bool
<= Int64
0 = ByteString
p
drop Int64
i ByteString
cs0 = forall {t}. Integral t => t -> ByteString -> ByteString
drop' Int64
i ByteString
cs0
where drop' :: t -> ByteString -> ByteString
drop' t
0 ByteString
cs = ByteString
cs
drop' t
_ ByteString
Empty = ByteString
Empty
drop' t
n (Chunk ByteString
c ByteString
cs) =
if t
n forall a. Ord a => a -> a -> Bool
< forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
S.length ByteString
c)
then ByteString -> ByteString -> ByteString
Chunk (Int -> ByteString -> ByteString
S.drop (forall a b. (Integral a, Num b) => a -> b
fromIntegral t
n) ByteString
c) ByteString
cs
else t -> ByteString -> ByteString
drop' (t
n forall a. Num a => a -> a -> a
- forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
S.length ByteString
c)) ByteString
cs
dropEnd :: Int64 -> ByteString -> ByteString
dropEnd :: Int64 -> ByteString -> ByteString
dropEnd Int64
i ByteString
p | Int64
i forall a. Ord a => a -> a -> Bool
<= Int64
0 = ByteString
p
dropEnd Int64
i ByteString
p = Deque -> ByteString -> ByteString
go Deque
D.empty ByteString
p
where go :: D.Deque -> ByteString -> ByteString
go :: Deque -> ByteString -> ByteString
go Deque
deque (Chunk ByteString
c ByteString
cs)
| Deque -> Int64
D.byteLength Deque
deque forall a. Ord a => a -> a -> Bool
< Int64
i = Deque -> ByteString -> ByteString
go (ByteString -> Deque -> Deque
D.snoc ByteString
c Deque
deque) ByteString
cs
| Bool
otherwise =
let (ByteString
output, Deque
deque') = ByteString -> Deque -> (ByteString, Deque)
getOutput ByteString
empty (ByteString -> Deque -> Deque
D.snoc ByteString
c Deque
deque)
in forall a. (ByteString -> a -> a) -> a -> ByteString -> a
foldrChunks ByteString -> ByteString -> ByteString
Chunk (Deque -> ByteString -> ByteString
go Deque
deque' ByteString
cs) ByteString
output
go Deque
deque ByteString
Empty = Deque -> ByteString
fromDeque forall a b. (a -> b) -> a -> b
$ Deque -> Int64 -> Deque
dropEndBytes Deque
deque Int64
i
len :: ByteString -> b
len ByteString
c = forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
S.length ByteString
c)
getOutput :: ByteString -> D.Deque -> (ByteString, D.Deque)
getOutput :: ByteString -> Deque -> (ByteString, Deque)
getOutput ByteString
out Deque
deque = case Deque -> Maybe (ByteString, Deque)
D.popFront Deque
deque of
Maybe (ByteString, Deque)
Nothing -> (ByteString -> ByteString
reverseChunks ByteString
out, Deque
deque)
Just (ByteString
x, Deque
deque') | Deque -> Int64
D.byteLength Deque
deque' forall a. Ord a => a -> a -> Bool
>= Int64
i ->
ByteString -> Deque -> (ByteString, Deque)
getOutput (ByteString -> ByteString -> ByteString
Chunk ByteString
x ByteString
out) Deque
deque'
Maybe (ByteString, Deque)
_ -> (ByteString -> ByteString
reverseChunks ByteString
out, Deque
deque)
reverseChunks :: ByteString -> ByteString
reverseChunks = forall a. (a -> ByteString -> a) -> a -> ByteString -> a
foldlChunks (forall a b c. (a -> b -> c) -> b -> a -> c
flip ByteString -> ByteString -> ByteString
Chunk) ByteString
empty
dropEndBytes :: D.Deque -> Int64 -> D.Deque
dropEndBytes :: Deque -> Int64 -> Deque
dropEndBytes Deque
deque Int64
n = case Deque -> Maybe (Deque, ByteString)
D.popRear Deque
deque of
Maybe (Deque, ByteString)
Nothing -> Deque
deque
Just (Deque
deque', ByteString
x) | forall {b}. Num b => ByteString -> b
len ByteString
x forall a. Ord a => a -> a -> Bool
<= Int64
n -> Deque -> Int64 -> Deque
dropEndBytes Deque
deque' (Int64
n forall a. Num a => a -> a -> a
- forall {b}. Num b => ByteString -> b
len ByteString
x)
| Bool
otherwise ->
ByteString -> Deque -> Deque
D.snoc (Int -> ByteString -> ByteString
S.dropEnd (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
n) ByteString
x) Deque
deque'
fromDeque :: D.Deque -> ByteString
fromDeque :: Deque -> ByteString
fromDeque Deque
deque =
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
List.foldr ByteString -> ByteString -> ByteString
chunk ByteString
Empty (Deque -> [ByteString]
D.front Deque
deque) ByteString -> ByteString -> ByteString
`append`
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl' (forall a b c. (a -> b -> c) -> b -> a -> c
flip ByteString -> ByteString -> ByteString
chunk) ByteString
Empty (Deque -> [ByteString]
D.rear Deque
deque)
splitAt :: Int64 -> ByteString -> (ByteString, ByteString)
splitAt :: Int64 -> ByteString -> (ByteString, ByteString)
splitAt Int64
i ByteString
cs0 | Int64
i forall a. Ord a => a -> a -> Bool
<= Int64
0 = (ByteString
Empty, ByteString
cs0)
splitAt Int64
i ByteString
cs0 = forall {a}.
Integral a =>
a -> ByteString -> (ByteString, ByteString)
splitAt' Int64
i ByteString
cs0
where splitAt' :: a -> ByteString -> (ByteString, ByteString)
splitAt' a
0 ByteString
cs = (ByteString
Empty, ByteString
cs)
splitAt' a
_ ByteString
Empty = (ByteString
Empty, ByteString
Empty)
splitAt' a
n (Chunk ByteString
c ByteString
cs) =
if a
n forall a. Ord a => a -> a -> Bool
< forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
S.length ByteString
c)
then (ByteString -> ByteString -> ByteString
Chunk (Int -> ByteString -> ByteString
S.take (forall a b. (Integral a, Num b) => a -> b
fromIntegral a
n) ByteString
c) ByteString
Empty
,ByteString -> ByteString -> ByteString
Chunk (Int -> ByteString -> ByteString
S.drop (forall a b. (Integral a, Num b) => a -> b
fromIntegral a
n) ByteString
c) ByteString
cs)
else let (ByteString
cs', ByteString
cs'') = a -> ByteString -> (ByteString, ByteString)
splitAt' (a
n forall a. Num a => a -> a -> a
- forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
S.length ByteString
c)) ByteString
cs
in (ByteString -> ByteString -> ByteString
Chunk ByteString
c ByteString
cs', ByteString
cs'')
takeWhile :: (Word8 -> Bool) -> ByteString -> ByteString
takeWhile :: (Word8 -> Bool) -> ByteString -> ByteString
takeWhile Word8 -> Bool
f = ByteString -> ByteString
takeWhile'
where takeWhile' :: ByteString -> ByteString
takeWhile' ByteString
Empty = ByteString
Empty
takeWhile' (Chunk ByteString
c ByteString
cs) =
case (Word8 -> Bool) -> ByteString -> Int
S.findIndexOrLength (Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Bool
f) ByteString
c of
Int
0 -> ByteString
Empty
Int
n | Int
n forall a. Ord a => a -> a -> Bool
< ByteString -> Int
S.length ByteString
c -> ByteString -> ByteString -> ByteString
Chunk (Int -> ByteString -> ByteString
S.take Int
n ByteString
c) ByteString
Empty
| Bool
otherwise -> ByteString -> ByteString -> ByteString
Chunk ByteString
c (ByteString -> ByteString
takeWhile' ByteString
cs)
takeWhileEnd :: (Word8 -> Bool) -> ByteString -> ByteString
takeWhileEnd :: (Word8 -> Bool) -> ByteString -> ByteString
takeWhileEnd Word8 -> Bool
f = ByteString -> ByteString
takeWhileEnd'
where takeWhileEnd' :: ByteString -> ByteString
takeWhileEnd' ByteString
Empty = ByteString
Empty
takeWhileEnd' ByteString
cs =
forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall a. (ByteString -> a -> a) -> a -> ByteString -> a
foldrChunks ByteString -> (Bool, ByteString) -> (Bool, ByteString)
takeTuple (Bool
True,ByteString
Empty) ByteString
cs
takeTuple :: ByteString -> (Bool, ByteString) -> (Bool, ByteString)
takeTuple ByteString
_ (Bool
False, ByteString
bs) = (Bool
False,ByteString
bs)
takeTuple ByteString
c (Bool
True,ByteString
bs) =
case (Word8 -> Bool) -> ByteString -> ByteString
S.takeWhileEnd Word8 -> Bool
f ByteString
c of
ByteString
c' | ByteString -> Int
S.length ByteString
c' forall a. Eq a => a -> a -> Bool
== ByteString -> Int
S.length ByteString
c -> (Bool
True, ByteString -> ByteString -> ByteString
Chunk ByteString
c ByteString
bs)
| Bool
otherwise -> (Bool
False, ByteString -> ByteString
fromStrict ByteString
c' ByteString -> ByteString -> ByteString
`append` ByteString
bs)
dropWhile :: (Word8 -> Bool) -> ByteString -> ByteString
dropWhile :: (Word8 -> Bool) -> ByteString -> ByteString
dropWhile Word8 -> Bool
f = ByteString -> ByteString
dropWhile'
where dropWhile' :: ByteString -> ByteString
dropWhile' ByteString
Empty = ByteString
Empty
dropWhile' (Chunk ByteString
c ByteString
cs) =
case (Word8 -> Bool) -> ByteString -> Int
S.findIndexOrLength (Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Bool
f) ByteString
c of
Int
n | Int
n forall a. Ord a => a -> a -> Bool
< ByteString -> Int
S.length ByteString
c -> ByteString -> ByteString -> ByteString
Chunk (Int -> ByteString -> ByteString
S.drop Int
n ByteString
c) ByteString
cs
| Bool
otherwise -> ByteString -> ByteString
dropWhile' ByteString
cs
dropWhileEnd :: (Word8 -> Bool) -> ByteString -> ByteString
dropWhileEnd :: (Word8 -> Bool) -> ByteString -> ByteString
dropWhileEnd Word8 -> Bool
f = [ByteString] -> ByteString -> ByteString
go []
where go :: [ByteString] -> ByteString -> ByteString
go [ByteString]
acc (Chunk ByteString
c ByteString
cs)
| Word8 -> Bool
f (HasCallStack => ByteString -> Word8
S.last ByteString
c) = [ByteString] -> ByteString -> ByteString
go (ByteString
c forall a. a -> [a] -> [a]
: [ByteString]
acc) ByteString
cs
| Bool
otherwise = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl (forall a b c. (a -> b -> c) -> b -> a -> c
flip ByteString -> ByteString -> ByteString
Chunk) ([ByteString] -> ByteString -> ByteString
go [] ByteString
cs) (ByteString
c forall a. a -> [a] -> [a]
: [ByteString]
acc)
go [ByteString]
acc ByteString
Empty = [ByteString] -> ByteString
dropEndBytes [ByteString]
acc
dropEndBytes :: [ByteString] -> ByteString
dropEndBytes [] = ByteString
Empty
dropEndBytes (ByteString
x : [ByteString]
xs) =
case (Word8 -> Bool) -> ByteString -> ByteString
S.dropWhileEnd Word8 -> Bool
f ByteString
x of
ByteString
x' | ByteString -> Bool
S.null ByteString
x' -> [ByteString] -> ByteString
dropEndBytes [ByteString]
xs
| Bool
otherwise -> forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl' (forall a b c. (a -> b -> c) -> b -> a -> c
flip ByteString -> ByteString -> ByteString
Chunk) ByteString
Empty (ByteString
x' forall a. a -> [a] -> [a]
: [ByteString]
xs)
break :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
break :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
break Word8 -> Bool
f = ByteString -> (ByteString, ByteString)
break'
where break' :: ByteString -> (ByteString, ByteString)
break' ByteString
Empty = (ByteString
Empty, ByteString
Empty)
break' (Chunk ByteString
c ByteString
cs) =
case (Word8 -> Bool) -> ByteString -> Int
S.findIndexOrLength Word8 -> Bool
f ByteString
c of
Int
0 -> (ByteString
Empty, ByteString -> ByteString -> ByteString
Chunk ByteString
c ByteString
cs)
Int
n | Int
n forall a. Ord a => a -> a -> Bool
< ByteString -> Int
S.length ByteString
c -> (ByteString -> ByteString -> ByteString
Chunk (Int -> ByteString -> ByteString
S.take Int
n ByteString
c) ByteString
Empty
,ByteString -> ByteString -> ByteString
Chunk (Int -> ByteString -> ByteString
S.drop Int
n ByteString
c) ByteString
cs)
| Bool
otherwise -> let (ByteString
cs', ByteString
cs'') = ByteString -> (ByteString, ByteString)
break' ByteString
cs
in (ByteString -> ByteString -> ByteString
Chunk ByteString
c ByteString
cs', ByteString
cs'')
breakEnd :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
breakEnd :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
breakEnd Word8 -> Bool
f = [ByteString] -> ByteString -> (ByteString, ByteString)
go []
where go :: [ByteString] -> ByteString -> (ByteString, ByteString)
go [ByteString]
acc (Chunk ByteString
c ByteString
cs)
| Word8 -> Bool
f (HasCallStack => ByteString -> Word8
S.last ByteString
c) = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl (forall a b c. (a -> b -> c) -> b -> a -> c
flip forall a b. (a -> b) -> a -> b
$ forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
BF.first forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString -> ByteString
Chunk) ([ByteString] -> ByteString -> (ByteString, ByteString)
go [] ByteString
cs) (ByteString
c forall a. a -> [a] -> [a]
: [ByteString]
acc)
| Bool
otherwise = [ByteString] -> ByteString -> (ByteString, ByteString)
go (ByteString
c forall a. a -> [a] -> [a]
: [ByteString]
acc) ByteString
cs
go [ByteString]
acc ByteString
Empty = [ByteString] -> (ByteString, ByteString)
dropEndBytes [ByteString]
acc
dropEndBytes :: [ByteString] -> (ByteString, ByteString)
dropEndBytes [] = (ByteString
Empty, ByteString
Empty)
dropEndBytes (ByteString
x : [ByteString]
xs) =
case (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
S.breakEnd Word8 -> Bool
f ByteString
x of
(ByteString
x', ByteString
x'') | ByteString -> Bool
S.null ByteString
x' -> let (ByteString
y, ByteString
y') = [ByteString] -> (ByteString, ByteString)
dropEndBytes [ByteString]
xs
in (ByteString
y, ByteString
y' ByteString -> ByteString -> ByteString
`append` ByteString -> ByteString
fromStrict ByteString
x)
| Bool
otherwise ->
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl' (forall a b c. (a -> b -> c) -> b -> a -> c
flip forall a b. (a -> b) -> a -> b
$ forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
BF.first forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString -> ByteString
Chunk) (ByteString -> ByteString
fromStrict ByteString
x', ByteString -> ByteString
fromStrict ByteString
x'') [ByteString]
xs
span :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
span :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
span Word8 -> Bool
p = (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
break (Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Bool
p)
spanEnd :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
spanEnd :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
spanEnd Word8 -> Bool
p = (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
breakEnd (Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Bool
p)
splitWith :: (Word8 -> Bool) -> ByteString -> [ByteString]
splitWith :: (Word8 -> Bool) -> ByteString -> [ByteString]
splitWith Word8 -> Bool
_ ByteString
Empty = []
splitWith Word8 -> Bool
p (Chunk ByteString
c0 ByteString
cs0) = [ByteString] -> [ByteString] -> ByteString -> [ByteString]
comb [] ((Word8 -> Bool) -> ByteString -> [ByteString]
S.splitWith Word8 -> Bool
p ByteString
c0) ByteString
cs0
where comb :: [P.ByteString] -> [P.ByteString] -> ByteString -> [ByteString]
comb :: [ByteString] -> [ByteString] -> ByteString -> [ByteString]
comb [ByteString]
acc [ByteString
s] ByteString
Empty = [[ByteString] -> ByteString
revChunks (ByteString
sforall a. a -> [a] -> [a]
:[ByteString]
acc)]
comb [ByteString]
acc [ByteString
s] (Chunk ByteString
c ByteString
cs) = [ByteString] -> [ByteString] -> ByteString -> [ByteString]
comb (ByteString
sforall a. a -> [a] -> [a]
:[ByteString]
acc) ((Word8 -> Bool) -> ByteString -> [ByteString]
S.splitWith Word8 -> Bool
p ByteString
c) ByteString
cs
comb [ByteString]
acc (ByteString
s:[ByteString]
ss) ByteString
cs = [ByteString] -> ByteString
revChunks (ByteString
sforall a. a -> [a] -> [a]
:[ByteString]
acc) forall a. a -> [a] -> [a]
: [ByteString] -> [ByteString] -> ByteString -> [ByteString]
comb [] [ByteString]
ss ByteString
cs
{-# INLINE splitWith #-}
split :: Word8 -> ByteString -> [ByteString]
split :: Word8 -> ByteString -> [ByteString]
split Word8
_ ByteString
Empty = []
split Word8
w (Chunk ByteString
c0 ByteString
cs0) = [ByteString] -> [ByteString] -> ByteString -> [ByteString]
comb [] (Word8 -> ByteString -> [ByteString]
S.split Word8
w ByteString
c0) ByteString
cs0
where comb :: [P.ByteString] -> [P.ByteString] -> ByteString -> [ByteString]
comb :: [ByteString] -> [ByteString] -> ByteString -> [ByteString]
comb [ByteString]
acc [ByteString
s] ByteString
Empty = [[ByteString] -> ByteString
revChunks (ByteString
sforall a. a -> [a] -> [a]
:[ByteString]
acc)]
comb [ByteString]
acc [ByteString
s] (Chunk ByteString
c ByteString
cs) = [ByteString] -> [ByteString] -> ByteString -> [ByteString]
comb (ByteString
sforall a. a -> [a] -> [a]
:[ByteString]
acc) (Word8 -> ByteString -> [ByteString]
S.split Word8
w ByteString
c) ByteString
cs
comb [ByteString]
acc (ByteString
s:[ByteString]
ss) ByteString
cs = [ByteString] -> ByteString
revChunks (ByteString
sforall a. a -> [a] -> [a]
:[ByteString]
acc) forall a. a -> [a] -> [a]
: [ByteString] -> [ByteString] -> ByteString -> [ByteString]
comb [] [ByteString]
ss ByteString
cs
{-# INLINE split #-}
group :: ByteString -> [ByteString]
group :: ByteString -> [ByteString]
group = ByteString -> [ByteString]
go
where
go :: ByteString -> [ByteString]
go ByteString
Empty = []
go (Chunk ByteString
c ByteString
cs)
| ByteString -> Int
S.length ByteString
c forall a. Eq a => a -> a -> Bool
== Int
1 = [ByteString] -> Word8 -> ByteString -> [ByteString]
to [ByteString
c] (ByteString -> Word8
S.unsafeHead ByteString
c) ByteString
cs
| Bool
otherwise = [ByteString] -> Word8 -> ByteString -> [ByteString]
to [Int -> ByteString -> ByteString
S.unsafeTake Int
1 ByteString
c] (ByteString -> Word8
S.unsafeHead ByteString
c) (ByteString -> ByteString -> ByteString
Chunk (ByteString -> ByteString
S.unsafeTail ByteString
c) ByteString
cs)
to :: [ByteString] -> Word8 -> ByteString -> [ByteString]
to [ByteString]
acc !Word8
_ ByteString
Empty = [[ByteString] -> ByteString
revNonEmptyChunks [ByteString]
acc]
to [ByteString]
acc !Word8
w (Chunk ByteString
c ByteString
cs) =
case (Word8 -> Bool) -> ByteString -> Int
S.findIndexOrLength (forall a. Eq a => a -> a -> Bool
/= Word8
w) ByteString
c of
Int
0 -> [ByteString] -> ByteString
revNonEmptyChunks [ByteString]
acc
forall a. a -> [a] -> [a]
: ByteString -> [ByteString]
go (ByteString -> ByteString -> ByteString
Chunk ByteString
c ByteString
cs)
Int
n | Int
n forall a. Eq a => a -> a -> Bool
== ByteString -> Int
S.length ByteString
c -> [ByteString] -> Word8 -> ByteString -> [ByteString]
to (Int -> ByteString -> ByteString
S.unsafeTake Int
n ByteString
c forall a. a -> [a] -> [a]
: [ByteString]
acc) Word8
w ByteString
cs
| Bool
otherwise -> [ByteString] -> ByteString
revNonEmptyChunks (Int -> ByteString -> ByteString
S.unsafeTake Int
n ByteString
c forall a. a -> [a] -> [a]
: [ByteString]
acc)
forall a. a -> [a] -> [a]
: ByteString -> [ByteString]
go (ByteString -> ByteString -> ByteString
Chunk (Int -> ByteString -> ByteString
S.unsafeDrop Int
n ByteString
c) ByteString
cs)
groupBy :: (Word8 -> Word8 -> Bool) -> ByteString -> [ByteString]
groupBy :: (Word8 -> Word8 -> Bool) -> ByteString -> [ByteString]
groupBy Word8 -> Word8 -> Bool
k = ByteString -> [ByteString]
go
where
go :: ByteString -> [ByteString]
go ByteString
Empty = []
go (Chunk ByteString
c ByteString
cs)
| ByteString -> Int
S.length ByteString
c forall a. Eq a => a -> a -> Bool
== Int
1 = [ByteString] -> Word8 -> ByteString -> [ByteString]
to [ByteString
c] (ByteString -> Word8
S.unsafeHead ByteString
c) ByteString
cs
| Bool
otherwise = [ByteString] -> Word8 -> ByteString -> [ByteString]
to [Int -> ByteString -> ByteString
S.unsafeTake Int
1 ByteString
c] (ByteString -> Word8
S.unsafeHead ByteString
c) (ByteString -> ByteString -> ByteString
Chunk (ByteString -> ByteString
S.unsafeTail ByteString
c) ByteString
cs)
to :: [ByteString] -> Word8 -> ByteString -> [ByteString]
to [ByteString]
acc !Word8
_ ByteString
Empty = [[ByteString] -> ByteString
revNonEmptyChunks [ByteString]
acc]
to [ByteString]
acc !Word8
w (Chunk ByteString
c ByteString
cs) =
case (Word8 -> Bool) -> ByteString -> Int
S.findIndexOrLength (Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Word8 -> Bool
k Word8
w) ByteString
c of
Int
0 -> [ByteString] -> ByteString
revNonEmptyChunks [ByteString]
acc
forall a. a -> [a] -> [a]
: ByteString -> [ByteString]
go (ByteString -> ByteString -> ByteString
Chunk ByteString
c ByteString
cs)
Int
n | Int
n forall a. Eq a => a -> a -> Bool
== ByteString -> Int
S.length ByteString
c -> [ByteString] -> Word8 -> ByteString -> [ByteString]
to (Int -> ByteString -> ByteString
S.unsafeTake Int
n ByteString
c forall a. a -> [a] -> [a]
: [ByteString]
acc) Word8
w ByteString
cs
| Bool
otherwise -> [ByteString] -> ByteString
revNonEmptyChunks (Int -> ByteString -> ByteString
S.unsafeTake Int
n ByteString
c forall a. a -> [a] -> [a]
: [ByteString]
acc)
forall a. a -> [a] -> [a]
: ByteString -> [ByteString]
go (ByteString -> ByteString -> ByteString
Chunk (Int -> ByteString -> ByteString
S.unsafeDrop Int
n ByteString
c) ByteString
cs)
intercalate :: ByteString -> [ByteString] -> ByteString
intercalate :: ByteString -> [ByteString] -> ByteString
intercalate ByteString
s = [ByteString] -> ByteString
concat forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> [a] -> [a]
List.intersperse ByteString
s
index :: HasCallStack => ByteString -> Int64 -> Word8
index :: HasCallStack => ByteString -> Int64 -> Word8
index ByteString
_ Int64
i | Int64
i forall a. Ord a => a -> a -> Bool
< Int64
0 = forall a. HasCallStack => String -> String -> a
moduleError String
"index" (String
"negative index: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int64
i)
index ByteString
cs0 Int64
i = forall {a}. (Show a, Integral a) => ByteString -> a -> Word8
index' ByteString
cs0 Int64
i
where index' :: ByteString -> a -> Word8
index' ByteString
Empty a
n = forall a. HasCallStack => String -> String -> a
moduleError String
"index" (String
"index too large: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show a
n)
index' (Chunk ByteString
c ByteString
cs) a
n
| a
n forall a. Ord a => a -> a -> Bool
>= forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
S.length ByteString
c) =
ByteString -> a -> Word8
index' ByteString
cs (a
n forall a. Num a => a -> a -> a
- forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
S.length ByteString
c))
| Bool
otherwise = ByteString -> Int -> Word8
S.unsafeIndex ByteString
c (forall a b. (Integral a, Num b) => a -> b
fromIntegral a
n)
indexMaybe :: ByteString -> Int64 -> Maybe Word8
indexMaybe :: ByteString -> Int64 -> Maybe Word8
indexMaybe ByteString
_ Int64
i | Int64
i forall a. Ord a => a -> a -> Bool
< Int64
0 = forall a. Maybe a
Nothing
indexMaybe ByteString
cs0 Int64
i = forall {a}. Integral a => ByteString -> a -> Maybe Word8
index' ByteString
cs0 Int64
i
where index' :: ByteString -> a -> Maybe Word8
index' ByteString
Empty a
_ = forall a. Maybe a
Nothing
index' (Chunk ByteString
c ByteString
cs) a
n
| a
n forall a. Ord a => a -> a -> Bool
>= forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
S.length ByteString
c) =
ByteString -> a -> Maybe Word8
index' ByteString
cs (a
n forall a. Num a => a -> a -> a
- forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
S.length ByteString
c))
| Bool
otherwise = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$! ByteString -> Int -> Word8
S.unsafeIndex ByteString
c (forall a b. (Integral a, Num b) => a -> b
fromIntegral a
n)
(!?) :: ByteString -> Int64 -> Maybe Word8
!? :: ByteString -> Int64 -> Maybe Word8
(!?) = ByteString -> Int64 -> Maybe Word8
indexMaybe
{-# INLINE (!?) #-}
elemIndex :: Word8 -> ByteString -> Maybe Int64
elemIndex :: Word8 -> ByteString -> Maybe Int64
elemIndex Word8
w = forall {a}. Num a => a -> ByteString -> Maybe a
elemIndex' Int64
0
where elemIndex' :: a -> ByteString -> Maybe a
elemIndex' a
_ ByteString
Empty = forall a. Maybe a
Nothing
elemIndex' a
n (Chunk ByteString
c ByteString
cs) =
case Word8 -> ByteString -> Maybe Int
S.elemIndex Word8
w ByteString
c of
Maybe Int
Nothing -> a -> ByteString -> Maybe a
elemIndex' (a
n forall a. Num a => a -> a -> a
+ forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
S.length ByteString
c)) ByteString
cs
Just Int
i -> forall a. a -> Maybe a
Just (a
n forall a. Num a => a -> a -> a
+ forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i)
elemIndexEnd :: Word8 -> ByteString -> Maybe Int64
elemIndexEnd :: Word8 -> ByteString -> Maybe Int64
elemIndexEnd = (Word8 -> Bool) -> ByteString -> Maybe Int64
findIndexEnd forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Eq a => a -> a -> Bool
(==)
{-# INLINE elemIndexEnd #-}
elemIndices :: Word8 -> ByteString -> [Int64]
elemIndices :: Word8 -> ByteString -> [Int64]
elemIndices Word8
w = forall {t}. Num t => t -> ByteString -> [t]
elemIndices' Int64
0
where elemIndices' :: t -> ByteString -> [t]
elemIndices' t
_ ByteString
Empty = []
elemIndices' t
n (Chunk ByteString
c ByteString
cs) = forall a b. (a -> b) -> [a] -> [b]
List.map ((forall a. Num a => a -> a -> a
+t
n)forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall a b. (Integral a, Num b) => a -> b
fromIntegral) (Word8 -> ByteString -> [Int]
S.elemIndices Word8
w ByteString
c)
forall a. [a] -> [a] -> [a]
++ t -> ByteString -> [t]
elemIndices' (t
n forall a. Num a => a -> a -> a
+ forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
S.length ByteString
c)) ByteString
cs
count :: Word8 -> ByteString -> Int64
count :: Word8 -> ByteString -> Int64
count Word8
w = forall a. (a -> ByteString -> a) -> a -> ByteString -> a
foldlChunks (\Int64
n ByteString
c -> Int64
n forall a. Num a => a -> a -> a
+ forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word8 -> ByteString -> Int
S.count Word8
w ByteString
c)) Int64
0
findIndex :: (Word8 -> Bool) -> ByteString -> Maybe Int64
findIndex :: (Word8 -> Bool) -> ByteString -> Maybe Int64
findIndex Word8 -> Bool
k = forall {a}. Num a => a -> ByteString -> Maybe a
findIndex' Int64
0
where findIndex' :: a -> ByteString -> Maybe a
findIndex' a
_ ByteString
Empty = forall a. Maybe a
Nothing
findIndex' a
n (Chunk ByteString
c ByteString
cs) =
case (Word8 -> Bool) -> ByteString -> Maybe Int
S.findIndex Word8 -> Bool
k ByteString
c of
Maybe Int
Nothing -> a -> ByteString -> Maybe a
findIndex' (a
n forall a. Num a => a -> a -> a
+ forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
S.length ByteString
c)) ByteString
cs
Just Int
i -> forall a. a -> Maybe a
Just (a
n forall a. Num a => a -> a -> a
+ forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i)
{-# INLINE findIndex #-}
findIndexEnd :: (Word8 -> Bool) -> ByteString -> Maybe Int64
findIndexEnd :: (Word8 -> Bool) -> ByteString -> Maybe Int64
findIndexEnd Word8 -> Bool
k = forall {a}. Num a => Int -> ByteString -> Maybe a
findIndexEnd' Int
0
where
findIndexEnd' :: Int -> ByteString -> Maybe a
findIndexEnd' Int
_ ByteString
Empty = forall a. Maybe a
Nothing
findIndexEnd' Int
n (Chunk ByteString
c ByteString
cs) =
let !n' :: Int
n' = Int
n forall a. Num a => a -> a -> a
+ ByteString -> Int
S.length ByteString
c
!i :: Maybe a
i = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int
n forall a. Num a => a -> a -> a
+) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Word8 -> Bool) -> ByteString -> Maybe Int
S.findIndexEnd Word8 -> Bool
k ByteString
c
in Int -> ByteString -> Maybe a
findIndexEnd' Int
n' ByteString
cs forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` Maybe a
i
{-# INLINE findIndexEnd #-}
find :: (Word8 -> Bool) -> ByteString -> Maybe Word8
find :: (Word8 -> Bool) -> ByteString -> Maybe Word8
find Word8 -> Bool
f = ByteString -> Maybe Word8
find'
where find' :: ByteString -> Maybe Word8
find' ByteString
Empty = forall a. Maybe a
Nothing
find' (Chunk ByteString
c ByteString
cs) = case (Word8 -> Bool) -> ByteString -> Maybe Word8
S.find Word8 -> Bool
f ByteString
c of
Maybe Word8
Nothing -> ByteString -> Maybe Word8
find' ByteString
cs
Just Word8
w -> forall a. a -> Maybe a
Just Word8
w
{-# INLINE find #-}
findIndices :: (Word8 -> Bool) -> ByteString -> [Int64]
findIndices :: (Word8 -> Bool) -> ByteString -> [Int64]
findIndices Word8 -> Bool
k = forall {t}. Num t => t -> ByteString -> [t]
findIndices' Int64
0
where findIndices' :: t -> ByteString -> [t]
findIndices' t
_ ByteString
Empty = []
findIndices' t
n (Chunk ByteString
c ByteString
cs) = forall a b. (a -> b) -> [a] -> [b]
List.map ((forall a. Num a => a -> a -> a
+t
n)forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall a b. (Integral a, Num b) => a -> b
fromIntegral) ((Word8 -> Bool) -> ByteString -> [Int]
S.findIndices Word8 -> Bool
k ByteString
c)
forall a. [a] -> [a] -> [a]
++ t -> ByteString -> [t]
findIndices' (t
n forall a. Num a => a -> a -> a
+ forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
S.length ByteString
c)) ByteString
cs
{-# INLINE findIndices #-}
elem :: Word8 -> ByteString -> Bool
elem :: Word8 -> ByteString -> Bool
elem Word8
w ByteString
cs = case Word8 -> ByteString -> Maybe Int64
elemIndex Word8
w ByteString
cs of Maybe Int64
Nothing -> Bool
False ; Maybe Int64
_ -> Bool
True
notElem :: Word8 -> ByteString -> Bool
notElem :: Word8 -> ByteString -> Bool
notElem Word8
w ByteString
cs = Bool -> Bool
not (Word8
w Word8 -> ByteString -> Bool
`elem` ByteString
cs)
filter :: (Word8 -> Bool) -> ByteString -> ByteString
filter :: (Word8 -> Bool) -> ByteString -> ByteString
filter Word8 -> Bool
p = ByteString -> ByteString
go
where
go :: ByteString -> ByteString
go ByteString
Empty = ByteString
Empty
go (Chunk ByteString
x ByteString
xs) = ByteString -> ByteString -> ByteString
chunk ((Word8 -> Bool) -> ByteString -> ByteString
S.filter Word8 -> Bool
p ByteString
x) (ByteString -> ByteString
go ByteString
xs)
{-# INLINE filter #-}
partition :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
partition :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
partition Word8 -> Bool
_ ByteString
Empty = (ByteString
Empty, ByteString
Empty)
partition Word8 -> Bool
p (Chunk ByteString
x ByteString
xs) = (ByteString -> ByteString -> ByteString
chunk ByteString
t ByteString
ts, ByteString -> ByteString -> ByteString
chunk ByteString
f ByteString
fs)
where
(ByteString
t, ByteString
f) = (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
S.partition Word8 -> Bool
p ByteString
x
(ByteString
ts, ByteString
fs) = (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
partition Word8 -> Bool
p ByteString
xs
isPrefixOf :: ByteString -> ByteString -> Bool
isPrefixOf :: ByteString -> ByteString -> Bool
isPrefixOf ByteString
Empty ByteString
_ = Bool
True
isPrefixOf ByteString
_ ByteString
Empty = Bool
False
isPrefixOf (Chunk ByteString
x ByteString
xs) (Chunk ByteString
y ByteString
ys)
| ByteString -> Int
S.length ByteString
x forall a. Eq a => a -> a -> Bool
== ByteString -> Int
S.length ByteString
y = ByteString
x forall a. Eq a => a -> a -> Bool
== ByteString
y Bool -> Bool -> Bool
&& ByteString -> ByteString -> Bool
isPrefixOf ByteString
xs ByteString
ys
| ByteString -> Int
S.length ByteString
x forall a. Ord a => a -> a -> Bool
< ByteString -> Int
S.length ByteString
y = ByteString
x forall a. Eq a => a -> a -> Bool
== ByteString
yh Bool -> Bool -> Bool
&& ByteString -> ByteString -> Bool
isPrefixOf ByteString
xs (ByteString -> ByteString -> ByteString
Chunk ByteString
yt ByteString
ys)
| Bool
otherwise = ByteString
xh forall a. Eq a => a -> a -> Bool
== ByteString
y Bool -> Bool -> Bool
&& ByteString -> ByteString -> Bool
isPrefixOf (ByteString -> ByteString -> ByteString
Chunk ByteString
xt ByteString
xs) ByteString
ys
where (ByteString
xh,ByteString
xt) = Int -> ByteString -> (ByteString, ByteString)
S.splitAt (ByteString -> Int
S.length ByteString
y) ByteString
x
(ByteString
yh,ByteString
yt) = Int -> ByteString -> (ByteString, ByteString)
S.splitAt (ByteString -> Int
S.length ByteString
x) ByteString
y
stripPrefix :: ByteString -> ByteString -> Maybe ByteString
stripPrefix :: ByteString -> ByteString -> Maybe ByteString
stripPrefix ByteString
Empty ByteString
bs = forall a. a -> Maybe a
Just ByteString
bs
stripPrefix ByteString
_ ByteString
Empty = forall a. Maybe a
Nothing
stripPrefix (Chunk ByteString
x ByteString
xs) (Chunk ByteString
y ByteString
ys)
| ByteString -> Int
S.length ByteString
x forall a. Eq a => a -> a -> Bool
== ByteString -> Int
S.length ByteString
y = if ByteString
x forall a. Eq a => a -> a -> Bool
== ByteString
y then ByteString -> ByteString -> Maybe ByteString
stripPrefix ByteString
xs ByteString
ys else forall a. Maybe a
Nothing
| ByteString -> Int
S.length ByteString
x forall a. Ord a => a -> a -> Bool
< ByteString -> Int
S.length ByteString
y = do ByteString
yt <- ByteString -> ByteString -> Maybe ByteString
S.stripPrefix ByteString
x ByteString
y
ByteString -> ByteString -> Maybe ByteString
stripPrefix ByteString
xs (ByteString -> ByteString -> ByteString
Chunk ByteString
yt ByteString
ys)
| Bool
otherwise = do ByteString
xt <- ByteString -> ByteString -> Maybe ByteString
S.stripPrefix ByteString
y ByteString
x
ByteString -> ByteString -> Maybe ByteString
stripPrefix (ByteString -> ByteString -> ByteString
Chunk ByteString
xt ByteString
xs) ByteString
ys
isSuffixOf :: ByteString -> ByteString -> Bool
isSuffixOf :: ByteString -> ByteString -> Bool
isSuffixOf ByteString
x ByteString
y = ByteString -> ByteString
reverse ByteString
x ByteString -> ByteString -> Bool
`isPrefixOf` ByteString -> ByteString
reverse ByteString
y
stripSuffix :: ByteString -> ByteString -> Maybe ByteString
stripSuffix :: ByteString -> ByteString -> Maybe ByteString
stripSuffix ByteString
x ByteString
y = ByteString -> ByteString
reverse forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString -> ByteString -> Maybe ByteString
stripPrefix (ByteString -> ByteString
reverse ByteString
x) (ByteString -> ByteString
reverse ByteString
y)
zip :: ByteString -> ByteString -> [(Word8,Word8)]
zip :: ByteString -> ByteString -> [(Word8, Word8)]
zip = forall a. (Word8 -> Word8 -> a) -> ByteString -> ByteString -> [a]
zipWith (,)
zipWith :: (Word8 -> Word8 -> a) -> ByteString -> ByteString -> [a]
zipWith :: forall a. (Word8 -> Word8 -> a) -> ByteString -> ByteString -> [a]
zipWith Word8 -> Word8 -> a
_ ByteString
Empty ByteString
_ = []
zipWith Word8 -> Word8 -> a
_ ByteString
_ ByteString
Empty = []
zipWith Word8 -> Word8 -> a
f (Chunk ByteString
a ByteString
as) (Chunk ByteString
b ByteString
bs) = ByteString -> ByteString -> ByteString -> ByteString -> [a]
go ByteString
a ByteString
as ByteString
b ByteString
bs
where
go :: ByteString -> ByteString -> ByteString -> ByteString -> [a]
go ByteString
x ByteString
xs ByteString
y ByteString
ys = Word8 -> Word8 -> a
f (ByteString -> Word8
S.unsafeHead ByteString
x) (ByteString -> Word8
S.unsafeHead ByteString
y)
forall a. a -> [a] -> [a]
: ByteString -> ByteString -> ByteString -> ByteString -> [a]
to (ByteString -> ByteString
S.unsafeTail ByteString
x) ByteString
xs (ByteString -> ByteString
S.unsafeTail ByteString
y) ByteString
ys
to :: ByteString -> ByteString -> ByteString -> ByteString -> [a]
to ByteString
x ByteString
Empty ByteString
_ ByteString
_ | ByteString -> Bool
S.null ByteString
x = []
to ByteString
_ ByteString
_ ByteString
y ByteString
Empty | ByteString -> Bool
S.null ByteString
y = []
to ByteString
x ByteString
xs ByteString
y ByteString
ys | Bool -> Bool
not (ByteString -> Bool
S.null ByteString
x)
Bool -> Bool -> Bool
&& Bool -> Bool
not (ByteString -> Bool
S.null ByteString
y) = ByteString -> ByteString -> ByteString -> ByteString -> [a]
go ByteString
x ByteString
xs ByteString
y ByteString
ys
to ByteString
x ByteString
xs ByteString
_ (Chunk ByteString
y' ByteString
ys) | Bool -> Bool
not (ByteString -> Bool
S.null ByteString
x) = ByteString -> ByteString -> ByteString -> ByteString -> [a]
go ByteString
x ByteString
xs ByteString
y' ByteString
ys
to ByteString
_ (Chunk ByteString
x' ByteString
xs) ByteString
y ByteString
ys | Bool -> Bool
not (ByteString -> Bool
S.null ByteString
y) = ByteString -> ByteString -> ByteString -> ByteString -> [a]
go ByteString
x' ByteString
xs ByteString
y ByteString
ys
to ByteString
_ (Chunk ByteString
x' ByteString
xs) ByteString
_ (Chunk ByteString
y' ByteString
ys) = ByteString -> ByteString -> ByteString -> ByteString -> [a]
go ByteString
x' ByteString
xs ByteString
y' ByteString
ys
packZipWith :: (Word8 -> Word8 -> Word8) -> ByteString -> ByteString -> ByteString
packZipWith :: (Word8 -> Word8 -> Word8) -> ByteString -> ByteString -> ByteString
packZipWith Word8 -> Word8 -> Word8
_ ByteString
Empty ByteString
_ = ByteString
Empty
packZipWith Word8 -> Word8 -> Word8
_ ByteString
_ ByteString
Empty = ByteString
Empty
packZipWith Word8 -> Word8 -> Word8
f (Chunk a :: ByteString
a@(S.BS ForeignPtr Word8
_ Int
al) ByteString
as) (Chunk b :: ByteString
b@(S.BS ForeignPtr Word8
_ Int
bl) ByteString
bs) = ByteString -> ByteString -> ByteString
Chunk ((Word8 -> Word8 -> Word8) -> ByteString -> ByteString -> ByteString
S.packZipWith Word8 -> Word8 -> Word8
f ByteString
a ByteString
b) forall a b. (a -> b) -> a -> b
$
case forall a. Ord a => a -> a -> Ordering
compare Int
al Int
bl of
Ordering
LT -> (Word8 -> Word8 -> Word8) -> ByteString -> ByteString -> ByteString
packZipWith Word8 -> Word8 -> Word8
f ByteString
as forall a b. (a -> b) -> a -> b
$ ByteString -> ByteString -> ByteString
Chunk (Int -> ByteString -> ByteString
S.drop Int
al ByteString
b) ByteString
bs
Ordering
EQ -> (Word8 -> Word8 -> Word8) -> ByteString -> ByteString -> ByteString
packZipWith Word8 -> Word8 -> Word8
f ByteString
as ByteString
bs
Ordering
GT -> (Word8 -> Word8 -> Word8) -> ByteString -> ByteString -> ByteString
packZipWith Word8 -> Word8 -> Word8
f (ByteString -> ByteString -> ByteString
Chunk (Int -> ByteString -> ByteString
S.drop Int
bl ByteString
a) ByteString
as) ByteString
bs
{-# INLINE packZipWith #-}
unzip :: [(Word8,Word8)] -> (ByteString,ByteString)
unzip :: [(Word8, Word8)] -> (ByteString, ByteString)
unzip [(Word8, Word8)]
ls = ([Word8] -> ByteString
pack (forall a b. (a -> b) -> [a] -> [b]
List.map forall a b. (a, b) -> a
fst [(Word8, Word8)]
ls), [Word8] -> ByteString
pack (forall a b. (a -> b) -> [a] -> [b]
List.map forall a b. (a, b) -> b
snd [(Word8, Word8)]
ls))
{-# INLINE unzip #-}
inits :: ByteString -> [ByteString]
inits :: ByteString -> [ByteString]
inits ByteString
bs = forall a. NonEmpty a -> [a]
NE.toList forall a b. (a -> b) -> a -> b
$! ByteString -> NonEmpty ByteString
initsNE ByteString
bs
initsNE :: ByteString -> NonEmpty ByteString
initsNE :: ByteString -> NonEmpty ByteString
initsNE = (ByteString
Empty forall a. a -> [a] -> NonEmpty a
:|) forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ByteString -> ByteString) -> ByteString -> [ByteString]
inits' forall a. a -> a
id
where
inits' :: (ByteString -> ByteString) -> ByteString -> [ByteString]
inits' :: (ByteString -> ByteString) -> ByteString -> [ByteString]
inits' ByteString -> ByteString
_ ByteString
Empty = []
inits' ByteString -> ByteString
f (Chunk c :: ByteString
c@(S.BS ForeignPtr Word8
x Int
len) ByteString
cs)
= [ByteString -> ByteString
f (ForeignPtr Word8 -> Int -> ByteString
S.BS ForeignPtr Word8
x Int
n ByteString -> ByteString -> ByteString
`Chunk` ByteString
Empty) | Int
n <- [Int
1..Int
len]]
forall a. [a] -> [a] -> [a]
++ (ByteString -> ByteString) -> ByteString -> [ByteString]
inits' (ByteString -> ByteString
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString -> ByteString
Chunk ByteString
c) ByteString
cs
tails :: ByteString -> [ByteString]
tails :: ByteString -> [ByteString]
tails ByteString
bs = forall a. NonEmpty a -> [a]
NE.toList forall a b. (a -> b) -> a -> b
$! ByteString -> NonEmpty ByteString
tailsNE ByteString
bs
tailsNE :: ByteString -> NonEmpty ByteString
tailsNE :: ByteString -> NonEmpty ByteString
tailsNE ByteString
bs = case ByteString -> Maybe (Word8, ByteString)
uncons ByteString
bs of
Maybe (Word8, ByteString)
Nothing -> ByteString
Empty forall a. a -> [a] -> NonEmpty a
:| []
Just (Word8
_, ByteString
tl) -> ByteString
bs forall a. a -> [a] -> NonEmpty a
:| ByteString -> [ByteString]
tails ByteString
tl
copy :: ByteString -> ByteString
copy :: ByteString -> ByteString
copy = forall a. (ByteString -> a -> a) -> a -> ByteString -> a
foldrChunks (ByteString -> ByteString -> ByteString
Chunk forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
S.copy) ByteString
Empty
hGetContentsN :: Int -> Handle -> IO ByteString
hGetContentsN :: Int -> Handle -> IO ByteString
hGetContentsN Int
k Handle
h = IO ByteString
lazyRead
where
lazyRead :: IO ByteString
lazyRead = forall a. IO a -> IO a
unsafeInterleaveIO IO ByteString
loop
loop :: IO ByteString
loop = do
ByteString
c <- Handle -> Int -> IO ByteString
S.hGetSome Handle
h Int
k
if ByteString -> Bool
S.null ByteString
c
then Handle -> IO ()
hClose Handle
h forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
Empty
else ByteString -> ByteString -> ByteString
Chunk ByteString
c forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO ByteString
lazyRead
hGetN :: Int -> Handle -> Int -> IO ByteString
hGetN :: Int -> Handle -> Int -> IO ByteString
hGetN Int
k Handle
h Int
n | Int
n forall a. Ord a => a -> a -> Bool
> Int
0 = Int -> IO ByteString
readChunks Int
n
where
readChunks :: Int -> IO ByteString
readChunks !Int
i = do
ByteString
c <- Handle -> Int -> IO ByteString
S.hGet Handle
h (forall a. Ord a => a -> a -> a
min Int
k Int
i)
case ByteString -> Int
S.length ByteString
c of
Int
0 -> forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
Empty
Int
m -> do ByteString
cs <- Int -> IO ByteString
readChunks (Int
i forall a. Num a => a -> a -> a
- Int
m)
forall (m :: * -> *) a. Monad m => a -> m a
return (ByteString -> ByteString -> ByteString
Chunk ByteString
c ByteString
cs)
hGetN Int
_ Handle
_ Int
0 = forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
Empty
hGetN Int
_ Handle
h Int
n = forall a. Handle -> String -> Int -> IO a
illegalBufferSize Handle
h String
"hGet" Int
n
hGetNonBlockingN :: Int -> Handle -> Int -> IO ByteString
hGetNonBlockingN :: Int -> Handle -> Int -> IO ByteString
hGetNonBlockingN Int
k Handle
h Int
n | Int
n forall a. Ord a => a -> a -> Bool
> Int
0= Int -> IO ByteString
readChunks Int
n
where
readChunks :: Int -> IO ByteString
readChunks !Int
i = do
ByteString
c <- Handle -> Int -> IO ByteString
S.hGetNonBlocking Handle
h (forall a. Ord a => a -> a -> a
min Int
k Int
i)
case ByteString -> Int
S.length ByteString
c of
Int
0 -> forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
Empty
Int
m -> do ByteString
cs <- Int -> IO ByteString
readChunks (Int
i forall a. Num a => a -> a -> a
- Int
m)
forall (m :: * -> *) a. Monad m => a -> m a
return (ByteString -> ByteString -> ByteString
Chunk ByteString
c ByteString
cs)
hGetNonBlockingN Int
_ Handle
_ Int
0 = forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
Empty
hGetNonBlockingN Int
_ Handle
h Int
n = forall a. Handle -> String -> Int -> IO a
illegalBufferSize Handle
h String
"hGetNonBlocking" Int
n
illegalBufferSize :: Handle -> String -> Int -> IO a
illegalBufferSize :: forall a. Handle -> String -> Int -> IO a
illegalBufferSize Handle
handle String
fn Int
sz =
forall a. IOError -> IO a
ioError (IOErrorType -> String -> Maybe Handle -> Maybe String -> IOError
mkIOError IOErrorType
illegalOperationErrorType String
msg (forall a. a -> Maybe a
Just Handle
handle) forall a. Maybe a
Nothing)
where
msg :: String
msg = String
fn forall a. [a] -> [a] -> [a]
++ String
": illegal ByteString size " forall a. [a] -> [a] -> [a]
++ forall a. Show a => Int -> a -> ShowS
showsPrec Int
9 Int
sz []
hGetContents :: Handle -> IO ByteString
hGetContents :: Handle -> IO ByteString
hGetContents = Int -> Handle -> IO ByteString
hGetContentsN Int
defaultChunkSize
hGet :: Handle -> Int -> IO ByteString
hGet :: Handle -> Int -> IO ByteString
hGet = Int -> Handle -> Int -> IO ByteString
hGetN Int
defaultChunkSize
hGetNonBlocking :: Handle -> Int -> IO ByteString
hGetNonBlocking :: Handle -> Int -> IO ByteString
hGetNonBlocking = Int -> Handle -> Int -> IO ByteString
hGetNonBlockingN Int
defaultChunkSize
readFile :: FilePath -> IO ByteString
readFile :: String -> IO ByteString
readFile String
f = String -> IOMode -> IO Handle
openBinaryFile String
f IOMode
ReadMode forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Handle -> IO ByteString
hGetContents
modifyFile :: IOMode -> FilePath -> ByteString -> IO ()
modifyFile :: IOMode -> String -> ByteString -> IO ()
modifyFile IOMode
mode String
f ByteString
txt = forall r. String -> IOMode -> (Handle -> IO r) -> IO r
withBinaryFile String
f IOMode
mode (Handle -> ByteString -> IO ()
`hPut` ByteString
txt)
writeFile :: FilePath -> ByteString -> IO ()
writeFile :: String -> ByteString -> IO ()
writeFile = IOMode -> String -> ByteString -> IO ()
modifyFile IOMode
WriteMode
appendFile :: FilePath -> ByteString -> IO ()
appendFile :: String -> ByteString -> IO ()
appendFile = IOMode -> String -> ByteString -> IO ()
modifyFile IOMode
AppendMode
getContents :: IO ByteString
getContents :: IO ByteString
getContents = Handle -> IO ByteString
hGetContents Handle
stdin
hPut :: Handle -> ByteString -> IO ()
hPut :: Handle -> ByteString -> IO ()
hPut Handle
h = forall a. (ByteString -> a -> a) -> a -> ByteString -> a
foldrChunks (\ByteString
c IO ()
rest -> Handle -> ByteString -> IO ()
S.hPut Handle
h ByteString
c forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> IO ()
rest) (forall (m :: * -> *) a. Monad m => a -> m a
return ())
hPutNonBlocking :: Handle -> ByteString -> IO ByteString
hPutNonBlocking :: Handle -> ByteString -> IO ByteString
hPutNonBlocking Handle
_ ByteString
Empty = forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
Empty
hPutNonBlocking Handle
h bs :: ByteString
bs@(Chunk ByteString
c ByteString
cs) = do
ByteString
c' <- Handle -> ByteString -> IO ByteString
S.hPutNonBlocking Handle
h ByteString
c
case ByteString -> Int
S.length ByteString
c' of
Int
l' | Int
l' forall a. Eq a => a -> a -> Bool
== ByteString -> Int
S.length ByteString
c -> Handle -> ByteString -> IO ByteString
hPutNonBlocking Handle
h ByteString
cs
Int
0 -> forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
bs
Int
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return (ByteString -> ByteString -> ByteString
Chunk ByteString
c' ByteString
cs)
hPutStr :: Handle -> ByteString -> IO ()
hPutStr :: Handle -> ByteString -> IO ()
hPutStr = Handle -> ByteString -> IO ()
hPut
putStr :: ByteString -> IO ()
putStr :: ByteString -> IO ()
putStr = Handle -> ByteString -> IO ()
hPut Handle
stdout
interact :: (ByteString -> ByteString) -> IO ()
interact :: (ByteString -> ByteString) -> IO ()
interact ByteString -> ByteString
transformer = ByteString -> IO ()
putStr forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
transformer forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO ByteString
getContents
errorEmptyList :: HasCallStack => String -> a
errorEmptyList :: forall a. HasCallStack => String -> a
errorEmptyList String
fun = forall a. HasCallStack => String -> String -> a
moduleError String
fun String
"empty ByteString"
{-# NOINLINE errorEmptyList #-}
moduleError :: HasCallStack => String -> String -> a
moduleError :: forall a. HasCallStack => String -> String -> a
moduleError String
fun String
msg = forall a. HasCallStack => String -> a
error (String
"Data.ByteString.Lazy." forall a. [a] -> [a] -> [a]
++ String
fun forall a. [a] -> [a] -> [a]
++ Char
':'forall a. a -> [a] -> [a]
:Char
' 'forall a. a -> [a] -> [a]
:String
msg)
{-# NOINLINE moduleError #-}
revNonEmptyChunks :: [P.ByteString] -> ByteString
revNonEmptyChunks :: [ByteString] -> ByteString
revNonEmptyChunks = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl' (forall a b c. (a -> b -> c) -> b -> a -> c
flip ByteString -> ByteString -> ByteString
Chunk) ByteString
Empty
revChunks :: [P.ByteString] -> ByteString
revChunks :: [ByteString] -> ByteString
revChunks = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl' (forall a b c. (a -> b -> c) -> b -> a -> c
flip ByteString -> ByteString -> ByteString
chunk) ByteString
Empty