{-# LANGUAGE 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(..))

import Data.Functor.Classes (Show1(..))
import Data.Functor.Compose (Compose(..))
import Data.List (nub)
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 qualified Data.Monoid.Cancellative as Cancellative
import qualified Data.Monoid.Factorial as Factorial
import qualified Data.Monoid.Null as Null
import qualified Data.Monoid.Textual as Textual

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.Token (TokenParsing)
import qualified Text.Parser.Token
import Text.Grampa.Class (Lexical(..), MonoidParsing(..), MultiParsing(..), ParseResults, ParseFailure(..))
import Text.Grampa.Internal (FailureInfo(..))

data Result (g :: (* -> *) -> *) s v = Parsed{Result g s v -> v
parsedPrefix :: !v,
                                              Result g s v -> s
parsedSuffix :: !s}
                                     | NoParse FailureInfo

-- | 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 :: (* -> *) -> *) s r =
   Parser{Parser g s r
-> forall x.
   s -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
applyParser :: forall x. s -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x}

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

instance Functor (Result g s) where
   fmap :: (a -> b) -> Result g s a -> Result g s b
fmap f :: a -> b
f (Parsed a :: a
a rest :: 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 _ (NoParse failure :: FailureInfo
failure) = FailureInfo -> Result g s b
forall (g :: (* -> *) -> *) s v. FailureInfo -> Result g s v
NoParse FailureInfo
failure
   
instance Functor (Parser g s) where
   fmap :: (a -> b) -> Parser g s a -> Parser g s b
fmap f :: a -> b
f (Parser p :: forall x.
s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p) = (forall x.
 s
 -> (b -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s b
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s r
Parser (\input :: s
input success :: b -> s -> (FailureInfo -> x) -> x
success-> s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
forall x.
s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p s
input (b -> s -> (FailureInfo -> x) -> x
success (b -> s -> (FailureInfo -> x) -> x)
-> (a -> b) -> a -> s -> (FailureInfo -> 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
a = (forall x.
 s
 -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s a
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s r
Parser (\input :: s
input success :: a -> s -> (FailureInfo -> x) -> x
success failure :: FailureInfo -> x
failure-> a -> s -> (FailureInfo -> x) -> x
success a
a s
input FailureInfo -> x
failure)
   (<*>) :: forall a b. Parser g s (a -> b) -> Parser g s a -> Parser g s b
   Parser p :: forall x.
s
-> ((a -> b) -> s -> (FailureInfo -> x) -> x)
-> (FailureInfo -> x)
-> x
p <*> :: Parser g s (a -> b) -> Parser g s a -> Parser g s b
<*> Parser q :: forall x.
s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
q = (forall x.
 s
 -> (b -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s b
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s r
Parser forall x.
s -> (b -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
r where
      r :: forall x. s -> (b -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
      r :: s -> (b -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
r rest :: s
rest success :: b -> s -> (FailureInfo -> x) -> x
success failure :: FailureInfo -> x
failure = s
-> ((a -> b) -> s -> (FailureInfo -> x) -> x)
-> (FailureInfo -> x)
-> x
forall x.
s
-> ((a -> b) -> s -> (FailureInfo -> x) -> x)
-> (FailureInfo -> x)
-> x
p s
rest (\f :: a -> b
f rest' :: s
rest'-> s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
forall x.
s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
q s
rest' (b -> s -> (FailureInfo -> x) -> x
success (b -> s -> (FailureInfo -> x) -> x)
-> (a -> b) -> a -> s -> (FailureInfo -> x) -> x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
f)) FailureInfo -> x
failure
   {-# INLINABLE (<*>) #-}

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

instance Monad (Parser g s) where
   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 p :: forall x.
s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p >>= :: Parser g s a -> (a -> Parser g s b) -> Parser g s b
>>= f :: a -> Parser g s b
f = (forall x.
 s
 -> (b -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s b
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s r
Parser forall x.
s -> (b -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
r where
      r :: forall x. s -> (b -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
      r :: s -> (b -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
r rest :: s
rest success :: b -> s -> (FailureInfo -> x) -> x
success failure :: FailureInfo -> x
failure = s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
forall x.
s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p s
rest (\a :: a
a rest' :: s
rest'-> Parser g s b
-> s
-> (b -> s -> (FailureInfo -> x) -> x)
-> (FailureInfo -> x)
-> x
forall (g :: (* -> *) -> *) s r.
Parser g s r
-> forall x.
   s -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
applyParser (a -> Parser g s b
f a
a) s
rest' b -> s -> (FailureInfo -> x) -> x
success) FailureInfo -> x
failure

instance Factorial.FactorialMonoid 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 = (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. Monoid a => a -> a -> a
mappend

instance Factorial.FactorialMonoid 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 p :: forall x.
s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p) = (forall x.
 s
 -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s a
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s r
Parser forall x.
s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
q
      where q :: forall x. s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
            q :: s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
q input :: s
input success :: a -> s -> (FailureInfo -> x) -> x
success failure :: FailureInfo -> x
failure = s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
forall x.
s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p s
input a -> s -> (FailureInfo -> x) -> x
success (FailureInfo -> x
failure (FailureInfo -> x)
-> (FailureInfo -> FailureInfo) -> FailureInfo -> x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FailureInfo -> FailureInfo
rewindFailure)
               where rewindFailure :: FailureInfo -> FailureInfo
rewindFailure (FailureInfo _pos :: Int
_pos _msgs :: [String]
_msgs) = Int -> [String] -> FailureInfo
FailureInfo (s -> Int
forall m. Factorial m => m -> Int
Factorial.length s
input) []
   (<?>) :: forall a. Parser g s a -> String -> Parser g s a
   Parser p :: forall x.
s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p <?> :: Parser g s a -> String -> Parser g s a
<?> msg :: String
msg  = (forall x.
 s
 -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s a
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s r
Parser forall x.
s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
q
      where q :: forall x. s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
            q :: s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
q input :: s
input success :: a -> s -> (FailureInfo -> x) -> x
success failure :: FailureInfo -> x
failure = s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
forall x.
s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p s
input a -> s -> (FailureInfo -> x) -> x
success (FailureInfo -> x
failure (FailureInfo -> x)
-> (FailureInfo -> FailureInfo) -> FailureInfo -> x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FailureInfo -> FailureInfo
replaceFailure)
               where replaceFailure :: FailureInfo -> FailureInfo
replaceFailure (FailureInfo pos :: Int
pos msgs :: [String]
msgs) =
                        Int -> [String] -> FailureInfo
FailureInfo Int
pos (if Int
pos Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== s -> Int
forall m. Factorial m => m -> Int
Factorial.length s
input then [String
msg] else [String]
msgs)

   eof :: Parser g s ()
eof = Parser g s ()
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
m s ()
endOfInput
   unexpected :: String -> Parser g s a
unexpected msg :: String
msg = (forall x.
 s
 -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s a
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s r
Parser (\t :: s
t _ failure :: FailureInfo -> x
failure -> FailureInfo -> x
failure (FailureInfo -> x) -> FailureInfo -> x
forall a b. (a -> b) -> a -> b
$ Int -> [String] -> FailureInfo
FailureInfo (s -> Int
forall m. Factorial m => m -> Int
Factorial.length s
t) [String
msg])
   notFollowedBy :: Parser g s a -> Parser g s ()
notFollowedBy (Parser p :: forall x.
s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p) = (forall x.
 s
 -> (() -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s ()
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s r
Parser forall x.
s
-> (() -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
q
      where q :: forall x. s -> (() -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
            q :: s
-> (() -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
q input :: s
input success :: () -> s -> (FailureInfo -> x) -> x
success failure :: FailureInfo -> x
failure = s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
forall x.
s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p s
input a -> s -> (FailureInfo -> x) -> x
success' FailureInfo -> x
failure'
               where success' :: a -> s -> (FailureInfo -> x) -> x
success' _ _ _ = FailureInfo -> x
failure (Int -> [String] -> FailureInfo
FailureInfo (s -> Int
forall m. Factorial m => m -> Int
Factorial.length s
input) ["notFollowedBy"])
                     failure' :: FailureInfo -> x
failure' _ = () -> s -> (FailureInfo -> x) -> x
success () s
input FailureInfo -> x
failure

instance Factorial.FactorialMonoid 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 p :: forall x.
s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p) = (forall x.
 s
 -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s a
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s r
Parser forall x.
s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
q
      where q :: forall x. s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
            q :: s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
q input :: s
input success :: a -> s -> (FailureInfo -> x) -> x
success failure :: FailureInfo -> x
failure = s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
forall x.
s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p s
input a -> s -> (FailureInfo -> x) -> x
success' FailureInfo -> x
failure'
               where success' :: a -> s -> (FailureInfo -> x) -> x
success' a :: a
a _ = a -> s -> (FailureInfo -> x) -> x
success a
a s
input
                     failure' :: FailureInfo -> x
failure' f :: FailureInfo
f = FailureInfo -> x
failure FailureInfo
f

instance (Show s, TextualMonoid s) => CharParsing (Parser g s) where
   satisfy :: (Char -> Bool) -> Parser g s Char
satisfy = (Char -> Bool) -> Parser g s Char
forall (m :: * -> * -> *) s.
(MonoidParsing m, TextualMonoid s) =>
(Char -> Bool) -> m s Char
satisfyChar
   string :: String -> Parser g s String
string s :: 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 "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
<$> s -> Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s, LeftReductiveMonoid s,
 Show s) =>
s -> m s s
string (String -> s
forall a. IsString a => String -> a
fromString String
s)
   char :: Char -> Parser g s Char
char = (Char -> Bool) -> Parser g s Char
forall (m :: * -> * -> *) s.
(MonoidParsing m, TextualMonoid s) =>
(Char -> Bool) -> m s Char
satisfyChar ((Char -> Bool) -> Parser g s Char)
-> (Char -> Char -> Bool) -> Char -> Parser g s Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
(==)
   notChar :: Char -> Parser g s Char
notChar = (Char -> Bool) -> Parser g s Char
forall (m :: * -> * -> *) s.
(MonoidParsing m, TextualMonoid s) =>
(Char -> Bool) -> m s Char
satisfyChar ((Char -> Bool) -> Parser g s Char)
-> (Char -> Char -> Bool) -> Char -> Parser g s Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
(/=)
   anyChar :: Parser g s Char
anyChar = (Char -> Bool) -> Parser g s Char
forall (m :: * -> * -> *) s.
(MonoidParsing m, TextualMonoid s) =>
(Char -> Bool) -> m s Char
satisfyChar (Bool -> Char -> Bool
forall a b. a -> b -> a
const Bool
True)
   text :: Text -> Parser g s Text
text t :: 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 "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
<$> s -> Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s, LeftReductiveMonoid s,
 Show s) =>
s -> m s s
string (Text -> s
forall t. TextualMonoid t => Text -> t
Textual.fromText Text
t)

instance (Lexical g, LexicalConstraint Parser g s, Show s, TextualMonoid s) => TokenParsing (Parser g s) where
   someSpace :: Parser g s ()
someSpace = Parser g s ()
forall (g :: (* -> *) -> *) (m :: ((* -> *) -> *) -> * -> * -> *)
       s.
(Lexical g, LexicalConstraint m g s) =>
m g s ()
someLexicalSpace
   semi :: Parser g s Char
semi = Parser g s Char
forall (g :: (* -> *) -> *) (m :: ((* -> *) -> *) -> * -> * -> *)
       s.
(Lexical g, LexicalConstraint m g s) =>
m g s Char
lexicalSemicolon
   token :: Parser g s a -> Parser g s a
token = Parser g s a -> Parser g s a
forall (g :: (* -> *) -> *) (m :: ((* -> *) -> *) -> * -> * -> *) s
       a.
(Lexical g, LexicalConstraint m g s) =>
m g s a -> m g s a
lexicalToken

instance MonoidParsing (Parser g) where
   endOfInput :: Parser g s ()
endOfInput = (forall x.
 s
 -> (() -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s ()
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s r
Parser forall x.
s
-> (() -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
forall m p.
(MonoidNull m, Factorial m) =>
m
-> (() -> m -> (FailureInfo -> p) -> p) -> (FailureInfo -> p) -> p
p
      where p :: m
-> (() -> m -> (FailureInfo -> p) -> p) -> (FailureInfo -> p) -> p
p rest :: m
rest success :: () -> m -> (FailureInfo -> p) -> p
success failure :: FailureInfo -> p
failure
               | m -> Bool
forall m. MonoidNull m => m -> Bool
Null.null m
rest = () -> m -> (FailureInfo -> p) -> p
success () m
rest FailureInfo -> p
failure
               | Bool
otherwise = FailureInfo -> p
failure (Int -> [String] -> FailureInfo
FailureInfo (m -> Int
forall m. Factorial m => m -> Int
Factorial.length m
rest) ["endOfInput"])
   getInput :: Parser g s s
getInput = (forall x.
 s
 -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s s
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s r
Parser forall x.
s -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
forall t t t. t -> (t -> t -> t -> t) -> t -> t
p
      where p :: t -> (t -> t -> t -> t) -> t -> t
p rest :: t
rest success :: t -> t -> t -> t
success failure :: t
failure = t -> t -> t -> t
success t
rest t
rest t
failure
   anyToken :: Parser g s s
anyToken = (forall x.
 s
 -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s s
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s r
Parser forall x.
s -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
forall m p.
FactorialMonoid m =>
m -> (m -> m -> (FailureInfo -> p) -> p) -> (FailureInfo -> p) -> p
p
      where p :: m -> (m -> m -> (FailureInfo -> p) -> p) -> (FailureInfo -> p) -> p
p rest :: m
rest success :: m -> m -> (FailureInfo -> p) -> p
success failure :: FailureInfo -> p
failure =
               case m -> Maybe (m, m)
forall m. FactorialMonoid m => m -> Maybe (m, m)
Factorial.splitPrimePrefix m
rest
               of Just (first :: m
first, suffix :: m
suffix) -> m -> m -> (FailureInfo -> p) -> p
success m
first m
suffix FailureInfo -> p
failure
                  _ -> FailureInfo -> p
failure (Int -> [String] -> FailureInfo
FailureInfo (m -> Int
forall m. Factorial m => m -> Int
Factorial.length m
rest) ["anyToken"])
   satisfy :: forall s. FactorialMonoid s => (s -> Bool) -> Parser g s s
   satisfy :: (s -> Bool) -> Parser g s s
satisfy predicate :: s -> Bool
predicate = (forall x.
 s
 -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s s
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s r
Parser forall x.
s -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p
      where p :: forall x. s -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
            p :: s -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p rest :: s
rest success :: s -> s -> (FailureInfo -> x) -> x
success failure :: FailureInfo -> x
failure =
               case s -> Maybe (s, s)
forall m. FactorialMonoid m => m -> Maybe (m, m)
Factorial.splitPrimePrefix s
rest
               of Just (first :: s
first, suffix :: s
suffix) | s -> Bool
predicate s
first -> s -> s -> (FailureInfo -> x) -> x
success s
first s
suffix FailureInfo -> x
failure
                  _ -> FailureInfo -> x
failure (Int -> [String] -> FailureInfo
FailureInfo (s -> Int
forall m. Factorial m => m -> Int
Factorial.length s
rest) ["satisfy"])
   satisfyChar :: forall s. TextualMonoid s => (Char -> Bool) -> Parser g s Char
   satisfyChar :: (Char -> Bool) -> Parser g s Char
satisfyChar predicate :: Char -> Bool
predicate = (forall x.
 s
 -> (Char -> s -> (FailureInfo -> x) -> x)
 -> (FailureInfo -> x)
 -> x)
-> Parser g s Char
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s r
Parser forall x.
s
-> (Char -> s -> (FailureInfo -> x) -> x)
-> (FailureInfo -> x)
-> x
p
      where p :: forall x. s -> (Char -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
            p :: s
-> (Char -> s -> (FailureInfo -> x) -> x)
-> (FailureInfo -> x)
-> x
p rest :: s
rest success :: Char -> s -> (FailureInfo -> x) -> x
success failure :: FailureInfo -> x
failure =
               case s -> Maybe (Char, s)
forall t. TextualMonoid t => t -> Maybe (Char, t)
Textual.splitCharacterPrefix s
rest
               of Just (first :: Char
first, suffix :: s
suffix) | Char -> Bool
predicate Char
first -> Char -> s -> (FailureInfo -> x) -> x
success Char
first s
suffix FailureInfo -> x
failure
                  _ -> FailureInfo -> x
failure (Int -> [String] -> FailureInfo
FailureInfo (s -> Int
forall m. Factorial m => m -> Int
Factorial.length s
rest) ["satisfyChar"])
   satisfyCharInput :: forall s. TextualMonoid s => (Char -> Bool) -> Parser g s s
   satisfyCharInput :: (Char -> Bool) -> Parser g s s
satisfyCharInput predicate :: Char -> Bool
predicate = (forall x.
 s
 -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s s
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s r
Parser forall x.
s -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p
      where p :: forall x. s -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
            p :: s -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p rest :: s
rest success :: s -> s -> (FailureInfo -> x) -> x
success failure :: FailureInfo -> x
failure =
               case s -> Maybe (Char, s)
forall t. TextualMonoid t => t -> Maybe (Char, t)
Textual.splitCharacterPrefix s
rest
               of Just (first :: Char
first, suffix :: s
suffix) | Char -> Bool
predicate Char
first -> s -> s -> (FailureInfo -> x) -> x
success (s -> s
forall m. Factorial m => m -> m
Factorial.primePrefix s
rest) s
suffix FailureInfo -> x
failure
                  _ -> FailureInfo -> x
failure (Int -> [String] -> FailureInfo
FailureInfo (s -> Int
forall m. Factorial m => m -> Int
Factorial.length s
rest) ["satisfyChar"])
   notSatisfy :: forall s. FactorialMonoid s => (s -> Bool) -> Parser g s ()
   notSatisfy :: (s -> Bool) -> Parser g s ()
notSatisfy predicate :: s -> Bool
predicate = (forall x.
 s
 -> (() -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s ()
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s r
Parser forall x.
s
-> (() -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p
      where p :: forall x. s -> (() -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
            p :: s
-> (() -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p rest :: s
rest success :: () -> s -> (FailureInfo -> x) -> x
success failure :: FailureInfo -> x
failure =
               case s -> Maybe (s, s)
forall m. FactorialMonoid m => m -> Maybe (m, m)
Factorial.splitPrimePrefix s
rest
               of Just (first :: s
first, _)
                     | s -> Bool
predicate s
first -> FailureInfo -> x
failure (Int -> [String] -> FailureInfo
FailureInfo (s -> Int
forall m. Factorial m => m -> Int
Factorial.length s
rest) ["notSatisfy"])
                  _ -> () -> s -> (FailureInfo -> x) -> x
success () s
rest FailureInfo -> x
failure
   notSatisfyChar :: forall s. TextualMonoid s => (Char -> Bool) -> Parser g s ()
   notSatisfyChar :: (Char -> Bool) -> Parser g s ()
notSatisfyChar predicate :: Char -> Bool
predicate = (forall x.
 s
 -> (() -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s ()
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s r
Parser forall x.
s
-> (() -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p
      where p :: forall x. s -> (() -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
            p :: s
-> (() -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p rest :: s
rest success :: () -> s -> (FailureInfo -> x) -> x
success failure :: FailureInfo -> x
failure =
               case s -> Maybe Char
forall t. TextualMonoid t => t -> Maybe Char
Textual.characterPrefix s
rest
               of Just first :: Char
first | Char -> Bool
predicate Char
first
                               -> FailureInfo -> x
failure (Int -> [String] -> FailureInfo
FailureInfo (s -> Int
forall m. Factorial m => m -> Int
Factorial.length s
rest) ["notSatisfyChar"])
                  _ -> () -> s -> (FailureInfo -> x) -> x
success () s
rest FailureInfo -> x
failure
   scan :: forall t s. FactorialMonoid t => s -> (s -> t -> Maybe s) -> Parser g t t
   scan :: s -> (s -> t -> Maybe s) -> Parser g t t
scan s0 :: s
s0 f :: s -> t -> Maybe s
f = (forall x.
 t
 -> (t -> t -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g t t
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s r
Parser (s
-> t
-> (t -> t -> (FailureInfo -> x) -> x)
-> (FailureInfo -> x)
-> x
forall x.
s
-> t
-> (t -> t -> (FailureInfo -> x) -> x)
-> (FailureInfo -> x)
-> x
p s
s0)
      where p :: forall x. s -> t -> (t -> t -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
            p :: s
-> t
-> (t -> t -> (FailureInfo -> x) -> x)
-> (FailureInfo -> x)
-> x
p s :: s
s rest :: t
rest success :: t -> t -> (FailureInfo -> x) -> x
success failure :: FailureInfo -> x
failure = t -> t -> (FailureInfo -> x) -> x
success t
prefix t
suffix FailureInfo -> x
failure
               where (prefix :: t
prefix, suffix :: t
suffix, _) = s -> (s -> t -> Maybe s) -> t -> (t, t, s)
forall m s.
FactorialMonoid m =>
s -> (s -> m -> Maybe s) -> m -> (m, m, s)
Factorial.spanMaybe' s
s s -> t -> Maybe s
f t
rest
   scanChars :: forall t s. TextualMonoid t => s -> (s -> Char -> Maybe s) -> Parser g t t
   scanChars :: s -> (s -> Char -> Maybe s) -> Parser g t t
scanChars s0 :: s
s0 f :: s -> Char -> Maybe s
f = (forall x.
 t
 -> (t -> t -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g t t
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s r
Parser (s
-> t
-> (t -> t -> (FailureInfo -> x) -> x)
-> (FailureInfo -> x)
-> x
forall x.
s
-> t
-> (t -> t -> (FailureInfo -> x) -> x)
-> (FailureInfo -> x)
-> x
p s
s0)
      where p :: forall x. s -> t -> (t -> t -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
            p :: s
-> t
-> (t -> t -> (FailureInfo -> x) -> x)
-> (FailureInfo -> x)
-> x
p s :: s
s rest :: t
rest success :: t -> t -> (FailureInfo -> x) -> x
success failure :: FailureInfo -> x
failure = t -> t -> (FailureInfo -> x) -> x
success t
prefix t
suffix FailureInfo -> x
failure
               where (prefix :: t
prefix, suffix :: t
suffix, _) = s -> (s -> Char -> Maybe s) -> t -> (t, t, s)
forall t s.
TextualMonoid t =>
s -> (s -> Char -> Maybe s) -> t -> (t, t, s)
Textual.spanMaybe_' s
s s -> Char -> Maybe s
f t
rest
   takeWhile :: forall s. FactorialMonoid s => (s -> Bool) -> Parser g s s
   takeWhile :: (s -> Bool) -> Parser g s s
takeWhile predicate :: s -> Bool
predicate = (forall x.
 s
 -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s s
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s r
Parser forall x.
s -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p
      where p :: forall x. s -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
            p :: s -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p rest :: s
rest success :: s -> s -> (FailureInfo -> x) -> x
success failure :: FailureInfo -> x
failure | (prefix :: s
prefix, suffix :: s
suffix) <- (s -> Bool) -> s -> (s, s)
forall m. FactorialMonoid m => (m -> Bool) -> m -> (m, m)
Factorial.span s -> Bool
predicate s
rest = s -> s -> (FailureInfo -> x) -> x
success s
prefix s
suffix FailureInfo -> x
failure
   takeWhile1 :: forall s. FactorialMonoid s => (s -> Bool) -> Parser g s s
   takeWhile1 :: (s -> Bool) -> Parser g s s
takeWhile1 predicate :: s -> Bool
predicate = (forall x.
 s
 -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s s
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s r
Parser forall x.
s -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p
      where p :: forall x. s -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
            p :: s -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p rest :: s
rest success :: s -> s -> (FailureInfo -> x) -> x
success failure :: FailureInfo -> x
failure
               | (prefix :: s
prefix, suffix :: s
suffix) <- (s -> Bool) -> s -> (s, s)
forall m. FactorialMonoid m => (m -> Bool) -> m -> (m, m)
Factorial.span s -> Bool
predicate s
rest =
                    if s -> Bool
forall m. MonoidNull m => m -> Bool
Null.null s
prefix
                    then FailureInfo -> x
failure (Int -> [String] -> FailureInfo
FailureInfo (s -> Int
forall m. Factorial m => m -> Int
Factorial.length s
rest) ["takeWhile1"])
                    else s -> s -> (FailureInfo -> x) -> x
success s
prefix s
suffix FailureInfo -> x
failure
   takeCharsWhile :: forall s. TextualMonoid s => (Char -> Bool) -> Parser g s s
   takeCharsWhile :: (Char -> Bool) -> Parser g s s
takeCharsWhile predicate :: Char -> Bool
predicate = (forall x.
 s
 -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s s
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s r
Parser forall x.
s -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p
      where p :: forall x. s -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
            p :: s -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p rest :: s
rest success :: s -> s -> (FailureInfo -> x) -> x
success failure :: FailureInfo -> x
failure
               | (prefix :: s
prefix, suffix :: 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 -> (FailureInfo -> x) -> x
success s
prefix s
suffix FailureInfo -> x
failure
   takeCharsWhile1 :: forall s. TextualMonoid s => (Char -> Bool) -> Parser g s s
   takeCharsWhile1 :: (Char -> Bool) -> Parser g s s
takeCharsWhile1 predicate :: Char -> Bool
predicate = (forall x.
 s
 -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s s
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s r
Parser forall x.
s -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p
      where p :: forall x. s -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
            p :: s -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p rest :: s
rest success :: s -> s -> (FailureInfo -> x) -> x
success failure :: FailureInfo -> x
failure
               | s -> Bool
forall m. MonoidNull m => m -> Bool
Null.null s
prefix = FailureInfo -> x
failure (Int -> [String] -> FailureInfo
FailureInfo (s -> Int
forall m. Factorial m => m -> Int
Factorial.length s
rest) ["takeCharsWhile1"])
               | Bool
otherwise = s -> s -> (FailureInfo -> x) -> x
success s
prefix s
suffix FailureInfo -> x
failure
               where (prefix :: s
prefix, suffix :: 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
   string :: forall s. (Cancellative.LeftReductiveMonoid s, FactorialMonoid s, Show s) => s -> Parser g s s
   string :: s -> Parser g s s
string s :: s
s = (forall x.
 s
 -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s s
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s r
Parser forall x.
s -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p where
      p :: forall x. s -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
      p :: s -> (s -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p s' :: s
s' success :: s -> s -> (FailureInfo -> x) -> x
success failure :: FailureInfo -> x
failure
         | Just suffix :: s
suffix <- s -> s -> Maybe s
forall m. LeftReductive m => m -> m -> Maybe m
Cancellative.stripPrefix s
s s
s' = s -> s -> (FailureInfo -> x) -> x
success s
s s
suffix FailureInfo -> x
failure
         | Bool
otherwise = FailureInfo -> x
failure (Int -> [String] -> FailureInfo
FailureInfo (s -> Int
forall m. Factorial m => m -> Int
Factorial.length s
s') ["string " String -> ShowS
forall a. [a] -> [a] -> [a]
++ s -> String
forall a. Show a => a -> String
show s
s])
   concatMany :: forall s a. Monoid a => Parser g s a -> Parser g s a
   concatMany :: Parser g s a -> Parser g s a
concatMany (Parser p :: forall x.
s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p) = (forall x.
 s
 -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s a
forall (g :: (* -> *) -> *) s r.
(forall x.
 s
 -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x)
-> Parser g s r
Parser forall x.
s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
q
      where q :: forall x. s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
            q :: s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
q rest :: s
rest success :: a -> s -> (FailureInfo -> x) -> x
success failure :: FailureInfo -> x
failure = s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
forall x.
s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
p s
rest a -> s -> (FailureInfo -> x) -> x
success' (x -> FailureInfo -> x
forall a b. a -> b -> a
const (x -> FailureInfo -> x) -> x -> FailureInfo -> x
forall a b. (a -> b) -> a -> b
$ a -> s -> (FailureInfo -> x) -> x
success a
forall a. Monoid a => a
mempty s
rest FailureInfo -> x
failure)
               where success' :: a -> s -> (FailureInfo -> x) -> x
success' prefix :: a
prefix suffix :: s
suffix failure' :: FailureInfo -> x
failure' =
                        s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
forall x.
s -> (a -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
q s
suffix (a -> s -> (FailureInfo -> x) -> x
success (a -> s -> (FailureInfo -> x) -> x)
-> (a -> a) -> a -> s -> (FailureInfo -> x) -> x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> a
forall a. Monoid a => a -> a -> a
mappend a
prefix) (x -> FailureInfo -> x
forall a b. a -> b -> a
const (x -> FailureInfo -> x) -> x -> FailureInfo -> x
forall a b. (a -> b) -> a -> b
$ a -> s -> (FailureInfo -> x) -> x
success a
prefix s
suffix FailureInfo -> x
failure')
   {-# INLINABLE string #-}

-- | Continuation-passing context-free parser
--
-- @
-- 'parseComplete' :: ("Rank2".'Rank2.Functor' g, 'FactorialMonoid' s) =>
--                  g (Continued.'Parser' g s) -> s -> g 'ParseResults'
-- @
instance MultiParsing Parser where
   type ResultFunctor Parser = ParseResults
   -- | Returns an input prefix parse paired with the remaining input suffix.
   parsePrefix :: g (Parser g s) -> s -> g (Compose (ResultFunctor Parser) ((,) s))
parsePrefix g :: g (Parser g s)
g input :: s
input = (forall a. Parser g s a -> Compose ParseResults ((,) s) a)
-> g (Parser g s) -> g (Compose 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 (Either ParseFailure (s, a) -> Compose ParseResults ((,) s) a
forall k k1 (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose (Either ParseFailure (s, a) -> Compose ParseResults ((,) s) a)
-> (Parser g s a -> Either ParseFailure (s, a))
-> Parser g s a
-> Compose ParseResults ((,) s) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\p :: Parser g s a
p-> Parser g s a
-> s
-> (a
    -> s
    -> (FailureInfo -> Either ParseFailure (s, a))
    -> Either ParseFailure (s, a))
-> (FailureInfo -> Either ParseFailure (s, a))
-> Either ParseFailure (s, a)
forall (g :: (* -> *) -> *) s r.
Parser g s r
-> forall x.
   s -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
applyParser Parser g s a
p s
input (\a :: a
a rest :: s
rest _-> (s, a) -> Either ParseFailure (s, a)
forall a b. b -> Either a b
Right (s
rest, a
a)) (ParseFailure -> Either ParseFailure (s, a)
forall a b. a -> Either a b
Left (ParseFailure -> Either ParseFailure (s, a))
-> (FailureInfo -> ParseFailure)
-> FailureInfo
-> Either ParseFailure (s, a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> FailureInfo -> ParseFailure
forall s. FactorialMonoid s => s -> FailureInfo -> ParseFailure
fromFailure s
input))) g (Parser g s)
g
   parseComplete :: g (Parser g s) -> s -> g (ResultFunctor Parser)
parseComplete g :: g (Parser g s)
g input :: s
input = (forall a. Parser g s a -> ParseResults a)
-> g (Parser g s) -> g ParseResults
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Functor g =>
(forall (a :: k). p a -> q a) -> g p -> g q
Rank2.fmap (\p :: Parser g s a
p-> Parser g s a
-> s
-> (a
    -> s
    -> (FailureInfo -> Either ParseFailure a)
    -> Either ParseFailure a)
-> (FailureInfo -> Either ParseFailure a)
-> Either ParseFailure a
forall (g :: (* -> *) -> *) s r.
Parser g s r
-> forall x.
   s -> (r -> s -> (FailureInfo -> x) -> x) -> (FailureInfo -> x) -> x
applyParser Parser g s a
p s
input (((FailureInfo -> Either ParseFailure a) -> Either ParseFailure a)
-> s
-> (FailureInfo -> Either ParseFailure a)
-> Either ParseFailure a
forall a b. a -> b -> a
const (((FailureInfo -> Either ParseFailure a) -> Either ParseFailure a)
 -> s
 -> (FailureInfo -> Either ParseFailure a)
 -> Either ParseFailure a)
-> (a
    -> (FailureInfo -> Either ParseFailure a) -> Either ParseFailure a)
-> a
-> s
-> (FailureInfo -> Either ParseFailure a)
-> Either ParseFailure a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Either ParseFailure a
-> (FailureInfo -> Either ParseFailure a) -> Either ParseFailure a
forall a b. a -> b -> a
const (Either ParseFailure a
 -> (FailureInfo -> Either ParseFailure a) -> Either ParseFailure a)
-> (a -> Either ParseFailure a)
-> a
-> (FailureInfo -> Either ParseFailure a)
-> Either ParseFailure a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Either ParseFailure a
forall a b. b -> Either a b
Right) (ParseFailure -> Either ParseFailure a
forall a b. a -> Either a b
Left (ParseFailure -> Either ParseFailure a)
-> (FailureInfo -> ParseFailure)
-> FailureInfo
-> Either ParseFailure a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> FailureInfo -> ParseFailure
forall s. FactorialMonoid s => s -> FailureInfo -> ParseFailure
fromFailure s
input))
                                      ((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 :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
m s ()
endOfInput) g (Parser g s)
g)

fromFailure :: FactorialMonoid s => s -> FailureInfo -> ParseFailure
fromFailure :: s -> FailureInfo -> ParseFailure
fromFailure s :: s
s (FailureInfo pos :: Int
pos msgs :: [String]
msgs) = Int -> [String] -> ParseFailure
ParseFailure (s -> Int
forall m. Factorial m => m -> Int
Factorial.length s
s Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
pos Int -> Int -> Int
forall a. Num a => a -> a -> a
+ 1) ([String] -> [String]
forall a. Eq a => [a] -> [a]
nub [String]
msgs)