{-# LANGUAGE CPP, FlexibleContexts, InstanceSigs, RankNTypes, ScopedTypeVariables, TypeFamilies, UndecidableInstances #-}
-- | Continuation-passing parser for context-free grammars
module Text.Grampa.ContextFree.Continued (Parser(..), Result(..), alt) where

import Control.Applicative (Applicative(..), Alternative(..), liftA2)
import Control.Monad (Monad(..), MonadPlus(..))
#if MIN_VERSION_base(4,13,0)
import Control.Monad (MonadFail(fail))
#endif

import Data.Functor.Classes (Show1(..))
import Data.Functor.Compose (Compose(..))
import Data.Kind (Type)
import Data.Semigroup (Semigroup(..))
import Data.Monoid (Monoid(mappend, mempty))
import Data.Monoid.Factorial(FactorialMonoid)
import Data.Monoid.Textual(TextualMonoid)
import Data.String (fromString)
import Debug.Trace (trace)
import Witherable (Filterable(mapMaybe))

import qualified Data.Monoid.Factorial as Factorial
import qualified Data.Monoid.Null as Null
import qualified Data.Monoid.Textual as Textual
import qualified Data.Semigroup.Cancellative as Cancellative

import qualified Rank2

import qualified Text.Parser.Char
import Text.Parser.Char (CharParsing)
import Text.Parser.Combinators (Parsing(..))
import Text.Parser.LookAhead (LookAheadParsing(..))
import Text.Parser.Input.Position (fromEnd)
import Text.Grampa.Class (CommittedParsing(..), DeterministicParsing(..),
                          InputParsing(..), InputCharParsing(..), MultiParsing(..),
                          ParseResults, ParseFailure(..), FailureDescription(..), Pos)
import Text.Grampa.Internal (emptyFailure, erroneous, expected, expectedInput, replaceExpected, TraceableParsing(..))

data Result (g :: (Type -> Type) -> Type) s v =
     Parsed{forall (g :: (* -> *) -> *) s v. Result g s v -> v
parsedPrefix :: !v,
            forall (g :: (* -> *) -> *) s v. Result g s v -> s
parsedSuffix :: !s}
   | NoParse {-# UNPACK #-} !(ParseFailure Pos s)

-- | Parser type for context-free grammars that uses a continuation-passing algorithm, fast for grammars in LL(1)
-- class but with potentially exponential performance for longer ambiguous prefixes.
newtype Parser (g :: (Type -> Type) -> Type) s r =
   Parser{forall (g :: (* -> *) -> *) s r.
Parser g s r
-> forall x.
   s
   -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
   -> (ParseFailure (Down Int) s -> x)
   -> x
applyParser :: forall x. s -> (r -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x}

instance Show s => Show1 (Result g s) where
   liftShowsPrec :: forall a.
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> Int -> Result g s a -> ShowS
liftShowsPrec Int -> a -> ShowS
showsPrecSub [a] -> ShowS
_showList Int
prec Parsed{parsedPrefix :: forall (g :: (* -> *) -> *) s v. Result g s v -> v
parsedPrefix= a
r} String
rest = String
"Parsed " forall a. [a] -> [a] -> [a]
++ Int -> a -> ShowS
showsPrecSub Int
prec a
r String
rest
   liftShowsPrec Int -> a -> ShowS
_showsPrec [a] -> ShowS
_showList Int
_prec (NoParse ParseFailure (Down Int) s
f) String
rest = String
"NoParse " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> ShowS
shows ParseFailure (Down Int) s
f String
rest

instance Functor (Result g s) where
   fmap :: forall a b. (a -> b) -> Result g s a -> Result g s b
fmap a -> b
f (Parsed a
a s
rest) = forall (g :: (* -> *) -> *) s v. v -> s -> Result g s v
Parsed (a -> b
f a
a) s
rest
   fmap a -> b
_ (NoParse ParseFailure (Down Int) s
failure) = forall (g :: (* -> *) -> *) s v.
ParseFailure (Down Int) s -> Result g s v
NoParse ParseFailure (Down Int) s
failure
   
instance Functor (Parser g s) where
   fmap :: forall a b. (a -> b) -> Parser g s a -> Parser g s b
fmap a -> b
f (Parser forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p) = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser (\s
input b -> s -> (ParseFailure (Down Int) s -> x) -> x
success-> forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p s
input (b -> s -> (ParseFailure (Down Int) s -> x) -> x
success forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
f))
   {-# INLINABLE fmap #-}

instance Applicative (Parser g s) where
   pure :: forall a. a -> Parser g s a
pure a
a = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser (\s
input a -> s -> (ParseFailure (Down Int) s -> x) -> x
success ParseFailure (Down Int) s -> x
failure-> a -> s -> (ParseFailure (Down Int) s -> x) -> x
success a
a s
input ParseFailure (Down Int) s -> x
failure)
   (<*>) :: forall a b. Parser g s (a -> b) -> Parser g s a -> Parser g s b
   Parser forall x.
s
-> ((a -> b) -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p <*> :: forall a b. Parser g s (a -> b) -> Parser g s a -> Parser g s b
<*> Parser forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
q = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (b -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
r where
      r :: forall x. s -> (b -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
      r :: forall x.
s
-> (b -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
r s
rest b -> s -> (ParseFailure (Down Int) s -> x) -> x
success ParseFailure (Down Int) s -> x
failure = forall x.
s
-> ((a -> b) -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p s
rest (\a -> b
f s
rest'-> forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
q s
rest' (b -> s -> (ParseFailure (Down Int) s -> x) -> x
success forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
f)) ParseFailure (Down Int) s -> x
failure
   {-# INLINABLE (<*>) #-}

instance (Factorial.FactorialMonoid s, Ord s) => Alternative (Parser g s) where
   empty :: forall a. Parser g s a
empty = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser (\s
rest a -> s -> (ParseFailure (Down Int) s -> x) -> x
_ ParseFailure (Down Int) s -> x
failure-> ParseFailure (Down Int) s -> x
failure forall a b. (a -> b) -> a -> b
$ forall s. Down Int -> ParseFailure (Down Int) s
emptyFailure forall a b. (a -> b) -> a -> b
$ Int -> Down Int
fromEnd forall a b. (a -> b) -> a -> b
$ forall m. Factorial m => m -> Int
Factorial.length s
rest)
   <|> :: forall a. Parser g s a -> Parser g s a -> Parser g s a
(<|>) = forall (g :: (* -> *) -> *) s a.
Ord s =>
Parser g s a -> Parser g s a -> Parser g s a
alt

-- | A named and unconstrained version of the '<|>' operator
alt :: forall g s a. Ord s => Parser g s a -> Parser g s a -> Parser g s a
Parser forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p alt :: forall (g :: (* -> *) -> *) s a.
Ord s =>
Parser g s a -> Parser g s a -> Parser g s a
`alt` Parser forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
q = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
r where
   r :: forall x. s -> (a -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
   r :: forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
r s
rest a -> s -> (ParseFailure (Down Int) s -> x) -> x
success ParseFailure (Down Int) s -> x
failure = forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p s
rest a -> s -> (ParseFailure (Down Int) s -> x) -> x
success' ParseFailure (Down Int) s -> x
failure'
      where success' :: a -> s -> (ParseFailure (Down Int) s -> x) -> x
success' a
a s
rest' ParseFailure (Down Int) s -> x
_ = a -> s -> (ParseFailure (Down Int) s -> x) -> x
success a
a s
rest' ParseFailure (Down Int) s -> x
failure'
            failure' :: ParseFailure (Down Int) s -> x
failure' ParseFailure (Down Int) s
f1 = forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
q s
rest a -> s -> (ParseFailure (Down Int) s -> x) -> x
success (\ParseFailure (Down Int) s
f2 -> ParseFailure (Down Int) s -> x
failure (ParseFailure (Down Int) s
f1 forall a. Semigroup a => a -> a -> a
<> ParseFailure (Down Int) s
f2))

instance Factorial.FactorialMonoid s => Filterable (Result g s) where
   mapMaybe :: forall a b. (a -> Maybe b) -> Result g s a -> Result g s b
mapMaybe a -> Maybe b
f (Parsed a
a s
rest) =
      forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall (g :: (* -> *) -> *) s v.
ParseFailure (Down Int) s -> Result g s v
NoParse forall a b. (a -> b) -> a -> b
$ forall s. Down Int -> String -> ParseFailure (Down Int) s
expected (Int -> Down Int
fromEnd forall a b. (a -> b) -> a -> b
$ forall m. Factorial m => m -> Int
Factorial.length s
rest) String
"filter") (forall (g :: (* -> *) -> *) s v. v -> s -> Result g s v
`Parsed` s
rest) (a -> Maybe b
f a
a)
   mapMaybe a -> Maybe b
_ (NoParse ParseFailure (Down Int) s
failure) = forall (g :: (* -> *) -> *) s v.
ParseFailure (Down Int) s -> Result g s v
NoParse ParseFailure (Down Int) s
failure
   
instance Factorial.FactorialMonoid s => Filterable (Parser g s) where
   mapMaybe :: forall a b. (a -> Maybe b) -> Parser g s a -> Parser g s b
   mapMaybe :: forall a b. (a -> Maybe b) -> Parser g s a -> Parser g s b
mapMaybe a -> Maybe b
f (Parser forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p) = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (b -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
q where
      q :: forall x. s -> (b -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
      q :: forall x.
s
-> (b -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
q s
rest b -> s -> (ParseFailure (Down Int) s -> x) -> x
success ParseFailure (Down Int) s -> x
failure = forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p s
rest (forall b a. b -> (a -> b) -> Maybe a -> b
maybe s -> (ParseFailure (Down Int) s -> x) -> x
filterFailure b -> s -> (ParseFailure (Down Int) s -> x) -> x
success forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Maybe b
f) ParseFailure (Down Int) s -> x
failure
         where filterFailure :: s -> (ParseFailure (Down Int) s -> x) -> x
filterFailure s
_ ParseFailure (Down Int) s -> x
_ = ParseFailure (Down Int) s -> x
failure (forall s. Down Int -> String -> ParseFailure (Down Int) s
expected (Int -> Down Int
fromEnd forall a b. (a -> b) -> a -> b
$ forall m. Factorial m => m -> Int
Factorial.length s
rest) String
"filter")
   {-# INLINABLE mapMaybe #-}

#if MIN_VERSION_base(4,13,0)
instance Monad (Parser g s) where
#else
instance Factorial.FactorialMonoid s => Monad (Parser g s) where
#endif
   return :: forall a. a -> Parser g s a
return = forall (f :: * -> *) a. Applicative f => a -> f a
pure
   (>>=) :: forall a b. Parser g s a -> (a -> Parser g s b) -> Parser g s b
   Parser forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p >>= :: forall a b. Parser g s a -> (a -> Parser g s b) -> Parser g s b
>>= a -> Parser g s b
f = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (b -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
r where
      r :: forall x. s -> (b -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
      r :: forall x.
s
-> (b -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
r s
rest b -> s -> (ParseFailure (Down Int) s -> x) -> x
success ParseFailure (Down Int) s -> x
failure = forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p s
rest (\a
a s
rest'-> forall (g :: (* -> *) -> *) s r.
Parser g s r
-> forall x.
   s
   -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
   -> (ParseFailure (Down Int) s -> x)
   -> x
applyParser (a -> Parser g s b
f a
a) s
rest' b -> s -> (ParseFailure (Down Int) s -> x) -> x
success) ParseFailure (Down Int) s -> x
failure

#if MIN_VERSION_base(4,13,0)
instance Factorial.FactorialMonoid s => MonadFail (Parser g s) where
#endif
   fail :: forall a. String -> Parser g s a
fail String
msg = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser (\s
rest a -> s -> (ParseFailure (Down Int) s -> x) -> x
_ ParseFailure (Down Int) s -> x
failure-> ParseFailure (Down Int) s -> x
failure forall a b. (a -> b) -> a -> b
$ forall s. Down Int -> String -> ParseFailure (Down Int) s
erroneous (Int -> Down Int
fromEnd forall a b. (a -> b) -> a -> b
$ forall m. Factorial m => m -> Int
Factorial.length s
rest) String
msg)

instance (Factorial.FactorialMonoid s, Ord s) => MonadPlus (Parser g s) where
   mzero :: forall a. Parser g s a
mzero = forall (f :: * -> *) a. Alternative f => f a
empty
   mplus :: forall a. Parser g s a -> Parser g s a -> Parser g s a
mplus = forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
(<|>)

instance Semigroup x => Semigroup (Parser g s x) where
   <> :: Parser g s x -> Parser g s x -> Parser g s x
(<>) = forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 forall a. Semigroup a => a -> a -> a
(<>)

instance Monoid x => Monoid (Parser g s x) where
   mempty :: Parser g s x
mempty = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. Monoid a => a
mempty
   mappend :: Parser g s x -> Parser g s x -> Parser g s x
mappend = forall a. Semigroup a => a -> a -> a
(<>)

instance (Factorial.FactorialMonoid s, Ord s) => Parsing (Parser g s) where
   try :: forall a. Parser g s a -> Parser g s a
   try :: forall a. Parser g s a -> Parser g s a
try (Parser forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p) = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
q
      where q :: forall x. s -> (a -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            q :: forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
q s
input a -> s -> (ParseFailure (Down Int) s -> x) -> x
success ParseFailure (Down Int) s -> x
failure = forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p s
input a -> s -> (ParseFailure (Down Int) s -> x) -> x
success (ParseFailure (Down Int) s -> x
failure forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParseFailure (Down Int) s -> ParseFailure (Down Int) s
rewindFailure)
               where rewindFailure :: ParseFailure (Down Int) s -> ParseFailure (Down Int) s
rewindFailure ParseFailure{} = forall s. Down Int -> ParseFailure (Down Int) s
emptyFailure (Int -> Down Int
fromEnd forall a b. (a -> b) -> a -> b
$ forall m. Factorial m => m -> Int
Factorial.length s
input)
   (<?>) :: forall a. Parser g s a -> String -> Parser g s a
   Parser forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p <?> :: forall a. Parser g s a -> String -> Parser g s a
<?> String
msg  = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
q
      where q :: forall x. s -> (a -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            q :: forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
q s
input a -> s -> (ParseFailure (Down Int) s -> x) -> x
success ParseFailure (Down Int) s -> x
failure = forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p s
input a -> s -> (ParseFailure (Down Int) s -> x) -> x
success (ParseFailure (Down Int) s -> x
failure forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s.
Down Int
-> String -> ParseFailure (Down Int) s -> ParseFailure (Down Int) s
replaceExpected (Int -> Down Int
fromEnd forall a b. (a -> b) -> a -> b
$ forall m. Factorial m => m -> Int
Factorial.length s
input) String
msg)

   eof :: Parser g s ()
eof = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser forall {m} {s} {t}.
(MonoidNull m, Factorial m) =>
m
-> (() -> m -> (ParseFailure (Down Int) s -> t) -> t)
-> (ParseFailure (Down Int) s -> t)
-> t
p
      where p :: m
-> (() -> m -> (ParseFailure (Down Int) s -> t) -> t)
-> (ParseFailure (Down Int) s -> t)
-> t
p m
rest () -> m -> (ParseFailure (Down Int) s -> t) -> t
success ParseFailure (Down Int) s -> t
failure
               | forall m. MonoidNull m => m -> Bool
Null.null m
rest = () -> m -> (ParseFailure (Down Int) s -> t) -> t
success () m
rest ParseFailure (Down Int) s -> t
failure
               | Bool
otherwise = ParseFailure (Down Int) s -> t
failure (forall s. Down Int -> String -> ParseFailure (Down Int) s
expected (Int -> Down Int
fromEnd forall a b. (a -> b) -> a -> b
$ forall m. Factorial m => m -> Int
Factorial.length m
rest) String
"end of input")
   unexpected :: forall a. String -> Parser g s a
unexpected String
msg = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser (\s
t a -> s -> (ParseFailure (Down Int) s -> x) -> x
_ ParseFailure (Down Int) s -> x
failure -> ParseFailure (Down Int) s -> x
failure forall a b. (a -> b) -> a -> b
$ forall s. Down Int -> String -> ParseFailure (Down Int) s
erroneous (Int -> Down Int
fromEnd forall a b. (a -> b) -> a -> b
$ forall m. Factorial m => m -> Int
Factorial.length s
t) String
msg)
   notFollowedBy :: forall a. Show a => Parser g s a -> Parser g s ()
notFollowedBy (Parser forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p) = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (() -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
q
      where q :: forall x. s -> (() -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            q :: forall x.
s
-> (() -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
q s
input () -> s -> (ParseFailure (Down Int) s -> x) -> x
success ParseFailure (Down Int) s -> x
failure = forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p s
input a -> s -> (ParseFailure (Down Int) s -> x) -> x
success' ParseFailure (Down Int) s -> x
failure'
               where success' :: a -> s -> (ParseFailure (Down Int) s -> x) -> x
success' a
_ s
_ ParseFailure (Down Int) s -> x
_ = ParseFailure (Down Int) s -> x
failure (forall s. Down Int -> String -> ParseFailure (Down Int) s
expected (Int -> Down Int
fromEnd forall a b. (a -> b) -> a -> b
$ forall m. Factorial m => m -> Int
Factorial.length s
input) String
"notFollowedBy")
                     failure' :: ParseFailure (Down Int) s -> x
failure' ParseFailure (Down Int) s
_ = () -> s -> (ParseFailure (Down Int) s -> x) -> x
success () s
input ParseFailure (Down Int) s -> x
failure

instance (FactorialMonoid s, Ord s) => DeterministicParsing (Parser g s) where
   (<<|>) :: forall a. Parser g s a -> Parser g s a -> Parser g s a
   Parser forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p <<|> :: forall a. Parser g s a -> Parser g s a -> Parser g s a
<<|> Parser forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
q = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
r where
      r :: forall x. s -> (a -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
      r :: forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
r s
rest a -> s -> (ParseFailure (Down Int) s -> x) -> x
success ParseFailure (Down Int) s -> x
failure = forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p s
rest a -> s -> (ParseFailure (Down Int) s -> x) -> x
success' ParseFailure (Down Int) s -> x
failure'
         where success' :: a -> s -> (ParseFailure (Down Int) s -> x) -> x
success' a
a s
rest' ParseFailure (Down Int) s -> x
_ = a -> s -> (ParseFailure (Down Int) s -> x) -> x
success a
a s
rest' ParseFailure (Down Int) s -> x
failure
               failure' :: ParseFailure (Down Int) s -> x
failure' ParseFailure (Down Int) s
f1 = forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
q s
rest a -> s -> (ParseFailure (Down Int) s -> x) -> x
success (\ParseFailure (Down Int) s
f2 -> ParseFailure (Down Int) s -> x
failure (ParseFailure (Down Int) s
f1 forall a. Semigroup a => a -> a -> a
<> ParseFailure (Down Int) s
f2))
   takeSome :: forall a. Parser g s a -> Parser g s [a]
takeSome Parser g s a
p = (:) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g s a
p forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. DeterministicParsing m => m a -> m [a]
takeMany Parser g s a
p
   takeMany :: forall a. Parser g s a -> Parser g s [a]
takeMany Parser g s a
p = forall (m :: * -> *) a. DeterministicParsing m => m a -> m [a]
takeSome Parser g s a
p forall (m :: * -> *) a. DeterministicParsing m => m a -> m a -> m a
<<|> forall (f :: * -> *) a. Applicative f => a -> f a
pure []

instance (FactorialMonoid s, Ord s) => CommittedParsing (Parser g s) where
   type CommittedResults (Parser g s) = ParseResults s
   commit :: forall a. Parser g s a -> Parser g s (ParseResults s a)
   commit :: forall a. Parser g s a -> Parser g s (ParseResults s a)
commit (Parser forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p) = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (ParseResults s a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
q
      where q :: forall x. s -> (ParseResults s a -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            q :: forall x.
s
-> (ParseResults s a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
q s
input ParseResults s a -> s -> (ParseFailure (Down Int) s -> x) -> x
success ParseFailure (Down Int) s -> x
failure = forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p s
input (ParseResults s a -> s -> (ParseFailure (Down Int) s -> x) -> x
success forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. b -> Either a b
Right) ParseFailure (Down Int) s -> x
failure'
               where failure' :: ParseFailure (Down Int) s -> x
failure' ParseFailure (Down Int) s
f = ParseResults s a -> s -> (ParseFailure (Down Int) s -> x) -> x
success (forall a b. a -> Either a b
Left ParseFailure (Down Int) s
f) s
input ParseFailure (Down Int) s -> x
failure
   admit :: forall a. Parser g s (ParseResults s a) -> Parser g s a
   admit :: forall a. Parser g s (ParseResults s a) -> Parser g s a
admit (Parser forall x.
s
-> (ParseResults s a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p) = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
q
      where q :: forall x. s -> (a -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            q :: forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
q s
input a -> s -> (ParseFailure (Down Int) s -> x) -> x
success ParseFailure (Down Int) s -> x
failure = forall x.
s
-> (ParseResults s a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p s
input ParseResults s a -> s -> (ParseFailure (Down Int) s -> x) -> x
success' ParseFailure (Down Int) s -> x
failure
               where success' :: ParseResults s a -> s -> (ParseFailure (Down Int) s -> x) -> x
success' (Left ParseFailure (Down Int) s
f) s
_rest = forall a b. a -> b -> a
const (ParseFailure (Down Int) s -> x
failure ParseFailure (Down Int) s
f)
                     success' (Right a
a) s
rest = a -> s -> (ParseFailure (Down Int) s -> x) -> x
success a
a s
rest

instance (FactorialMonoid s, Ord s) => LookAheadParsing (Parser g s) where
   lookAhead :: forall a. Parser g s a -> Parser g s a
   lookAhead :: forall a. Parser g s a -> Parser g s a
lookAhead (Parser forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p) = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
q
      where q :: forall x. s -> (a -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            q :: forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
q s
input a -> s -> (ParseFailure (Down Int) s -> x) -> x
success ParseFailure (Down Int) s -> x
failure = forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p s
input a -> s -> (ParseFailure (Down Int) s -> x) -> x
success' ParseFailure (Down Int) s -> x
failure'
               where success' :: a -> s -> (ParseFailure (Down Int) s -> x) -> x
success' a
a s
_ = a -> s -> (ParseFailure (Down Int) s -> x) -> x
success a
a s
input
                     failure' :: ParseFailure (Down Int) s -> x
failure' ParseFailure (Down Int) s
f = ParseFailure (Down Int) s -> x
failure ParseFailure (Down Int) s
f

instance (Ord s, Show s, TextualMonoid s) => CharParsing (Parser g s) where
   satisfy :: (Char -> Bool) -> Parser g s Char
satisfy Char -> Bool
predicate = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (Char -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p
      where p :: forall x. s -> (Char -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            p :: forall x.
s
-> (Char -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p s
rest Char -> s -> (ParseFailure (Down Int) s -> x) -> x
success ParseFailure (Down Int) s -> x
failure =
               case forall t. TextualMonoid t => t -> Maybe (Char, t)
Textual.splitCharacterPrefix s
rest
               of Just (Char
first, s
suffix) | Char -> Bool
predicate Char
first -> Char -> s -> (ParseFailure (Down Int) s -> x) -> x
success Char
first s
suffix ParseFailure (Down Int) s -> x
failure
                  Maybe (Char, s)
_ -> ParseFailure (Down Int) s -> x
failure (forall s. Down Int -> String -> ParseFailure (Down Int) s
expected (Int -> Down Int
fromEnd forall a b. (a -> b) -> a -> b
$ forall m. Factorial m => m -> Int
Factorial.length s
rest) String
"Char.satisfy")
   string :: String -> Parser g s String
string String
s = forall t. TextualMonoid t => (t -> String) -> t -> String
Textual.toString (forall a. HasCallStack => String -> a
error String
"unexpected non-character") forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string (forall a. IsString a => String -> a
fromString String
s)
   text :: Text -> Parser g s Text
text Text
t = (forall a. IsString a => String -> a
fromString forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t. TextualMonoid t => (t -> String) -> t -> String
Textual.toString (forall a. HasCallStack => String -> a
error String
"unexpected non-character")) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string (forall t. TextualMonoid t => Text -> t
Textual.fromText Text
t)

instance (Cancellative.LeftReductive s, Factorial.FactorialMonoid s, Ord s) => InputParsing (Parser g s) where
   type ParserInput (Parser g s) = s
   getInput :: Parser g s (ParserInput (Parser g s))
getInput = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser forall {t} {t} {t}. t -> (t -> t -> t -> t) -> t -> t
p
      where p :: t -> (t -> t -> t -> t) -> t -> t
p t
rest t -> t -> t -> t
success t
failure = t -> t -> t -> t
success t
rest t
rest t
failure
   anyToken :: Parser g s (ParserInput (Parser g s))
anyToken = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser forall {m} {s} {t}.
FactorialMonoid m =>
m
-> (m -> m -> (ParseFailure (Down Int) s -> t) -> t)
-> (ParseFailure (Down Int) s -> t)
-> t
p
      where p :: m
-> (m -> m -> (ParseFailure (Down Int) s -> t) -> t)
-> (ParseFailure (Down Int) s -> t)
-> t
p m
rest m -> m -> (ParseFailure (Down Int) s -> t) -> t
success ParseFailure (Down Int) s -> t
failure =
               case forall m. FactorialMonoid m => m -> Maybe (m, m)
Factorial.splitPrimePrefix m
rest
               of Just (m
first, m
suffix) -> m -> m -> (ParseFailure (Down Int) s -> t) -> t
success m
first m
suffix ParseFailure (Down Int) s -> t
failure
                  Maybe (m, m)
_ -> ParseFailure (Down Int) s -> t
failure (forall s. Down Int -> String -> ParseFailure (Down Int) s
expected (Int -> Down Int
fromEnd forall a b. (a -> b) -> a -> b
$ forall m. Factorial m => m -> Int
Factorial.length m
rest) String
"anyToken")
   satisfy :: (ParserInput (Parser g s) -> Bool)
-> Parser g s (ParserInput (Parser g s))
satisfy ParserInput (Parser g s) -> Bool
predicate = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (s -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p
      where p :: forall x. s -> (s -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            p :: forall x.
s
-> (s -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p s
rest s -> s -> (ParseFailure (Down Int) s -> x) -> x
success ParseFailure (Down Int) s -> x
failure =
               case forall m. FactorialMonoid m => m -> Maybe (m, m)
Factorial.splitPrimePrefix s
rest
               of Just (s
first, s
suffix) | ParserInput (Parser g s) -> Bool
predicate s
first -> s -> s -> (ParseFailure (Down Int) s -> x) -> x
success s
first s
suffix ParseFailure (Down Int) s -> x
failure
                  Maybe (s, s)
_ -> ParseFailure (Down Int) s -> x
failure (forall s. Down Int -> String -> ParseFailure (Down Int) s
expected (Int -> Down Int
fromEnd forall a b. (a -> b) -> a -> b
$ forall m. Factorial m => m -> Int
Factorial.length s
rest) String
"satisfy")
   notSatisfy :: (ParserInput (Parser g s) -> Bool) -> Parser g s ()
notSatisfy ParserInput (Parser g s) -> Bool
predicate = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (() -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p
      where p :: forall x. s -> (() -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            p :: forall x.
s
-> (() -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p s
rest () -> s -> (ParseFailure (Down Int) s -> x) -> x
success ParseFailure (Down Int) s -> x
failure =
               case forall m. FactorialMonoid m => m -> Maybe (m, m)
Factorial.splitPrimePrefix s
rest
               of Just (s
first, s
_)
                     | ParserInput (Parser g s) -> Bool
predicate s
first -> ParseFailure (Down Int) s -> x
failure (forall s. Down Int -> String -> ParseFailure (Down Int) s
expected (Int -> Down Int
fromEnd forall a b. (a -> b) -> a -> b
$ forall m. Factorial m => m -> Int
Factorial.length s
rest) String
"notSatisfy")
                  Maybe (s, s)
_ -> () -> s -> (ParseFailure (Down Int) s -> x) -> x
success () s
rest ParseFailure (Down Int) s -> x
failure
   scan :: forall state. state -> (state -> s -> Maybe state) -> Parser g s s
   scan :: forall state. state -> (state -> s -> Maybe state) -> Parser g s s
scan state
s0 state -> s -> Maybe state
f = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser (forall x.
state
-> s
-> (s -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p state
s0)
      where p :: forall x. state -> s -> (s -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            p :: forall x.
state
-> s
-> (s -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p state
s s
rest s -> s -> (ParseFailure (Down Int) s -> x) -> x
success ParseFailure (Down Int) s -> x
failure = s -> s -> (ParseFailure (Down Int) s -> x) -> x
success s
prefix s
suffix ParseFailure (Down Int) s -> x
failure
               where (s
prefix, s
suffix, state
_) = forall m s.
FactorialMonoid m =>
s -> (s -> m -> Maybe s) -> m -> (m, m, s)
Factorial.spanMaybe' state
s state -> s -> Maybe state
f s
rest
   take :: Int -> Parser g s (ParserInput (Parser g s))
take Int
n = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (s -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p
      where p :: forall x. s -> (s -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            p :: forall x.
s
-> (s -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p s
rest s -> s -> (ParseFailure (Down Int) s -> x) -> x
success ParseFailure (Down Int) s -> x
failure
              | (s
prefix, s
suffix) <- forall m. FactorialMonoid m => Int -> m -> (m, m)
Factorial.splitAt Int
n s
rest,
                forall m. Factorial m => m -> Int
Factorial.length s
prefix forall a. Eq a => a -> a -> Bool
== Int
n = s -> s -> (ParseFailure (Down Int) s -> x) -> x
success s
prefix s
suffix ParseFailure (Down Int) s -> x
failure
              | Bool
otherwise = ParseFailure (Down Int) s -> x
failure (forall s. Down Int -> String -> ParseFailure (Down Int) s
expected (Int -> Down Int
fromEnd forall a b. (a -> b) -> a -> b
$ forall m. Factorial m => m -> Int
Factorial.length s
rest) forall a b. (a -> b) -> a -> b
$ String
"take " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int
n)
   takeWhile :: (ParserInput (Parser g s) -> Bool)
-> Parser g s (ParserInput (Parser g s))
takeWhile ParserInput (Parser g s) -> Bool
predicate = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (s -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p
      where p :: forall x. s -> (s -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            p :: forall x.
s
-> (s -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p s
rest s -> s -> (ParseFailure (Down Int) s -> x) -> x
success ParseFailure (Down Int) s -> x
failure | (s
prefix, s
suffix) <- forall m. FactorialMonoid m => (m -> Bool) -> m -> (m, m)
Factorial.span ParserInput (Parser g s) -> Bool
predicate s
rest = s -> s -> (ParseFailure (Down Int) s -> x) -> x
success s
prefix s
suffix ParseFailure (Down Int) s -> x
failure
   takeWhile1 :: (ParserInput (Parser g s) -> Bool)
-> Parser g s (ParserInput (Parser g s))
takeWhile1 ParserInput (Parser g s) -> Bool
predicate = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (s -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p
      where p :: forall x. s -> (s -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            p :: forall x.
s
-> (s -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p s
rest s -> s -> (ParseFailure (Down Int) s -> x) -> x
success ParseFailure (Down Int) s -> x
failure
               | (s
prefix, s
suffix) <- forall m. FactorialMonoid m => (m -> Bool) -> m -> (m, m)
Factorial.span ParserInput (Parser g s) -> Bool
predicate s
rest =
                    if forall m. MonoidNull m => m -> Bool
Null.null s
prefix
                    then ParseFailure (Down Int) s -> x
failure (forall s. Down Int -> String -> ParseFailure (Down Int) s
expected (Int -> Down Int
fromEnd forall a b. (a -> b) -> a -> b
$ forall m. Factorial m => m -> Int
Factorial.length s
rest) String
"takeWhile1")
                    else s -> s -> (ParseFailure (Down Int) s -> x) -> x
success s
prefix s
suffix ParseFailure (Down Int) s -> x
failure
   string :: ParserInput (Parser g s) -> Parser g s (ParserInput (Parser g s))
string ParserInput (Parser g s)
s = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (s -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p where
      p :: forall x. s -> (s -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
      p :: forall x.
s
-> (s -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p s
s' s -> s -> (ParseFailure (Down Int) s -> x) -> x
success ParseFailure (Down Int) s -> x
failure
         | Just s
suffix <- forall m. LeftReductive m => m -> m -> Maybe m
Cancellative.stripPrefix ParserInput (Parser g s)
s s
s' = s -> s -> (ParseFailure (Down Int) s -> x) -> x
success ParserInput (Parser g s)
s s
suffix ParseFailure (Down Int) s -> x
failure
         | Bool
otherwise = ParseFailure (Down Int) s -> x
failure (forall s. Down Int -> s -> ParseFailure (Down Int) s
expectedInput (Int -> Down Int
fromEnd forall a b. (a -> b) -> a -> b
$ forall m. Factorial m => m -> Int
Factorial.length s
s') ParserInput (Parser g s)
s)
   {-# INLINABLE string #-}

instance (InputParsing (Parser g s), FactorialMonoid s)  => TraceableParsing (Parser g s) where
   traceInput :: forall a. (s -> String) -> Parser g s a -> Parser g s a
   traceInput :: forall a. (s -> String) -> Parser g s a -> Parser g s a
traceInput s -> String
description (Parser forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p) = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
q
      where q :: forall x. s -> (a -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            q :: forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
q s
rest a -> s -> (ParseFailure (Down Int) s -> x) -> x
success ParseFailure (Down Int) s -> x
failure = String -> x -> x
traceWith String
"Parsing " (forall x.
s
-> (a -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p s
rest a -> s -> (ParseFailure (Down Int) s -> x) -> x
success' ParseFailure (Down Int) s -> x
failure')
               where traceWith :: String -> x -> x
traceWith String
prefix = forall a. String -> a -> a
trace (String
prefix forall a. Semigroup a => a -> a -> a
<> s -> String
description s
rest)
                     failure' :: ParseFailure (Down Int) s -> x
failure' ParseFailure (Down Int) s
f = String -> x -> x
traceWith String
"Failed " (ParseFailure (Down Int) s -> x
failure ParseFailure (Down Int) s
f)
                     success' :: a -> s -> (ParseFailure (Down Int) s -> x) -> x
success' a
r s
suffix ParseFailure (Down Int) s -> x
failure'' = forall a. String -> a -> a
trace (String
"Parsed " forall a. Semigroup a => a -> a -> a
<> s -> String
description s
prefix) (a -> s -> (ParseFailure (Down Int) s -> x) -> x
success a
r s
suffix ParseFailure (Down Int) s -> x
failure'')
                        where prefix :: s
prefix = forall m. FactorialMonoid m => Int -> m -> m
Factorial.take (forall m. Factorial m => m -> Int
Factorial.length s
rest forall a. Num a => a -> a -> a
- forall m. Factorial m => m -> Int
Factorial.length s
suffix) s
rest

instance (Ord s, Show s, TextualMonoid s) => InputCharParsing (Parser g s) where
   satisfyCharInput :: (Char -> Bool) -> Parser g s (ParserInput (Parser g s))
satisfyCharInput Char -> Bool
predicate = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (s -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p
      where p :: forall x. s -> (s -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            p :: forall x.
s
-> (s -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p s
rest s -> s -> (ParseFailure (Down Int) s -> x) -> x
success ParseFailure (Down Int) s -> x
failure =
               case forall t. TextualMonoid t => t -> Maybe (Char, t)
Textual.splitCharacterPrefix s
rest
               of Just (Char
first, s
suffix) | Char -> Bool
predicate Char
first -> s -> s -> (ParseFailure (Down Int) s -> x) -> x
success (forall m. Factorial m => m -> m
Factorial.primePrefix s
rest) s
suffix ParseFailure (Down Int) s -> x
failure
                  Maybe (Char, s)
_ -> ParseFailure (Down Int) s -> x
failure (forall s. Down Int -> String -> ParseFailure (Down Int) s
expected (Int -> Down Int
fromEnd forall a b. (a -> b) -> a -> b
$ forall m. Factorial m => m -> Int
Factorial.length s
rest) String
"satisfyChar")
   notSatisfyChar :: (Char -> Bool) -> Parser g s ()
notSatisfyChar Char -> Bool
predicate = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (() -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p
      where p :: forall x. s -> (() -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            p :: forall x.
s
-> (() -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p s
rest () -> s -> (ParseFailure (Down Int) s -> x) -> x
success ParseFailure (Down Int) s -> x
failure =
               case forall t. TextualMonoid t => t -> Maybe Char
Textual.characterPrefix s
rest
               of Just Char
first | Char -> Bool
predicate Char
first
                               -> ParseFailure (Down Int) s -> x
failure (forall s. Down Int -> String -> ParseFailure (Down Int) s
expected (Int -> Down Int
fromEnd forall a b. (a -> b) -> a -> b
$ forall m. Factorial m => m -> Int
Factorial.length s
rest) String
"notSatisfyChar")
                  Maybe Char
_ -> () -> s -> (ParseFailure (Down Int) s -> x) -> x
success () s
rest ParseFailure (Down Int) s -> x
failure
   scanChars :: forall state. state -> (state -> Char -> Maybe state) -> Parser g s s
   scanChars :: forall state.
state -> (state -> Char -> Maybe state) -> Parser g s s
scanChars state
s0 state -> Char -> Maybe state
f = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser (forall x.
state
-> s
-> (s -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p state
s0)
      where p :: forall x. state -> s -> (s -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            p :: forall x.
state
-> s
-> (s -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p state
s s
rest s -> s -> (ParseFailure (Down Int) s -> x) -> x
success ParseFailure (Down Int) s -> x
failure = s -> s -> (ParseFailure (Down Int) s -> x) -> x
success s
prefix s
suffix ParseFailure (Down Int) s -> x
failure
               where (s
prefix, s
suffix, state
_) = forall t s.
TextualMonoid t =>
s -> (s -> Char -> Maybe s) -> t -> (t, t, s)
Textual.spanMaybe_' state
s state -> Char -> Maybe state
f s
rest
   takeCharsWhile :: (Char -> Bool) -> Parser g s (ParserInput (Parser g s))
takeCharsWhile Char -> Bool
predicate = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (s -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p
      where p :: forall x. s -> (s -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            p :: forall x.
s
-> (s -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p s
rest s -> s -> (ParseFailure (Down Int) s -> x) -> x
success ParseFailure (Down Int) s -> x
failure
               | (s
prefix, s
suffix) <- forall t. TextualMonoid t => Bool -> (Char -> Bool) -> t -> (t, t)
Textual.span_ Bool
False Char -> Bool
predicate s
rest = s -> s -> (ParseFailure (Down Int) s -> x) -> x
success s
prefix s
suffix ParseFailure (Down Int) s -> x
failure
   takeCharsWhile1 :: (Char -> Bool) -> Parser g s (ParserInput (Parser g s))
takeCharsWhile1 Char -> Bool
predicate = forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
 -> (ParseFailure (Down Int) s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (s -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p
      where p :: forall x. s -> (s -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            p :: forall x.
s
-> (s -> s -> (ParseFailure (Down Int) s -> x) -> x)
-> (ParseFailure (Down Int) s -> x)
-> x
p s
rest s -> s -> (ParseFailure (Down Int) s -> x) -> x
success ParseFailure (Down Int) s -> x
failure
               | forall m. MonoidNull m => m -> Bool
Null.null s
prefix = ParseFailure (Down Int) s -> x
failure (forall s. Down Int -> String -> ParseFailure (Down Int) s
expected (Int -> Down Int
fromEnd forall a b. (a -> b) -> a -> b
$ forall m. Factorial m => m -> Int
Factorial.length s
rest) String
"takeCharsWhile1")
               | Bool
otherwise = s -> s -> (ParseFailure (Down Int) s -> x) -> x
success s
prefix s
suffix ParseFailure (Down Int) s -> x
failure
               where (s
prefix, s
suffix) = forall t. TextualMonoid t => Bool -> (Char -> Bool) -> t -> (t, t)
Textual.span_ Bool
False Char -> Bool
predicate s
rest

-- | Continuation-passing context-free parser
--
-- @
-- 'parseComplete' :: ("Rank2".'Rank2.Functor' g, 'FactorialMonoid' s) =>
--                  g (Continued.'Parser' g s) -> s -> g ('ParseResults' s)
-- @
instance (Cancellative.LeftReductive s, Factorial.FactorialMonoid s, Ord s) => MultiParsing (Parser g s) where
   type ResultFunctor (Parser g s) = ParseResults s
   -- | Returns an input prefix parse paired with the remaining input suffix.
   parsePrefix :: forall s (g :: (* -> *) -> *).
(ParserInput (Parser g s) ~ s, GrammarConstraint (Parser g s) g,
 Eq s, FactorialMonoid s) =>
g (Parser g s)
-> s -> g (Compose (ResultFunctor (Parser g s)) ((,) s))
parsePrefix g (Parser g s)
g s
input = forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Functor g =>
(forall (a :: k). p a -> q a) -> g p -> g q
Rank2.fmap (forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\Parser g s a
p-> forall (g :: (* -> *) -> *) s r.
Parser g s r
-> forall x.
   s
   -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
   -> (ParseFailure (Down Int) s -> x)
   -> x
applyParser Parser g s a
p s
input (\a
a s
rest ParseFailure (Down Int) s
-> Either (ParseFailure (Down Int) s) (s, a)
_-> forall a b. b -> Either a b
Right (s
rest, a
a)) forall a b. a -> Either a b
Left)) g (Parser g s)
g
   parseComplete :: forall s (g :: (* -> *) -> *).
(ParserInput (Parser g s) ~ s, GrammarConstraint (Parser g s) g,
 Eq s, FactorialMonoid s) =>
g (Parser g s) -> s -> g (ResultFunctor (Parser g s))
parseComplete g (Parser g s)
g s
input = forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Functor g =>
(forall (a :: k). p a -> q a) -> g p -> g q
Rank2.fmap (\Parser g s a
p-> forall (g :: (* -> *) -> *) s r.
Parser g s r
-> forall x.
   s
   -> (r -> s -> (ParseFailure (Down Int) s -> x) -> x)
   -> (ParseFailure (Down Int) s -> x)
   -> x
applyParser Parser g s a
p s
input (forall a b. a -> b -> a
const forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> b -> a
const forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. b -> Either a b
Right) forall a b. a -> Either a b
Left)
                                      (forall {k} (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Functor g =>
(forall (a :: k). p a -> q a) -> g p -> g q
Rank2.fmap (forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). Parsing m => m ()
eof) g (Parser g s)
g)