{-# 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 (expected, TraceableParsing(..))

data Result (g :: (Type -> Type) -> Type) s v =
     Parsed{Result g s v -> v
parsedPrefix :: !v,
            Result g s v -> s
parsedSuffix :: !s}
   | NoParse (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{Parser g s r
-> forall x.
   s
   -> (r -> s -> (ParseFailure Pos s -> x) -> x)
   -> (ParseFailure Pos 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 :: (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 " String -> ShowS
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 Pos s
f) String
rest = String
"NoParse " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ParseFailure Pos s -> ShowS
forall a. Show a => a -> ShowS
shows ParseFailure Pos s
f String
rest

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

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

instance (Factorial.FactorialMonoid s, Ord s) => Alternative (Parser g s) where
   empty :: Parser g s a
empty = (forall x.
 s
 -> (a -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s a
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser (\s
rest a -> s -> (ParseFailure Pos s -> x) -> x
_ ParseFailure Pos s -> x
failure-> ParseFailure Pos s -> x
failure (ParseFailure Pos s -> x) -> ParseFailure Pos s -> x
forall a b. (a -> b) -> a -> b
$ Pos
-> [FailureDescription s]
-> [FailureDescription s]
-> ParseFailure Pos s
forall pos s.
pos
-> [FailureDescription s]
-> [FailureDescription s]
-> ParseFailure pos s
ParseFailure (Int -> Pos
fromEnd (Int -> Pos) -> Int -> Pos
forall a b. (a -> b) -> a -> b
$ s -> Int
forall m. Factorial m => m -> Int
Factorial.length s
rest) [] [])
   <|> :: Parser g s a -> Parser g s a -> Parser g s 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 Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p alt :: Parser g s a -> Parser g s a -> Parser g s a
`alt` Parser forall x.
s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
q = (forall x.
 s
 -> (a -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s a
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
r where
   r :: forall x. s -> (a -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
   r :: s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
r s
rest a -> s -> (ParseFailure Pos s -> x) -> x
success ParseFailure Pos s -> x
failure = s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
forall x.
s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p s
rest a -> s -> (ParseFailure Pos s -> x) -> x
success' ParseFailure Pos s -> x
failure'
      where success' :: a -> s -> (ParseFailure Pos s -> x) -> x
success' a
a s
rest' ParseFailure Pos s -> x
_ = a -> s -> (ParseFailure Pos s -> x) -> x
success a
a s
rest' ParseFailure Pos s -> x
failure'
            failure' :: ParseFailure Pos s -> x
failure' ParseFailure Pos s
f1 = s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
forall x.
s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
q s
rest a -> s -> (ParseFailure Pos s -> x) -> x
success (\ParseFailure Pos s
f2 -> ParseFailure Pos s -> x
failure (ParseFailure Pos s
f1 ParseFailure Pos s -> ParseFailure Pos s -> ParseFailure Pos s
forall a. Semigroup a => a -> a -> a
<> ParseFailure Pos s
f2))

instance Factorial.FactorialMonoid s => Filterable (Result g s) where
   mapMaybe :: (a -> Maybe b) -> Result g s a -> Result g s b
mapMaybe a -> Maybe b
f (Parsed a
a s
rest) =
      Result g s b -> (b -> Result g s b) -> Maybe b -> Result g s b
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (ParseFailure Pos s -> Result g s b
forall (g :: (* -> *) -> *) s v. ParseFailure Pos s -> Result g s v
NoParse (ParseFailure Pos s -> Result g s b)
-> ParseFailure Pos s -> Result g s b
forall a b. (a -> b) -> a -> b
$ Pos -> String -> ParseFailure Pos s
forall s. Pos -> String -> ParseFailure Pos s
expected (Int -> Pos
fromEnd (Int -> Pos) -> Int -> Pos
forall a b. (a -> b) -> a -> b
$ s -> Int
forall m. Factorial m => m -> Int
Factorial.length s
rest) String
"filter") (b -> s -> Result g s b
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 Pos s
failure) = ParseFailure Pos s -> Result g s b
forall (g :: (* -> *) -> *) s v. ParseFailure Pos s -> Result g s v
NoParse ParseFailure Pos 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 :: (a -> Maybe b) -> Parser g s a -> Parser g s b
mapMaybe a -> Maybe b
f (Parser forall x.
s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p) = (forall x.
 s
 -> (b -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s b
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (b -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
q where
      q :: forall x. s -> (b -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
      q :: s
-> (b -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
q s
rest b -> s -> (ParseFailure Pos s -> x) -> x
success ParseFailure Pos s -> x
failure = s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
forall x.
s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p s
rest ((s -> (ParseFailure Pos s -> x) -> x)
-> (b -> s -> (ParseFailure Pos s -> x) -> x)
-> Maybe b
-> s
-> (ParseFailure Pos s -> x)
-> x
forall b a. b -> (a -> b) -> Maybe a -> b
maybe s -> (ParseFailure Pos s -> x) -> x
filterFailure b -> s -> (ParseFailure Pos s -> x) -> x
success (Maybe b -> s -> (ParseFailure Pos s -> x) -> x)
-> (a -> Maybe b) -> a -> s -> (ParseFailure Pos s -> x) -> x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Maybe b
f) ParseFailure Pos s -> x
failure
         where filterFailure :: s -> (ParseFailure Pos s -> x) -> x
filterFailure s
_ ParseFailure Pos s -> x
_ = ParseFailure Pos s -> x
failure (Pos -> String -> ParseFailure Pos s
forall s. Pos -> String -> ParseFailure Pos s
expected (Int -> Pos
fromEnd (Int -> Pos) -> Int -> Pos
forall a b. (a -> b) -> a -> b
$ s -> Int
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 :: a -> Parser g s a
return = a -> Parser g s a
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 Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p >>= :: Parser g s a -> (a -> Parser g s b) -> Parser g s b
>>= a -> Parser g s b
f = (forall x.
 s
 -> (b -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s b
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (b -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
r where
      r :: forall x. s -> (b -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
      r :: s
-> (b -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
r s
rest b -> s -> (ParseFailure Pos s -> x) -> x
success ParseFailure Pos s -> x
failure = s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
forall x.
s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p s
rest (\a
a s
rest'-> Parser g s b
-> s
-> (b -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
forall (g :: (* -> *) -> *) s r.
Parser g s r
-> forall x.
   s
   -> (r -> s -> (ParseFailure Pos s -> x) -> x)
   -> (ParseFailure Pos s -> x)
   -> x
applyParser (a -> Parser g s b
f a
a) s
rest' b -> s -> (ParseFailure Pos s -> x) -> x
success) ParseFailure Pos s -> x
failure

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

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

instance Monoid x => Monoid (Parser g s x) where
   mempty :: Parser g s x
mempty = x -> Parser g s x
forall (f :: * -> *) a. Applicative f => a -> f a
pure x
forall a. Monoid a => a
mempty
   mappend :: Parser g s x -> Parser g s x -> Parser g s x
mappend = Parser g s x -> Parser g s x -> Parser g s x
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 :: Parser g s a -> Parser g s a
try (Parser forall x.
s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p) = (forall x.
 s
 -> (a -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s a
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
q
      where q :: forall x. s -> (a -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            q :: s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
q s
input a -> s -> (ParseFailure Pos s -> x) -> x
success ParseFailure Pos s -> x
failure = s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
forall x.
s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p s
input a -> s -> (ParseFailure Pos s -> x) -> x
success (ParseFailure Pos s -> x
failure (ParseFailure Pos s -> x)
-> (ParseFailure Pos s -> ParseFailure Pos s)
-> ParseFailure Pos s
-> x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParseFailure Pos s -> ParseFailure Pos s
rewindFailure)
               where rewindFailure :: ParseFailure Pos s -> ParseFailure Pos s
rewindFailure ParseFailure{} = Pos
-> [FailureDescription s]
-> [FailureDescription s]
-> ParseFailure Pos s
forall pos s.
pos
-> [FailureDescription s]
-> [FailureDescription s]
-> ParseFailure pos s
ParseFailure (Int -> Pos
fromEnd (Int -> Pos) -> Int -> Pos
forall a b. (a -> b) -> a -> b
$ s -> Int
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 Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p <?> :: Parser g s a -> String -> Parser g s a
<?> String
msg  = (forall x.
 s
 -> (a -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s a
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
q
      where q :: forall x. s -> (a -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            q :: s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
q s
input a -> s -> (ParseFailure Pos s -> x) -> x
success ParseFailure Pos s -> x
failure = s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
forall x.
s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p s
input a -> s -> (ParseFailure Pos s -> x) -> x
success (ParseFailure Pos s -> x
failure (ParseFailure Pos s -> x)
-> (ParseFailure Pos s -> ParseFailure Pos s)
-> ParseFailure Pos s
-> x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParseFailure Pos s -> ParseFailure Pos s
replaceFailure)
               where replaceFailure :: ParseFailure Pos s -> ParseFailure Pos s
replaceFailure (ParseFailure Pos
pos [FailureDescription s]
msgs [FailureDescription s]
erroneous) =
                        Pos
-> [FailureDescription s]
-> [FailureDescription s]
-> ParseFailure Pos s
forall pos s.
pos
-> [FailureDescription s]
-> [FailureDescription s]
-> ParseFailure pos s
ParseFailure Pos
pos (if Pos
pos Pos -> Pos -> Bool
forall a. Eq a => a -> a -> Bool
== Int -> Pos
fromEnd (s -> Int
forall m. Factorial m => m -> Int
Factorial.length s
input) then [String -> FailureDescription s
forall s. String -> FailureDescription s
StaticDescription String
msg]
                                          else [FailureDescription s]
msgs) [FailureDescription s]
erroneous

   eof :: Parser g s ()
eof = (forall x.
 s
 -> (() -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s ()
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (() -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
forall m s p.
(MonoidNull m, Factorial m) =>
m
-> (() -> m -> (ParseFailure Pos s -> p) -> p)
-> (ParseFailure Pos s -> p)
-> p
p
      where p :: m
-> (() -> m -> (ParseFailure Pos s -> p) -> p)
-> (ParseFailure Pos s -> p)
-> p
p m
rest () -> m -> (ParseFailure Pos s -> p) -> p
success ParseFailure Pos s -> p
failure
               | m -> Bool
forall m. MonoidNull m => m -> Bool
Null.null m
rest = () -> m -> (ParseFailure Pos s -> p) -> p
success () m
rest ParseFailure Pos s -> p
failure
               | Bool
otherwise = ParseFailure Pos s -> p
failure (Pos -> String -> ParseFailure Pos s
forall s. Pos -> String -> ParseFailure Pos s
expected (Int -> Pos
fromEnd (Int -> Pos) -> Int -> Pos
forall a b. (a -> b) -> a -> b
$ m -> Int
forall m. Factorial m => m -> Int
Factorial.length m
rest) String
"end of input")
   unexpected :: String -> Parser g s a
unexpected String
msg = (forall x.
 s
 -> (a -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s a
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser (\s
t a -> s -> (ParseFailure Pos s -> x) -> x
_ ParseFailure Pos s -> x
failure ->
                             ParseFailure Pos s -> x
failure (ParseFailure Pos s -> x) -> ParseFailure Pos s -> x
forall a b. (a -> b) -> a -> b
$ Pos
-> [FailureDescription s]
-> [FailureDescription s]
-> ParseFailure Pos s
forall pos s.
pos
-> [FailureDescription s]
-> [FailureDescription s]
-> ParseFailure pos s
ParseFailure (Int -> Pos
fromEnd (Int -> Pos) -> Int -> Pos
forall a b. (a -> b) -> a -> b
$ s -> Int
forall m. Factorial m => m -> Int
Factorial.length s
t) [] [String -> FailureDescription s
forall s. String -> FailureDescription s
StaticDescription String
msg])
   notFollowedBy :: Parser g s a -> Parser g s ()
notFollowedBy (Parser forall x.
s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p) = (forall x.
 s
 -> (() -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s ()
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (() -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
q
      where q :: forall x. s -> (() -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            q :: s
-> (() -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
q s
input () -> s -> (ParseFailure Pos s -> x) -> x
success ParseFailure Pos s -> x
failure = s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
forall x.
s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p s
input a -> s -> (ParseFailure Pos s -> x) -> x
success' ParseFailure Pos s -> x
failure'
               where success' :: a -> s -> (ParseFailure Pos s -> x) -> x
success' a
_ s
_ ParseFailure Pos s -> x
_ = ParseFailure Pos s -> x
failure (Pos -> String -> ParseFailure Pos s
forall s. Pos -> String -> ParseFailure Pos s
expected (Int -> Pos
fromEnd (Int -> Pos) -> Int -> Pos
forall a b. (a -> b) -> a -> b
$ s -> Int
forall m. Factorial m => m -> Int
Factorial.length s
input) String
"notFollowedBy")
                     failure' :: ParseFailure Pos s -> x
failure' ParseFailure Pos s
_ = () -> s -> (ParseFailure Pos s -> x) -> x
success () s
input ParseFailure Pos 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 Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p <<|> :: Parser g s a -> Parser g s a -> Parser g s a
<<|> Parser forall x.
s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
q = (forall x.
 s
 -> (a -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s a
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
r where
      r :: forall x. s -> (a -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
      r :: s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
r s
rest a -> s -> (ParseFailure Pos s -> x) -> x
success ParseFailure Pos s -> x
failure = s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
forall x.
s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p s
rest a -> s -> (ParseFailure Pos s -> x) -> x
success' ParseFailure Pos s -> x
failure'
         where success' :: a -> s -> (ParseFailure Pos s -> x) -> x
success' a
a s
rest' ParseFailure Pos s -> x
_ = a -> s -> (ParseFailure Pos s -> x) -> x
success a
a s
rest' ParseFailure Pos s -> x
failure
               failure' :: ParseFailure Pos s -> x
failure' ParseFailure Pos s
f1 = s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
forall x.
s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
q s
rest a -> s -> (ParseFailure Pos s -> x) -> x
success (\ParseFailure Pos s
f2 -> ParseFailure Pos s -> x
failure (ParseFailure Pos s
f1 ParseFailure Pos s -> ParseFailure Pos s -> ParseFailure Pos s
forall a. Semigroup a => a -> a -> a
<> ParseFailure Pos s
f2))
   takeSome :: Parser g s a -> Parser g s [a]
takeSome Parser g s a
p = (:) (a -> [a] -> [a]) -> Parser g s a -> Parser g s ([a] -> [a])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g s a
p Parser g s ([a] -> [a]) -> Parser g s [a] -> Parser g s [a]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g s a -> Parser g s [a]
forall (m :: * -> *) a. DeterministicParsing m => m a -> m [a]
takeMany Parser g s a
p
   takeMany :: Parser g s a -> Parser g s [a]
takeMany Parser g s a
p = Parser g s a -> Parser g s [a]
forall (m :: * -> *) a. DeterministicParsing m => m a -> m [a]
takeSome Parser g s a
p Parser g s [a] -> Parser g s [a] -> Parser g s [a]
forall (m :: * -> *) a. DeterministicParsing m => m a -> m a -> m a
<<|> [a] -> Parser g s [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 :: Parser g s a -> Parser g s (ParseResults s a)
commit (Parser forall x.
s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p) = (forall x.
 s
 -> (ParseResults s a -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s (ParseResults s a)
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (ParseResults s a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
q
      where q :: forall x. s -> (ParseResults s a -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            q :: s
-> (ParseResults s a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
q s
input ParseResults s a -> s -> (ParseFailure Pos s -> x) -> x
success ParseFailure Pos s -> x
failure = s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
forall x.
s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p s
input (ParseResults s a -> s -> (ParseFailure Pos s -> x) -> x
success (ParseResults s a -> s -> (ParseFailure Pos s -> x) -> x)
-> (a -> ParseResults s a)
-> a
-> s
-> (ParseFailure Pos s -> x)
-> x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ParseResults s a
forall a b. b -> Either a b
Right) ParseFailure Pos s -> x
failure'
               where failure' :: ParseFailure Pos s -> x
failure' ParseFailure Pos s
f = ParseResults s a -> s -> (ParseFailure Pos s -> x) -> x
success (ParseFailure Pos s -> ParseResults s a
forall a b. a -> Either a b
Left ParseFailure Pos s
f) s
input ParseFailure Pos s -> x
failure
   admit :: forall a. Parser g s (ParseResults s a) -> Parser g s a
   admit :: Parser g s (ParseResults s a) -> Parser g s a
admit (Parser forall x.
s
-> (ParseResults s a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p) = (forall x.
 s
 -> (a -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s a
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
q
      where q :: forall x. s -> (a -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            q :: s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
q s
input a -> s -> (ParseFailure Pos s -> x) -> x
success ParseFailure Pos s -> x
failure = s
-> (ParseResults s a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
forall x.
s
-> (ParseResults s a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p s
input ParseResults s a -> s -> (ParseFailure Pos s -> x) -> x
success' ParseFailure Pos s -> x
failure
               where success' :: ParseResults s a -> s -> (ParseFailure Pos s -> x) -> x
success' (Left ParseFailure Pos s
f) s
_rest = x -> (ParseFailure Pos s -> x) -> x
forall a b. a -> b -> a
const (ParseFailure Pos s -> x
failure ParseFailure Pos s
f)
                     success' (Right a
a) s
rest = a -> s -> (ParseFailure Pos 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 :: Parser g s a -> Parser g s a
lookAhead (Parser forall x.
s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p) = (forall x.
 s
 -> (a -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s a
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
q
      where q :: forall x. s -> (a -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            q :: s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
q s
input a -> s -> (ParseFailure Pos s -> x) -> x
success ParseFailure Pos s -> x
failure = s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
forall x.
s
-> (a -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p s
input a -> s -> (ParseFailure Pos s -> x) -> x
success' ParseFailure Pos s -> x
failure'
               where success' :: a -> s -> (ParseFailure Pos s -> x) -> x
success' a
a s
_ = a -> s -> (ParseFailure Pos s -> x) -> x
success a
a s
input
                     failure' :: ParseFailure Pos s -> x
failure' ParseFailure Pos s
f = ParseFailure Pos s -> x
failure ParseFailure Pos 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 x.
 s
 -> (Char -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s Char
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (Char -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p
      where p :: forall x. s -> (Char -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            p :: s
-> (Char -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p s
rest Char -> s -> (ParseFailure Pos s -> x) -> x
success ParseFailure Pos s -> x
failure =
               case s -> Maybe (Char, s)
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 Pos s -> x) -> x
success Char
first s
suffix ParseFailure Pos s -> x
failure
                  Maybe (Char, s)
_ -> ParseFailure Pos s -> x
failure (Pos -> String -> ParseFailure Pos s
forall s. Pos -> String -> ParseFailure Pos s
expected (Int -> Pos
fromEnd (Int -> Pos) -> Int -> Pos
forall a b. (a -> b) -> a -> b
$ s -> Int
forall m. Factorial m => m -> Int
Factorial.length s
rest) String
"Char.satisfy")
   string :: String -> Parser g s String
string String
s = (s -> String) -> s -> String
forall t. TextualMonoid t => (t -> String) -> t -> String
Textual.toString (String -> s -> String
forall a. HasCallStack => String -> a
error String
"unexpected non-character") (s -> String) -> Parser g s s -> Parser g s String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParserInput (Parser g s) -> Parser g s (ParserInput (Parser g s))
forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string (String -> s
forall a. IsString a => String -> a
fromString String
s)
   text :: Text -> Parser g s Text
text Text
t = (String -> Text
forall a. IsString a => String -> a
fromString (String -> Text) -> (s -> String) -> s -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (s -> String) -> s -> String
forall t. TextualMonoid t => (t -> String) -> t -> String
Textual.toString (String -> s -> String
forall a. HasCallStack => String -> a
error String
"unexpected non-character")) (s -> Text) -> Parser g s s -> Parser g s Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParserInput (Parser g s) -> Parser g s (ParserInput (Parser g s))
forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string (Text -> s
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 x.
 s
 -> (s -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s s
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (s -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
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 x.
 s
 -> (s -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s s
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (s -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
forall m s p.
FactorialMonoid m =>
m
-> (m -> m -> (ParseFailure Pos s -> p) -> p)
-> (ParseFailure Pos s -> p)
-> p
p
      where p :: m
-> (m -> m -> (ParseFailure Pos s -> p) -> p)
-> (ParseFailure Pos s -> p)
-> p
p m
rest m -> m -> (ParseFailure Pos s -> p) -> p
success ParseFailure Pos s -> p
failure =
               case m -> Maybe (m, m)
forall m. FactorialMonoid m => m -> Maybe (m, m)
Factorial.splitPrimePrefix m
rest
               of Just (m
first, m
suffix) -> m -> m -> (ParseFailure Pos s -> p) -> p
success m
first m
suffix ParseFailure Pos s -> p
failure
                  Maybe (m, m)
_ -> ParseFailure Pos s -> p
failure (Pos -> String -> ParseFailure Pos s
forall s. Pos -> String -> ParseFailure Pos s
expected (Int -> Pos
fromEnd (Int -> Pos) -> Int -> Pos
forall a b. (a -> b) -> a -> b
$ m -> Int
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 x.
 s
 -> (s -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s s
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (s -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p
      where p :: forall x. s -> (s -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            p :: s
-> (s -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p s
rest s -> s -> (ParseFailure Pos s -> x) -> x
success ParseFailure Pos s -> x
failure =
               case s -> Maybe (s, s)
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
ParserInput (Parser g s)
first -> s -> s -> (ParseFailure Pos s -> x) -> x
success s
first s
suffix ParseFailure Pos s -> x
failure
                  Maybe (s, s)
_ -> ParseFailure Pos s -> x
failure (Pos -> String -> ParseFailure Pos s
forall s. Pos -> String -> ParseFailure Pos s
expected (Int -> Pos
fromEnd (Int -> Pos) -> Int -> Pos
forall a b. (a -> b) -> a -> b
$ s -> Int
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 x.
 s
 -> (() -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s ()
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (() -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p
      where p :: forall x. s -> (() -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            p :: s
-> (() -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p s
rest () -> s -> (ParseFailure Pos s -> x) -> x
success ParseFailure Pos s -> x
failure =
               case s -> Maybe (s, s)
forall m. FactorialMonoid m => m -> Maybe (m, m)
Factorial.splitPrimePrefix s
rest
               of Just (s
first, s
_)
                     | ParserInput (Parser g s) -> Bool
predicate s
ParserInput (Parser g s)
first -> ParseFailure Pos s -> x
failure (Pos -> String -> ParseFailure Pos s
forall s. Pos -> String -> ParseFailure Pos s
expected (Int -> Pos
fromEnd (Int -> Pos) -> Int -> Pos
forall a b. (a -> b) -> a -> b
$ s -> Int
forall m. Factorial m => m -> Int
Factorial.length s
rest) String
"notSatisfy")
                  Maybe (s, s)
_ -> () -> s -> (ParseFailure Pos s -> x) -> x
success () s
rest ParseFailure Pos s -> x
failure
   scan :: forall state. state -> (state -> s -> Maybe state) -> Parser g s s
   scan :: state -> (state -> s -> Maybe state) -> Parser g s s
scan state
s0 state -> s -> Maybe state
f = (forall x.
 s
 -> (s -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s s
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser (state
-> s
-> (s -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
forall x.
state
-> s
-> (s -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos 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 :: state
-> s
-> (s -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p state
s s
rest s -> s -> (ParseFailure Pos s -> x) -> x
success ParseFailure Pos s -> x
failure = s -> s -> (ParseFailure Pos s -> x) -> x
success s
prefix s
suffix ParseFailure Pos s -> x
failure
               where (s
prefix, s
suffix, state
_) = state -> (state -> s -> Maybe state) -> s -> (s, s, 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 x.
 s
 -> (s -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s s
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (s -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p
      where p :: forall x. s -> (s -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            p :: s
-> (s -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p s
rest s -> s -> (ParseFailure Pos s -> x) -> x
success ParseFailure Pos s -> x
failure
              | (s
prefix, s
suffix) <- Int -> s -> (s, s)
forall m. FactorialMonoid m => Int -> m -> (m, m)
Factorial.splitAt Int
n s
rest,
                s -> Int
forall m. Factorial m => m -> Int
Factorial.length s
prefix Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
n = s -> s -> (ParseFailure Pos s -> x) -> x
success s
prefix s
suffix ParseFailure Pos s -> x
failure
              | Bool
otherwise = ParseFailure Pos s -> x
failure (Pos -> String -> ParseFailure Pos s
forall s. Pos -> String -> ParseFailure Pos s
expected (Int -> Pos
fromEnd (Int -> Pos) -> Int -> Pos
forall a b. (a -> b) -> a -> b
$ s -> Int
forall m. Factorial m => m -> Int
Factorial.length s
rest) (String -> ParseFailure Pos s) -> String -> ParseFailure Pos s
forall a b. (a -> b) -> a -> b
$ String
"take " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> String
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 x.
 s
 -> (s -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s s
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (s -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p
      where p :: forall x. s -> (s -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            p :: s
-> (s -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p s
rest s -> s -> (ParseFailure Pos s -> x) -> x
success ParseFailure Pos s -> x
failure | (s
prefix, s
suffix) <- (s -> Bool) -> s -> (s, s)
forall m. FactorialMonoid m => (m -> Bool) -> m -> (m, m)
Factorial.span s -> Bool
ParserInput (Parser g s) -> Bool
predicate s
rest = s -> s -> (ParseFailure Pos s -> x) -> x
success s
prefix s
suffix ParseFailure Pos s -> x
failure
   takeWhile1 :: (ParserInput (Parser g s) -> Bool)
-> Parser g s (ParserInput (Parser g s))
takeWhile1 ParserInput (Parser g s) -> Bool
predicate = (forall x.
 s
 -> (s -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s s
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (s -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p
      where p :: forall x. s -> (s -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            p :: s
-> (s -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p s
rest s -> s -> (ParseFailure Pos s -> x) -> x
success ParseFailure Pos s -> x
failure
               | (s
prefix, s
suffix) <- (s -> Bool) -> s -> (s, s)
forall m. FactorialMonoid m => (m -> Bool) -> m -> (m, m)
Factorial.span s -> Bool
ParserInput (Parser g s) -> Bool
predicate s
rest =
                    if s -> Bool
forall m. MonoidNull m => m -> Bool
Null.null s
prefix
                    then ParseFailure Pos s -> x
failure (Pos -> String -> ParseFailure Pos s
forall s. Pos -> String -> ParseFailure Pos s
expected (Int -> Pos
fromEnd (Int -> Pos) -> Int -> Pos
forall a b. (a -> b) -> a -> b
$ s -> Int
forall m. Factorial m => m -> Int
Factorial.length s
rest) String
"takeWhile1")
                    else s -> s -> (ParseFailure Pos s -> x) -> x
success s
prefix s
suffix ParseFailure Pos s -> x
failure
   string :: ParserInput (Parser g s) -> Parser g s (ParserInput (Parser g s))
string ParserInput (Parser g s)
s = (forall x.
 s
 -> (s -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s s
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (s -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p where
      p :: forall x. s -> (s -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
      p :: s
-> (s -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p s
s' s -> s -> (ParseFailure Pos s -> x) -> x
success ParseFailure Pos s -> x
failure
         | Just s
suffix <- s -> s -> Maybe s
forall m. LeftReductive m => m -> m -> Maybe m
Cancellative.stripPrefix s
ParserInput (Parser g s)
s s
s' = s -> s -> (ParseFailure Pos s -> x) -> x
success s
ParserInput (Parser g s)
s s
suffix ParseFailure Pos s -> x
failure
         | Bool
otherwise = ParseFailure Pos s -> x
failure (Pos
-> [FailureDescription s]
-> [FailureDescription s]
-> ParseFailure Pos s
forall pos s.
pos
-> [FailureDescription s]
-> [FailureDescription s]
-> ParseFailure pos s
ParseFailure (Int -> Pos
fromEnd (Int -> Pos) -> Int -> Pos
forall a b. (a -> b) -> a -> b
$ s -> Int
forall m. Factorial m => m -> Int
Factorial.length s
s') [s -> FailureDescription s
forall s. s -> FailureDescription s
LiteralDescription s
ParserInput (Parser g s)
s] [])
   {-# INLINABLE string #-}

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

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 x.
 s
 -> (s -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s s
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (s -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p
      where p :: forall x. s -> (s -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            p :: s
-> (s -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p s
rest s -> s -> (ParseFailure Pos s -> x) -> x
success ParseFailure Pos s -> x
failure =
               case s -> Maybe (Char, s)
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 Pos s -> x) -> x
success (s -> s
forall m. Factorial m => m -> m
Factorial.primePrefix s
rest) s
suffix ParseFailure Pos s -> x
failure
                  Maybe (Char, s)
_ -> ParseFailure Pos s -> x
failure (Pos -> String -> ParseFailure Pos s
forall s. Pos -> String -> ParseFailure Pos s
expected (Int -> Pos
fromEnd (Int -> Pos) -> Int -> Pos
forall a b. (a -> b) -> a -> b
$ s -> Int
forall m. Factorial m => m -> Int
Factorial.length s
rest) String
"satisfyChar")
   notSatisfyChar :: (Char -> Bool) -> Parser g s ()
notSatisfyChar Char -> Bool
predicate = (forall x.
 s
 -> (() -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s ()
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (() -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p
      where p :: forall x. s -> (() -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            p :: s
-> (() -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p s
rest () -> s -> (ParseFailure Pos s -> x) -> x
success ParseFailure Pos s -> x
failure =
               case s -> Maybe Char
forall t. TextualMonoid t => t -> Maybe Char
Textual.characterPrefix s
rest
               of Just Char
first | Char -> Bool
predicate Char
first
                               -> ParseFailure Pos s -> x
failure (Pos -> String -> ParseFailure Pos s
forall s. Pos -> String -> ParseFailure Pos s
expected (Int -> Pos
fromEnd (Int -> Pos) -> Int -> Pos
forall a b. (a -> b) -> a -> b
$ s -> Int
forall m. Factorial m => m -> Int
Factorial.length s
rest) String
"notSatisfyChar")
                  Maybe Char
_ -> () -> s -> (ParseFailure Pos s -> x) -> x
success () s
rest ParseFailure Pos s -> x
failure
   scanChars :: forall state. state -> (state -> Char -> Maybe state) -> Parser g s s
   scanChars :: state -> (state -> Char -> Maybe state) -> Parser g s s
scanChars state
s0 state -> Char -> Maybe state
f = (forall x.
 s
 -> (s -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s s
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser (state
-> s
-> (s -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
forall x.
state
-> s
-> (s -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos 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 :: state
-> s
-> (s -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p state
s s
rest s -> s -> (ParseFailure Pos s -> x) -> x
success ParseFailure Pos s -> x
failure = s -> s -> (ParseFailure Pos s -> x) -> x
success s
prefix s
suffix ParseFailure Pos s -> x
failure
               where (s
prefix, s
suffix, state
_) = state -> (state -> Char -> Maybe state) -> s -> (s, s, 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 x.
 s
 -> (s -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s s
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (s -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p
      where p :: forall x. s -> (s -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            p :: s
-> (s -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p s
rest s -> s -> (ParseFailure Pos s -> x) -> x
success ParseFailure Pos s -> x
failure
               | (s
prefix, s
suffix) <- Bool -> (Char -> Bool) -> s -> (s, s)
forall t. TextualMonoid t => Bool -> (Char -> Bool) -> t -> (t, t)
Textual.span_ Bool
False Char -> Bool
predicate s
rest = s -> s -> (ParseFailure Pos s -> x) -> x
success s
prefix s
suffix ParseFailure Pos s -> x
failure
   takeCharsWhile1 :: (Char -> Bool) -> Parser g s (ParserInput (Parser g s))
takeCharsWhile1 Char -> Bool
predicate = (forall x.
 s
 -> (s -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s s
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (ParseFailure Pos s -> x) -> x)
 -> (ParseFailure Pos s -> x)
 -> x)
-> Parser g s r
Parser forall x.
s
-> (s -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p
      where p :: forall x. s -> (s -> s -> (ParseFailure Pos s -> x) -> x) -> (ParseFailure Pos s -> x) -> x
            p :: s
-> (s -> s -> (ParseFailure Pos s -> x) -> x)
-> (ParseFailure Pos s -> x)
-> x
p s
rest s -> s -> (ParseFailure Pos s -> x) -> x
success ParseFailure Pos s -> x
failure
               | s -> Bool
forall m. MonoidNull m => m -> Bool
Null.null s
prefix = ParseFailure Pos s -> x
failure (Pos -> String -> ParseFailure Pos s
forall s. Pos -> String -> ParseFailure Pos s
expected (Int -> Pos
fromEnd (Int -> Pos) -> Int -> Pos
forall a b. (a -> b) -> a -> b
$ s -> Int
forall m. Factorial m => m -> Int
Factorial.length s
rest) String
"takeCharsWhile1")
               | Bool
otherwise = s -> s -> (ParseFailure Pos s -> x) -> x
success s
prefix s
suffix ParseFailure Pos s -> x
failure
               where (s
prefix, s
suffix) = Bool -> (Char -> Bool) -> s -> (s, s)
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 :: g (Parser g s)
-> s -> g (Compose (ResultFunctor (Parser g s)) ((,) s))
parsePrefix g (Parser g s)
g s
input = (forall a. Parser g s a -> Compose (ParseResults s) ((,) s) a)
-> g (Parser g s) -> g (Compose (ParseResults s) ((,) s))
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Functor g =>
(forall (a :: k). p a -> q a) -> g p -> g q
Rank2.fmap (Either (ParseFailure Pos s) (s, a)
-> Compose (Either (ParseFailure Pos s)) ((,) s) a
forall k k1 (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose (Either (ParseFailure Pos s) (s, a)
 -> Compose (Either (ParseFailure Pos s)) ((,) s) a)
-> (Parser g s a -> Either (ParseFailure Pos s) (s, a))
-> Parser g s a
-> Compose (Either (ParseFailure Pos s)) ((,) s) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\Parser g s a
p-> Parser g s a
-> s
-> (a
    -> s
    -> (ParseFailure Pos s -> Either (ParseFailure Pos s) (s, a))
    -> Either (ParseFailure Pos s) (s, a))
-> (ParseFailure Pos s -> Either (ParseFailure Pos s) (s, a))
-> Either (ParseFailure Pos s) (s, a)
forall (g :: (* -> *) -> *) s r.
Parser g s r
-> forall x.
   s
   -> (r -> s -> (ParseFailure Pos s -> x) -> x)
   -> (ParseFailure Pos s -> x)
   -> x
applyParser Parser g s a
p s
input (\a
a s
rest ParseFailure Pos s -> Either (ParseFailure Pos s) (s, a)
_-> (s, a) -> Either (ParseFailure Pos s) (s, a)
forall a b. b -> Either a b
Right (s
rest, a
a)) ParseFailure Pos s -> Either (ParseFailure Pos s) (s, a)
forall a b. a -> Either a b
Left)) g (Parser g s)
g
   parseComplete :: g (Parser g s) -> s -> g (ResultFunctor (Parser g s))
parseComplete g (Parser g s)
g s
input = (forall a. Parser g s a -> ParseResults s a)
-> g (Parser g s) -> g (ParseResults s)
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-> Parser g s a
-> s
-> (a
    -> s
    -> (ParseFailure Pos s -> Either (ParseFailure Pos s) a)
    -> Either (ParseFailure Pos s) a)
-> (ParseFailure Pos s -> Either (ParseFailure Pos s) a)
-> Either (ParseFailure Pos s) a
forall (g :: (* -> *) -> *) s r.
Parser g s r
-> forall x.
   s
   -> (r -> s -> (ParseFailure Pos s -> x) -> x)
   -> (ParseFailure Pos s -> x)
   -> x
applyParser Parser g s a
Parser g s a
p s
input (((ParseFailure Pos s -> Either (ParseFailure Pos s) a)
 -> Either (ParseFailure Pos s) a)
-> s
-> (ParseFailure Pos s -> Either (ParseFailure Pos s) a)
-> Either (ParseFailure Pos s) a
forall a b. a -> b -> a
const (((ParseFailure Pos s -> Either (ParseFailure Pos s) a)
  -> Either (ParseFailure Pos s) a)
 -> s
 -> (ParseFailure Pos s -> Either (ParseFailure Pos s) a)
 -> Either (ParseFailure Pos s) a)
-> (a
    -> (ParseFailure Pos s -> Either (ParseFailure Pos s) a)
    -> Either (ParseFailure Pos s) a)
-> a
-> s
-> (ParseFailure Pos s -> Either (ParseFailure Pos s) a)
-> Either (ParseFailure Pos s) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Either (ParseFailure Pos s) a
-> (ParseFailure Pos s -> Either (ParseFailure Pos s) a)
-> Either (ParseFailure Pos s) a
forall a b. a -> b -> a
const (Either (ParseFailure Pos s) a
 -> (ParseFailure Pos s -> Either (ParseFailure Pos s) a)
 -> Either (ParseFailure Pos s) a)
-> (a -> Either (ParseFailure Pos s) a)
-> a
-> (ParseFailure Pos s -> Either (ParseFailure Pos s) a)
-> Either (ParseFailure Pos s) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Either (ParseFailure Pos s) a
forall a b. b -> Either a b
Right) ParseFailure Pos s -> Either (ParseFailure Pos s) a
forall a b. a -> Either a b
Left)
                                      ((forall a. Parser g s a -> Parser g s a)
-> g (Parser g s) -> g (Parser g s)
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 -> Parser g s () -> Parser g s a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser g s ()
forall (m :: * -> *). Parsing m => m ()
eof) g (Parser g s)
g)