{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE MultiWayIf #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE ViewPatterns #-}
module Streaming.ByteString.Char8
(
ByteStream
, ByteString
, empty
, pack
, unpack
, string
, unlines
, unwords
, singleton
, fromChunks
, fromLazy
, fromStrict
, toChunks
, toLazy
, toLazy_
, toStrict
, toStrict_
, effects
, copy
, drained
, mwrap
, map
, intercalate
, intersperse
, cons
, cons'
, snoc
, append
, filter
, head
, head_
, last
, last_
, null
, null_
, nulls
, testNull
, uncons
, nextChar
, skipSomeWS
, break
, drop
, dropWhile
, group
, groupBy
, span
, splitAt
, splitWith
, take
, takeWhile
, split
, lines
, lineSplit
, words
, concat
, denull
, toStreamingByteString
, toStreamingByteStringWith
, toBuilder
, concatBuilders
, repeat
, iterate
, cycle
, unfoldr
, unfoldM
, reread
, fold
, fold_
, length
, length_
, count
, count_
, readInt
, getContents
, stdin
, stdout
, interact
, putStr
, putStrLn
, readFile
, writeFile
, appendFile
, fromHandle
, toHandle
, hGet
, hGetContents
, hGetContentsN
, hGetN
, hGetNonBlocking
, hGetNonBlockingN
, hPut
, unconsChunk
, nextChunk
, chunk
, foldrChunks
, foldlChunks
, chunkFold
, chunkFoldM
, chunkMap
, chunkMapM
, chunkMapM_
, dematerialize
, materialize
, distribute
, zipWithStream
) where
import Prelude hiding
(all, any, appendFile, break, concat, concatMap, cycle, drop, dropWhile,
elem, filter, foldl, foldl1, foldr, foldr1, getContents, getLine, head,
init, interact, iterate, last, length, lines, map, maximum, minimum,
notElem, null, putStr, putStrLn, readFile, repeat, replicate, reverse,
scanl, scanl1, scanr, scanr1, span, splitAt, tail, take, takeWhile,
unlines, unwords, unzip, words, writeFile, zip, zipWith)
import qualified Prelude
import qualified Data.ByteString as B
import qualified Data.ByteString.Char8 as Char8
import Data.ByteString.Internal (c2w, w2c)
import qualified Data.ByteString.Internal as B
import qualified Data.ByteString.Unsafe as B
import Streaming hiding (concats, distribute, unfold)
import Streaming.Internal (Stream(..))
import qualified Streaming.Prelude as SP
import qualified Streaming.ByteString as Q
import Streaming.ByteString.Internal
import Streaming.ByteString
(append, appendFile, concat, concatBuilders, cycle, denull, distribute,
drained, drop, effects, empty, fromChunks, fromHandle, fromLazy,
fromStrict, getContents, group, hGet, hGetContents, hGetContentsN, hGetN,
hGetNonBlocking, hGetNonBlockingN, hPut, interact, intercalate, length,
length_, nextChunk, null, null_, nulls, readFile, splitAt, stdin, stdout,
take, testNull, toBuilder, toChunks, toHandle, toLazy, toLazy_,
toStreamingByteString, toStreamingByteStringWith, toStrict, toStrict_,
unconsChunk, writeFile, zipWithStream)
import Data.Bits ((.&.))
import Data.Word (Word8)
import Foreign.Ptr
import Foreign.Storable
import qualified System.IO as IO
unpack :: Monad m => ByteStream m r -> Stream (Of Char) m r
unpack :: forall (m :: * -> *) r.
Monad m =>
ByteStream m r -> Stream (Of Char) m r
unpack ByteStream m r
bs = case ByteStream m r
bs of
Empty r
r -> forall (f :: * -> *) (m :: * -> *) r. r -> Stream f m r
Return r
r
Go m (ByteStream m r)
m -> forall (f :: * -> *) (m :: * -> *) r.
m (Stream f m r) -> Stream f m r
Effect (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall (m :: * -> *) r.
Monad m =>
ByteStream m r -> Stream (Of Char) m r
unpack m (ByteStream m r)
m)
Chunk ByteString
c ByteStream m r
cs -> forall (m :: * -> *) r.
ByteString -> Stream (Of Char) m r -> Stream (Of Char) m r
unpackAppendCharsLazy ByteString
c (forall (m :: * -> *) r.
Monad m =>
ByteStream m r -> Stream (Of Char) m r
unpack ByteStream m r
cs)
where
unpackAppendCharsLazy :: B.ByteString -> Stream (Of Char) m r -> Stream (Of Char) m r
unpackAppendCharsLazy :: forall (m :: * -> *) r.
ByteString -> Stream (Of Char) m r -> Stream (Of Char) m r
unpackAppendCharsLazy (B.PS ForeignPtr Word8
fp Int
off Int
len) Stream (Of Char) m r
xs
| Int
len forall a. Ord a => a -> a -> Bool
<= Int
100 = forall (m :: * -> *) r.
ByteString -> Stream (Of Char) m r -> Stream (Of Char) m r
unpackAppendCharsStrict (ForeignPtr Word8 -> Int -> Int -> ByteString
B.PS ForeignPtr Word8
fp Int
off Int
len) Stream (Of Char) m r
xs
| Bool
otherwise = forall (m :: * -> *) r.
ByteString -> Stream (Of Char) m r -> Stream (Of Char) m r
unpackAppendCharsStrict (ForeignPtr Word8 -> Int -> Int -> ByteString
B.PS ForeignPtr Word8
fp Int
off Int
100) Stream (Of Char) m r
remainder
where
remainder :: Stream (Of Char) m r
remainder = forall (m :: * -> *) r.
ByteString -> Stream (Of Char) m r -> Stream (Of Char) m r
unpackAppendCharsLazy (ForeignPtr Word8 -> Int -> Int -> ByteString
B.PS ForeignPtr Word8
fp (Int
offforall a. Num a => a -> a -> a
+Int
100) (Int
lenforall a. Num a => a -> a -> a
-Int
100)) Stream (Of Char) m r
xs
unpackAppendCharsStrict :: B.ByteString -> Stream (Of Char) m r -> Stream (Of Char) m r
unpackAppendCharsStrict :: forall (m :: * -> *) r.
ByteString -> Stream (Of Char) m r -> Stream (Of Char) m r
unpackAppendCharsStrict (B.PS ForeignPtr Word8
fp Int
off Int
len) Stream (Of Char) m r
xs =
forall a. IO a -> a
B.accursedUnutterablePerformIO forall a b. (a -> b) -> a -> b
$ forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
unsafeWithForeignPtr ForeignPtr Word8
fp forall a b. (a -> b) -> a -> b
$ \Ptr Word8
base -> do
forall {m :: * -> *} {r}.
Ptr Word8
-> Ptr Word8 -> Stream (Of Char) m r -> IO (Stream (Of Char) m r)
loop (Ptr Word8
base forall a b. Ptr a -> Int -> Ptr b
`plusPtr` (Int
offforall a. Num a => a -> a -> a
-Int
1)) (Ptr Word8
base forall a b. Ptr a -> Int -> Ptr b
`plusPtr` (Int
offforall a. Num a => a -> a -> a
-Int
1forall a. Num a => a -> a -> a
+Int
len)) Stream (Of Char) m r
xs
where
loop :: Ptr Word8
-> Ptr Word8 -> Stream (Of Char) m r -> IO (Stream (Of Char) m r)
loop !Ptr Word8
sentinal !Ptr Word8
p Stream (Of Char) m r
acc
| Ptr Word8
p forall a. Eq a => a -> a -> Bool
== Ptr Word8
sentinal = forall (m :: * -> *) a. Monad m => a -> m a
return Stream (Of Char) m r
acc
| Bool
otherwise = do Word8
x <- forall a. Storable a => Ptr a -> IO a
peek Ptr Word8
p
Ptr Word8
-> Ptr Word8 -> Stream (Of Char) m r -> IO (Stream (Of Char) m r)
loop Ptr Word8
sentinal (Ptr Word8
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` (-Int
1)) (forall (f :: * -> *) (m :: * -> *) r.
f (Stream f m r) -> Stream f m r
Step (Word8 -> Char
B.w2c Word8
x forall a b. a -> b -> Of a b
:> Stream (Of Char) m r
acc))
{-# INLINABLE unpack #-}
pack :: Monad m => Stream (Of Char) m r -> ByteStream m r
pack :: forall (m :: * -> *) r.
Monad m =>
Stream (Of Char) m r -> ByteStream m r
pack = forall (m :: * -> *) r.
Monad m =>
Stream (Of ByteString) m r -> ByteStream m r
fromChunks
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) (f :: * -> *) (g :: * -> *) r.
(Monad m, Functor f) =>
(forall x. f x -> m (g x)) -> Stream f m r -> Stream g m r
mapped (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(String
str :> x
r) -> String -> ByteString
Char8.pack String
str forall a b. a -> b -> Of a b
:> x
r) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a r.
Monad m =>
Stream (Of a) m r -> m (Of [a] r)
SP.toList)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) (f :: * -> *) r.
(Monad m, Functor f) =>
Int -> Stream f m r -> Stream (Stream f m) m r
chunksOf Int
32
{-# INLINABLE pack #-}
cons :: Monad m => Char -> ByteStream m r -> ByteStream m r
cons :: forall (m :: * -> *) r.
Monad m =>
Char -> ByteStream m r -> ByteStream m r
cons Char
c = forall (m :: * -> *) r.
Monad m =>
Word8 -> ByteStream m r -> ByteStream m r
Q.cons (Char -> Word8
c2w Char
c)
{-# INLINE cons #-}
singleton :: Monad m => Char -> ByteStream m ()
singleton :: forall (m :: * -> *). Monad m => Char -> ByteStream m ()
singleton = forall (m :: * -> *). Monad m => Word8 -> ByteStream m ()
Q.singleton forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Word8
c2w
{-# INLINE singleton #-}
cons' :: Char -> ByteStream m r -> ByteStream m r
cons' :: forall (m :: * -> *) r. Char -> ByteStream m r -> ByteStream m r
cons' Char
c (Chunk ByteString
bs ByteStream m r
bss) | ByteString -> Int
B.length ByteString
bs forall a. Ord a => a -> a -> Bool
< Int
16 = forall (m :: * -> *) r.
ByteString -> ByteStream m r -> ByteStream m r
Chunk (Word8 -> ByteString -> ByteString
B.cons (Char -> Word8
c2w Char
c) ByteString
bs) ByteStream m r
bss
cons' Char
c ByteStream m r
cs = forall (m :: * -> *) r.
ByteString -> ByteStream m r -> ByteStream m r
Chunk (Word8 -> ByteString
B.singleton (Char -> Word8
c2w Char
c)) ByteStream m r
cs
{-# INLINE cons' #-}
snoc :: Monad m => ByteStream m r -> Char -> ByteStream m r
snoc :: forall (m :: * -> *) r.
Monad m =>
ByteStream m r -> Char -> ByteStream m r
snoc ByteStream m r
cs = forall (m :: * -> *) r.
Monad m =>
ByteStream m r -> Word8 -> ByteStream m r
Q.snoc ByteStream m r
cs forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Word8
c2w
{-# INLINE snoc #-}
head_ :: Monad m => ByteStream m r -> m Char
head_ :: forall (m :: * -> *) r. Monad m => ByteStream m r -> m Char
head_ = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word8 -> Char
w2c forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) r. Monad m => ByteStream m r -> m Word8
Q.head_
{-# INLINE head_ #-}
head :: Monad m => ByteStream m r -> m (Of (Maybe Char) r)
head :: forall (m :: * -> *) r.
Monad m =>
ByteStream m r -> m (Of (Maybe Char) r)
head = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(Maybe Word8
m:>r
r) -> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word8 -> Char
w2c Maybe Word8
m forall a b. a -> b -> Of a b
:> r
r) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) r.
Monad m =>
ByteStream m r -> m (Of (Maybe Word8) r)
Q.head
{-# INLINE head #-}
last_ :: Monad m => ByteStream m r -> m Char
last_ :: forall (m :: * -> *) r. Monad m => ByteStream m r -> m Char
last_ = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word8 -> Char
w2c forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) r. Monad m => ByteStream m r -> m Word8
Q.last_
{-# INLINE last_ #-}
last :: Monad m => ByteStream m r -> m (Of (Maybe Char) r)
last :: forall (m :: * -> *) r.
Monad m =>
ByteStream m r -> m (Of (Maybe Char) r)
last = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(Maybe Word8
m:>r
r) -> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word8 -> Char
w2c Maybe Word8
m forall a b. a -> b -> Of a b
:> r
r) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) r.
Monad m =>
ByteStream m r -> m (Of (Maybe Word8) r)
Q.last
{-# INLINE last #-}
groupBy :: Monad m => (Char -> Char -> Bool) -> ByteStream m r -> Stream (ByteStream m) m r
groupBy :: forall (m :: * -> *) r.
Monad m =>
(Char -> Char -> Bool)
-> ByteStream m r -> Stream (ByteStream m) m r
groupBy Char -> Char -> Bool
rel = forall (m :: * -> *) r.
Monad m =>
(Word8 -> Word8 -> Bool)
-> ByteStream m r -> Stream (ByteStream m) m r
Q.groupBy (\Word8
w Word8
w' -> Char -> Char -> Bool
rel (Word8 -> Char
w2c Word8
w) (Word8 -> Char
w2c Word8
w'))
{-# INLINE groupBy #-}
uncons :: Monad m => ByteStream m r -> m (Either r (Char, ByteStream m r))
uncons :: forall (m :: * -> *) r.
Monad m =>
ByteStream m r -> m (Either r (Char, ByteStream m r))
uncons (Chunk c :: ByteString
c@(ByteString -> Int
B.length -> Int
len) ByteStream m r
cs)
| Int
len forall a. Ord a => a -> a -> Bool
> Int
0 = let !h :: Char
h = Word8 -> Char
w2c forall a b. (a -> b) -> a -> b
$ ByteString -> Word8
B.unsafeHead ByteString
c
!t :: ByteStream m r
t = if Int
len forall a. Ord a => a -> a -> Bool
> Int
1 then forall (m :: * -> *) r.
ByteString -> ByteStream m r -> ByteStream m r
Chunk (ByteString -> ByteString
B.unsafeTail ByteString
c) ByteStream m r
cs else ByteStream m r
cs
in forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. b -> Either a b
Right (Char
h, ByteStream m r
t)
| Bool
otherwise = forall (m :: * -> *) r.
Monad m =>
ByteStream m r -> m (Either r (Char, ByteStream m r))
uncons ByteStream m r
cs
uncons (Go m (ByteStream m r)
m) = m (ByteStream m r)
m forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) r.
Monad m =>
ByteStream m r -> m (Either r (Char, ByteStream m r))
uncons
uncons (Empty r
r) = forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. a -> Either a b
Left r
r)
{-# INLINABLE uncons #-}
nextChar :: Monad m => ByteStream m r -> m (Either r (Char, ByteStream m r))
nextChar :: forall (m :: * -> *) r.
Monad m =>
ByteStream m r -> m (Either r (Char, ByteStream m r))
nextChar = forall (m :: * -> *) r.
Monad m =>
ByteStream m r -> m (Either r (Char, ByteStream m r))
uncons
{-# INLINABLE nextChar #-}
{-# DEPRECATED nextChar "Use uncons instead." #-}
map :: Monad m => (Char -> Char) -> ByteStream m r -> ByteStream m r
map :: forall (m :: * -> *) r.
Monad m =>
(Char -> Char) -> ByteStream m r -> ByteStream m r
map Char -> Char
f = forall (m :: * -> *) r.
Monad m =>
(Word8 -> Word8) -> ByteStream m r -> ByteStream m r
Q.map (Char -> Word8
c2w forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Char
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Char
w2c)
{-# INLINE map #-}
intersperse :: Monad m => Char -> ByteStream m r -> ByteStream m r
intersperse :: forall (m :: * -> *) r.
Monad m =>
Char -> ByteStream m r -> ByteStream m r
intersperse Char
c = forall (m :: * -> *) r.
Monad m =>
Word8 -> ByteStream m r -> ByteStream m r
Q.intersperse (Char -> Word8
c2w Char
c)
{-# INLINE intersperse #-}
fold_ :: Monad m => (x -> Char -> x) -> x -> (x -> b) -> ByteStream m () -> m b
fold_ :: forall (m :: * -> *) x b.
Monad m =>
(x -> Char -> x) -> x -> (x -> b) -> ByteStream m () -> m b
fold_ x -> Char -> x
step x
begin x -> b
done ByteStream m ()
p0 = forall {m :: * -> *} {r}. Monad m => ByteStream m r -> x -> m b
loop ByteStream m ()
p0 x
begin
where
loop :: ByteStream m r -> x -> m b
loop ByteStream m r
p !x
x = case ByteStream m r
p of
Chunk ByteString
bs ByteStream m r
bss -> ByteStream m r -> x -> m b
loop ByteStream m r
bss forall a b. (a -> b) -> a -> b
$! forall a. (a -> Char -> a) -> a -> ByteString -> a
Char8.foldl' x -> Char -> x
step x
x ByteString
bs
Go m (ByteStream m r)
m -> m (ByteStream m r)
m forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ByteStream m r
p' -> ByteStream m r -> x -> m b
loop ByteStream m r
p' x
x
Empty r
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return (x -> b
done x
x)
{-# INLINABLE fold_ #-}
fold :: Monad m => (x -> Char -> x) -> x -> (x -> b) -> ByteStream m r -> m (Of b r)
fold :: forall (m :: * -> *) x b r.
Monad m =>
(x -> Char -> x) -> x -> (x -> b) -> ByteStream m r -> m (Of b r)
fold x -> Char -> x
step x
begin x -> b
done ByteStream m r
p0 = forall {m :: * -> *} {b}.
Monad m =>
ByteStream m b -> x -> m (Of b b)
loop ByteStream m r
p0 x
begin
where
loop :: ByteStream m b -> x -> m (Of b b)
loop ByteStream m b
p !x
x = case ByteStream m b
p of
Chunk ByteString
bs ByteStream m b
bss -> ByteStream m b -> x -> m (Of b b)
loop ByteStream m b
bss forall a b. (a -> b) -> a -> b
$! forall a. (a -> Char -> a) -> a -> ByteString -> a
Char8.foldl' x -> Char -> x
step x
x ByteString
bs
Go m (ByteStream m b)
m -> m (ByteStream m b)
m forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ByteStream m b
p' -> ByteStream m b -> x -> m (Of b b)
loop ByteStream m b
p' x
x
Empty b
r -> forall (m :: * -> *) a. Monad m => a -> m a
return (x -> b
done x
x forall a b. a -> b -> Of a b
:> b
r)
{-# INLINABLE fold #-}
iterate :: (Char -> Char) -> Char -> ByteStream m r
iterate :: forall (m :: * -> *) r. (Char -> Char) -> Char -> ByteStream m r
iterate Char -> Char
f Char
c = forall (m :: * -> *) r. (Word8 -> Word8) -> Word8 -> ByteStream m r
Q.iterate (Char -> Word8
c2w forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Char
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Char
w2c) (Char -> Word8
c2w Char
c)
{-# INLINE iterate #-}
repeat :: Char -> ByteStream m r
repeat :: forall (m :: * -> *) r. Char -> ByteStream m r
repeat = forall (m :: * -> *) r. Word8 -> ByteStream m r
Q.repeat forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Word8
c2w
{-# INLINE repeat #-}
unfoldM :: Monad m => (a -> Maybe (Char, a)) -> a -> ByteStream m ()
unfoldM :: forall (m :: * -> *) a.
Monad m =>
(a -> Maybe (Char, a)) -> a -> ByteStream m ()
unfoldM a -> Maybe (Char, a)
f = forall (m :: * -> *) a.
Monad m =>
(a -> Maybe (Word8, a)) -> a -> ByteStream m ()
Q.unfoldM a -> Maybe (Word8, a)
go where
go :: a -> Maybe (Word8, a)
go a
a = case a -> Maybe (Char, a)
f a
a of
Maybe (Char, a)
Nothing -> forall a. Maybe a
Nothing
Just (Char
c,a
a') -> forall a. a -> Maybe a
Just (Char -> Word8
c2w Char
c, a
a')
{-# INLINE unfoldM #-}
unfoldr :: (a -> Either r (Char, a)) -> a -> ByteStream m r
unfoldr :: forall a r (m :: * -> *).
(a -> Either r (Char, a)) -> a -> ByteStream m r
unfoldr a -> Either r (Char, a)
step = forall a r (m :: * -> *).
(a -> Either r (Word8, a)) -> a -> ByteStream m r
Q.unfoldr (forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a b. a -> Either a b
Left (\(Char
c,a
a) -> forall a b. b -> Either a b
Right (Char -> Word8
c2w Char
c,a
a)) forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Either r (Char, a)
step)
{-# INLINE unfoldr #-}
takeWhile :: Monad m => (Char -> Bool) -> ByteStream m r -> ByteStream m ()
takeWhile :: forall (m :: * -> *) r.
Monad m =>
(Char -> Bool) -> ByteStream m r -> ByteStream m ()
takeWhile Char -> Bool
f = forall (m :: * -> *) r.
Monad m =>
(Word8 -> Bool) -> ByteStream m r -> ByteStream m ()
Q.takeWhile (Char -> Bool
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Char
w2c)
{-# INLINE takeWhile #-}
dropWhile :: Monad m => (Char -> Bool) -> ByteStream m r -> ByteStream m r
dropWhile :: forall (m :: * -> *) r.
Monad m =>
(Char -> Bool) -> ByteStream m r -> ByteStream m r
dropWhile Char -> Bool
f = forall (m :: * -> *) r.
Monad m =>
(Word8 -> Bool) -> ByteStream m r -> ByteStream m r
Q.dropWhile (Char -> Bool
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Char
w2c)
{-# INLINE dropWhile #-}
break :: Monad m => (Char -> Bool) -> ByteStream m r -> ByteStream m (ByteStream m r)
break :: forall (m :: * -> *) r.
Monad m =>
(Char -> Bool) -> ByteStream m r -> ByteStream m (ByteStream m r)
break Char -> Bool
f = forall (m :: * -> *) r.
Monad m =>
(Word8 -> Bool) -> ByteStream m r -> ByteStream m (ByteStream m r)
Q.break (Char -> Bool
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Char
w2c)
{-# INLINE break #-}
span :: Monad m => (Char -> Bool) -> ByteStream m r -> ByteStream m (ByteStream m r)
span :: forall (m :: * -> *) r.
Monad m =>
(Char -> Bool) -> ByteStream m r -> ByteStream m (ByteStream m r)
span Char -> Bool
p = forall (m :: * -> *) r.
Monad m =>
(Char -> Bool) -> ByteStream m r -> ByteStream m (ByteStream m r)
break (Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Bool
p)
{-# INLINE span #-}
splitWith :: Monad m => (Char -> Bool) -> ByteStream m r -> Stream (ByteStream m) m r
splitWith :: forall (m :: * -> *) r.
Monad m =>
(Char -> Bool) -> ByteStream m r -> Stream (ByteStream m) m r
splitWith Char -> Bool
f = forall (m :: * -> *) r.
Monad m =>
(Word8 -> Bool) -> ByteStream m r -> Stream (ByteStream m) m r
Q.splitWith (Char -> Bool
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Char
w2c)
{-# INLINE splitWith #-}
split :: Monad m => Char -> ByteStream m r -> Stream (ByteStream m) m r
split :: forall (m :: * -> *) r.
Monad m =>
Char -> ByteStream m r -> Stream (ByteStream m) m r
split Char
c = forall (m :: * -> *) r.
Monad m =>
Word8 -> ByteStream m r -> Stream (ByteStream m) m r
Q.split (Char -> Word8
c2w Char
c)
{-# INLINE split #-}
filter :: Monad m => (Char -> Bool) -> ByteStream m r -> ByteStream m r
filter :: forall (m :: * -> *) r.
Monad m =>
(Char -> Bool) -> ByteStream m r -> ByteStream m r
filter Char -> Bool
p = forall (m :: * -> *) r.
Monad m =>
(Word8 -> Bool) -> ByteStream m r -> ByteStream m r
Q.filter (Char -> Bool
p forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Char
w2c)
{-# INLINE filter #-}
lines :: forall m r . Monad m => ByteStream m r -> Stream (ByteStream m) m r
lines :: forall (m :: * -> *) r.
Monad m =>
ByteStream m r -> Stream (ByteStream m) m r
lines ByteStream m r
text0 = ByteStream m r -> Stream (ByteStream m) m r
loop1 ByteStream m r
text0
where
loop1 :: ByteStream m r -> Stream (ByteStream m) m r
loop1 :: ByteStream m r -> Stream (ByteStream m) m r
loop1 ByteStream m r
text =
case ByteStream m r
text of
Empty r
r -> forall (f :: * -> *) (m :: * -> *) r. r -> Stream f m r
Return r
r
Go m (ByteStream m r)
m -> forall (f :: * -> *) (m :: * -> *) r.
m (Stream f m r) -> Stream f m r
Effect forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteStream m r -> Stream (ByteStream m) m r
loop1 m (ByteStream m r)
m
Chunk ByteString
c ByteStream m r
cs
| ByteString -> Bool
B.null ByteString
c -> ByteStream m r -> Stream (ByteStream m) m r
loop1 ByteStream m r
cs
| Bool
otherwise -> forall (f :: * -> *) (m :: * -> *) r.
f (Stream f m r) -> Stream f m r
Step (Bool -> ByteStream m r -> ByteStream m (Stream (ByteStream m) m r)
loop2 Bool
False ByteStream m r
text)
loop2 :: Bool -> ByteStream m r -> ByteStream m (Stream (ByteStream m) m r)
loop2 :: Bool -> ByteStream m r -> ByteStream m (Stream (ByteStream m) m r)
loop2 Bool
prevCr ByteStream m r
text =
case ByteStream m r
text of
Empty r
r -> if Bool
prevCr
then forall (m :: * -> *) r.
ByteString -> ByteStream m r -> ByteStream m r
Chunk (Word8 -> ByteString
B.singleton Word8
13) (forall (m :: * -> *) r. r -> ByteStream m r
Empty (forall (f :: * -> *) (m :: * -> *) r. r -> Stream f m r
Return r
r))
else forall (m :: * -> *) r. r -> ByteStream m r
Empty (forall (f :: * -> *) (m :: * -> *) r. r -> Stream f m r
Return r
r)
Go m (ByteStream m r)
m -> forall (m :: * -> *) r. m (ByteStream m r) -> ByteStream m r
Go forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Bool -> ByteStream m r -> ByteStream m (Stream (ByteStream m) m r)
loop2 Bool
prevCr) m (ByteStream m r)
m
Chunk ByteString
c ByteStream m r
cs ->
case Word8 -> ByteString -> Maybe Int
B.elemIndex Word8
10 ByteString
c of
Maybe Int
Nothing -> if ByteString -> Bool
B.null ByteString
c
then Bool -> ByteStream m r -> ByteStream m (Stream (ByteStream m) m r)
loop2 Bool
prevCr ByteStream m r
cs
else if ByteString -> Word8
unsafeLast ByteString
c forall a. Eq a => a -> a -> Bool
== Word8
13
then forall (m :: * -> *) r.
ByteString -> ByteStream m r -> ByteStream m r
Chunk (ByteString -> ByteString
unsafeInit ByteString
c) (Bool -> ByteStream m r -> ByteStream m (Stream (ByteStream m) m r)
loop2 Bool
True ByteStream m r
cs)
else forall (m :: * -> *) r.
ByteString -> ByteStream m r -> ByteStream m r
Chunk ByteString
c (Bool -> ByteStream m r -> ByteStream m (Stream (ByteStream m) m r)
loop2 Bool
False ByteStream m r
cs)
Just Int
i -> do
let prefixLength :: Int
prefixLength =
if Int
i forall a. Ord a => a -> a -> Bool
>= Int
1 Bool -> Bool -> Bool
&& ByteString -> Int -> Word8
B.unsafeIndex ByteString
c (Int
iforall a. Num a => a -> a -> a
-Int
1) forall a. Eq a => a -> a -> Bool
== Word8
13
then Int
iforall a. Num a => a -> a -> a
-Int
1
else Int
i
rest :: ByteStream m r
rest =
if ByteString -> Int
B.length ByteString
c forall a. Ord a => a -> a -> Bool
> Int
iforall a. Num a => a -> a -> a
+Int
1
then forall (m :: * -> *) r.
ByteString -> ByteStream m r -> ByteStream m r
Chunk (Int -> ByteString -> ByteString
B.drop (Int
iforall a. Num a => a -> a -> a
+Int
1) ByteString
c) ByteStream m r
cs
else ByteStream m r
cs
result :: ByteStream m (Stream (ByteStream m) m r)
result = forall (m :: * -> *) r.
ByteString -> ByteStream m r -> ByteStream m r
Chunk (Int -> ByteString -> ByteString
B.unsafeTake Int
prefixLength ByteString
c) (forall (m :: * -> *) r. r -> ByteStream m r
Empty (ByteStream m r -> Stream (ByteStream m) m r
loop1 ByteStream m r
rest))
if Int
i forall a. Ord a => a -> a -> Bool
> Int
0 Bool -> Bool -> Bool
&& Bool
prevCr
then forall (m :: * -> *) r.
ByteString -> ByteStream m r -> ByteStream m r
Chunk (Word8 -> ByteString
B.singleton Word8
13) forall {m :: * -> *}. ByteStream m (Stream (ByteStream m) m r)
result
else forall {m :: * -> *}. ByteStream m (Stream (ByteStream m) m r)
result
{-# INLINABLE lines #-}
unlines :: Monad m => Stream (ByteStream m) m r -> ByteStream m r
unlines :: forall (m :: * -> *) r.
Monad m =>
Stream (ByteStream m) m r -> ByteStream m r
unlines = forall (m :: * -> *) r.
Monad m =>
Stream (ByteStream m) m r -> ByteStream m r
loop where
loop :: Stream (ByteStream m) m r -> ByteStream m r
loop Stream (ByteStream m) m r
str = case Stream (ByteStream m) m r
str of
Return r
r -> forall (m :: * -> *) r. r -> ByteStream m r
Empty r
r
Step ByteStream m (Stream (ByteStream m) m r)
bstr -> do
Stream (ByteStream m) m r
st <- ByteStream m (Stream (ByteStream m) m r)
bstr
forall (m :: * -> *) r. Char -> ByteStream m r -> ByteStream m r
cons' Char
'\n' forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) r.
Monad m =>
Stream (ByteStream m) m r -> ByteStream m r
unlines Stream (ByteStream m) m r
st
Effect m (Stream (ByteStream m) m r)
m -> forall (m :: * -> *) r. m (ByteStream m r) -> ByteStream m r
Go (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall (m :: * -> *) r.
Monad m =>
Stream (ByteStream m) m r -> ByteStream m r
unlines m (Stream (ByteStream m) m r)
m)
{-# INLINABLE unlines #-}
words :: Monad m => ByteStream m r -> Stream (ByteStream m) m r
words :: forall (m :: * -> *) r.
Monad m =>
ByteStream m r -> Stream (ByteStream m) m r
words = forall {m :: * -> *} {r}.
Monad m =>
Stream (ByteStream m) m r -> Stream (ByteStream m) m r
filtered forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) r.
Monad m =>
(Word8 -> Bool) -> ByteStream m r -> Stream (ByteStream m) m r
Q.splitWith Word8 -> Bool
w8IsSpace
where
filtered :: Stream (ByteStream m) m r -> Stream (ByteStream m) m r
filtered Stream (ByteStream m) m r
stream = case Stream (ByteStream m) m r
stream of
Return r
r -> forall (f :: * -> *) (m :: * -> *) r. r -> Stream f m r
Return r
r
Effect m (Stream (ByteStream m) m r)
m -> forall (f :: * -> *) (m :: * -> *) r.
m (Stream f m r) -> Stream f m r
Effect (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Stream (ByteStream m) m r -> Stream (ByteStream m) m r
filtered m (Stream (ByteStream m) m r)
m)
Step ByteStream m (Stream (ByteStream m) m r)
bs -> forall (f :: * -> *) (m :: * -> *) r.
m (Stream f m r) -> Stream f m r
Effect forall a b. (a -> b) -> a -> b
$ ByteStream m (Stream (ByteStream m) m r)
-> m (Stream (ByteStream m) m r)
bs_loop ByteStream m (Stream (ByteStream m) m r)
bs
bs_loop :: ByteStream m (Stream (ByteStream m) m r)
-> m (Stream (ByteStream m) m r)
bs_loop ByteStream m (Stream (ByteStream m) m r)
bs = case ByteStream m (Stream (ByteStream m) m r)
bs of
Empty Stream (ByteStream m) m r
r -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Stream (ByteStream m) m r -> Stream (ByteStream m) m r
filtered Stream (ByteStream m) m r
r
Go m (ByteStream m (Stream (ByteStream m) m r))
m -> m (ByteStream m (Stream (ByteStream m) m r))
m forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ByteStream m (Stream (ByteStream m) m r)
-> m (Stream (ByteStream m) m r)
bs_loop
Chunk ByteString
b ByteStream m (Stream (ByteStream m) m r)
bs' -> if ByteString -> Bool
B.null ByteString
b
then ByteStream m (Stream (ByteStream m) m r)
-> m (Stream (ByteStream m) m r)
bs_loop ByteStream m (Stream (ByteStream m) m r)
bs'
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) (m :: * -> *) r.
f (Stream f m r) -> Stream f m r
Step forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) r.
ByteString -> ByteStream m r -> ByteStream m r
Chunk ByteString
b (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Stream (ByteStream m) m r -> Stream (ByteStream m) m r
filtered ByteStream m (Stream (ByteStream m) m r)
bs')
{-# INLINABLE words #-}
unwords :: Monad m => Stream (ByteStream m) m r -> ByteStream m r
unwords :: forall (m :: * -> *) r.
Monad m =>
Stream (ByteStream m) m r -> ByteStream m r
unwords = forall (m :: * -> *) r.
Monad m =>
ByteStream m () -> Stream (ByteStream m) m r -> ByteStream m r
intercalate (forall (m :: * -> *). Monad m => Char -> ByteStream m ()
singleton Char
' ')
{-# INLINE unwords #-}
lineSplit :: forall m r. Monad m
=> Int
-> ByteStream m r
-> Stream (ByteStream m) m r
lineSplit :: forall (m :: * -> *) r.
Monad m =>
Int -> ByteStream m r -> Stream (ByteStream m) m r
lineSplit !Int
n0 ByteStream m r
text0 = ByteStream m r -> Stream (ByteStream m) m r
loop1 ByteStream m r
text0
where
n :: Int
!n :: Int
n = forall a. Ord a => a -> a -> a
max Int
n0 Int
1
loop1 :: ByteStream m r -> Stream (ByteStream m) m r
loop1 :: ByteStream m r -> Stream (ByteStream m) m r
loop1 ByteStream m r
text =
case ByteStream m r
text of
Empty r
r -> forall (f :: * -> *) (m :: * -> *) r. r -> Stream f m r
Return r
r
Go m (ByteStream m r)
m -> forall (f :: * -> *) (m :: * -> *) r.
m (Stream f m r) -> Stream f m r
Effect forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteStream m r -> Stream (ByteStream m) m r
loop1 m (ByteStream m r)
m
Chunk ByteString
c ByteStream m r
cs
| ByteString -> Bool
B.null ByteString
c -> ByteStream m r -> Stream (ByteStream m) m r
loop1 ByteStream m r
cs
| Bool
otherwise -> forall (f :: * -> *) (m :: * -> *) r.
f (Stream f m r) -> Stream f m r
Step (Int -> ByteStream m r -> ByteStream m (Stream (ByteStream m) m r)
loop2 Int
0 ByteStream m r
text)
loop2 :: Int -> ByteStream m r -> ByteStream m (Stream (ByteStream m) m r)
loop2 :: Int -> ByteStream m r -> ByteStream m (Stream (ByteStream m) m r)
loop2 !Int
counter ByteStream m r
text =
case ByteStream m r
text of
Empty r
r -> forall (m :: * -> *) r. r -> ByteStream m r
Empty (forall (f :: * -> *) (m :: * -> *) r. r -> Stream f m r
Return r
r)
Go m (ByteStream m r)
m -> forall (m :: * -> *) r. m (ByteStream m r) -> ByteStream m r
Go forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Int -> ByteStream m r -> ByteStream m (Stream (ByteStream m) m r)
loop2 Int
counter) m (ByteStream m r)
m
Chunk ByteString
c ByteStream m r
cs ->
case ByteString -> Int -> Either Int Int
nthNewLine ByteString
c (Int
n forall a. Num a => a -> a -> a
- Int
counter) of
Left !Int
i -> forall (m :: * -> *) r.
ByteString -> ByteStream m r -> ByteStream m r
Chunk ByteString
c (Int -> ByteStream m r -> ByteStream m (Stream (ByteStream m) m r)
loop2 (Int
counter forall a. Num a => a -> a -> a
+ Int
i) ByteStream m r
cs)
Right !Int
l -> forall (m :: * -> *) r.
ByteString -> ByteStream m r -> ByteStream m r
Chunk (Int -> ByteString -> ByteString
B.unsafeTake Int
l ByteString
c)
forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) r. r -> ByteStream m r
Empty forall a b. (a -> b) -> a -> b
$ ByteStream m r -> Stream (ByteStream m) m r
loop1 forall a b. (a -> b) -> a -> b
$! forall (m :: * -> *) r.
ByteString -> ByteStream m r -> ByteStream m r
Chunk (Int -> ByteString -> ByteString
B.unsafeDrop Int
l ByteString
c) ByteStream m r
cs
{-# INLINABLE lineSplit #-}
nthNewLine :: B.ByteString
-> Int
-> Either Int Int
nthNewLine :: ByteString -> Int -> Either Int Int
nthNewLine (B.PS ForeignPtr Word8
fp Int
off Int
len) Int
targetLines =
forall a. IO a -> a
B.accursedUnutterablePerformIO forall a b. (a -> b) -> a -> b
$ forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
unsafeWithForeignPtr ForeignPtr Word8
fp forall a b. (a -> b) -> a -> b
$ \Ptr Word8
base ->
Ptr Word8 -> Int -> Int -> Int -> IO (Either Int Int)
loop (Ptr Word8
base forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
off) Int
targetLines Int
0 Int
len
where
loop :: Ptr Word8 -> Int -> Int -> Int -> IO (Either Int Int)
loop :: Ptr Word8 -> Int -> Int -> Int -> IO (Either Int Int)
loop !Ptr Word8
_ Int
0 !Int
startIx !Int
_ = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. b -> Either a b
Right Int
startIx
loop !Ptr Word8
p !Int
linesNeeded !Int
startIx !Int
bytesLeft = do
Ptr Word8
q <- Ptr Word8 -> Word8 -> CSize -> IO (Ptr Word8)
B.memchr Ptr Word8
p Word8
newline forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
bytesLeft
if Ptr Word8
q forall a. Eq a => a -> a -> Bool
== forall a. Ptr a
nullPtr
then forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. a -> Either a b
Left forall a b. (a -> b) -> a -> b
$! Int
targetLines forall a. Num a => a -> a -> a
- Int
linesNeeded
else let !pnext :: Ptr b
pnext = Ptr Word8
q forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
1
!skip :: Int
skip = forall a. Ptr a
pnext forall a b. Ptr a -> Ptr b -> Int
`minusPtr` Ptr Word8
p
!snext :: Int
snext = Int
startIx forall a. Num a => a -> a -> a
+ Int
skip
!bytes :: Int
bytes = Int
bytesLeft forall a. Num a => a -> a -> a
- Int
skip
in Ptr Word8 -> Int -> Int -> Int -> IO (Either Int Int)
loop forall a. Ptr a
pnext (Int
linesNeeded forall a. Num a => a -> a -> a
- Int
1) Int
snext Int
bytes
newline :: Word8
newline :: Word8
newline = Word8
10
{-# INLINE newline #-}
string :: String -> ByteStream m ()
string :: forall (m :: * -> *). String -> ByteStream m ()
string = forall (m :: * -> *). ByteString -> ByteStream m ()
chunk forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Word8] -> ByteString
B.pack forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
Prelude.map Char -> Word8
B.c2w
{-# INLINE string #-}
count_ :: Monad m => Char -> ByteStream m r -> m Int
count_ :: forall (m :: * -> *) r. Monad m => Char -> ByteStream m r -> m Int
count_ Char
c = forall (m :: * -> *) r. Monad m => Word8 -> ByteStream m r -> m Int
Q.count_ (Char -> Word8
c2w Char
c)
{-# INLINE count_ #-}
count :: Monad m => Char -> ByteStream m r -> m (Of Int r)
count :: forall (m :: * -> *) r.
Monad m =>
Char -> ByteStream m r -> m (Of Int r)
count Char
c = forall (m :: * -> *) r.
Monad m =>
Word8 -> ByteStream m r -> m (Of Int r)
Q.count (Char -> Word8
c2w Char
c)
{-# INLINE count #-}
putStr :: MonadIO m => ByteStream m r -> m r
putStr :: forall (m :: * -> *) r. MonadIO m => ByteStream m r -> m r
putStr = forall (m :: * -> *) r.
MonadIO m =>
Handle -> ByteStream m r -> m r
hPut Handle
IO.stdout
{-# INLINE putStr #-}
putStrLn :: MonadIO m => ByteStream m r -> m r
putStrLn :: forall (m :: * -> *) r. MonadIO m => ByteStream m r -> m r
putStrLn ByteStream m r
bs = forall (m :: * -> *) r.
MonadIO m =>
Handle -> ByteStream m r -> m r
hPut Handle
IO.stdout (forall (m :: * -> *) r.
Monad m =>
ByteStream m r -> Char -> ByteStream m r
snoc ByteStream m r
bs Char
'\n')
{-# INLINE putStrLn #-}
intmaxWord, intminWord, intmaxQuot10, intmaxRem10, intminQuot10, intminRem10 :: Word
intmaxWord :: Word
intmaxWord = forall a b. (Integral a, Num b) => a -> b
fromIntegral (forall a. Bounded a => a
maxBound :: Int)
intminWord :: Word
intminWord = forall a b. (Integral a, Num b) => a -> b
fromIntegral (forall a. Num a => a -> a
negate (forall a. Bounded a => a
minBound :: Int))
(Word
intmaxQuot10, Word
intmaxRem10) = Word
intmaxWord forall a. Integral a => a -> a -> (a, a)
`quotRem` Word
10
(Word
intminQuot10, Word
intminRem10) = Word
intminWord forall a. Integral a => a -> a -> (a, a)
`quotRem` Word
10
w8IsSpace :: Word8 -> Bool
w8IsSpace :: Word8 -> Bool
w8IsSpace = \ !Word8
w8 ->
let w :: Word
!w :: Word
w = forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
w8
in Word
w forall a. Bits a => a -> a -> a
.&. Word
0x50 forall a. Eq a => a -> a -> Bool
== Word
0
Bool -> Bool -> Bool
&& Word
w forall a. Num a => a -> a -> a
- Word
0x21 forall a. Ord a => a -> a -> Bool
> Word
0x7e
Bool -> Bool -> Bool
&& ( Word
w forall a. Eq a => a -> a -> Bool
== Word
0x20
Bool -> Bool -> Bool
|| Word
w forall a. Num a => a -> a -> a
- Word
0x09 forall a. Ord a => a -> a -> Bool
< Word
5
Bool -> Bool -> Bool
|| Word
w forall a. Eq a => a -> a -> Bool
== Word
0xa0 )
{-# INLINE w8IsSpace #-}
skipSomeWS :: Monad m => ByteStream m r -> ByteStream m r
{-# INLINE skipSomeWS #-}
skipSomeWS :: forall (m :: * -> *) r. Monad m => ByteStream m r -> ByteStream m r
skipSomeWS = forall {m :: * -> *} {r}.
Functor m =>
Int -> ByteStream m r -> ByteStream m r
go Int
0
where
go :: Int -> ByteStream m r -> ByteStream m r
go !Int
n (Chunk ByteString
c ByteStream m r
cs)
| ByteString
k <- (Word8 -> Bool) -> ByteString -> ByteString
B.dropWhile Word8 -> Bool
w8IsSpace ByteString
c
, Bool -> Bool
not forall a b. (a -> b) -> a -> b
$ ByteString -> Bool
B.null ByteString
k = forall (m :: * -> *) r.
ByteString -> ByteStream m r -> ByteStream m r
Chunk ByteString
k ByteStream m r
cs
| Int
n' <- Int
n forall a. Num a => a -> a -> a
+ ByteString -> Int
B.length ByteString
c
, Int
n' forall a. Ord a => a -> a -> Bool
< Int
defaultChunkSize = Int -> ByteStream m r -> ByteStream m r
go Int
n' ByteStream m r
cs
| Bool
otherwise = ByteStream m r
cs
go !Int
n (Go m (ByteStream m r)
m) = forall (m :: * -> *) r. m (ByteStream m r) -> ByteStream m r
Go forall a b. (a -> b) -> a -> b
$ Int -> ByteStream m r -> ByteStream m r
go Int
n forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (ByteStream m r)
m
go Int
_ ByteStream m r
r = ByteStream m r
r
readInt :: Monad m
=> ByteStream m r
-> m (Compose (Of (Maybe Int)) (ByteStream m) r)
{-# INLINABLE readInt #-}
readInt :: forall (m :: * -> *) r.
Monad m =>
ByteStream m r -> m (Compose (Of (Maybe Int)) (ByteStream m) r)
readInt = forall {a} {m :: * -> *} {a}.
(Num a, Monad m) =>
ByteStream m a -> m (Compose (Of (Maybe a)) (ByteStream m) a)
start
where
nada :: g a -> m (Compose (Of (Maybe a)) g a)
nada g a
str = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$! forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose forall a b. (a -> b) -> a -> b
$ forall a. Maybe a
Nothing forall a b. a -> b -> Of a b
:> g a
str
start :: ByteStream m a -> m (Compose (Of (Maybe a)) (ByteStream m) a)
start bs :: ByteStream m a
bs@(Chunk ByteString
c ByteStream m a
cs)
| ByteString -> Bool
B.null ByteString
c = ByteStream m a -> m (Compose (Of (Maybe a)) (ByteStream m) a)
start ByteStream m a
cs
| Word8
w <- ByteString -> Word8
B.unsafeHead ByteString
c
= if | Word8
w forall a. Num a => a -> a -> a
- Word8
0x30 forall a. Ord a => a -> a -> Bool
<= Word8
9 -> forall {a} {m :: * -> *} {a}.
(Num a, Monad m) =>
Bool
-> Maybe Word8
-> ByteStream m a
-> m (Compose (Of (Maybe a)) (ByteStream m) a)
readDec Bool
True forall a. Maybe a
Nothing ByteStream m a
bs
| let rest :: ByteStream m a
rest = forall (m :: * -> *) r.
ByteString -> ByteStream m r -> ByteStream m r
Chunk (HasCallStack => ByteString -> ByteString
B.tail ByteString
c) ByteStream m a
cs
-> if | Word8
w forall a. Eq a => a -> a -> Bool
== Word8
0x2b -> forall {a} {m :: * -> *} {a}.
(Num a, Monad m) =>
Bool
-> Maybe Word8
-> ByteStream m a
-> m (Compose (Of (Maybe a)) (ByteStream m) a)
readDec Bool
True (forall a. a -> Maybe a
Just Word8
w) ByteStream m a
rest
| Word8
w forall a. Eq a => a -> a -> Bool
== Word8
0x2d -> forall {a} {m :: * -> *} {a}.
(Num a, Monad m) =>
Bool
-> Maybe Word8
-> ByteStream m a
-> m (Compose (Of (Maybe a)) (ByteStream m) a)
readDec Bool
False (forall a. a -> Maybe a
Just Word8
w) ByteStream m a
rest
| Bool
otherwise -> forall {m :: * -> *} {g :: * -> *} {a} {a}.
Monad m =>
g a -> m (Compose (Of (Maybe a)) g a)
nada ByteStream m a
bs
start (Go m (ByteStream m a)
m) = m (ByteStream m a)
m forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ByteStream m a -> m (Compose (Of (Maybe a)) (ByteStream m) a)
start
start bs :: ByteStream m a
bs@(Empty a
_) = forall {m :: * -> *} {g :: * -> *} {a} {a}.
Monad m =>
g a -> m (Compose (Of (Maybe a)) g a)
nada ByteStream m a
bs
{-# INLINE readDec #-}
readDec :: Bool
-> Maybe Word8
-> ByteStream m a
-> m (Compose (Of (Maybe a)) (ByteStream m) a)
readDec !Bool
positive Maybe Word8
signByte = forall {a} {m :: * -> *} {a}.
(Num a, Monad m) =>
Int
-> Word
-> ByteStream m a
-> m (Compose (Of (Maybe a)) (ByteStream m) a)
loop Int
0 Word
0
where
loop :: Int
-> Word
-> ByteStream m a
-> m (Compose (Of (Maybe a)) (ByteStream m) a)
loop !Int
nbytes !Word
acc = \ ByteStream m a
str -> case ByteStream m a
str of
Empty a
_ -> forall {a} {m :: * -> *} {m :: * -> *} {a}.
(Num a, Monad m) =>
Int
-> Word
-> ByteStream m a
-> m (Compose (Of (Maybe a)) (ByteStream m) a)
result Int
nbytes Word
acc ByteStream m a
str
Go m (ByteStream m a)
m -> m (ByteStream m a)
m forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Int
-> Word
-> ByteStream m a
-> m (Compose (Of (Maybe a)) (ByteStream m) a)
loop Int
nbytes Word
acc
Chunk ByteString
c ByteStream m a
cs
| !Int
l <- ByteString -> Int
B.length ByteString
c
, Int
l forall a. Ord a => a -> a -> Bool
> Int
0 -> case Word -> ByteString -> (Int, Word, Bool)
accumWord Word
acc ByteString
c of
(Int
0, !Word
_, !Bool
inrange)
| Bool
inrange
-> forall {a} {m :: * -> *} {m :: * -> *} {a}.
(Num a, Monad m) =>
Int
-> Word
-> ByteStream m a
-> m (Compose (Of (Maybe a)) (ByteStream m) a)
result Int
nbytes Word
acc ByteStream m a
str
| Bool
otherwise
-> forall {m :: * -> *} {m :: * -> *} {a} {a}.
Monad m =>
Int
-> Word
-> ByteStream m a
-> m (Compose (Of (Maybe a)) (ByteStream m) a)
overflow Int
nbytes Word
acc ByteStream m a
str
(!Int
n, !Word
a, !Bool
inrange)
| Bool
False <- Bool
inrange
-> forall {m :: * -> *} {m :: * -> *} {a} {a}.
Monad m =>
Int
-> Word
-> ByteStream m a
-> m (Compose (Of (Maybe a)) (ByteStream m) a)
overflow Int
nbytes Word
acc ByteStream m a
str
| Int
n forall a. Ord a => a -> a -> Bool
< Int
l, !ByteString
t <- Int -> ByteString -> ByteString
B.drop Int
n ByteString
c
-> forall {a} {m :: * -> *} {m :: * -> *} {a}.
(Num a, Monad m) =>
Int
-> Word
-> ByteStream m a
-> m (Compose (Of (Maybe a)) (ByteStream m) a)
result (Int
nbytes forall a. Num a => a -> a -> a
+ Int
n) Word
a forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) r.
ByteString -> ByteStream m r -> ByteStream m r
Chunk ByteString
t ByteStream m a
cs
| Word
a forall a. Ord a => a -> a -> Bool
> Word
0 Bool -> Bool -> Bool
|| Int
nbytes forall a. Num a => a -> a -> a
+ Int
n forall a. Ord a => a -> a -> Bool
< Int
defaultChunkSize
-> Int
-> Word
-> ByteStream m a
-> m (Compose (Of (Maybe a)) (ByteStream m) a)
loop (Int
nbytes forall a. Num a => a -> a -> a
+ Int
n) Word
a ByteStream m a
cs
| Bool
otherwise
-> forall {m :: * -> *} {m :: * -> *} {a} {a}.
Monad m =>
Int
-> Word
-> ByteStream m a
-> m (Compose (Of (Maybe a)) (ByteStream m) a)
overflow Int
nbytes Word
acc ByteStream m a
str
| Bool
otherwise
-> Int
-> Word
-> ByteStream m a
-> m (Compose (Of (Maybe a)) (ByteStream m) a)
loop Int
nbytes Word
acc ByteStream m a
cs
accumWord :: Word -> ByteString -> (Int, Word, Bool)
accumWord Word
acc (B.PS ForeignPtr Word8
fp Int
off Int
len) =
forall a. IO a -> a
B.accursedUnutterablePerformIO forall a b. (a -> b) -> a -> b
$ do
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
unsafeWithForeignPtr ForeignPtr Word8
fp forall a b. (a -> b) -> a -> b
$ \Ptr Word8
p -> do
let ptr :: Ptr b
ptr = Ptr Word8
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
off
end :: Ptr b
end = forall a. Ptr a
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
len
x :: (Int, Word, Bool)
x@(!Int
_, !Word
_, !Bool
_) <- if Bool
positive
then Word
-> Word
-> Ptr Word8
-> Ptr Word8
-> Int
-> Word
-> IO (Int, Word, Bool)
digits Word
intmaxQuot10 Word
intmaxRem10 forall a. Ptr a
end forall a. Ptr a
ptr Int
0 Word
acc
else Word
-> Word
-> Ptr Word8
-> Ptr Word8
-> Int
-> Word
-> IO (Int, Word, Bool)
digits Word
intminQuot10 Word
intminRem10 forall a. Ptr a
end forall a. Ptr a
ptr Int
0 Word
acc
forall (m :: * -> *) a. Monad m => a -> m a
return (Int, Word, Bool)
x
where
digits :: Word
-> Word
-> Ptr Word8
-> Ptr Word8
-> Int
-> Word
-> IO (Int, Word, Bool)
digits !Word
maxq !Word
maxr !Ptr Word8
e !Ptr Word8
ptr = Ptr Word8 -> Int -> Word -> IO (Int, Word, Bool)
go Ptr Word8
ptr
where
go :: Ptr Word8 -> Int -> Word -> IO (Int, Word, Bool)
go :: Ptr Word8 -> Int -> Word -> IO (Int, Word, Bool)
go !Ptr Word8
p !Int
b !Word
a | Ptr Word8
p forall a. Eq a => a -> a -> Bool
== Ptr Word8
e = forall (m :: * -> *) a. Monad m => a -> m a
return (Int
b, Word
a, Bool
True)
go !Ptr Word8
p !Int
b !Word
a = do
!Word8
byte <- forall a. Storable a => Ptr a -> IO a
peek Ptr Word8
p
let !w :: Word8
w = Word8
byte forall a. Num a => a -> a -> a
- Word8
0x30
!d :: Word
d = forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
w
if | Word8
w forall a. Ord a => a -> a -> Bool
> Word8
9
-> forall (m :: * -> *) a. Monad m => a -> m a
return (Int
b, Word
a, Bool
True)
| Word
a forall a. Ord a => a -> a -> Bool
< Word
maxq
-> Ptr Word8 -> Int -> Word -> IO (Int, Word, Bool)
go (Ptr Word8
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
1) (Int
b forall a. Num a => a -> a -> a
+ Int
1) (Word
a forall a. Num a => a -> a -> a
* Word
10 forall a. Num a => a -> a -> a
+ Word
d)
| Word
a forall a. Ord a => a -> a -> Bool
> Word
maxq
-> forall (m :: * -> *) a. Monad m => a -> m a
return (Int
b, Word
a, Bool
False)
| Word
d forall a. Ord a => a -> a -> Bool
<= Word
maxr
-> Ptr Word8 -> Int -> Word -> IO (Int, Word, Bool)
go (Ptr Word8
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
1) (Int
b forall a. Num a => a -> a -> a
+ Int
1) (Word
a forall a. Num a => a -> a -> a
* Word
10 forall a. Num a => a -> a -> a
+ Word
d)
| Bool
otherwise
-> forall (m :: * -> *) a. Monad m => a -> m a
return (Int
b, Word
a, Bool
False)
result :: Int
-> Word
-> ByteStream m a
-> m (Compose (Of (Maybe a)) (ByteStream m) a)
result !Int
nbytes !Word
acc ByteStream m a
str
| Int
nbytes forall a. Ord a => a -> a -> Bool
> Int
0, !a
i <- forall a b. (Integral a, Num b) => a -> b
w2int Word
acc = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$! forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just a
i forall a b. a -> b -> Of a b
:> ByteStream m a
str
| Bool
otherwise = forall {m :: * -> *} {m :: * -> *} {a} {a}.
Monad m =>
Int
-> Word
-> ByteStream m a
-> m (Compose (Of (Maybe a)) (ByteStream m) a)
overflow Int
nbytes Word
acc ByteStream m a
str
w2int :: a -> b
w2int !a
n | Bool
positive = forall a b. (Integral a, Num b) => a -> b
fromIntegral a
n
| Bool
otherwise = forall a. Num a => a -> a
negate forall a b. (a -> b) -> a -> b
$! forall a b. (Integral a, Num b) => a -> b
fromIntegral a
n
overflow :: Int
-> Word
-> ByteStream m a
-> m (Compose (Of (Maybe a)) (ByteStream m) a)
overflow Int
0 Word
_ ByteStream m a
str = case Maybe Word8
signByte of
Maybe Word8
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose forall a b. (a -> b) -> a -> b
$ forall a. Maybe a
Nothing forall a b. a -> b -> Of a b
:> ByteStream m a
str
Just Word8
w -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose forall a b. (a -> b) -> a -> b
$ forall a. Maybe a
Nothing forall a b. a -> b -> Of a b
:> forall (m :: * -> *) r.
ByteString -> ByteStream m r -> ByteStream m r
Chunk (Word8 -> ByteString
B.singleton Word8
w) ByteStream m a
str
overflow !Int
nbytes !Word
acc ByteStream m a
str =
let !c :: ByteString
c = Int -> Word -> ByteString
overflowBytes Int
nbytes Word
acc
in forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$! forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose forall a b. (a -> b) -> a -> b
$ forall a. Maybe a
Nothing forall a b. a -> b -> Of a b
:> forall (m :: * -> *) r.
ByteString -> ByteStream m r -> ByteStream m r
Chunk ByteString
c ByteStream m a
str
overflowBytes :: Int -> Word -> B.ByteString
overflowBytes :: Int -> Word -> ByteString
overflowBytes !Int
nbytes !Word
acc =
Int -> (Ptr Word8 -> IO ()) -> ByteString
B.unsafeCreate (Int
nbytes forall a. Num a => a -> a -> a
+ Int
signlen) forall a b. (a -> b) -> a -> b
$ \Ptr Word8
p -> do
let end :: Ptr b
end = Ptr Word8
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` (Int
signlen forall a. Num a => a -> a -> a
- Int
1)
ptr :: Ptr b
ptr = Ptr Word8
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` (Int
nbytes forall a. Num a => a -> a -> a
+ Int
signlen forall a. Num a => a -> a -> a
- Int
1)
Ptr Word8 -> Ptr Word8 -> Word -> IO ()
go forall a. Ptr a
end forall a. Ptr a
ptr Word
acc
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr Word8
p) Maybe Word8
signByte
where
signlen :: Int
signlen = if Maybe Word8
signByte forall a. Eq a => a -> a -> Bool
== forall a. Maybe a
Nothing then Int
0 else Int
1
go :: Ptr Word8 -> Ptr Word8 -> Word -> IO ()
go :: Ptr Word8 -> Ptr Word8 -> Word -> IO ()
go Ptr Word8
end !Ptr Word8
ptr !Word
_ | Ptr Word8
end forall a. Eq a => a -> a -> Bool
== Ptr Word8
ptr = forall (m :: * -> *) a. Monad m => a -> m a
return ()
go Ptr Word8
end !Ptr Word8
ptr !Word
a = do
let (Word
q, Word
r) = Word
a forall a. Integral a => a -> a -> (a, a)
`quotRem` Word
10
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr Word8
ptr forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
r forall a. Num a => a -> a -> a
+ Word8
0x30
Ptr Word8 -> Ptr Word8 -> Word -> IO ()
go Ptr Word8
end (Ptr Word8
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` (-Int
1)) Word
q