-- | Useful combinators for 'ParserT' and 'Stream'.
-- Classified as SAFE or UNSAFE. SAFE always return a value. UNSAFE throw.
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 (..), 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 (NESeq (ParseError l s e) -> ParseResult l s e a
forall l s e a. NESeq (ParseError l s e) -> ParseResult l s e a
ParseResultError (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)))))))

-- | Fetches the next token from the stream and runs the callback.
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

-- | Fetches the next chunk from the stream and runs the callback.
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)

-- | Return the next token, if any, but don't consume it. (SAFE)
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)

-- | Return the next token, if any, and consume it. (SAFE)
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))

-- | Return the next chunk of the given size, if any, but don't consume it.
-- May return a smaller chunk at end of stream, but never returns an empty chunk. (SAFE)
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)

-- | Return the next chunk of the given size, if any, and consume it.
-- May return a smaller chunk at end of stream, but never returns an empty chunk. (SAFE)
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))

-- | Drop the next chunk of the given size, if any, and consume it.
-- May return a smaller size at end of stream, but never returns size 0. (SAFE)
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))

-- | Is this the end of the stream? (SAFE)
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

-- | Match the end of the stream or terminate the parser. (UNSAFE)
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))

-- | Return the next token or terminate the parser at end of stream. (UNSAFE)
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)

-- | Return the next chunk of the given size or terminate the parser at end of stream.
-- May return a smaller chunk at end of stream, but never returns an empty chunk. (UNSAFE)
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)

-- | Match the next token with the given predicate or terminate the parser at predicate false or end of stream. (UNSAFE)
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)

-- | Folds over a stream of tokens while the boolean value is true.
-- Always succeeds, even at end of stream. Only consumes greediest match. (SAFE)
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

-- | Take tokens into a chunk while they satisfy the given predicate.
-- Always succeeds, even at end of stream. May return an empty chunk. Only yields greediest match. (SAFE)
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

-- | Take tokens into a chunk while they satisfy the given predicate.
-- Only succeeds if 1 or more tokens are taken, so it never returns an empty chunk.
-- Also takes an optional label to describe the predicate. (UNSAFE)
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

-- | Drop tokens and return chunk size while they satisfy the given predicate.
-- Always succeeds, even at end of stream. May return empty chunk size 0. Only drops greediest match. (SAFE)
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

-- | Drop tokens and return chunk size while they satisfy the given predicate.
-- Only succeeds if 1 or more tokens are dropped.
-- Also takes an optional label to describe the predicate. (UNSAFE)
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

-- | Match token with equality or terminate the parser at inequality or end of stream. (UNSAFE)
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)

-- | Match chunk with equality or terminate the parser at inequality or end of stream. (UNSAFE)
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)