-- | This reworks 'Text.Megaparsec.Stream' to split interfaces.
-- See https://hackage.haskell.org/package/megaparsec-9.0.1/docs/Text-Megaparsec-Stream.html
module SimpleParser.Stream
  ( Chunked (..)
  , Stream (..)
  , defaultStreamDropN
  , defaultStreamDropWhile
  , OffsetStream (..)
  , newOffsetStream
  ) where

import Data.Bifunctor (first, second)
import Data.Foldable (toList)
import Data.Kind (Type)
import Data.List (uncons)
import Data.Sequence (Seq (..))
import qualified Data.Sequence as Seq
import Data.Text (Text)
import qualified Data.Text as T

-- | 'Chunked' captures the basic relationship between tokens and chunks of them.
-- Basically, these things behave like lists, sequences, text, etc.
class Monoid chunk => Chunked chunk token | chunk -> token where
  consChunk :: token -> chunk -> chunk
  unconsChunk :: chunk -> Maybe (token, chunk)
  tokenToChunk :: token -> chunk
  tokensToChunk :: [token] -> chunk
  chunkToTokens :: chunk -> [token]
  chunkLength :: chunk -> Int
  chunkEmpty :: chunk -> Bool

-- TODO(ejconlon) Add instances for Strict BS, Lazy BS, and Lazy Text

instance Chunked [a] a where
  consChunk :: a -> [a] -> [a]
consChunk = (:)
  unconsChunk :: [a] -> Maybe (a, [a])
unconsChunk = [a] -> Maybe (a, [a])
forall a. [a] -> Maybe (a, [a])
uncons
  tokenToChunk :: a -> [a]
tokenToChunk a
a = [a
a]
  tokensToChunk :: [a] -> [a]
tokensToChunk = [a] -> [a]
forall a. a -> a
id
  chunkToTokens :: [a] -> [a]
chunkToTokens = [a] -> [a]
forall a. a -> a
id
  chunkLength :: [a] -> Int
chunkLength = [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length
  chunkEmpty :: [a] -> Bool
chunkEmpty = [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null

instance Chunked (Seq a) a where
  consChunk :: a -> Seq a -> Seq a
consChunk = a -> Seq a -> Seq a
forall a. a -> Seq a -> Seq a
(:<|)
  unconsChunk :: Seq a -> Maybe (a, Seq a)
unconsChunk Seq a
s =
    case Seq a
s of
      Seq a
Empty -> Maybe (a, Seq a)
forall a. Maybe a
Nothing
      a
a :<| Seq a
b -> (a, Seq a) -> Maybe (a, Seq a)
forall a. a -> Maybe a
Just (a
a, Seq a
b)
  tokenToChunk :: a -> Seq a
tokenToChunk = a -> Seq a
forall a. a -> Seq a
Seq.singleton
  tokensToChunk :: [a] -> Seq a
tokensToChunk = [a] -> Seq a
forall a. [a] -> Seq a
Seq.fromList
  chunkToTokens :: Seq a -> [a]
chunkToTokens = Seq a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList
  chunkLength :: Seq a -> Int
chunkLength = Seq a -> Int
forall a. Seq a -> Int
Seq.length
  chunkEmpty :: Seq a -> Bool
chunkEmpty = Seq a -> Bool
forall a. Seq a -> Bool
Seq.null

instance Chunked Text Char where
  consChunk :: Char -> Text -> Text
consChunk = Char -> Text -> Text
T.cons
  unconsChunk :: Text -> Maybe (Char, Text)
unconsChunk = Text -> Maybe (Char, Text)
T.uncons
  tokenToChunk :: Char -> Text
tokenToChunk = Char -> Text
T.singleton
  tokensToChunk :: [Char] -> Text
tokensToChunk = [Char] -> Text
T.pack
  chunkToTokens :: Text -> [Char]
chunkToTokens = Text -> [Char]
T.unpack
  chunkLength :: Text -> Int
chunkLength = Text -> Int
T.length
  chunkEmpty :: Text -> Bool
chunkEmpty = Text -> Bool
T.null

-- | 'Stream' lets us peel off tokens and chunks for parsing
-- with explicit state passing.
class Chunked (Chunk s) (Token s) => Stream s where
  type family Chunk s :: Type
  type family Token s :: Type

  streamTake1 :: s -> Maybe (Token s, s)
  streamTakeN :: Int -> s -> Maybe (Chunk s, s)
  streamTakeWhile :: (Token s -> Bool) -> s -> (Chunk s, s)

  streamDropN :: Int -> s -> Maybe (Int, s)
  streamDropN = Int -> s -> Maybe (Int, s)
forall s. Stream s => Int -> s -> Maybe (Int, s)
defaultStreamDropN

  streamDropWhile :: (Token s -> Bool) -> s -> (Int, s)
  streamDropWhile = (Token s -> Bool) -> s -> (Int, s)
forall s. Stream s => (Token s -> Bool) -> s -> (Int, s)
defaultStreamDropWhile

-- TODO(ejconlon) Specialize drops

defaultStreamDropN :: Stream s => Int -> s -> Maybe (Int, s)
defaultStreamDropN :: Int -> s -> Maybe (Int, s)
defaultStreamDropN Int
n = ((Chunk s, s) -> (Int, s)) -> Maybe (Chunk s, s) -> Maybe (Int, s)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Chunk s -> Int) -> (Chunk s, s) -> (Int, s)
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first Chunk s -> Int
forall chunk token. Chunked chunk token => chunk -> Int
chunkLength) (Maybe (Chunk s, s) -> Maybe (Int, s))
-> (s -> Maybe (Chunk s, s)) -> s -> Maybe (Int, s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> s -> Maybe (Chunk s, s)
forall s. Stream s => Int -> s -> Maybe (Chunk s, s)
streamTakeN Int
n

defaultStreamDropWhile :: Stream s => (Token s -> Bool) -> s -> (Int, s)
defaultStreamDropWhile :: (Token s -> Bool) -> s -> (Int, s)
defaultStreamDropWhile Token s -> Bool
pcate = (Chunk s -> Int) -> (Chunk s, s) -> (Int, s)
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first Chunk s -> Int
forall chunk token. Chunked chunk token => chunk -> Int
chunkLength ((Chunk s, s) -> (Int, s)) -> (s -> (Chunk s, s)) -> s -> (Int, s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Token s -> Bool) -> s -> (Chunk s, s)
forall s. Stream s => (Token s -> Bool) -> s -> (Chunk s, s)
streamTakeWhile Token s -> Bool
pcate

instance Stream [a] where
  type instance Chunk [a] = [a]
  type instance Token [a] = a

  streamTake1 :: [a] -> Maybe (Token [a], [a])
streamTake1 [a]
l =
    case [a]
l of
      [] -> Maybe (Token [a], [a])
forall a. Maybe a
Nothing
      a
t:[a]
ts -> (a, [a]) -> Maybe (a, [a])
forall a. a -> Maybe a
Just (a
t, [a]
ts)
  streamTakeN :: Int -> [a] -> Maybe (Chunk [a], [a])
streamTakeN Int
n [a]
s
    | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0 = ([a], [a]) -> Maybe ([a], [a])
forall a. a -> Maybe a
Just ([], [a]
s)
    | [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [a]
s = Maybe (Chunk [a], [a])
forall a. Maybe a
Nothing
    | Bool
otherwise = ([a], [a]) -> Maybe ([a], [a])
forall a. a -> Maybe a
Just (Int -> [a] -> ([a], [a])
forall a. Int -> [a] -> ([a], [a])
splitAt Int
n [a]
s)
  streamTakeWhile :: (Token [a] -> Bool) -> [a] -> (Chunk [a], [a])
streamTakeWhile = (Token [a] -> Bool) -> [a] -> (Chunk [a], [a])
forall a. (a -> Bool) -> [a] -> ([a], [a])
span

instance Stream (Seq a) where
  type instance Chunk (Seq a) = Seq a
  type instance Token (Seq a) = a

  streamTake1 :: Seq a -> Maybe (Token (Seq a), Seq a)
streamTake1 Seq a
s =
    case Seq a
s of
      Seq a
Empty -> Maybe (Token (Seq a), Seq a)
forall a. Maybe a
Nothing
      a
t :<| Seq a
ts -> (a, Seq a) -> Maybe (a, Seq a)
forall a. a -> Maybe a
Just (a
t, Seq a
ts)
  streamTakeN :: Int -> Seq a -> Maybe (Chunk (Seq a), Seq a)
streamTakeN Int
n Seq a
s
    | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0 = (Seq a, Seq a) -> Maybe (Seq a, Seq a)
forall a. a -> Maybe a
Just (Seq a
forall a. Seq a
Seq.empty, Seq a
s)
    | Seq a -> Bool
forall a. Seq a -> Bool
Seq.null Seq a
s = Maybe (Chunk (Seq a), Seq a)
forall a. Maybe a
Nothing
    | Bool
otherwise = (Seq a, Seq a) -> Maybe (Seq a, Seq a)
forall a. a -> Maybe a
Just (Int -> Seq a -> (Seq a, Seq a)
forall a. Int -> Seq a -> (Seq a, Seq a)
Seq.splitAt Int
n Seq a
s)
  streamTakeWhile :: (Token (Seq a) -> Bool) -> Seq a -> (Chunk (Seq a), Seq a)
streamTakeWhile = (Token (Seq a) -> Bool) -> Seq a -> (Chunk (Seq a), Seq a)
forall a. (a -> Bool) -> Seq a -> (Seq a, Seq a)
Seq.spanl

instance Stream Text where
  type instance Chunk Text = Text
  type instance Token Text = Char

  streamTake1 :: Text -> Maybe (Token Text, Text)
streamTake1 = Text -> Maybe (Char, Text)
Text -> Maybe (Token Text, Text)
T.uncons
  streamTakeN :: Int -> Text -> Maybe (Chunk Text, Text)
streamTakeN Int
n Text
s
    | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0 = (Text, Text) -> Maybe (Text, Text)
forall a. a -> Maybe a
Just (Text
T.empty, Text
s)
    | Text -> Bool
T.null Text
s = Maybe (Chunk Text, Text)
forall a. Maybe a
Nothing
    | Bool
otherwise = (Text, Text) -> Maybe (Text, Text)
forall a. a -> Maybe a
Just (Int -> Text -> (Text, Text)
T.splitAt Int
n Text
s)
  streamTakeWhile :: (Token Text -> Bool) -> Text -> (Chunk Text, Text)
streamTakeWhile = (Char -> Bool) -> Text -> (Text, Text)
(Token Text -> Bool) -> Text -> (Chunk Text, Text)
T.span

data OffsetStream s = OffsetStream
  { OffsetStream s -> Int
osOffset :: !Int
  , OffsetStream s -> s
osState :: !s
  } deriving (OffsetStream s -> OffsetStream s -> Bool
(OffsetStream s -> OffsetStream s -> Bool)
-> (OffsetStream s -> OffsetStream s -> Bool)
-> Eq (OffsetStream s)
forall s. Eq s => OffsetStream s -> OffsetStream s -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OffsetStream s -> OffsetStream s -> Bool
$c/= :: forall s. Eq s => OffsetStream s -> OffsetStream s -> Bool
== :: OffsetStream s -> OffsetStream s -> Bool
$c== :: forall s. Eq s => OffsetStream s -> OffsetStream s -> Bool
Eq, Int -> OffsetStream s -> ShowS
[OffsetStream s] -> ShowS
OffsetStream s -> [Char]
(Int -> OffsetStream s -> ShowS)
-> (OffsetStream s -> [Char])
-> ([OffsetStream s] -> ShowS)
-> Show (OffsetStream s)
forall s. Show s => Int -> OffsetStream s -> ShowS
forall s. Show s => [OffsetStream s] -> ShowS
forall s. Show s => OffsetStream s -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [OffsetStream s] -> ShowS
$cshowList :: forall s. Show s => [OffsetStream s] -> ShowS
show :: OffsetStream s -> [Char]
$cshow :: forall s. Show s => OffsetStream s -> [Char]
showsPrec :: Int -> OffsetStream s -> ShowS
$cshowsPrec :: forall s. Show s => Int -> OffsetStream s -> ShowS
Show, a -> OffsetStream b -> OffsetStream a
(a -> b) -> OffsetStream a -> OffsetStream b
(forall a b. (a -> b) -> OffsetStream a -> OffsetStream b)
-> (forall a b. a -> OffsetStream b -> OffsetStream a)
-> Functor OffsetStream
forall a b. a -> OffsetStream b -> OffsetStream a
forall a b. (a -> b) -> OffsetStream a -> OffsetStream b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> OffsetStream b -> OffsetStream a
$c<$ :: forall a b. a -> OffsetStream b -> OffsetStream a
fmap :: (a -> b) -> OffsetStream a -> OffsetStream b
$cfmap :: forall a b. (a -> b) -> OffsetStream a -> OffsetStream b
Functor, OffsetStream a -> Bool
(a -> m) -> OffsetStream a -> m
(a -> b -> b) -> b -> OffsetStream a -> b
(forall m. Monoid m => OffsetStream m -> m)
-> (forall m a. Monoid m => (a -> m) -> OffsetStream a -> m)
-> (forall m a. Monoid m => (a -> m) -> OffsetStream a -> m)
-> (forall a b. (a -> b -> b) -> b -> OffsetStream a -> b)
-> (forall a b. (a -> b -> b) -> b -> OffsetStream a -> b)
-> (forall b a. (b -> a -> b) -> b -> OffsetStream a -> b)
-> (forall b a. (b -> a -> b) -> b -> OffsetStream a -> b)
-> (forall a. (a -> a -> a) -> OffsetStream a -> a)
-> (forall a. (a -> a -> a) -> OffsetStream a -> a)
-> (forall a. OffsetStream a -> [a])
-> (forall a. OffsetStream a -> Bool)
-> (forall a. OffsetStream a -> Int)
-> (forall a. Eq a => a -> OffsetStream a -> Bool)
-> (forall a. Ord a => OffsetStream a -> a)
-> (forall a. Ord a => OffsetStream a -> a)
-> (forall a. Num a => OffsetStream a -> a)
-> (forall a. Num a => OffsetStream a -> a)
-> Foldable OffsetStream
forall a. Eq a => a -> OffsetStream a -> Bool
forall a. Num a => OffsetStream a -> a
forall a. Ord a => OffsetStream a -> a
forall m. Monoid m => OffsetStream m -> m
forall a. OffsetStream a -> Bool
forall a. OffsetStream a -> Int
forall a. OffsetStream a -> [a]
forall a. (a -> a -> a) -> OffsetStream a -> a
forall m a. Monoid m => (a -> m) -> OffsetStream a -> m
forall b a. (b -> a -> b) -> b -> OffsetStream a -> b
forall a b. (a -> b -> b) -> b -> OffsetStream a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: OffsetStream a -> a
$cproduct :: forall a. Num a => OffsetStream a -> a
sum :: OffsetStream a -> a
$csum :: forall a. Num a => OffsetStream a -> a
minimum :: OffsetStream a -> a
$cminimum :: forall a. Ord a => OffsetStream a -> a
maximum :: OffsetStream a -> a
$cmaximum :: forall a. Ord a => OffsetStream a -> a
elem :: a -> OffsetStream a -> Bool
$celem :: forall a. Eq a => a -> OffsetStream a -> Bool
length :: OffsetStream a -> Int
$clength :: forall a. OffsetStream a -> Int
null :: OffsetStream a -> Bool
$cnull :: forall a. OffsetStream a -> Bool
toList :: OffsetStream a -> [a]
$ctoList :: forall a. OffsetStream a -> [a]
foldl1 :: (a -> a -> a) -> OffsetStream a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> OffsetStream a -> a
foldr1 :: (a -> a -> a) -> OffsetStream a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> OffsetStream a -> a
foldl' :: (b -> a -> b) -> b -> OffsetStream a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> OffsetStream a -> b
foldl :: (b -> a -> b) -> b -> OffsetStream a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> OffsetStream a -> b
foldr' :: (a -> b -> b) -> b -> OffsetStream a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> OffsetStream a -> b
foldr :: (a -> b -> b) -> b -> OffsetStream a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> OffsetStream a -> b
foldMap' :: (a -> m) -> OffsetStream a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> OffsetStream a -> m
foldMap :: (a -> m) -> OffsetStream a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> OffsetStream a -> m
fold :: OffsetStream m -> m
$cfold :: forall m. Monoid m => OffsetStream m -> m
Foldable, Functor OffsetStream
Foldable OffsetStream
Functor OffsetStream
-> Foldable OffsetStream
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> OffsetStream a -> f (OffsetStream b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    OffsetStream (f a) -> f (OffsetStream a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> OffsetStream a -> m (OffsetStream b))
-> (forall (m :: * -> *) a.
    Monad m =>
    OffsetStream (m a) -> m (OffsetStream a))
-> Traversable OffsetStream
(a -> f b) -> OffsetStream a -> f (OffsetStream b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
OffsetStream (m a) -> m (OffsetStream a)
forall (f :: * -> *) a.
Applicative f =>
OffsetStream (f a) -> f (OffsetStream a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> OffsetStream a -> m (OffsetStream b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> OffsetStream a -> f (OffsetStream b)
sequence :: OffsetStream (m a) -> m (OffsetStream a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
OffsetStream (m a) -> m (OffsetStream a)
mapM :: (a -> m b) -> OffsetStream a -> m (OffsetStream b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> OffsetStream a -> m (OffsetStream b)
sequenceA :: OffsetStream (f a) -> f (OffsetStream a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
OffsetStream (f a) -> f (OffsetStream a)
traverse :: (a -> f b) -> OffsetStream a -> f (OffsetStream b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> OffsetStream a -> f (OffsetStream b)
$cp2Traversable :: Foldable OffsetStream
$cp1Traversable :: Functor OffsetStream
Traversable)

instance Stream s => Stream (OffsetStream s) where
  type instance Chunk (OffsetStream s) = Chunk s
  type instance Token (OffsetStream s) = Token s

  streamTake1 :: OffsetStream s -> Maybe (Token (OffsetStream s), OffsetStream s)
streamTake1 (OffsetStream Int
o s
s) = ((Token s, s) -> (Token s, OffsetStream s))
-> Maybe (Token s, s) -> Maybe (Token s, OffsetStream s)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((s -> OffsetStream s) -> (Token s, s) -> (Token s, OffsetStream s)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second (Int -> s -> OffsetStream s
forall s. Int -> s -> OffsetStream s
OffsetStream (Int -> Int
forall a. Enum a => a -> a
succ Int
o))) (s -> Maybe (Token s, s)
forall s. Stream s => s -> Maybe (Token s, s)
streamTake1 s
s)
  streamTakeN :: Int
-> OffsetStream s -> Maybe (Chunk (OffsetStream s), OffsetStream s)
streamTakeN Int
n (OffsetStream Int
o s
s) = ((Chunk s, s) -> (Chunk s, OffsetStream s))
-> Maybe (Chunk s, s) -> Maybe (Chunk s, OffsetStream s)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Chunk s, s) -> (Chunk s, OffsetStream s)
go (Int -> s -> Maybe (Chunk s, s)
forall s. Stream s => Int -> s -> Maybe (Chunk s, s)
streamTakeN Int
n s
s) where
    go :: (Chunk s, s) -> (Chunk s, OffsetStream s)
go (Chunk s
a, s
b) = (Chunk s
a, Int -> s -> OffsetStream s
forall s. Int -> s -> OffsetStream s
OffsetStream (Int
o Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Chunk s -> Int
forall chunk token. Chunked chunk token => chunk -> Int
chunkLength Chunk s
a) s
b)
  streamTakeWhile :: (Token (OffsetStream s) -> Bool)
-> OffsetStream s -> (Chunk (OffsetStream s), OffsetStream s)
streamTakeWhile Token (OffsetStream s) -> Bool
pcate (OffsetStream Int
o s
s) =
    let (Chunk s
a, s
b) = (Token s -> Bool) -> s -> (Chunk s, s)
forall s. Stream s => (Token s -> Bool) -> s -> (Chunk s, s)
streamTakeWhile Token s -> Bool
Token (OffsetStream s) -> Bool
pcate s
s
    in (Chunk s
Chunk (OffsetStream s)
a, Int -> s -> OffsetStream s
forall s. Int -> s -> OffsetStream s
OffsetStream (Int
o Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Chunk s -> Int
forall chunk token. Chunked chunk token => chunk -> Int
chunkLength Chunk s
a) s
b)
  streamDropN :: Int -> OffsetStream s -> Maybe (Int, OffsetStream s)
streamDropN Int
n (OffsetStream Int
o s
s) = ((Int, s) -> (Int, OffsetStream s))
-> Maybe (Int, s) -> Maybe (Int, OffsetStream s)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Int, s) -> (Int, OffsetStream s)
go (Int -> s -> Maybe (Int, s)
forall s. Stream s => Int -> s -> Maybe (Int, s)
streamDropN Int
n s
s) where
    go :: (Int, s) -> (Int, OffsetStream s)
go (Int
m, s
b) = (Int
m, Int -> s -> OffsetStream s
forall s. Int -> s -> OffsetStream s
OffsetStream (Int
o Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
m) s
b)
  streamDropWhile :: (Token (OffsetStream s) -> Bool)
-> OffsetStream s -> (Int, OffsetStream s)
streamDropWhile Token (OffsetStream s) -> Bool
pcate (OffsetStream Int
o s
s) =
    let (Int
m, s
b) = (Token s -> Bool) -> s -> (Int, s)
forall s. Stream s => (Token s -> Bool) -> s -> (Int, s)
streamDropWhile Token s -> Bool
Token (OffsetStream s) -> Bool
pcate s
s
    in (Int
m, Int -> s -> OffsetStream s
forall s. Int -> s -> OffsetStream s
OffsetStream (Int
o Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
m) s
b)

newOffsetStream :: s -> OffsetStream s
newOffsetStream :: s -> OffsetStream s
newOffsetStream = Int -> s -> OffsetStream s
forall s. Int -> s -> OffsetStream s
OffsetStream Int
0