module SimpleParser.Input
( withToken
, withChunk
, peekToken
, popToken
, peekChunk
, popChunk
, dropChunk
, isEnd
, matchEnd
, anyToken
, anyChunk
, satisfyToken
, foldTokensWhile
, takeTokensWhile
, takeTokensWhile1
, dropTokensWhile
, dropTokensWhile1
, matchToken
, matchChunk
) where
import Control.Monad.State (gets, state)
import Data.Bifunctor (first)
import Data.Maybe (isNothing)
import SimpleParser.Chunked (Chunked (..))
import SimpleParser.Parser (ParserT (..), markWithOptStateParser, markWithStateParser)
import SimpleParser.Result (CompoundError (..), ParseError (..), ParseErrorBundle (..), ParseResult (..), RawError (..),
StreamError (..))
import SimpleParser.Stack (emptyStack)
import SimpleParser.Stream (Stream (..))
throwStreamError :: Monad m => RawError (Chunk s) (Token s) -> ParserT l s e m a
throwStreamError :: RawError (Chunk s) (Token s) -> ParserT l s e m a
throwStreamError RawError (Chunk s) (Token s)
re = (s -> m (Maybe (ParseResult l s e a))) -> ParserT l s e m a
forall l s e (m :: * -> *) a.
(s -> m (Maybe (ParseResult l s e a))) -> ParserT l s e m a
ParserT (\s
s -> Maybe (ParseResult l s e a) -> m (Maybe (ParseResult l s e a))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ParseResult l s e a -> Maybe (ParseResult l s e a)
forall a. a -> Maybe a
Just (ParseErrorBundle l s e -> ParseResult l s e a
forall l s e a. ParseErrorBundle l s e -> ParseResult l s e a
ParseResultError (NESeq (ParseError l s e) -> ParseErrorBundle l s e
forall l s e. NESeq (ParseError l s e) -> ParseErrorBundle l s e
ParseErrorBundle (ParseError l s e -> NESeq (ParseError l s e)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (MarkStack l s -> s -> CompoundError s e -> ParseError l s e
forall l s e.
MarkStack l s -> s -> CompoundError s e -> ParseError l s e
ParseError MarkStack l s
forall a. Stack a
emptyStack s
s (StreamError s -> CompoundError s e
forall s e. StreamError s -> CompoundError s e
CompoundErrorStream (RawError (Chunk s) (Token s) -> StreamError s
forall s. RawError (Chunk s) (Token s) -> StreamError s
StreamError RawError (Chunk s) (Token s)
re))))))))
withToken :: (Stream s, Monad m) => Maybe l -> (Maybe (Token s) -> ParserT l s e m a) -> ParserT l s e m a
withToken :: Maybe l
-> (Maybe (Token s) -> ParserT l s e m a) -> ParserT l s e m a
withToken Maybe l
ml = Maybe l
-> (s -> Maybe (Token s, s))
-> (Maybe (Token s) -> ParserT l s e m a)
-> ParserT l s e m a
forall (m :: * -> *) l s b e a.
Monad m =>
Maybe l
-> (s -> Maybe (b, s))
-> (Maybe b -> ParserT l s e m a)
-> ParserT l s e m a
markWithOptStateParser Maybe l
ml s -> Maybe (Token s, s)
forall s. Stream s => s -> Maybe (Token s, s)
streamTake1
withChunk :: (Stream s, Monad m) => Maybe l -> Int -> (Maybe (Chunk s) -> ParserT l s e m a) -> ParserT l s e m a
withChunk :: Maybe l
-> Int
-> (Maybe (Chunk s) -> ParserT l s e m a)
-> ParserT l s e m a
withChunk Maybe l
ml Int
n = Maybe l
-> (s -> Maybe (Chunk s, s))
-> (Maybe (Chunk s) -> ParserT l s e m a)
-> ParserT l s e m a
forall (m :: * -> *) l s b e a.
Monad m =>
Maybe l
-> (s -> Maybe (b, s))
-> (Maybe b -> ParserT l s e m a)
-> ParserT l s e m a
markWithOptStateParser Maybe l
ml (Int -> s -> Maybe (Chunk s, s)
forall s. Stream s => Int -> s -> Maybe (Chunk s, s)
streamTakeN Int
n)
peekToken :: (Stream s, Monad m) => ParserT l s e m (Maybe (Token s))
peekToken :: ParserT l s e m (Maybe (Token s))
peekToken = (s -> Maybe (Token s)) -> ParserT l s e m (Maybe (Token s))
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets (((Token s, s) -> Token s) -> Maybe (Token s, s) -> Maybe (Token s)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Token s, s) -> Token s
forall a b. (a, b) -> a
fst (Maybe (Token s, s) -> Maybe (Token s))
-> (s -> Maybe (Token s, s)) -> s -> Maybe (Token s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> Maybe (Token s, s)
forall s. Stream s => s -> Maybe (Token s, s)
streamTake1)
popToken :: (Stream s, Monad m) => ParserT l s e m (Maybe (Token s))
popToken :: ParserT l s e m (Maybe (Token s))
popToken = (s -> (Maybe (Token s), s)) -> ParserT l s e m (Maybe (Token s))
forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
state (\s
stream -> (Maybe (Token s), s)
-> ((Token s, s) -> (Maybe (Token s), s))
-> Maybe (Token s, s)
-> (Maybe (Token s), s)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Maybe (Token s)
forall a. Maybe a
Nothing, s
stream) ((Token s -> Maybe (Token s))
-> (Token s, s) -> (Maybe (Token s), s)
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first Token s -> Maybe (Token s)
forall a. a -> Maybe a
Just) (s -> Maybe (Token s, s)
forall s. Stream s => s -> Maybe (Token s, s)
streamTake1 s
stream))
peekChunk :: (Stream s, Monad m) => Int -> ParserT l s e m (Maybe (Chunk s))
peekChunk :: Int -> ParserT l s e m (Maybe (Chunk s))
peekChunk Int
n = (s -> Maybe (Chunk s)) -> ParserT l s e m (Maybe (Chunk s))
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets (((Chunk s, s) -> Chunk s) -> Maybe (Chunk s, s) -> Maybe (Chunk s)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Chunk s, s) -> Chunk s
forall a b. (a, b) -> a
fst (Maybe (Chunk s, s) -> Maybe (Chunk s))
-> (s -> Maybe (Chunk s, s)) -> s -> Maybe (Chunk 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)
popChunk :: (Stream s, Monad m) => Int -> ParserT l s e m (Maybe (Chunk s))
popChunk :: Int -> ParserT l s e m (Maybe (Chunk s))
popChunk Int
n = (s -> (Maybe (Chunk s), s)) -> ParserT l s e m (Maybe (Chunk s))
forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
state (\s
stream -> (Maybe (Chunk s), s)
-> ((Chunk s, s) -> (Maybe (Chunk s), s))
-> Maybe (Chunk s, s)
-> (Maybe (Chunk s), s)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Maybe (Chunk s)
forall a. Maybe a
Nothing, s
stream) ((Chunk s -> Maybe (Chunk s))
-> (Chunk s, s) -> (Maybe (Chunk s), s)
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first Chunk s -> Maybe (Chunk s)
forall a. a -> Maybe a
Just) (Int -> s -> Maybe (Chunk s, s)
forall s. Stream s => Int -> s -> Maybe (Chunk s, s)
streamTakeN Int
n s
stream))
dropChunk :: (Stream s, Monad m) => Int -> ParserT l s e m (Maybe Int)
dropChunk :: Int -> ParserT l s e m (Maybe Int)
dropChunk Int
n = (s -> (Maybe Int, s)) -> ParserT l s e m (Maybe Int)
forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
state (\s
stream -> (Maybe Int, s)
-> ((Int, s) -> (Maybe Int, s)) -> Maybe (Int, s) -> (Maybe Int, s)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Maybe Int
forall a. Maybe a
Nothing, s
stream) ((Int -> Maybe Int) -> (Int, s) -> (Maybe Int, s)
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first Int -> Maybe Int
forall a. a -> Maybe a
Just) (Int -> s -> Maybe (Int, s)
forall s. Stream s => Int -> s -> Maybe (Int, s)
streamDropN Int
n s
stream))
isEnd :: (Stream s, Monad m) => ParserT l s e m Bool
isEnd :: ParserT l s e m Bool
isEnd = (Maybe (Token s) -> Bool)
-> ParserT l s e m (Maybe (Token s)) -> ParserT l s e m Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Maybe (Token s) -> Bool
forall a. Maybe a -> Bool
isNothing ParserT l s e m (Maybe (Token s))
forall s (m :: * -> *) l e.
(Stream s, Monad m) =>
ParserT l s e m (Maybe (Token s))
peekToken
matchEnd :: (Stream s, Monad m) => ParserT l s e m ()
matchEnd :: ParserT l s e m ()
matchEnd = Maybe l
-> (Maybe (Token s) -> ParserT l s e m ()) -> ParserT l s e m ()
forall s (m :: * -> *) l e a.
(Stream s, Monad m) =>
Maybe l
-> (Maybe (Token s) -> ParserT l s e m a) -> ParserT l s e m a
withToken Maybe l
forall a. Maybe a
Nothing (ParserT l s e m ()
-> (Token s -> ParserT l s e m ())
-> Maybe (Token s)
-> ParserT l s e m ()
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (() -> ParserT l s e m ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()) (RawError (Chunk s) (Token s) -> ParserT l s e m ()
forall (m :: * -> *) s l e a.
Monad m =>
RawError (Chunk s) (Token s) -> ParserT l s e m a
throwStreamError (RawError (Chunk s) (Token s) -> ParserT l s e m ())
-> (Token s -> RawError (Chunk s) (Token s))
-> Token s
-> ParserT l s e m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Token s -> RawError (Chunk s) (Token s)
forall chunk token. token -> RawError chunk token
RawErrorMatchEnd))
anyToken :: (Stream s, Monad m) => ParserT l s e m (Token s)
anyToken :: ParserT l s e m (Token s)
anyToken = Maybe l
-> (Maybe (Token s) -> ParserT l s e m (Token s))
-> ParserT l s e m (Token s)
forall s (m :: * -> *) l e a.
(Stream s, Monad m) =>
Maybe l
-> (Maybe (Token s) -> ParserT l s e m a) -> ParserT l s e m a
withToken Maybe l
forall a. Maybe a
Nothing (ParserT l s e m (Token s)
-> (Token s -> ParserT l s e m (Token s))
-> Maybe (Token s)
-> ParserT l s e m (Token s)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (RawError (Chunk s) (Token s) -> ParserT l s e m (Token s)
forall (m :: * -> *) s l e a.
Monad m =>
RawError (Chunk s) (Token s) -> ParserT l s e m a
throwStreamError RawError (Chunk s) (Token s)
forall chunk token. RawError chunk token
RawErrorAnyToken) Token s -> ParserT l s e m (Token s)
forall (f :: * -> *) a. Applicative f => a -> f a
pure)
anyChunk :: (Stream s, Monad m) => Int -> ParserT l s e m (Chunk s)
anyChunk :: Int -> ParserT l s e m (Chunk s)
anyChunk Int
n = Maybe l
-> Int
-> (Maybe (Chunk s) -> ParserT l s e m (Chunk s))
-> ParserT l s e m (Chunk s)
forall s (m :: * -> *) l e a.
(Stream s, Monad m) =>
Maybe l
-> Int
-> (Maybe (Chunk s) -> ParserT l s e m a)
-> ParserT l s e m a
withChunk Maybe l
forall a. Maybe a
Nothing Int
n (ParserT l s e m (Chunk s)
-> (Chunk s -> ParserT l s e m (Chunk s))
-> Maybe (Chunk s)
-> ParserT l s e m (Chunk s)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (RawError (Chunk s) (Token s) -> ParserT l s e m (Chunk s)
forall (m :: * -> *) s l e a.
Monad m =>
RawError (Chunk s) (Token s) -> ParserT l s e m a
throwStreamError RawError (Chunk s) (Token s)
forall chunk token. RawError chunk token
RawErrorAnyChunk) Chunk s -> ParserT l s e m (Chunk s)
forall (f :: * -> *) a. Applicative f => a -> f a
pure)
satisfyToken :: (Stream s, Monad m) => Maybe l -> (Token s -> Bool) -> ParserT l s e m (Token s)
satisfyToken :: Maybe l -> (Token s -> Bool) -> ParserT l s e m (Token s)
satisfyToken Maybe l
ml Token s -> Bool
pcate = Maybe l
-> (Maybe (Token s) -> ParserT l s e m (Token s))
-> ParserT l s e m (Token s)
forall s (m :: * -> *) l e a.
(Stream s, Monad m) =>
Maybe l
-> (Maybe (Token s) -> ParserT l s e m a) -> ParserT l s e m a
withToken Maybe l
ml ((Maybe (Token s) -> ParserT l s e m (Token s))
-> ParserT l s e m (Token s))
-> (Maybe (Token s) -> ParserT l s e m (Token s))
-> ParserT l s e m (Token s)
forall a b. (a -> b) -> a -> b
$ \Maybe (Token s)
mu ->
case Maybe (Token s)
mu of
Just Token s
u | Token s -> Bool
pcate Token s
u -> Token s -> ParserT l s e m (Token s)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Token s
u
Maybe (Token s)
_ -> RawError (Chunk s) (Token s) -> ParserT l s e m (Token s)
forall (m :: * -> *) s l e a.
Monad m =>
RawError (Chunk s) (Token s) -> ParserT l s e m a
throwStreamError (Maybe (Token s) -> RawError (Chunk s) (Token s)
forall chunk token. Maybe token -> RawError chunk token
RawErrorSatisfyToken Maybe (Token s)
mu)
foldTokensWhile :: (Stream s, Monad m) => (Token s -> x -> (Bool, x)) -> x -> ParserT l s e m x
foldTokensWhile :: (Token s -> x -> (Bool, x)) -> x -> ParserT l s e m x
foldTokensWhile Token s -> x -> (Bool, x)
processNext = x -> ParserT l s e m x
go where
go :: x -> ParserT l s e m x
go !x
x = do
Maybe (Token s)
m <- ParserT l s e m (Maybe (Token s))
forall s (m :: * -> *) l e.
(Stream s, Monad m) =>
ParserT l s e m (Maybe (Token s))
peekToken
case Maybe (Token s)
m of
Maybe (Token s)
Nothing -> x -> ParserT l s e m x
forall (f :: * -> *) a. Applicative f => a -> f a
pure x
x
Just Token s
c ->
let (Bool
ok, x
newX) = Token s -> x -> (Bool, x)
processNext Token s
c x
x
in if Bool
ok
then ParserT l s e m (Maybe (Token s))
forall s (m :: * -> *) l e.
(Stream s, Monad m) =>
ParserT l s e m (Maybe (Token s))
popToken ParserT l s e m (Maybe (Token s))
-> ParserT l s e m x -> ParserT l s e m x
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> x -> ParserT l s e m x
go x
newX
else x -> ParserT l s e m x
forall (f :: * -> *) a. Applicative f => a -> f a
pure x
x
takeTokensWhile :: (Stream s, Monad m) => (Token s -> Bool) -> ParserT l s e m (Chunk s)
takeTokensWhile :: (Token s -> Bool) -> ParserT l s e m (Chunk s)
takeTokensWhile = (s -> (Chunk s, s)) -> ParserT l s e m (Chunk s)
forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
state ((s -> (Chunk s, s)) -> ParserT l s e m (Chunk s))
-> ((Token s -> Bool) -> s -> (Chunk s, s))
-> (Token s -> Bool)
-> ParserT l s e m (Chunk 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
takeTokensWhile1 :: (Stream s, Monad m) => Maybe l -> (Token s -> Bool) -> ParserT l s e m (Chunk s)
takeTokensWhile1 :: Maybe l -> (Token s -> Bool) -> ParserT l s e m (Chunk s)
takeTokensWhile1 Maybe l
ml Token s -> Bool
pcate = Maybe l
-> (s -> (Chunk s, s))
-> (Chunk s -> ParserT l s e m (Chunk s))
-> ParserT l s e m (Chunk s)
forall (m :: * -> *) l s b e a.
Monad m =>
Maybe l
-> (s -> (b, s)) -> (b -> ParserT l s e m a) -> ParserT l s e m a
markWithStateParser Maybe l
ml ((Token s -> Bool) -> s -> (Chunk s, s)
forall s. Stream s => (Token s -> Bool) -> s -> (Chunk s, s)
streamTakeWhile Token s -> Bool
pcate) ((Chunk s -> ParserT l s e m (Chunk s))
-> ParserT l s e m (Chunk s))
-> (Chunk s -> ParserT l s e m (Chunk s))
-> ParserT l s e m (Chunk s)
forall a b. (a -> b) -> a -> b
$ \Chunk s
j ->
if Chunk s -> Bool
forall chunk token. Chunked chunk token => chunk -> Bool
chunkEmpty Chunk s
j
then do
Maybe (Token s)
mu <- ParserT l s e m (Maybe (Token s))
forall s (m :: * -> *) l e.
(Stream s, Monad m) =>
ParserT l s e m (Maybe (Token s))
peekToken
RawError (Chunk s) (Token s) -> ParserT l s e m (Chunk s)
forall (m :: * -> *) s l e a.
Monad m =>
RawError (Chunk s) (Token s) -> ParserT l s e m a
throwStreamError (Maybe (Token s) -> RawError (Chunk s) (Token s)
forall chunk token. Maybe token -> RawError chunk token
RawErrorTakeTokensWhile1 Maybe (Token s)
mu)
else Chunk s -> ParserT l s e m (Chunk s)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Chunk s
j
dropTokensWhile :: (Stream s, Monad m) => (Token s -> Bool) -> ParserT l s e m Int
dropTokensWhile :: (Token s -> Bool) -> ParserT l s e m Int
dropTokensWhile = (s -> (Int, s)) -> ParserT l s e m Int
forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
state ((s -> (Int, s)) -> ParserT l s e m Int)
-> ((Token s -> Bool) -> s -> (Int, s))
-> (Token s -> Bool)
-> ParserT l s e m Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Token s -> Bool) -> s -> (Int, s)
forall s. Stream s => (Token s -> Bool) -> s -> (Int, s)
streamDropWhile
dropTokensWhile1 :: (Stream s, Monad m) => Maybe l -> (Token s -> Bool) -> ParserT l s e m Int
dropTokensWhile1 :: Maybe l -> (Token s -> Bool) -> ParserT l s e m Int
dropTokensWhile1 Maybe l
ml Token s -> Bool
pcate = Maybe l
-> (s -> (Int, s))
-> (Int -> ParserT l s e m Int)
-> ParserT l s e m Int
forall (m :: * -> *) l s b e a.
Monad m =>
Maybe l
-> (s -> (b, s)) -> (b -> ParserT l s e m a) -> ParserT l s e m a
markWithStateParser Maybe l
ml ((Token s -> Bool) -> s -> (Int, s)
forall s. Stream s => (Token s -> Bool) -> s -> (Int, s)
streamDropWhile Token s -> Bool
pcate) ((Int -> ParserT l s e m Int) -> ParserT l s e m Int)
-> (Int -> ParserT l s e m Int) -> ParserT l s e m Int
forall a b. (a -> b) -> a -> b
$ \Int
s ->
if Int
s Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0
then do
Maybe (Token s)
mu <- ParserT l s e m (Maybe (Token s))
forall s (m :: * -> *) l e.
(Stream s, Monad m) =>
ParserT l s e m (Maybe (Token s))
peekToken
RawError (Chunk s) (Token s) -> ParserT l s e m Int
forall (m :: * -> *) s l e a.
Monad m =>
RawError (Chunk s) (Token s) -> ParserT l s e m a
throwStreamError (Maybe (Token s) -> RawError (Chunk s) (Token s)
forall chunk token. Maybe token -> RawError chunk token
RawErrorDropTokensWhile1 Maybe (Token s)
mu)
else Int -> ParserT l s e m Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
s
matchToken :: (Stream s, Monad m, Eq (Token s)) => Token s -> ParserT l s e m (Token s)
matchToken :: Token s -> ParserT l s e m (Token s)
matchToken Token s
t = Maybe l
-> (Maybe (Token s) -> ParserT l s e m (Token s))
-> ParserT l s e m (Token s)
forall s (m :: * -> *) l e a.
(Stream s, Monad m) =>
Maybe l
-> (Maybe (Token s) -> ParserT l s e m a) -> ParserT l s e m a
withToken Maybe l
forall a. Maybe a
Nothing ((Maybe (Token s) -> ParserT l s e m (Token s))
-> ParserT l s e m (Token s))
-> (Maybe (Token s) -> ParserT l s e m (Token s))
-> ParserT l s e m (Token s)
forall a b. (a -> b) -> a -> b
$ \Maybe (Token s)
mu ->
case Maybe (Token s)
mu of
Just Token s
u | Token s
t Token s -> Token s -> Bool
forall a. Eq a => a -> a -> Bool
== Token s
u -> Token s -> ParserT l s e m (Token s)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Token s
u
Maybe (Token s)
_ -> RawError (Chunk s) (Token s) -> ParserT l s e m (Token s)
forall (m :: * -> *) s l e a.
Monad m =>
RawError (Chunk s) (Token s) -> ParserT l s e m a
throwStreamError (Token s -> Maybe (Token s) -> RawError (Chunk s) (Token s)
forall chunk token. token -> Maybe token -> RawError chunk token
RawErrorMatchToken Token s
t Maybe (Token s)
mu)
matchChunk :: (Stream s, Monad m, Eq (Chunk s)) => Chunk s -> ParserT l s e m (Chunk s)
matchChunk :: Chunk s -> ParserT l s e m (Chunk s)
matchChunk Chunk s
k = Maybe l
-> Int
-> (Maybe (Chunk s) -> ParserT l s e m (Chunk s))
-> ParserT l s e m (Chunk s)
forall s (m :: * -> *) l e a.
(Stream s, Monad m) =>
Maybe l
-> Int
-> (Maybe (Chunk s) -> ParserT l s e m a)
-> ParserT l s e m a
withChunk Maybe l
forall a. Maybe a
Nothing (Chunk s -> Int
forall chunk token. Chunked chunk token => chunk -> Int
chunkLength Chunk s
k) ((Maybe (Chunk s) -> ParserT l s e m (Chunk s))
-> ParserT l s e m (Chunk s))
-> (Maybe (Chunk s) -> ParserT l s e m (Chunk s))
-> ParserT l s e m (Chunk s)
forall a b. (a -> b) -> a -> b
$ \Maybe (Chunk s)
mj ->
case Maybe (Chunk s)
mj of
Just Chunk s
j | Chunk s
k Chunk s -> Chunk s -> Bool
forall a. Eq a => a -> a -> Bool
== Chunk s
j -> Chunk s -> ParserT l s e m (Chunk s)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Chunk s
j
Maybe (Chunk s)
_ -> RawError (Chunk s) (Token s) -> ParserT l s e m (Chunk s)
forall (m :: * -> *) s l e a.
Monad m =>
RawError (Chunk s) (Token s) -> ParserT l s e m a
throwStreamError (Chunk s -> Maybe (Chunk s) -> RawError (Chunk s) (Token s)
forall chunk token. chunk -> Maybe chunk -> RawError chunk token
RawErrorMatchChunk Chunk s
k Maybe (Chunk s)
mj)