{-# LANGUAGE Rank2Types #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE TypeOperators #-}
module Foundation.Parser
( Parser
, parse
, parseFeed
, parseOnly
,
Result(..)
, ParseError(..)
, reportError
,
ParserSource(..)
,
peek
, element
, anyElement
, elements
, string
, satisfy
, satisfy_
, take
, takeWhile
, takeAll
, skip
, skipWhile
, skipAll
, (<|>)
, many
, some
, optional
, repeat, Condition(..), And(..)
) where
import Control.Applicative (Alternative, empty, (<|>), many, some, optional)
import Control.Monad (MonadPlus, mzero, mplus)
import Basement.Compat.Base
import Basement.Types.OffsetSize
import Foundation.Numerical
import Foundation.Collection hiding (take, takeWhile)
import qualified Foundation.Collection as C
import Foundation.String
data ParseError input
= NotEnough (CountOf (Element input))
| NotEnoughParseOnly
| ExpectedElement (Element input) (Element input)
| Expected (Chunk input) (Chunk input)
| Satisfy (Maybe String)
deriving (Typeable)
instance (Typeable input, Show input) => Exception (ParseError input)
instance Show input => Show (ParseError input) where
show :: ParseError input -> String
show (NotEnough (CountOf Int
sz)) = String
"NotEnough: missing " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Int -> String
forall a. Show a => a -> String
show Int
sz String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
" element(s)"
show ParseError input
NotEnoughParseOnly = String
"NotEnough, parse only"
show (ExpectedElement Element input
_ Element input
_) = String
"Expected _ but received _"
show (Expected Chunk input
_ Chunk input
_) = String
"Expected _ but received _"
show (Satisfy Maybe String
Nothing) = String
"Satisfy"
show (Satisfy (Just String
s)) = String
"Satisfy: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String -> [Item String]
forall l. IsList l => l -> [Item l]
toList String
s
instance {-# OVERLAPPING #-} Show (ParseError String) where
show :: ParseError String -> String
show (NotEnough (CountOf Int
sz)) = String
"NotEnough: missing " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Int -> String
forall a. Show a => a -> String
show Int
sz String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
" element(s)"
show ParseError String
NotEnoughParseOnly = String
"NotEnough, parse only"
show (ExpectedElement Element String
a Element String
b) = String
"Expected "String -> ShowS
forall a. Semigroup a => a -> a -> a
<>Char -> String
forall a. Show a => a -> String
show Char
Element String
aString -> ShowS
forall a. Semigroup a => a -> a -> a
<>String
" but received " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Char -> String
forall a. Show a => a -> String
show Char
Element String
b
show (Expected Chunk String
a Chunk String
b) = String
"Expected "String -> ShowS
forall a. Semigroup a => a -> a -> a
<>String -> String
forall a. Show a => a -> String
show String
Chunk String
aString -> ShowS
forall a. Semigroup a => a -> a -> a
<>String
" but received " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String -> String
forall a. Show a => a -> String
show String
Chunk String
b
show (Satisfy Maybe String
Nothing) = String
"Satisfy"
show (Satisfy (Just String
s)) = String
"Satisfy: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String -> [Item String]
forall l. IsList l => l -> [Item l]
toList String
s
data Result input result
= ParseFailed (ParseError input)
| ParseOk (Chunk input) result
| ParseMore (Chunk input -> Result input result)
instance (Show k, Show input) => Show (Result input k) where
show :: Result input k -> String
show (ParseFailed ParseError input
err) = String
"Parser failed: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> ParseError input -> String
forall a. Show a => a -> String
show ParseError input
err
show (ParseOk Chunk input
_ k
k) = String
"Parser succeed: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> k -> String
forall a. Show a => a -> String
show k
k
show (ParseMore Chunk input -> Result input k
_) = String
"Parser incomplete: need more"
instance Functor (Result input) where
fmap :: (a -> b) -> Result input a -> Result input b
fmap a -> b
f Result input a
r = case Result input a
r of
ParseFailed ParseError input
err -> ParseError input -> Result input b
forall input result. ParseError input -> Result input result
ParseFailed ParseError input
err
ParseOk Chunk input
rest a
a -> Chunk input -> b -> Result input b
forall input result. Chunk input -> result -> Result input result
ParseOk Chunk input
rest (a -> b
f a
a)
ParseMore Chunk input -> Result input a
more -> (Chunk input -> Result input b) -> Result input b
forall input result.
(Chunk input -> Result input result) -> Result input result
ParseMore ((a -> b) -> Result input a -> Result input b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f (Result input a -> Result input b)
-> (Chunk input -> Result input a) -> Chunk input -> Result input b
forall k (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Chunk input -> Result input a
more)
class (Sequential input, IndexedCollection input) => ParserSource input where
type Chunk input
nullChunk :: input -> Chunk input -> Bool
appendChunk :: input -> Chunk input -> input
subChunk :: input -> Offset (Element input) -> CountOf (Element input) -> Chunk input
spanChunk :: input -> Offset (Element input) -> (Element input -> Bool) -> (Chunk input, Offset (Element input))
endOfParserSource :: ParserSource input => input -> Offset (Element input) -> Bool
endOfParserSource :: input -> Offset (Element input) -> Bool
endOfParserSource input
l Offset (Element input)
off = Offset (Element input)
off Offset (Element input) -> CountOf (Element input) -> Bool
forall ty. Offset ty -> CountOf ty -> Bool
.==# input -> CountOf (Element input)
forall c. Collection c => c -> CountOf (Element c)
length input
l
{-# INLINE endOfParserSource #-}
data NoMore = More | NoMore
deriving (Int -> NoMore -> ShowS
[NoMore] -> ShowS
NoMore -> String
(Int -> NoMore -> ShowS)
-> (NoMore -> String) -> ([NoMore] -> ShowS) -> Show NoMore
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NoMore] -> ShowS
$cshowList :: [NoMore] -> ShowS
show :: NoMore -> String
$cshow :: NoMore -> String
showsPrec :: Int -> NoMore -> ShowS
$cshowsPrec :: Int -> NoMore -> ShowS
Show, NoMore -> NoMore -> Bool
(NoMore -> NoMore -> Bool)
-> (NoMore -> NoMore -> Bool) -> Eq NoMore
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NoMore -> NoMore -> Bool
$c/= :: NoMore -> NoMore -> Bool
== :: NoMore -> NoMore -> Bool
$c== :: NoMore -> NoMore -> Bool
Eq)
type Failure input result = input -> Offset (Element input) -> NoMore -> ParseError input -> Result input result
type Success input result' result = input -> Offset (Element input) -> NoMore -> result' -> Result input result
newtype Parser input result = Parser
{ Parser input result
-> forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
runParser :: forall result'
. input -> Offset (Element input) -> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
}
instance Functor (Parser input) where
fmap :: (a -> b) -> Parser input a -> Parser input b
fmap a -> b
f Parser input a
fa = (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input b result'
-> Result input result')
-> Parser input b
forall input result.
(forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result')
-> Parser input result
Parser ((forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input b result'
-> Result input result')
-> Parser input b)
-> (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input b result'
-> Result input result')
-> Parser input b
forall a b. (a -> b) -> a -> b
$ \input
buf Offset (Element input)
off NoMore
nm Failure input result'
err Success input b result'
ok ->
Parser input a
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input a result'
-> Result input result'
forall input result.
Parser input result
-> forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
runParser Parser input a
fa input
buf Offset (Element input)
off NoMore
nm Failure input result'
err (Success input a result' -> Result input result')
-> Success input a result' -> Result input result'
forall a b. (a -> b) -> a -> b
$ \input
buf' Offset (Element input)
off' NoMore
nm' a
a -> Success input b result'
ok input
buf' Offset (Element input)
off' NoMore
nm' (a -> b
f a
a)
{-# INLINE fmap #-}
instance ParserSource input => Applicative (Parser input) where
pure :: a -> Parser input a
pure a
a = (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input a result'
-> Result input result')
-> Parser input a
forall input result.
(forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result')
-> Parser input result
Parser ((forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input a result'
-> Result input result')
-> Parser input a)
-> (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input a result'
-> Result input result')
-> Parser input a
forall a b. (a -> b) -> a -> b
$ \input
buf Offset (Element input)
off NoMore
nm Failure input result'
_ Success input a result'
ok -> Success input a result'
ok input
buf Offset (Element input)
off NoMore
nm a
a
{-# INLINE pure #-}
Parser input (a -> b)
fab <*> :: Parser input (a -> b) -> Parser input a -> Parser input b
<*> Parser input a
fa = (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input b result'
-> Result input result')
-> Parser input b
forall input result.
(forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result')
-> Parser input result
Parser ((forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input b result'
-> Result input result')
-> Parser input b)
-> (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input b result'
-> Result input result')
-> Parser input b
forall a b. (a -> b) -> a -> b
$ \input
buf0 Offset (Element input)
off0 NoMore
nm0 Failure input result'
err Success input b result'
ok ->
Parser input (a -> b)
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input (a -> b) result'
-> Result input result'
forall input result.
Parser input result
-> forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
runParser Parser input (a -> b)
fab input
buf0 Offset (Element input)
off0 NoMore
nm0 Failure input result'
err (Success input (a -> b) result' -> Result input result')
-> Success input (a -> b) result' -> Result input result'
forall a b. (a -> b) -> a -> b
$ \input
buf1 Offset (Element input)
off1 NoMore
nm1 a -> b
ab ->
Parser input a
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input a result'
-> Result input result'
forall input result result'.
ParserSource input =>
Parser input result
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
runParser_ Parser input a
fa input
buf1 Offset (Element input)
off1 NoMore
nm1 Failure input result'
err (Success input a result' -> Result input result')
-> Success input a result' -> Result input result'
forall a b. (a -> b) -> a -> b
$ \input
buf2 Offset (Element input)
off2 NoMore
nm2 -> Success input b result'
ok input
buf2 Offset (Element input)
off2 NoMore
nm2 (b -> Result input result')
-> (a -> b) -> a -> Result input result'
forall k (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. a -> b
ab
{-# INLINE (<*>) #-}
instance ParserSource input => Monad (Parser input) where
return :: a -> Parser input a
return = a -> Parser input a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
{-# INLINE return #-}
Parser input a
m >>= :: Parser input a -> (a -> Parser input b) -> Parser input b
>>= a -> Parser input b
k = (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input b result'
-> Result input result')
-> Parser input b
forall input result.
(forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result')
-> Parser input result
Parser ((forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input b result'
-> Result input result')
-> Parser input b)
-> (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input b result'
-> Result input result')
-> Parser input b
forall a b. (a -> b) -> a -> b
$ \input
buf Offset (Element input)
off NoMore
nm Failure input result'
err Success input b result'
ok ->
Parser input a
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input a result'
-> Result input result'
forall input result.
Parser input result
-> forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
runParser Parser input a
m input
buf Offset (Element input)
off NoMore
nm Failure input result'
err (Success input a result' -> Result input result')
-> Success input a result' -> Result input result'
forall a b. (a -> b) -> a -> b
$ \input
buf' Offset (Element input)
off' NoMore
nm' a
a ->
Parser input b
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input b result'
-> Result input result'
forall input result result'.
ParserSource input =>
Parser input result
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
runParser_ (a -> Parser input b
k a
a) input
buf' Offset (Element input)
off' NoMore
nm' Failure input result'
err Success input b result'
ok
{-# INLINE (>>=) #-}
instance ParserSource input => MonadPlus (Parser input) where
mzero :: Parser input a
mzero = String -> Parser input a
forall a. HasCallStack => String -> a
error String
"Foundation.Parser.Internal.MonadPlus.mzero"
mplus :: Parser input a -> Parser input a -> Parser input a
mplus Parser input a
f Parser input a
g = (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input a result'
-> Result input result')
-> Parser input a
forall input result.
(forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result')
-> Parser input result
Parser ((forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input a result'
-> Result input result')
-> Parser input a)
-> (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input a result'
-> Result input result')
-> Parser input a
forall a b. (a -> b) -> a -> b
$ \input
buf Offset (Element input)
off NoMore
nm Failure input result'
err Success input a result'
ok ->
Parser input a
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input a result'
-> Result input result'
forall input result.
Parser input result
-> forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
runParser Parser input a
f input
buf Offset (Element input)
off NoMore
nm (\input
buf' Offset (Element input)
_ NoMore
nm' ParseError input
_ -> Parser input a
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input a result'
-> Result input result'
forall input result.
Parser input result
-> forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
runParser Parser input a
g input
buf' Offset (Element input)
off NoMore
nm' Failure input result'
err Success input a result'
ok) Success input a result'
ok
{-# INLINE mplus #-}
instance ParserSource input => Alternative (Parser input) where
empty :: Parser input a
empty = String -> Parser input a
forall a. HasCallStack => String -> a
error String
"Foundation.Parser.Internal.Alternative.empty"
<|> :: Parser input a -> Parser input a -> Parser input a
(<|>) = Parser input a -> Parser input a -> Parser input a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus
{-# INLINE (<|>) #-}
runParser_ :: ParserSource input
=> Parser input result
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
runParser_ :: Parser input result
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
runParser_ Parser input result
parser input
buf Offset (Element input)
off NoMore
NoMore Failure input result'
err Success input result result'
ok = Parser input result
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
forall input result.
Parser input result
-> forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
runParser Parser input result
parser input
buf Offset (Element input)
off NoMore
NoMore Failure input result'
err Success input result result'
ok
runParser_ Parser input result
parser input
buf Offset (Element input)
off NoMore
nm Failure input result'
err Success input result result'
ok
| input -> Offset (Element input) -> Bool
forall input.
ParserSource input =>
input -> Offset (Element input) -> Bool
endOfParserSource input
buf Offset (Element input)
off = (Chunk input -> Result input result') -> Result input result'
forall input result.
(Chunk input -> Result input result) -> Result input result
ParseMore ((Chunk input -> Result input result') -> Result input result')
-> (Chunk input -> Result input result') -> Result input result'
forall a b. (a -> b) -> a -> b
$ \Chunk input
chunk ->
if input -> Chunk input -> Bool
forall input. ParserSource input => input -> Chunk input -> Bool
nullChunk input
buf Chunk input
chunk
then Parser input result
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
forall input result.
Parser input result
-> forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
runParser Parser input result
parser input
buf Offset (Element input)
off NoMore
NoMore Failure input result'
err Success input result result'
ok
else Parser input result
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
forall input result.
Parser input result
-> forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
runParser Parser input result
parser (input -> Chunk input -> input
forall input. ParserSource input => input -> Chunk input -> input
appendChunk input
buf Chunk input
chunk) Offset (Element input)
off NoMore
nm Failure input result'
err Success input result result'
ok
| Bool
otherwise = Parser input result
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
forall input result.
Parser input result
-> forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
runParser Parser input result
parser input
buf Offset (Element input)
off NoMore
nm Failure input result'
err Success input result result'
ok
{-# INLINE runParser_ #-}
parseFeed :: (ParserSource input, Monad m)
=> m (Chunk input)
-> Parser input a
-> input
-> m (Result input a)
parseFeed :: m (Chunk input) -> Parser input a -> input -> m (Result input a)
parseFeed m (Chunk input)
feeder Parser input a
p input
initial = Result input a -> m (Result input a)
loop (Result input a -> m (Result input a))
-> Result input a -> m (Result input a)
forall a b. (a -> b) -> a -> b
$ Parser input a -> input -> Result input a
forall input a.
ParserSource input =>
Parser input a -> input -> Result input a
parse Parser input a
p input
initial
where loop :: Result input a -> m (Result input a)
loop (ParseMore Chunk input -> Result input a
k) = m (Chunk input)
feeder m (Chunk input)
-> (Chunk input -> m (Result input a)) -> m (Result input a)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Result input a -> m (Result input a)
loop (Result input a -> m (Result input a))
-> (Chunk input -> Result input a)
-> Chunk input
-> m (Result input a)
forall k (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Chunk input -> Result input a
k)
loop Result input a
r = Result input a -> m (Result input a)
forall (m :: * -> *) a. Monad m => a -> m a
return Result input a
r
parse :: ParserSource input
=> Parser input a -> input -> Result input a
parse :: Parser input a -> input -> Result input a
parse Parser input a
p input
s = Parser input a
-> input
-> Offset (Element input)
-> NoMore
-> Failure input a
-> Success input a a
-> Result input a
forall input result.
Parser input result
-> forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
runParser Parser input a
p input
s Offset (Element input)
0 NoMore
More Failure input a
forall input r.
input
-> Offset (Element input)
-> NoMore
-> ParseError input
-> Result input r
failure Success input a a
forall input r.
ParserSource input =>
input -> Offset (Element input) -> NoMore -> r -> Result input r
success
failure :: input -> Offset (Element input) -> NoMore -> ParseError input -> Result input r
failure :: input
-> Offset (Element input)
-> NoMore
-> ParseError input
-> Result input r
failure input
_ Offset (Element input)
_ NoMore
_ = ParseError input -> Result input r
forall input result. ParseError input -> Result input result
ParseFailed
{-# INLINE failure #-}
success :: ParserSource input => input -> Offset (Element input) -> NoMore -> r -> Result input r
success :: input -> Offset (Element input) -> NoMore -> r -> Result input r
success input
buf Offset (Element input)
off NoMore
_ = Chunk input -> r -> Result input r
forall input result. Chunk input -> result -> Result input result
ParseOk Chunk input
rest
where
!rest :: Chunk input
rest = input
-> Offset (Element input) -> CountOf (Element input) -> Chunk input
forall input.
ParserSource input =>
input
-> Offset (Element input) -> CountOf (Element input) -> Chunk input
subChunk input
buf Offset (Element input)
off (input -> CountOf (Element input)
forall c. Collection c => c -> CountOf (Element c)
length input
buf CountOf (Element input)
-> CountOf (Element input) -> CountOf (Element input)
forall a. CountOf a -> CountOf a -> CountOf a
`sizeSub` Offset (Element input) -> CountOf (Element input)
forall a. Offset a -> CountOf a
offsetAsSize Offset (Element input)
off)
{-# INLINE success #-}
parseOnly :: (ParserSource input, Monoid (Chunk input))
=> Parser input a
-> input
-> Either (ParseError input) a
parseOnly :: Parser input a -> input -> Either (ParseError input) a
parseOnly Parser input a
p input
i = case Parser input a
-> input
-> Offset (Element input)
-> NoMore
-> Failure input a
-> Success input a a
-> Result input a
forall input result.
Parser input result
-> forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
runParser Parser input a
p input
i Offset (Element input)
0 NoMore
NoMore Failure input a
forall input r.
input
-> Offset (Element input)
-> NoMore
-> ParseError input
-> Result input r
failure Success input a a
forall input r.
ParserSource input =>
input -> Offset (Element input) -> NoMore -> r -> Result input r
success of
ParseFailed ParseError input
err -> ParseError input -> Either (ParseError input) a
forall a b. a -> Either a b
Left ParseError input
err
ParseOk Chunk input
_ a
r -> a -> Either (ParseError input) a
forall a b. b -> Either a b
Right a
r
ParseMore Chunk input -> Result input a
_ -> ParseError input -> Either (ParseError input) a
forall a b. a -> Either a b
Left ParseError input
forall input. ParseError input
NotEnoughParseOnly
instance ParserSource String where
type Chunk String = String
nullChunk :: String -> Chunk String -> Bool
nullChunk String
_ = Chunk String -> Bool
forall c. Collection c => c -> Bool
null
{-# INLINE nullChunk #-}
appendChunk :: String -> Chunk String -> String
appendChunk = String -> Chunk String -> String
forall a. Monoid a => a -> a -> a
mappend
{-# INLINE appendChunk #-}
subChunk :: String
-> Offset (Element String)
-> CountOf (Element String)
-> Chunk String
subChunk String
c Offset (Element String)
off CountOf (Element String)
sz = CountOf (Element String) -> String -> String
forall c. Sequential c => CountOf (Element c) -> c -> c
C.take CountOf (Element String)
sz (String -> String) -> String -> String
forall a b. (a -> b) -> a -> b
$ CountOf (Element String) -> String -> String
forall c. Sequential c => CountOf (Element c) -> c -> c
C.drop (Offset Char -> CountOf Char
forall a. Offset a -> CountOf a
offsetAsSize Offset Char
Offset (Element String)
off) String
c
{-# INLINE subChunk #-}
spanChunk :: String
-> Offset (Element String)
-> (Element String -> Bool)
-> (Chunk String, Offset (Element String))
spanChunk String
buf Offset (Element String)
off Element String -> Bool
predicate =
let c :: String
c = CountOf (Element String) -> String -> String
forall c. Sequential c => CountOf (Element c) -> c -> c
C.drop (Offset Char -> CountOf Char
forall a. Offset a -> CountOf a
offsetAsSize Offset Char
Offset (Element String)
off) String
buf
(String
t, String
_) = (Element String -> Bool) -> String -> (String, String)
forall c. Sequential c => (Element c -> Bool) -> c -> (c, c)
C.span Element String -> Bool
predicate String
c
in (String
Chunk String
t, Offset Char
Offset (Element String)
off Offset Char -> CountOf Char -> Offset Char
forall ty. Offset ty -> CountOf ty -> Offset ty
`offsetPlusE` String -> CountOf (Element String)
forall c. Collection c => c -> CountOf (Element c)
length String
t)
{-# INLINE spanChunk #-}
instance ParserSource [a] where
type Chunk [a] = [a]
nullChunk :: [a] -> Chunk [a] -> Bool
nullChunk [a]
_ = Chunk [a] -> Bool
forall c. Collection c => c -> Bool
null
{-# INLINE nullChunk #-}
appendChunk :: [a] -> Chunk [a] -> [a]
appendChunk = [a] -> Chunk [a] -> [a]
forall a. Monoid a => a -> a -> a
mappend
{-# INLINE appendChunk #-}
subChunk :: [a] -> Offset (Element [a]) -> CountOf (Element [a]) -> Chunk [a]
subChunk [a]
c Offset (Element [a])
off CountOf (Element [a])
sz = CountOf (Element [a]) -> [a] -> [a]
forall c. Sequential c => CountOf (Element c) -> c -> c
C.take CountOf (Element [a])
sz ([a] -> [a]) -> [a] -> [a]
forall a b. (a -> b) -> a -> b
$ CountOf (Element [a]) -> [a] -> [a]
forall c. Sequential c => CountOf (Element c) -> c -> c
C.drop (Offset a -> CountOf a
forall a. Offset a -> CountOf a
offsetAsSize Offset a
Offset (Element [a])
off) [a]
c
{-# INLINE subChunk #-}
spanChunk :: [a]
-> Offset (Element [a])
-> (Element [a] -> Bool)
-> (Chunk [a], Offset (Element [a]))
spanChunk [a]
buf Offset (Element [a])
off Element [a] -> Bool
predicate =
let c :: [a]
c = CountOf (Element [a]) -> [a] -> [a]
forall c. Sequential c => CountOf (Element c) -> c -> c
C.drop (Offset a -> CountOf a
forall a. Offset a -> CountOf a
offsetAsSize Offset a
Offset (Element [a])
off) [a]
buf
([a]
t, [a]
_) = (Element [a] -> Bool) -> [a] -> ([a], [a])
forall c. Sequential c => (Element c -> Bool) -> c -> (c, c)
C.span Element [a] -> Bool
predicate [a]
c
in ([a]
Chunk [a]
t, Offset a
Offset (Element [a])
off Offset a -> CountOf a -> Offset a
forall ty. Offset ty -> CountOf ty -> Offset ty
`offsetPlusE` [a] -> CountOf (Element [a])
forall c. Collection c => c -> CountOf (Element c)
length [a]
t)
{-# INLINE spanChunk #-}
reportError :: ParseError input -> Parser input a
reportError :: ParseError input -> Parser input a
reportError ParseError input
pe = (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input a result'
-> Result input result')
-> Parser input a
forall input result.
(forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result')
-> Parser input result
Parser ((forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input a result'
-> Result input result')
-> Parser input a)
-> (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input a result'
-> Result input result')
-> Parser input a
forall a b. (a -> b) -> a -> b
$ \input
buf Offset (Element input)
off NoMore
nm Failure input result'
err Success input a result'
_ -> Failure input result'
err input
buf Offset (Element input)
off NoMore
nm ParseError input
pe
anyElement :: ParserSource input => Parser input (Element input)
anyElement :: Parser input (Element input)
anyElement = (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input (Element input) result'
-> Result input result')
-> Parser input (Element input)
forall input result.
(forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result')
-> Parser input result
Parser ((forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input (Element input) result'
-> Result input result')
-> Parser input (Element input))
-> (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input (Element input) result'
-> Result input result')
-> Parser input (Element input)
forall a b. (a -> b) -> a -> b
$ \input
buf Offset (Element input)
off NoMore
nm Failure input result'
err Success input (Element input) result'
ok ->
case input
buf input -> Offset (Element input) -> Maybe (Element input)
forall c.
IndexedCollection c =>
c -> Offset (Element c) -> Maybe (Element c)
! Offset (Element input)
off of
Maybe (Element input)
Nothing -> Failure input result'
err input
buf Offset (Element input)
off NoMore
nm (ParseError input -> Result input result')
-> ParseError input -> Result input result'
forall a b. (a -> b) -> a -> b
$ CountOf (Element input) -> ParseError input
forall input. CountOf (Element input) -> ParseError input
NotEnough CountOf (Element input)
1
Just Element input
x -> Success input (Element input) result'
ok input
buf (Offset (Element input) -> Offset (Element input)
forall a. Enum a => a -> a
succ Offset (Element input)
off) NoMore
nm Element input
x
{-# INLINE anyElement #-}
peek :: ParserSource input => Parser input (Maybe (Element input))
peek :: Parser input (Maybe (Element input))
peek = (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input (Maybe (Element input)) result'
-> Result input result')
-> Parser input (Maybe (Element input))
forall input result.
(forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result')
-> Parser input result
Parser ((forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input (Maybe (Element input)) result'
-> Result input result')
-> Parser input (Maybe (Element input)))
-> (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input (Maybe (Element input)) result'
-> Result input result')
-> Parser input (Maybe (Element input))
forall a b. (a -> b) -> a -> b
$ \input
buf Offset (Element input)
off NoMore
nm Failure input result'
err Success input (Maybe (Element input)) result'
ok ->
case input
buf input -> Offset (Element input) -> Maybe (Element input)
forall c.
IndexedCollection c =>
c -> Offset (Element c) -> Maybe (Element c)
! Offset (Element input)
off of
Maybe (Element input)
Nothing -> Parser input (Maybe (Element input))
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input (Maybe (Element input)) result'
-> Result input result'
forall input result result'.
ParserSource input =>
Parser input result
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
runParser_ Parser input (Maybe (Element input))
peekOnly input
buf Offset (Element input)
off NoMore
nm Failure input result'
err Success input (Maybe (Element input)) result'
ok
Just Element input
x -> Success input (Maybe (Element input)) result'
ok input
buf Offset (Element input)
off NoMore
nm (Element input -> Maybe (Element input)
forall a. a -> Maybe a
Just Element input
x)
where
peekOnly :: Parser input (Maybe (Element input))
peekOnly = (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input (Maybe (Element input)) result'
-> Result input result')
-> Parser input (Maybe (Element input))
forall input result.
(forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result')
-> Parser input result
Parser ((forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input (Maybe (Element input)) result'
-> Result input result')
-> Parser input (Maybe (Element input)))
-> (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input (Maybe (Element input)) result'
-> Result input result')
-> Parser input (Maybe (Element input))
forall a b. (a -> b) -> a -> b
$ \input
buf Offset (Element input)
off NoMore
nm Failure input result'
_ Success input (Maybe (Element input)) result'
ok ->
Success input (Maybe (Element input)) result'
ok input
buf Offset (Element input)
off NoMore
nm (input
buf input -> Offset (Element input) -> Maybe (Element input)
forall c.
IndexedCollection c =>
c -> Offset (Element c) -> Maybe (Element c)
! Offset (Element input)
off)
element :: ( ParserSource input
, Eq (Element input)
, Element input ~ Element (Chunk input)
)
=> Element input
-> Parser input ()
element :: Element input -> Parser input ()
element Element input
expectedElement = (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input () result'
-> Result input result')
-> Parser input ()
forall input result.
(forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result')
-> Parser input result
Parser ((forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input () result'
-> Result input result')
-> Parser input ())
-> (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input () result'
-> Result input result')
-> Parser input ()
forall a b. (a -> b) -> a -> b
$ \input
buf Offset (Element input)
off NoMore
nm Failure input result'
err Success input () result'
ok ->
case input
buf input -> Offset (Element input) -> Maybe (Element input)
forall c.
IndexedCollection c =>
c -> Offset (Element c) -> Maybe (Element c)
! Offset (Element input)
off of
Maybe (Element input)
Nothing -> Failure input result'
err input
buf Offset (Element input)
off NoMore
nm (ParseError input -> Result input result')
-> ParseError input -> Result input result'
forall a b. (a -> b) -> a -> b
$ CountOf (Element input) -> ParseError input
forall input. CountOf (Element input) -> ParseError input
NotEnough CountOf (Element input)
1
Just Element input
x | Element input
Element (Chunk input)
expectedElement Element (Chunk input) -> Element (Chunk input) -> Bool
forall a. Eq a => a -> a -> Bool
== Element input
Element (Chunk input)
x -> Success input () result'
ok input
buf (Offset (Element (Chunk input)) -> Offset (Element (Chunk input))
forall a. Enum a => a -> a
succ Offset (Element input)
Offset (Element (Chunk input))
off) NoMore
nm ()
| Bool
otherwise -> Failure input result'
err input
buf Offset (Element input)
off NoMore
nm (ParseError input -> Result input result')
-> ParseError input -> Result input result'
forall a b. (a -> b) -> a -> b
$ Element input -> Element input -> ParseError input
forall input. Element input -> Element input -> ParseError input
ExpectedElement Element input
expectedElement Element input
x
{-# INLINE element #-}
elements :: ( ParserSource input, Sequential (Chunk input)
, Element (Chunk input) ~ Element input
, Eq (Chunk input)
)
=> Chunk input -> Parser input ()
elements :: Chunk input -> Parser input ()
elements = Chunk input -> Parser input ()
forall input.
(ParserSource input, Sequential (Chunk input),
Element (Chunk input) ~ Element input, Eq (Chunk input)) =>
Chunk input -> Parser input ()
consumeEq
where
consumeEq :: ( ParserSource input
, Sequential (Chunk input)
, Element (Chunk input) ~ Element input
, Eq (Chunk input)
)
=> Chunk input -> Parser input ()
consumeEq :: Chunk input -> Parser input ()
consumeEq Chunk input
expected = (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input () result'
-> Result input result')
-> Parser input ()
forall input result.
(forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result')
-> Parser input result
Parser ((forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input () result'
-> Result input result')
-> Parser input ())
-> (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input () result'
-> Result input result')
-> Parser input ()
forall a b. (a -> b) -> a -> b
$ \input
buf Offset (Element input)
off NoMore
nm Failure input result'
err Success input () result'
ok ->
if input -> Offset (Element input) -> Bool
forall input.
ParserSource input =>
input -> Offset (Element input) -> Bool
endOfParserSource input
buf Offset (Element input)
off
then
Failure input result'
err input
buf Offset (Element input)
off NoMore
nm (ParseError input -> Result input result')
-> ParseError input -> Result input result'
forall a b. (a -> b) -> a -> b
$ CountOf (Element input) -> ParseError input
forall input. CountOf (Element input) -> ParseError input
NotEnough CountOf (Element input)
CountOf (Element (Chunk input))
lenE
else
let !lenI :: Difference (Offset (Element input))
lenI = CountOf (Element input) -> Offset (Element input)
forall a. CountOf a -> Offset a
sizeAsOffset (input -> CountOf (Element input)
forall c. Collection c => c -> CountOf (Element c)
length input
buf) Offset (Element input)
-> Offset (Element input) -> Difference (Offset (Element input))
forall a. Subtractive a => a -> a -> Difference a
- Offset (Element input)
off
in if CountOf (Element input)
Difference (Offset (Element input))
lenI CountOf (Element input) -> CountOf (Element input) -> Bool
forall a. Ord a => a -> a -> Bool
>= CountOf (Element input)
CountOf (Element (Chunk input))
lenE
then
let a :: Chunk input
a = input
-> Offset (Element input) -> CountOf (Element input) -> Chunk input
forall input.
ParserSource input =>
input
-> Offset (Element input) -> CountOf (Element input) -> Chunk input
subChunk input
buf Offset (Element input)
off CountOf (Element input)
CountOf (Element (Chunk input))
lenE
in if Chunk input
a Chunk input -> Chunk input -> Bool
forall a. Eq a => a -> a -> Bool
== Chunk input
expected
then Success input () result'
ok input
buf (Offset (Element input)
off Offset (Element input)
-> Offset (Element input) -> Offset (Element input)
forall a. Additive a => a -> a -> a
+ CountOf (Element input) -> Offset (Element input)
forall a. CountOf a -> Offset a
sizeAsOffset CountOf (Element input)
CountOf (Element (Chunk input))
lenE) NoMore
nm ()
else Failure input result'
err input
buf Offset (Element input)
off NoMore
nm (ParseError input -> Result input result')
-> ParseError input -> Result input result'
forall a b. (a -> b) -> a -> b
$ Chunk input -> Chunk input -> ParseError input
forall input. Chunk input -> Chunk input -> ParseError input
Expected Chunk input
expected Chunk input
a
else
let a :: Chunk input
a = input
-> Offset (Element input) -> CountOf (Element input) -> Chunk input
forall input.
ParserSource input =>
input
-> Offset (Element input) -> CountOf (Element input) -> Chunk input
subChunk input
buf Offset (Element input)
off CountOf (Element input)
Difference (Offset (Element input))
lenI
(Chunk input
e', Chunk input
r) = CountOf (Element (Chunk input))
-> Chunk input -> (Chunk input, Chunk input)
forall c. Sequential c => CountOf (Element c) -> c -> (c, c)
splitAt CountOf (Element (Chunk input))
Difference (Offset (Element input))
lenI Chunk input
expected
in if Chunk input
a Chunk input -> Chunk input -> Bool
forall a. Eq a => a -> a -> Bool
== Chunk input
e'
then Parser input ()
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input () result'
-> Result input result'
forall input result result'.
ParserSource input =>
Parser input result
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
runParser_ (Chunk input -> Parser input ()
forall input.
(ParserSource input, Sequential (Chunk input),
Element (Chunk input) ~ Element input, Eq (Chunk input)) =>
Chunk input -> Parser input ()
consumeEq Chunk input
r) input
buf (Offset (Element input)
off Offset (Element input)
-> Offset (Element input) -> Offset (Element input)
forall a. Additive a => a -> a -> a
+ CountOf (Element input) -> Offset (Element input)
forall a. CountOf a -> Offset a
sizeAsOffset CountOf (Element input)
Difference (Offset (Element input))
lenI) NoMore
nm Failure input result'
err Success input () result'
ok
else Failure input result'
err input
buf Offset (Element input)
off NoMore
nm (ParseError input -> Result input result')
-> ParseError input -> Result input result'
forall a b. (a -> b) -> a -> b
$ Chunk input -> Chunk input -> ParseError input
forall input. Chunk input -> Chunk input -> ParseError input
Expected Chunk input
e' Chunk input
a
where
!lenE :: CountOf (Element (Chunk input))
lenE = Chunk input -> CountOf (Element (Chunk input))
forall c. Collection c => c -> CountOf (Element c)
length Chunk input
expected
{-# NOINLINE consumeEq #-}
{-# INLINE elements #-}
satisfy :: ParserSource input => Maybe String -> (Element input -> Bool) -> Parser input (Element input)
satisfy :: Maybe String
-> (Element input -> Bool) -> Parser input (Element input)
satisfy Maybe String
desc Element input -> Bool
predicate = (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input (Element input) result'
-> Result input result')
-> Parser input (Element input)
forall input result.
(forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result')
-> Parser input result
Parser ((forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input (Element input) result'
-> Result input result')
-> Parser input (Element input))
-> (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input (Element input) result'
-> Result input result')
-> Parser input (Element input)
forall a b. (a -> b) -> a -> b
$ \input
buf Offset (Element input)
off NoMore
nm Failure input result'
err Success input (Element input) result'
ok ->
case input
buf input -> Offset (Element input) -> Maybe (Element input)
forall c.
IndexedCollection c =>
c -> Offset (Element c) -> Maybe (Element c)
! Offset (Element input)
off of
Maybe (Element input)
Nothing -> Failure input result'
err input
buf Offset (Element input)
off NoMore
nm (ParseError input -> Result input result')
-> ParseError input -> Result input result'
forall a b. (a -> b) -> a -> b
$ CountOf (Element input) -> ParseError input
forall input. CountOf (Element input) -> ParseError input
NotEnough CountOf (Element input)
1
Just Element input
x | Element input -> Bool
predicate Element input
x -> Success input (Element input) result'
ok input
buf (Offset (Element input) -> Offset (Element input)
forall a. Enum a => a -> a
succ Offset (Element input)
off) NoMore
nm Element input
x
| Bool
otherwise -> Failure input result'
err input
buf Offset (Element input)
off NoMore
nm (ParseError input -> Result input result')
-> ParseError input -> Result input result'
forall a b. (a -> b) -> a -> b
$ Maybe String -> ParseError input
forall input. Maybe String -> ParseError input
Satisfy Maybe String
desc
{-# INLINE satisfy #-}
satisfy_ :: ParserSource input => (Element input -> Bool) -> Parser input (Element input)
satisfy_ :: (Element input -> Bool) -> Parser input (Element input)
satisfy_ = Maybe String
-> (Element input -> Bool) -> Parser input (Element input)
forall input.
ParserSource input =>
Maybe String
-> (Element input -> Bool) -> Parser input (Element input)
satisfy Maybe String
forall a. Maybe a
Nothing
{-# INLINE satisfy_ #-}
take :: ( ParserSource input
, Sequential (Chunk input)
, Element input ~ Element (Chunk input)
)
=> CountOf (Element (Chunk input))
-> Parser input (Chunk input)
take :: CountOf (Element (Chunk input)) -> Parser input (Chunk input)
take CountOf (Element (Chunk input))
n = (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input (Chunk input) result'
-> Result input result')
-> Parser input (Chunk input)
forall input result.
(forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result')
-> Parser input result
Parser ((forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input (Chunk input) result'
-> Result input result')
-> Parser input (Chunk input))
-> (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input (Chunk input) result'
-> Result input result')
-> Parser input (Chunk input)
forall a b. (a -> b) -> a -> b
$ \input
buf Offset (Element input)
off NoMore
nm Failure input result'
err Success input (Chunk input) result'
ok ->
let lenI :: Difference (Offset (Element (Chunk input)))
lenI = CountOf (Element (Chunk input)) -> Offset (Element (Chunk input))
forall a. CountOf a -> Offset a
sizeAsOffset (input -> CountOf (Element input)
forall c. Collection c => c -> CountOf (Element c)
length input
buf) Offset (Element (Chunk input))
-> Offset (Element (Chunk input))
-> Difference (Offset (Element (Chunk input)))
forall a. Subtractive a => a -> a -> Difference a
- Offset (Element input)
Offset (Element (Chunk input))
off
in if input -> Offset (Element input) -> Bool
forall input.
ParserSource input =>
input -> Offset (Element input) -> Bool
endOfParserSource input
buf Offset (Element input)
off Bool -> Bool -> Bool
&& CountOf (Element (Chunk input))
n CountOf (Element (Chunk input))
-> CountOf (Element (Chunk input)) -> Bool
forall a. Ord a => a -> a -> Bool
> CountOf (Element (Chunk input))
0
then Failure input result'
err input
buf Offset (Element input)
off NoMore
nm (ParseError input -> Result input result')
-> ParseError input -> Result input result'
forall a b. (a -> b) -> a -> b
$ CountOf (Element input) -> ParseError input
forall input. CountOf (Element input) -> ParseError input
NotEnough CountOf (Element input)
CountOf (Element (Chunk input))
n
else case CountOf (Element (Chunk input))
n CountOf (Element (Chunk input))
-> CountOf (Element (Chunk input))
-> Difference (CountOf (Element (Chunk input)))
forall a. Subtractive a => a -> a -> Difference a
- CountOf (Element (Chunk input))
Difference (Offset (Element (Chunk input)))
lenI of
Just s | CountOf (Element (Chunk input))
s CountOf (Element (Chunk input))
-> CountOf (Element (Chunk input)) -> Bool
forall a. Ord a => a -> a -> Bool
> CountOf (Element (Chunk input))
0 -> let h :: Chunk input
h = input
-> Offset (Element input) -> CountOf (Element input) -> Chunk input
forall input.
ParserSource input =>
input
-> Offset (Element input) -> CountOf (Element input) -> Chunk input
subChunk input
buf Offset (Element input)
off CountOf (Element input)
Difference (Offset (Element (Chunk input)))
lenI
in Parser input (Chunk input)
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input (Chunk input) result'
-> Result input result'
forall input result result'.
ParserSource input =>
Parser input result
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
runParser_ (CountOf (Element (Chunk input)) -> Parser input (Chunk input)
forall input.
(ParserSource input, Sequential (Chunk input),
Element input ~ Element (Chunk input)) =>
CountOf (Element (Chunk input)) -> Parser input (Chunk input)
take CountOf (Element (Chunk input))
s) input
buf (CountOf (Element (Chunk input)) -> Offset (Element (Chunk input))
forall a. CountOf a -> Offset a
sizeAsOffset CountOf (Element (Chunk input))
Difference (Offset (Element (Chunk input)))
lenI) NoMore
nm Failure input result'
err (Success input (Chunk input) result' -> Result input result')
-> Success input (Chunk input) result' -> Result input result'
forall a b. (a -> b) -> a -> b
$
\input
buf' Offset (Element input)
off' NoMore
nm' Chunk input
t -> Success input (Chunk input) result'
ok input
buf' Offset (Element input)
off' NoMore
nm' (Chunk input
h Chunk input -> Chunk input -> Chunk input
forall a. Semigroup a => a -> a -> a
<> Chunk input
t)
Difference (CountOf (Element (Chunk input)))
_ -> Success input (Chunk input) result'
ok input
buf (Offset (Element input)
Offset (Element (Chunk input))
off Offset (Element (Chunk input))
-> Offset (Element (Chunk input)) -> Offset (Element (Chunk input))
forall a. Additive a => a -> a -> a
+ CountOf (Element (Chunk input)) -> Offset (Element (Chunk input))
forall a. CountOf a -> Offset a
sizeAsOffset CountOf (Element (Chunk input))
n) NoMore
nm (input
-> Offset (Element input) -> CountOf (Element input) -> Chunk input
forall input.
ParserSource input =>
input
-> Offset (Element input) -> CountOf (Element input) -> Chunk input
subChunk input
buf Offset (Element input)
off CountOf (Element input)
CountOf (Element (Chunk input))
n)
takeWhile :: ( ParserSource input, Sequential (Chunk input)
)
=> (Element input -> Bool)
-> Parser input (Chunk input)
takeWhile :: (Element input -> Bool) -> Parser input (Chunk input)
takeWhile Element input -> Bool
predicate = (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input (Chunk input) result'
-> Result input result')
-> Parser input (Chunk input)
forall input result.
(forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result')
-> Parser input result
Parser ((forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input (Chunk input) result'
-> Result input result')
-> Parser input (Chunk input))
-> (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input (Chunk input) result'
-> Result input result')
-> Parser input (Chunk input)
forall a b. (a -> b) -> a -> b
$ \input
buf Offset (Element input)
off NoMore
nm Failure input result'
err Success input (Chunk input) result'
ok ->
if input -> Offset (Element input) -> Bool
forall input.
ParserSource input =>
input -> Offset (Element input) -> Bool
endOfParserSource input
buf Offset (Element input)
off
then Success input (Chunk input) result'
ok input
buf Offset (Element input)
off NoMore
nm Chunk input
forall a. Monoid a => a
mempty
else let (Chunk input
b1, Offset (Element input)
off') = input
-> Offset (Element input)
-> (Element input -> Bool)
-> (Chunk input, Offset (Element input))
forall input.
ParserSource input =>
input
-> Offset (Element input)
-> (Element input -> Bool)
-> (Chunk input, Offset (Element input))
spanChunk input
buf Offset (Element input)
off Element input -> Bool
predicate
in if input -> Offset (Element input) -> Bool
forall input.
ParserSource input =>
input -> Offset (Element input) -> Bool
endOfParserSource input
buf Offset (Element input)
off'
then Parser input (Chunk input)
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input (Chunk input) result'
-> Result input result'
forall input result result'.
ParserSource input =>
Parser input result
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
runParser_ ((Element input -> Bool) -> Parser input (Chunk input)
forall input.
(ParserSource input, Sequential (Chunk input)) =>
(Element input -> Bool) -> Parser input (Chunk input)
takeWhile Element input -> Bool
predicate) input
buf Offset (Element input)
off' NoMore
nm Failure input result'
err
(Success input (Chunk input) result' -> Result input result')
-> Success input (Chunk input) result' -> Result input result'
forall a b. (a -> b) -> a -> b
$ \input
buf' Offset (Element input)
off'' NoMore
nm' Chunk input
b1T -> Success input (Chunk input) result'
ok input
buf' Offset (Element input)
off'' NoMore
nm' (Chunk input
b1 Chunk input -> Chunk input -> Chunk input
forall a. Semigroup a => a -> a -> a
<> Chunk input
b1T)
else Success input (Chunk input) result'
ok input
buf Offset (Element input)
off' NoMore
nm Chunk input
b1
takeAll :: (ParserSource input, Sequential (Chunk input)) => Parser input (Chunk input)
takeAll :: Parser input (Chunk input)
takeAll = Parser input ()
forall input.
(ParserSource input, Sequential (Chunk input)) =>
Parser input ()
getAll Parser input ()
-> Parser input (Chunk input) -> Parser input (Chunk input)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser input (Chunk input)
forall input. ParserSource input => Parser input (Chunk input)
returnBuffer
where
returnBuffer :: ParserSource input => Parser input (Chunk input)
returnBuffer :: Parser input (Chunk input)
returnBuffer = (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input (Chunk input) result'
-> Result input result')
-> Parser input (Chunk input)
forall input result.
(forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result')
-> Parser input result
Parser ((forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input (Chunk input) result'
-> Result input result')
-> Parser input (Chunk input))
-> (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input (Chunk input) result'
-> Result input result')
-> Parser input (Chunk input)
forall a b. (a -> b) -> a -> b
$ \input
buf Offset (Element input)
off NoMore
nm Failure input result'
_ Success input (Chunk input) result'
ok ->
let !lenI :: CountOf (Element input)
lenI = input -> CountOf (Element input)
forall c. Collection c => c -> CountOf (Element c)
length input
buf
!off' :: Offset (Element input)
off' = CountOf (Element input) -> Offset (Element input)
forall a. CountOf a -> Offset a
sizeAsOffset CountOf (Element input)
lenI
!sz :: Difference (Offset (Element input))
sz = Offset (Element input)
off' Offset (Element input)
-> Offset (Element input) -> Difference (Offset (Element input))
forall a. Subtractive a => a -> a -> Difference a
- Offset (Element input)
off
in Success input (Chunk input) result'
ok input
buf Offset (Element input)
off' NoMore
nm (input
-> Offset (Element input) -> CountOf (Element input) -> Chunk input
forall input.
ParserSource input =>
input
-> Offset (Element input) -> CountOf (Element input) -> Chunk input
subChunk input
buf Offset (Element input)
off CountOf (Element input)
Difference (Offset (Element input))
sz)
{-# INLINE returnBuffer #-}
getAll :: (ParserSource input, Sequential (Chunk input)) => Parser input ()
getAll :: Parser input ()
getAll = (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input () result'
-> Result input result')
-> Parser input ()
forall input result.
(forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result')
-> Parser input result
Parser ((forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input () result'
-> Result input result')
-> Parser input ())
-> (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input () result'
-> Result input result')
-> Parser input ()
forall a b. (a -> b) -> a -> b
$ \input
buf Offset (Element input)
off NoMore
nm Failure input result'
err Success input () result'
ok ->
case NoMore
nm of
NoMore
NoMore -> Success input () result'
ok input
buf Offset (Element input)
off NoMore
nm ()
NoMore
More -> (Chunk input -> Result input result') -> Result input result'
forall input result.
(Chunk input -> Result input result) -> Result input result
ParseMore ((Chunk input -> Result input result') -> Result input result')
-> (Chunk input -> Result input result') -> Result input result'
forall a b. (a -> b) -> a -> b
$ \Chunk input
nextChunk ->
if input -> Chunk input -> Bool
forall input. ParserSource input => input -> Chunk input -> Bool
nullChunk input
buf Chunk input
nextChunk
then Success input () result'
ok input
buf Offset (Element input)
off NoMore
NoMore ()
else Parser input ()
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input () result'
-> Result input result'
forall input result.
Parser input result
-> forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
runParser Parser input ()
forall input.
(ParserSource input, Sequential (Chunk input)) =>
Parser input ()
getAll (input -> Chunk input -> input
forall input. ParserSource input => input -> Chunk input -> input
appendChunk input
buf Chunk input
nextChunk) Offset (Element input)
off NoMore
nm Failure input result'
err Success input () result'
ok
{-# NOINLINE getAll #-}
{-# INLINE takeAll #-}
skip :: ParserSource input => CountOf (Element input) -> Parser input ()
skip :: CountOf (Element input) -> Parser input ()
skip CountOf (Element input)
n = (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input () result'
-> Result input result')
-> Parser input ()
forall input result.
(forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result')
-> Parser input result
Parser ((forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input () result'
-> Result input result')
-> Parser input ())
-> (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input () result'
-> Result input result')
-> Parser input ()
forall a b. (a -> b) -> a -> b
$ \input
buf Offset (Element input)
off NoMore
nm Failure input result'
err Success input () result'
ok ->
let lenI :: Difference (Offset (Element input))
lenI = CountOf (Element input) -> Offset (Element input)
forall a. CountOf a -> Offset a
sizeAsOffset (input -> CountOf (Element input)
forall c. Collection c => c -> CountOf (Element c)
length input
buf) Offset (Element input)
-> Offset (Element input) -> Difference (Offset (Element input))
forall a. Subtractive a => a -> a -> Difference a
- Offset (Element input)
off
in if input -> Offset (Element input) -> Bool
forall input.
ParserSource input =>
input -> Offset (Element input) -> Bool
endOfParserSource input
buf Offset (Element input)
off Bool -> Bool -> Bool
&& CountOf (Element input)
n CountOf (Element input) -> CountOf (Element input) -> Bool
forall a. Ord a => a -> a -> Bool
> CountOf (Element input)
0
then Failure input result'
err input
buf Offset (Element input)
off NoMore
nm (ParseError input -> Result input result')
-> ParseError input -> Result input result'
forall a b. (a -> b) -> a -> b
$ CountOf (Element input) -> ParseError input
forall input. CountOf (Element input) -> ParseError input
NotEnough CountOf (Element input)
n
else case CountOf (Element input)
n CountOf (Element input)
-> CountOf (Element input) -> Difference (CountOf (Element input))
forall a. Subtractive a => a -> a -> Difference a
- CountOf (Element input)
Difference (Offset (Element input))
lenI of
Just s | CountOf (Element input)
s CountOf (Element input) -> CountOf (Element input) -> Bool
forall a. Ord a => a -> a -> Bool
> CountOf (Element input)
0 -> Parser input ()
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input () result'
-> Result input result'
forall input result result'.
ParserSource input =>
Parser input result
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
runParser_ (CountOf (Element input) -> Parser input ()
forall input.
ParserSource input =>
CountOf (Element input) -> Parser input ()
skip CountOf (Element input)
s) input
buf (CountOf (Element input) -> Offset (Element input)
forall a. CountOf a -> Offset a
sizeAsOffset CountOf (Element input)
Difference (Offset (Element input))
lenI) NoMore
nm Failure input result'
err Success input () result'
ok
Difference (CountOf (Element input))
_ -> Success input () result'
ok input
buf (Offset (Element input)
off Offset (Element input)
-> Offset (Element input) -> Offset (Element input)
forall a. Additive a => a -> a -> a
+ CountOf (Element input) -> Offset (Element input)
forall a. CountOf a -> Offset a
sizeAsOffset CountOf (Element input)
n) NoMore
nm ()
skipWhile :: ( ParserSource input, Sequential (Chunk input)
)
=> (Element input -> Bool)
-> Parser input ()
skipWhile :: (Element input -> Bool) -> Parser input ()
skipWhile Element input -> Bool
predicate = (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input () result'
-> Result input result')
-> Parser input ()
forall input result.
(forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result')
-> Parser input result
Parser ((forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input () result'
-> Result input result')
-> Parser input ())
-> (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input () result'
-> Result input result')
-> Parser input ()
forall a b. (a -> b) -> a -> b
$ \input
buf Offset (Element input)
off NoMore
nm Failure input result'
err Success input () result'
ok ->
if input -> Offset (Element input) -> Bool
forall input.
ParserSource input =>
input -> Offset (Element input) -> Bool
endOfParserSource input
buf Offset (Element input)
off
then Success input () result'
ok input
buf Offset (Element input)
off NoMore
nm ()
else let (Chunk input
_, Offset (Element input)
off') = input
-> Offset (Element input)
-> (Element input -> Bool)
-> (Chunk input, Offset (Element input))
forall input.
ParserSource input =>
input
-> Offset (Element input)
-> (Element input -> Bool)
-> (Chunk input, Offset (Element input))
spanChunk input
buf Offset (Element input)
off Element input -> Bool
predicate
in if input -> Offset (Element input) -> Bool
forall input.
ParserSource input =>
input -> Offset (Element input) -> Bool
endOfParserSource input
buf Offset (Element input)
off'
then Parser input ()
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input () result'
-> Result input result'
forall input result result'.
ParserSource input =>
Parser input result
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
runParser_ ((Element input -> Bool) -> Parser input ()
forall input.
(ParserSource input, Sequential (Chunk input)) =>
(Element input -> Bool) -> Parser input ()
skipWhile Element input -> Bool
predicate) input
buf Offset (Element input)
off' NoMore
nm Failure input result'
err Success input () result'
ok
else Success input () result'
ok input
buf Offset (Element input)
off' NoMore
nm ()
skipAll :: (ParserSource input, Collection (Chunk input)) => Parser input ()
skipAll :: Parser input ()
skipAll = Parser input ()
forall input.
(ParserSource input, Collection (Chunk input)) =>
Parser input ()
flushAll
where
flushAll :: (ParserSource input, Collection (Chunk input)) => Parser input ()
flushAll :: Parser input ()
flushAll = (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input () result'
-> Result input result')
-> Parser input ()
forall input result.
(forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result')
-> Parser input result
Parser ((forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input () result'
-> Result input result')
-> Parser input ())
-> (forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input () result'
-> Result input result')
-> Parser input ()
forall a b. (a -> b) -> a -> b
$ \input
buf Offset (Element input)
off NoMore
nm Failure input result'
err Success input () result'
ok ->
let !off' :: Offset (Element input)
off' = CountOf (Element input) -> Offset (Element input)
forall a. CountOf a -> Offset a
sizeAsOffset (CountOf (Element input) -> Offset (Element input))
-> CountOf (Element input) -> Offset (Element input)
forall a b. (a -> b) -> a -> b
$ input -> CountOf (Element input)
forall c. Collection c => c -> CountOf (Element c)
length input
buf in
case NoMore
nm of
NoMore
NoMore -> Success input () result'
ok input
buf Offset (Element input)
off' NoMore
NoMore ()
NoMore
More -> (Chunk input -> Result input result') -> Result input result'
forall input result.
(Chunk input -> Result input result) -> Result input result
ParseMore ((Chunk input -> Result input result') -> Result input result')
-> (Chunk input -> Result input result') -> Result input result'
forall a b. (a -> b) -> a -> b
$ \Chunk input
nextChunk ->
if Chunk input -> Bool
forall c. Collection c => c -> Bool
null Chunk input
nextChunk
then Success input () result'
ok input
buf Offset (Element input)
off' NoMore
NoMore ()
else Parser input ()
-> input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input () result'
-> Result input result'
forall input result.
Parser input result
-> forall result'.
input
-> Offset (Element input)
-> NoMore
-> Failure input result'
-> Success input result result'
-> Result input result'
runParser Parser input ()
forall input.
(ParserSource input, Collection (Chunk input)) =>
Parser input ()
flushAll input
buf Offset (Element input)
off NoMore
nm Failure input result'
err Success input () result'
ok
{-# NOINLINE flushAll #-}
{-# INLINE skipAll #-}
string :: String -> Parser String ()
string :: String -> Parser String ()
string = String -> Parser String ()
forall input.
(ParserSource input, Sequential (Chunk input),
Element (Chunk input) ~ Element input, Eq (Chunk input)) =>
Chunk input -> Parser input ()
elements
{-# INLINE string #-}
data Condition = Between !And | Exactly !Word
deriving (Int -> Condition -> ShowS
[Condition] -> ShowS
Condition -> String
(Int -> Condition -> ShowS)
-> (Condition -> String)
-> ([Condition] -> ShowS)
-> Show Condition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Condition] -> ShowS
$cshowList :: [Condition] -> ShowS
show :: Condition -> String
$cshow :: Condition -> String
showsPrec :: Int -> Condition -> ShowS
$cshowsPrec :: Int -> Condition -> ShowS
Show, Condition -> Condition -> Bool
(Condition -> Condition -> Bool)
-> (Condition -> Condition -> Bool) -> Eq Condition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Condition -> Condition -> Bool
$c/= :: Condition -> Condition -> Bool
== :: Condition -> Condition -> Bool
$c== :: Condition -> Condition -> Bool
Eq, Typeable)
data And = And !Word !Word
deriving (And -> And -> Bool
(And -> And -> Bool) -> (And -> And -> Bool) -> Eq And
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: And -> And -> Bool
$c/= :: And -> And -> Bool
== :: And -> And -> Bool
$c== :: And -> And -> Bool
Eq, Typeable)
instance Show And where
show :: And -> String
show (And Word
a Word
b) = Word -> String
forall a. Show a => a -> String
show Word
a String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
" and " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Word -> String
forall a. Show a => a -> String
show Word
b
repeat :: ParserSource input
=> Condition -> Parser input a -> Parser input [a]
repeat :: Condition -> Parser input a -> Parser input [a]
repeat (Exactly Word
n) = Word -> Parser input a -> Parser input [a]
forall input a.
ParserSource input =>
Word -> Parser input a -> Parser input [a]
repeatE Word
n
repeat (Between And
a) = And -> Parser input a -> Parser input [a]
forall input a.
ParserSource input =>
And -> Parser input a -> Parser input [a]
repeatA And
a
repeatE :: (ParserSource input)
=> Word -> Parser input a -> Parser input [a]
repeatE :: Word -> Parser input a -> Parser input [a]
repeatE Word
0 Parser input a
_ = [a] -> Parser input [a]
forall (m :: * -> *) a. Monad m => a -> m a
return []
repeatE Word
n Parser input a
p = (:) (a -> [a] -> [a]) -> Parser input a -> Parser input ([a] -> [a])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser input a
p Parser input ([a] -> [a]) -> Parser input [a] -> Parser input [a]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Word -> Parser input a -> Parser input [a]
forall input a.
ParserSource input =>
Word -> Parser input a -> Parser input [a]
repeatE (Word
nWord -> Word -> Difference Word
forall a. Subtractive a => a -> a -> Difference a
-Word
1) Parser input a
p
repeatA :: (ParserSource input)
=> And -> Parser input a -> Parser input [a]
repeatA :: And -> Parser input a -> Parser input [a]
repeatA (And Word
0 Word
0) Parser input a
_ = [a] -> Parser input [a]
forall (m :: * -> *) a. Monad m => a -> m a
return []
repeatA (And Word
0 Word
n) Parser input a
p = ((:) (a -> [a] -> [a]) -> Parser input a -> Parser input ([a] -> [a])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser input a
p Parser input ([a] -> [a]) -> Parser input [a] -> Parser input [a]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> And -> Parser input a -> Parser input [a]
forall input a.
ParserSource input =>
And -> Parser input a -> Parser input [a]
repeatA (Word -> Word -> And
And Word
0 (Word
nWord -> Word -> Difference Word
forall a. Subtractive a => a -> a -> Difference a
-Word
1)) Parser input a
p) Parser input [a] -> Parser input [a] -> Parser input [a]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [a] -> Parser input [a]
forall (m :: * -> *) a. Monad m => a -> m a
return []
repeatA (And Word
l Word
u) Parser input a
p = (:) (a -> [a] -> [a]) -> Parser input a -> Parser input ([a] -> [a])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser input a
p Parser input ([a] -> [a]) -> Parser input [a] -> Parser input [a]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> And -> Parser input a -> Parser input [a]
forall input a.
ParserSource input =>
And -> Parser input a -> Parser input [a]
repeatA (Word -> Word -> And
And (Word
lWord -> Word -> Difference Word
forall a. Subtractive a => a -> a -> Difference a
-Word
1) (Word
uWord -> Word -> Difference Word
forall a. Subtractive a => a -> a -> Difference a
-Word
1)) Parser input a
p