{-# LANGUAGE AllowAmbiguousTypes, ConstraintKinds, DefaultSignatures, DeriveDataTypeable, DeriveFunctor,
FlexibleContexts, FlexibleInstances, GeneralizedNewtypeDeriving, OverloadedStrings,
RankNTypes, ScopedTypeVariables, TypeApplications, TypeFamilies, TypeSynonymInstances,
UndecidableInstances #-}
module Text.Grampa.Class (MultiParsing(..), GrammarParsing(..),
AmbiguousParsing(..), DeterministicParsing(..), InputParsing(..), InputCharParsing(..),
CommittedParsing(..), ConsumedInputParsing(..), LexicalParsing(..), TailsParsing(..),
ParseResults, ParseFailure(..), FailureDescription(..), Pos,
Ambiguous(..), completeParser) where
import Control.Applicative (Alternative(empty), liftA2)
import Data.Char (isAlphaNum, isLetter, isSpace)
import Data.Functor.Classes (Show1(..))
import Data.Functor.Compose (Compose(..))
import Data.Kind (Type)
import Data.List.NonEmpty (NonEmpty((:|)))
import Data.Data (Data)
import Data.Typeable (Typeable)
import Data.Monoid (Monoid(mempty, mappend))
import qualified Data.Monoid.Null as Null
import Data.Monoid.Null (MonoidNull)
import Data.Monoid.Factorial (FactorialMonoid)
import Data.Monoid.Textual (TextualMonoid)
import Data.Semigroup (Semigroup((<>)))
import Data.Ord (Down(Down))
import Text.Parser.Combinators (Parsing((<?>)))
import Text.Parser.Token (TokenParsing)
import Text.Parser.Deterministic (DeterministicParsing(..))
import Text.Parser.Input (ConsumedInputParsing(..), InputParsing(..), InputCharParsing(..))
import qualified Text.Parser.Char
import Data.Kind (Constraint)
import qualified Rank2
import Prelude hiding (takeWhile)
type ParseResults s = Either (ParseFailure Pos s)
data ParseFailure pos s =
ParseFailure {ParseFailure pos s -> pos
failurePosition :: pos,
ParseFailure pos s -> [FailureDescription s]
expectedAlternatives :: [FailureDescription s],
ParseFailure pos s -> [FailureDescription s]
errorAlternatives :: [FailureDescription s]
}
deriving (ParseFailure pos s -> ParseFailure pos s -> Bool
(ParseFailure pos s -> ParseFailure pos s -> Bool)
-> (ParseFailure pos s -> ParseFailure pos s -> Bool)
-> Eq (ParseFailure pos s)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall pos s.
(Eq pos, Eq s) =>
ParseFailure pos s -> ParseFailure pos s -> Bool
/= :: ParseFailure pos s -> ParseFailure pos s -> Bool
$c/= :: forall pos s.
(Eq pos, Eq s) =>
ParseFailure pos s -> ParseFailure pos s -> Bool
== :: ParseFailure pos s -> ParseFailure pos s -> Bool
$c== :: forall pos s.
(Eq pos, Eq s) =>
ParseFailure pos s -> ParseFailure pos s -> Bool
Eq, a -> ParseFailure pos b -> ParseFailure pos a
(a -> b) -> ParseFailure pos a -> ParseFailure pos b
(forall a b. (a -> b) -> ParseFailure pos a -> ParseFailure pos b)
-> (forall a b. a -> ParseFailure pos b -> ParseFailure pos a)
-> Functor (ParseFailure pos)
forall a b. a -> ParseFailure pos b -> ParseFailure pos a
forall a b. (a -> b) -> ParseFailure pos a -> ParseFailure pos b
forall pos a b. a -> ParseFailure pos b -> ParseFailure pos a
forall pos a b.
(a -> b) -> ParseFailure pos a -> ParseFailure pos b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> ParseFailure pos b -> ParseFailure pos a
$c<$ :: forall pos a b. a -> ParseFailure pos b -> ParseFailure pos a
fmap :: (a -> b) -> ParseFailure pos a -> ParseFailure pos b
$cfmap :: forall pos a b.
(a -> b) -> ParseFailure pos a -> ParseFailure pos b
Functor, Int -> ParseFailure pos s -> ShowS
[ParseFailure pos s] -> ShowS
ParseFailure pos s -> String
(Int -> ParseFailure pos s -> ShowS)
-> (ParseFailure pos s -> String)
-> ([ParseFailure pos s] -> ShowS)
-> Show (ParseFailure pos s)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall pos s.
(Show pos, Show s) =>
Int -> ParseFailure pos s -> ShowS
forall pos s. (Show pos, Show s) => [ParseFailure pos s] -> ShowS
forall pos s. (Show pos, Show s) => ParseFailure pos s -> String
showList :: [ParseFailure pos s] -> ShowS
$cshowList :: forall pos s. (Show pos, Show s) => [ParseFailure pos s] -> ShowS
show :: ParseFailure pos s -> String
$cshow :: forall pos s. (Show pos, Show s) => ParseFailure pos s -> String
showsPrec :: Int -> ParseFailure pos s -> ShowS
$cshowsPrec :: forall pos s.
(Show pos, Show s) =>
Int -> ParseFailure pos s -> ShowS
Show)
type Pos = Down Int
data FailureDescription s = StaticDescription String
| LiteralDescription s
deriving (a -> FailureDescription b -> FailureDescription a
(a -> b) -> FailureDescription a -> FailureDescription b
(forall a b.
(a -> b) -> FailureDescription a -> FailureDescription b)
-> (forall a b. a -> FailureDescription b -> FailureDescription a)
-> Functor FailureDescription
forall a b. a -> FailureDescription b -> FailureDescription a
forall a b.
(a -> b) -> FailureDescription a -> FailureDescription b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> FailureDescription b -> FailureDescription a
$c<$ :: forall a b. a -> FailureDescription b -> FailureDescription a
fmap :: (a -> b) -> FailureDescription a -> FailureDescription b
$cfmap :: forall a b.
(a -> b) -> FailureDescription a -> FailureDescription b
Functor, FailureDescription s -> FailureDescription s -> Bool
(FailureDescription s -> FailureDescription s -> Bool)
-> (FailureDescription s -> FailureDescription s -> Bool)
-> Eq (FailureDescription s)
forall s.
Eq s =>
FailureDescription s -> FailureDescription s -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FailureDescription s -> FailureDescription s -> Bool
$c/= :: forall s.
Eq s =>
FailureDescription s -> FailureDescription s -> Bool
== :: FailureDescription s -> FailureDescription s -> Bool
$c== :: forall s.
Eq s =>
FailureDescription s -> FailureDescription s -> Bool
Eq, Eq (FailureDescription s)
Eq (FailureDescription s)
-> (FailureDescription s -> FailureDescription s -> Ordering)
-> (FailureDescription s -> FailureDescription s -> Bool)
-> (FailureDescription s -> FailureDescription s -> Bool)
-> (FailureDescription s -> FailureDescription s -> Bool)
-> (FailureDescription s -> FailureDescription s -> Bool)
-> (FailureDescription s
-> FailureDescription s -> FailureDescription s)
-> (FailureDescription s
-> FailureDescription s -> FailureDescription s)
-> Ord (FailureDescription s)
FailureDescription s -> FailureDescription s -> Bool
FailureDescription s -> FailureDescription s -> Ordering
FailureDescription s
-> FailureDescription s -> FailureDescription s
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall s. Ord s => Eq (FailureDescription s)
forall s.
Ord s =>
FailureDescription s -> FailureDescription s -> Bool
forall s.
Ord s =>
FailureDescription s -> FailureDescription s -> Ordering
forall s.
Ord s =>
FailureDescription s
-> FailureDescription s -> FailureDescription s
min :: FailureDescription s
-> FailureDescription s -> FailureDescription s
$cmin :: forall s.
Ord s =>
FailureDescription s
-> FailureDescription s -> FailureDescription s
max :: FailureDescription s
-> FailureDescription s -> FailureDescription s
$cmax :: forall s.
Ord s =>
FailureDescription s
-> FailureDescription s -> FailureDescription s
>= :: FailureDescription s -> FailureDescription s -> Bool
$c>= :: forall s.
Ord s =>
FailureDescription s -> FailureDescription s -> Bool
> :: FailureDescription s -> FailureDescription s -> Bool
$c> :: forall s.
Ord s =>
FailureDescription s -> FailureDescription s -> Bool
<= :: FailureDescription s -> FailureDescription s -> Bool
$c<= :: forall s.
Ord s =>
FailureDescription s -> FailureDescription s -> Bool
< :: FailureDescription s -> FailureDescription s -> Bool
$c< :: forall s.
Ord s =>
FailureDescription s -> FailureDescription s -> Bool
compare :: FailureDescription s -> FailureDescription s -> Ordering
$ccompare :: forall s.
Ord s =>
FailureDescription s -> FailureDescription s -> Ordering
$cp1Ord :: forall s. Ord s => Eq (FailureDescription s)
Ord, ReadPrec [FailureDescription s]
ReadPrec (FailureDescription s)
Int -> ReadS (FailureDescription s)
ReadS [FailureDescription s]
(Int -> ReadS (FailureDescription s))
-> ReadS [FailureDescription s]
-> ReadPrec (FailureDescription s)
-> ReadPrec [FailureDescription s]
-> Read (FailureDescription s)
forall s. Read s => ReadPrec [FailureDescription s]
forall s. Read s => ReadPrec (FailureDescription s)
forall s. Read s => Int -> ReadS (FailureDescription s)
forall s. Read s => ReadS [FailureDescription s]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FailureDescription s]
$creadListPrec :: forall s. Read s => ReadPrec [FailureDescription s]
readPrec :: ReadPrec (FailureDescription s)
$creadPrec :: forall s. Read s => ReadPrec (FailureDescription s)
readList :: ReadS [FailureDescription s]
$creadList :: forall s. Read s => ReadS [FailureDescription s]
readsPrec :: Int -> ReadS (FailureDescription s)
$creadsPrec :: forall s. Read s => Int -> ReadS (FailureDescription s)
Read, Int -> FailureDescription s -> ShowS
[FailureDescription s] -> ShowS
FailureDescription s -> String
(Int -> FailureDescription s -> ShowS)
-> (FailureDescription s -> String)
-> ([FailureDescription s] -> ShowS)
-> Show (FailureDescription s)
forall s. Show s => Int -> FailureDescription s -> ShowS
forall s. Show s => [FailureDescription s] -> ShowS
forall s. Show s => FailureDescription s -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FailureDescription s] -> ShowS
$cshowList :: forall s. Show s => [FailureDescription s] -> ShowS
show :: FailureDescription s -> String
$cshow :: forall s. Show s => FailureDescription s -> String
showsPrec :: Int -> FailureDescription s -> ShowS
$cshowsPrec :: forall s. Show s => Int -> FailureDescription s -> ShowS
Show)
instance (Ord pos, Ord s) => Semigroup (ParseFailure pos s) where
ParseFailure pos
pos1 [FailureDescription s]
exp1 [FailureDescription s]
err1 <> :: ParseFailure pos s -> ParseFailure pos s -> ParseFailure pos s
<> ParseFailure pos
pos2 [FailureDescription s]
exp2 [FailureDescription s]
err2 = pos
-> [FailureDescription s]
-> [FailureDescription s]
-> ParseFailure pos s
forall pos s.
pos
-> [FailureDescription s]
-> [FailureDescription s]
-> ParseFailure pos s
ParseFailure pos
pos' [FailureDescription s]
exp' [FailureDescription s]
err'
where (pos
pos', [FailureDescription s]
exp', [FailureDescription s]
err') | pos
pos1 pos -> pos -> Bool
forall a. Ord a => a -> a -> Bool
> pos
pos2 = (pos
pos1, [FailureDescription s]
exp1, [FailureDescription s]
err1)
| pos
pos1 pos -> pos -> Bool
forall a. Ord a => a -> a -> Bool
< pos
pos2 = (pos
pos2, [FailureDescription s]
exp2, [FailureDescription s]
err2)
| Bool
otherwise = (pos
pos1, [FailureDescription s]
-> [FailureDescription s] -> [FailureDescription s]
forall a. Ord a => [a] -> [a] -> [a]
merge [FailureDescription s]
exp1 [FailureDescription s]
exp2, [FailureDescription s]
-> [FailureDescription s] -> [FailureDescription s]
forall a. Ord a => [a] -> [a] -> [a]
merge [FailureDescription s]
err1 [FailureDescription s]
err2)
merge :: [a] -> [a] -> [a]
merge [] [a]
xs = [a]
xs
merge [a]
xs [] = [a]
xs
merge xs :: [a]
xs@(a
x:[a]
xs') ys :: [a]
ys@(a
y:[a]
ys')
| a
x a -> a -> Bool
forall a. Ord a => a -> a -> Bool
< a
y = a
x a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a] -> [a] -> [a]
merge [a]
xs' [a]
ys
| a
x a -> a -> Bool
forall a. Ord a => a -> a -> Bool
> a
y = a
y a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a] -> [a] -> [a]
merge [a]
xs [a]
ys'
| Bool
otherwise = a
x a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a] -> [a] -> [a]
merge [a]
xs' [a]
ys'
instance Ord s => Monoid (ParseFailure Pos s) where
mempty :: ParseFailure Pos s
mempty = Pos
-> [FailureDescription s]
-> [FailureDescription s]
-> ParseFailure Pos s
forall pos s.
pos
-> [FailureDescription s]
-> [FailureDescription s]
-> ParseFailure pos s
ParseFailure (Int -> Pos
forall a. a -> Down a
Down Int
forall a. Bounded a => a
maxBound) [] []
mappend :: ParseFailure Pos s -> ParseFailure Pos s -> ParseFailure Pos s
mappend = ParseFailure Pos s -> ParseFailure Pos s -> ParseFailure Pos s
forall a. Semigroup a => a -> a -> a
(<>)
newtype Ambiguous a = Ambiguous{Ambiguous a -> NonEmpty a
getAmbiguous :: NonEmpty a} deriving (Typeable (Ambiguous a)
DataType
Constr
Typeable (Ambiguous a)
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ambiguous a -> c (Ambiguous a))
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Ambiguous a))
-> (Ambiguous a -> Constr)
-> (Ambiguous a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Ambiguous a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Ambiguous a)))
-> ((forall b. Data b => b -> b) -> Ambiguous a -> Ambiguous a)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Ambiguous a -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Ambiguous a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Ambiguous a -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> Ambiguous a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Ambiguous a -> m (Ambiguous a))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ambiguous a -> m (Ambiguous a))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ambiguous a -> m (Ambiguous a))
-> Data (Ambiguous a)
Ambiguous a -> DataType
Ambiguous a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Ambiguous a))
(forall b. Data b => b -> b) -> Ambiguous a -> Ambiguous a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ambiguous a -> c (Ambiguous a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Ambiguous a)
forall a. Data a => Typeable (Ambiguous a)
forall a. Data a => Ambiguous a -> DataType
forall a. Data a => Ambiguous a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Ambiguous a -> Ambiguous a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Ambiguous a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Ambiguous a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Ambiguous a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Ambiguous a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Ambiguous a -> m (Ambiguous a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Ambiguous a -> m (Ambiguous a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Ambiguous a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ambiguous a -> c (Ambiguous a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Ambiguous a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Ambiguous a))
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Ambiguous a -> u
forall u. (forall d. Data d => d -> u) -> Ambiguous a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Ambiguous a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Ambiguous a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Ambiguous a -> m (Ambiguous a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ambiguous a -> m (Ambiguous a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Ambiguous a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ambiguous a -> c (Ambiguous a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Ambiguous a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Ambiguous a))
$cAmbiguous :: Constr
$tAmbiguous :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Ambiguous a -> m (Ambiguous a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Ambiguous a -> m (Ambiguous a)
gmapMp :: (forall d. Data d => d -> m d) -> Ambiguous a -> m (Ambiguous a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Ambiguous a -> m (Ambiguous a)
gmapM :: (forall d. Data d => d -> m d) -> Ambiguous a -> m (Ambiguous a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Ambiguous a -> m (Ambiguous a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Ambiguous a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Ambiguous a -> u
gmapQ :: (forall d. Data d => d -> u) -> Ambiguous a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Ambiguous a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Ambiguous a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Ambiguous a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Ambiguous a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Ambiguous a -> r
gmapT :: (forall b. Data b => b -> b) -> Ambiguous a -> Ambiguous a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Ambiguous a -> Ambiguous a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Ambiguous a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Ambiguous a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Ambiguous a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Ambiguous a))
dataTypeOf :: Ambiguous a -> DataType
$cdataTypeOf :: forall a. Data a => Ambiguous a -> DataType
toConstr :: Ambiguous a -> Constr
$ctoConstr :: forall a. Data a => Ambiguous a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Ambiguous a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Ambiguous a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ambiguous a -> c (Ambiguous a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ambiguous a -> c (Ambiguous a)
$cp1Data :: forall a. Data a => Typeable (Ambiguous a)
Data, Ambiguous a -> Ambiguous a -> Bool
(Ambiguous a -> Ambiguous a -> Bool)
-> (Ambiguous a -> Ambiguous a -> Bool) -> Eq (Ambiguous a)
forall a. Eq a => Ambiguous a -> Ambiguous a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Ambiguous a -> Ambiguous a -> Bool
$c/= :: forall a. Eq a => Ambiguous a -> Ambiguous a -> Bool
== :: Ambiguous a -> Ambiguous a -> Bool
$c== :: forall a. Eq a => Ambiguous a -> Ambiguous a -> Bool
Eq, Eq (Ambiguous a)
Eq (Ambiguous a)
-> (Ambiguous a -> Ambiguous a -> Ordering)
-> (Ambiguous a -> Ambiguous a -> Bool)
-> (Ambiguous a -> Ambiguous a -> Bool)
-> (Ambiguous a -> Ambiguous a -> Bool)
-> (Ambiguous a -> Ambiguous a -> Bool)
-> (Ambiguous a -> Ambiguous a -> Ambiguous a)
-> (Ambiguous a -> Ambiguous a -> Ambiguous a)
-> Ord (Ambiguous a)
Ambiguous a -> Ambiguous a -> Bool
Ambiguous a -> Ambiguous a -> Ordering
Ambiguous a -> Ambiguous a -> Ambiguous a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Ambiguous a)
forall a. Ord a => Ambiguous a -> Ambiguous a -> Bool
forall a. Ord a => Ambiguous a -> Ambiguous a -> Ordering
forall a. Ord a => Ambiguous a -> Ambiguous a -> Ambiguous a
min :: Ambiguous a -> Ambiguous a -> Ambiguous a
$cmin :: forall a. Ord a => Ambiguous a -> Ambiguous a -> Ambiguous a
max :: Ambiguous a -> Ambiguous a -> Ambiguous a
$cmax :: forall a. Ord a => Ambiguous a -> Ambiguous a -> Ambiguous a
>= :: Ambiguous a -> Ambiguous a -> Bool
$c>= :: forall a. Ord a => Ambiguous a -> Ambiguous a -> Bool
> :: Ambiguous a -> Ambiguous a -> Bool
$c> :: forall a. Ord a => Ambiguous a -> Ambiguous a -> Bool
<= :: Ambiguous a -> Ambiguous a -> Bool
$c<= :: forall a. Ord a => Ambiguous a -> Ambiguous a -> Bool
< :: Ambiguous a -> Ambiguous a -> Bool
$c< :: forall a. Ord a => Ambiguous a -> Ambiguous a -> Bool
compare :: Ambiguous a -> Ambiguous a -> Ordering
$ccompare :: forall a. Ord a => Ambiguous a -> Ambiguous a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (Ambiguous a)
Ord, Int -> Ambiguous a -> ShowS
[Ambiguous a] -> ShowS
Ambiguous a -> String
(Int -> Ambiguous a -> ShowS)
-> (Ambiguous a -> String)
-> ([Ambiguous a] -> ShowS)
-> Show (Ambiguous a)
forall a. Show a => Int -> Ambiguous a -> ShowS
forall a. Show a => [Ambiguous a] -> ShowS
forall a. Show a => Ambiguous a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Ambiguous a] -> ShowS
$cshowList :: forall a. Show a => [Ambiguous a] -> ShowS
show :: Ambiguous a -> String
$cshow :: forall a. Show a => Ambiguous a -> String
showsPrec :: Int -> Ambiguous a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Ambiguous a -> ShowS
Show, Typeable)
instance Show1 Ambiguous where
liftShowsPrec :: (Int -> a -> ShowS)
-> ([a] -> ShowS) -> Int -> Ambiguous a -> ShowS
liftShowsPrec Int -> a -> ShowS
sp [a] -> ShowS
sl Int
d (Ambiguous (a
h :| [a]
l)) String
t
| Int
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
5 = String
"(Ambiguous $ " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Int -> a -> ShowS
sp Int
0 a
h (String
" :| " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> [a] -> ShowS
sl [a]
l (Char
')' Char -> ShowS
forall a. a -> [a] -> [a]
: String
t))
| Bool
otherwise = String
"Ambiguous (" String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Int -> a -> ShowS
sp Int
0 a
h (String
" :| " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> [a] -> ShowS
sl [a]
l (Char
')' Char -> ShowS
forall a. a -> [a] -> [a]
: String
t))
instance Functor Ambiguous where
fmap :: (a -> b) -> Ambiguous a -> Ambiguous b
fmap a -> b
f (Ambiguous NonEmpty a
a) = NonEmpty b -> Ambiguous b
forall a. NonEmpty a -> Ambiguous a
Ambiguous ((a -> b) -> NonEmpty a -> NonEmpty b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f NonEmpty a
a)
instance Applicative Ambiguous where
pure :: a -> Ambiguous a
pure a
a = NonEmpty a -> Ambiguous a
forall a. NonEmpty a -> Ambiguous a
Ambiguous (a -> NonEmpty a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
a)
Ambiguous NonEmpty (a -> b)
f <*> :: Ambiguous (a -> b) -> Ambiguous a -> Ambiguous b
<*> Ambiguous NonEmpty a
a = NonEmpty b -> Ambiguous b
forall a. NonEmpty a -> Ambiguous a
Ambiguous (NonEmpty (a -> b)
f NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NonEmpty a
a)
instance Monad Ambiguous where
return :: a -> Ambiguous a
return = a -> Ambiguous a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
Ambiguous NonEmpty a
a >>= :: Ambiguous a -> (a -> Ambiguous b) -> Ambiguous b
>>= a -> Ambiguous b
f = NonEmpty b -> Ambiguous b
forall a. NonEmpty a -> Ambiguous a
Ambiguous (NonEmpty a
a NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Ambiguous b -> NonEmpty b
forall a. Ambiguous a -> NonEmpty a
getAmbiguous (Ambiguous b -> NonEmpty b)
-> (a -> Ambiguous b) -> a -> NonEmpty b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Ambiguous b
f)
instance Foldable Ambiguous where
foldMap :: (a -> m) -> Ambiguous a -> m
foldMap a -> m
f (Ambiguous NonEmpty a
a) = (a -> m) -> NonEmpty a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap a -> m
f NonEmpty a
a
instance Traversable Ambiguous where
traverse :: (a -> f b) -> Ambiguous a -> f (Ambiguous b)
traverse a -> f b
f (Ambiguous NonEmpty a
a) = NonEmpty b -> Ambiguous b
forall a. NonEmpty a -> Ambiguous a
Ambiguous (NonEmpty b -> Ambiguous b) -> f (NonEmpty b) -> f (Ambiguous b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> f b) -> NonEmpty a -> f (NonEmpty b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse a -> f b
f NonEmpty a
a
instance Semigroup a => Semigroup (Ambiguous a) where
Ambiguous NonEmpty a
xs <> :: Ambiguous a -> Ambiguous a -> Ambiguous a
<> Ambiguous NonEmpty a
ys = NonEmpty a -> Ambiguous a
forall a. NonEmpty a -> Ambiguous a
Ambiguous ((a -> a -> a) -> NonEmpty a -> NonEmpty a -> NonEmpty a
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Semigroup a => a -> a -> a
(<>) NonEmpty a
xs NonEmpty a
ys)
instance Monoid a => Monoid (Ambiguous a) where
mempty :: Ambiguous a
mempty = NonEmpty a -> Ambiguous a
forall a. NonEmpty a -> Ambiguous a
Ambiguous (a
forall a. Monoid a => a
mempty a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
:| [])
mappend :: Ambiguous a -> Ambiguous a -> Ambiguous a
mappend = Ambiguous a -> Ambiguous a -> Ambiguous a
forall a. Semigroup a => a -> a -> a
(<>)
completeParser :: MonoidNull s => Compose (ParseResults s) (Compose [] ((,) s)) r -> Compose (ParseResults s) [] r
completeParser :: Compose (ParseResults s) (Compose [] ((,) s)) r
-> Compose (ParseResults s) [] r
completeParser (Compose (Left ParseFailure Pos s
failure)) = Either (ParseFailure Pos s) [r] -> Compose (ParseResults s) [] r
forall k k1 (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose (ParseFailure Pos s -> Either (ParseFailure Pos s) [r]
forall a b. a -> Either a b
Left ParseFailure Pos s
failure)
completeParser (Compose (Right (Compose [(s, r)]
results))) =
case ((s, r) -> Bool) -> [(s, r)] -> [(s, r)]
forall a. (a -> Bool) -> [a] -> [a]
filter (s -> Bool
forall m. MonoidNull m => m -> Bool
Null.null (s -> Bool) -> ((s, r) -> s) -> (s, r) -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (s, r) -> s
forall a b. (a, b) -> a
fst) [(s, r)]
results
of [] -> Either (ParseFailure Pos s) [r] -> Compose (ParseResults s) [] r
forall k k1 (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose (ParseFailure Pos s -> Either (ParseFailure Pos s) [r]
forall a b. a -> Either a b
Left (ParseFailure Pos s -> Either (ParseFailure Pos s) [r])
-> ParseFailure Pos s -> Either (ParseFailure Pos s) [r]
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 Pos
0 [String -> FailureDescription s
forall s. String -> FailureDescription s
StaticDescription String
"a complete parse"] [])
[(s, r)]
completeResults -> Either (ParseFailure Pos s) [r] -> Compose (ParseResults s) [] r
forall k k1 (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose ([r] -> Either (ParseFailure Pos s) [r]
forall a b. b -> Either a b
Right ([r] -> Either (ParseFailure Pos s) [r])
-> [r] -> Either (ParseFailure Pos s) [r]
forall a b. (a -> b) -> a -> b
$ (s, r) -> r
forall a b. (a, b) -> b
snd ((s, r) -> r) -> [(s, r)] -> [r]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(s, r)]
completeResults)
class InputParsing m => MultiParsing m where
type ResultFunctor m :: Type -> Type
type GrammarConstraint m (g :: (Type -> Type) -> Type) :: Constraint
type GrammarConstraint m g = Rank2.Functor g
parseComplete :: (ParserInput m ~ s, GrammarConstraint m g, Eq s, FactorialMonoid s) =>
g m -> s -> g (ResultFunctor m)
parsePrefix :: (ParserInput m ~ s, GrammarConstraint m g, Eq s, FactorialMonoid s) =>
g m -> s -> g (Compose (ResultFunctor m) ((,) s))
class MultiParsing m => GrammarParsing m where
type ParserGrammar m :: (Type -> Type) -> Type
type GrammarFunctor m :: Type -> Type
parsingResult :: ParserInput m -> GrammarFunctor m a -> ResultFunctor m (ParserInput m, a)
nonTerminal :: (g ~ ParserGrammar m, GrammarConstraint m g) => (g (GrammarFunctor m) -> GrammarFunctor m a) -> m a
selfReferring :: (g ~ ParserGrammar m, GrammarConstraint m g, Rank2.Distributive g) => g m
fixGrammar :: (g ~ ParserGrammar m, GrammarConstraint m g, Rank2.Distributive g) => (g m -> g m) -> g m
recursive :: m a -> m a
selfReferring = (forall a. (g (GrammarFunctor m) -> GrammarFunctor m a) -> m a)
-> (g (GrammarFunctor m) -> g (GrammarFunctor m)) -> g m
forall k (g :: (k -> *) -> *) (m :: * -> *) (p :: k -> *)
(q :: k -> *).
(Distributive g, Functor m) =>
(forall (a :: k). m (p a) -> q a) -> m (g p) -> g q
Rank2.cotraverse forall a. (g (GrammarFunctor m) -> GrammarFunctor m a) -> m a
forall (m :: * -> *) (g :: (* -> *) -> *) a.
(GrammarParsing m, g ~ ParserGrammar m, GrammarConstraint m g) =>
(g (GrammarFunctor m) -> GrammarFunctor m a) -> m a
nonTerminal g (GrammarFunctor m) -> g (GrammarFunctor m)
forall a. a -> a
id
{-# INLINE selfReferring #-}
fixGrammar = ((g m -> g m) -> g m -> g m
forall a b. (a -> b) -> a -> b
$ g m
forall (m :: * -> *) (g :: (* -> *) -> *).
(GrammarParsing m, g ~ ParserGrammar m, GrammarConstraint m g,
Distributive g) =>
g m
selfReferring)
{-# INLINE fixGrammar #-}
recursive = m a -> m a
forall a. a -> a
id
class GrammarParsing m => TailsParsing m where
parseTails :: GrammarConstraint m g => m r -> [(ParserInput m, g (GrammarFunctor m))] -> GrammarFunctor m r
parseAllTails :: (GrammarConstraint m g, Rank2.Functor g) =>
g m -> [(ParserInput m, g (GrammarFunctor m))] -> [(ParserInput m, g (GrammarFunctor m))]
parseAllTails g m
_ [] = []
parseAllTails g m
final parsed :: [(ParserInput m, g (GrammarFunctor m))]
parsed@((ParserInput m
s, g (GrammarFunctor m)
_):[(ParserInput m, g (GrammarFunctor m))]
_) = (ParserInput m
s, g (GrammarFunctor m)
gd)(ParserInput m, g (GrammarFunctor m))
-> [(ParserInput m, g (GrammarFunctor m))]
-> [(ParserInput m, g (GrammarFunctor m))]
forall a. a -> [a] -> [a]
:[(ParserInput m, g (GrammarFunctor m))]
parsed
where gd :: g (GrammarFunctor m)
gd = (forall a. m a -> GrammarFunctor m a)
-> g m -> g (GrammarFunctor m)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Functor g =>
(forall (a :: k). p a -> q a) -> g p -> g q
Rank2.fmap (m a
-> [(ParserInput m, g (GrammarFunctor m))] -> GrammarFunctor m a
forall (m :: * -> *) (g :: (* -> *) -> *) r.
(TailsParsing m, GrammarConstraint m g) =>
m r
-> [(ParserInput m, g (GrammarFunctor m))] -> GrammarFunctor m r
`parseTails` [(ParserInput m, g (GrammarFunctor m))]
parsed) g m
final
class Alternative m => AmbiguousParsing m where
ambiguous :: m a -> m (Ambiguous a)
class Alternative m => CommittedParsing m where
type CommittedResults m :: Type -> Type
commit :: m a -> m (CommittedResults m a)
admit :: m (CommittedResults m a) -> m a
class (DeterministicParsing m, InputCharParsing m, TokenParsing m) => LexicalParsing m where
lexicalWhiteSpace :: m ()
someLexicalSpace :: m ()
:: m ()
lexicalSemicolon :: m Char
lexicalToken :: m a -> m a
identifierToken :: m (ParserInput m) -> m (ParserInput m)
isIdentifierStartChar :: Char -> Bool
isIdentifierFollowChar :: Char -> Bool
identifier :: m (ParserInput m)
keyword :: ParserInput m -> m ()
default identifier :: TextualMonoid (ParserInput m) => m (ParserInput m)
default keyword :: (Show (ParserInput m), TextualMonoid (ParserInput m)) => ParserInput m -> m ()
lexicalWhiteSpace = (Char -> Bool) -> m (ParserInput m)
forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
takeCharsWhile Char -> Bool
isSpace m (ParserInput m) -> m () -> m ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m (ParserInput m) -> m ()
forall (m :: * -> *) a. DeterministicParsing m => m a -> m ()
skipAll (m ()
forall (m :: * -> *). LexicalParsing m => m ()
lexicalComment m () -> m (ParserInput m) -> m (ParserInput m)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Char -> Bool) -> m (ParserInput m)
forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
takeCharsWhile Char -> Bool
isSpace)
someLexicalSpace = (Char -> Bool) -> m (ParserInput m)
forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
takeCharsWhile1 Char -> Bool
isSpace m (ParserInput m) -> m () -> m ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (m ()
forall (m :: * -> *). LexicalParsing m => m ()
lexicalComment m () -> m () -> m ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m ()
forall (m :: * -> *). LexicalParsing m => m ()
lexicalWhiteSpace m () -> m () -> m ()
forall (m :: * -> *) a. DeterministicParsing m => m a -> m a -> m a
<<|> () -> m ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ())
m () -> m () -> m ()
forall (m :: * -> *) a. DeterministicParsing m => m a -> m a -> m a
<<|> m ()
forall (m :: * -> *). LexicalParsing m => m ()
lexicalComment m () -> m () -> m ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m ()
forall (m :: * -> *). LexicalParsing m => m ()
lexicalWhiteSpace
m () -> String -> m ()
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"whitespace"
lexicalComment = m ()
forall (f :: * -> *) a. Alternative f => f a
empty
lexicalSemicolon = m Char -> m Char
forall (m :: * -> *) a. LexicalParsing m => m a -> m a
lexicalToken (Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
Text.Parser.Char.char Char
';')
lexicalToken m a
p = m a
p m a -> m () -> m a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* m ()
forall (m :: * -> *). LexicalParsing m => m ()
lexicalWhiteSpace
isIdentifierStartChar Char
c = Char -> Bool
isLetter Char
c Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'_'
isIdentifierFollowChar Char
c = Char -> Bool
isAlphaNum Char
c Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'_'
identifier = m (ParserInput m) -> m (ParserInput m)
forall (m :: * -> *).
LexicalParsing m =>
m (ParserInput m) -> m (ParserInput m)
identifierToken ((ParserInput m -> ParserInput m -> ParserInput m)
-> m (ParserInput m) -> m (ParserInput m) -> m (ParserInput m)
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 ParserInput m -> ParserInput m -> ParserInput m
forall a. Monoid a => a -> a -> a
mappend ((Char -> Bool) -> m (ParserInput m)
forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
satisfyCharInput (LexicalParsing m => Char -> Bool
forall (m :: * -> *). LexicalParsing m => Char -> Bool
isIdentifierStartChar @m))
((Char -> Bool) -> m (ParserInput m)
forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
takeCharsWhile (LexicalParsing m => Char -> Bool
forall (m :: * -> *). LexicalParsing m => Char -> Bool
isIdentifierFollowChar @m))) m (ParserInput m) -> String -> m (ParserInput m)
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"an identifier"
identifierToken = m (ParserInput m) -> m (ParserInput m)
forall (m :: * -> *) a. LexicalParsing m => m a -> m a
lexicalToken
keyword ParserInput m
s = m () -> m ()
forall (m :: * -> *) a. LexicalParsing m => m a -> m a
lexicalToken (ParserInput m -> m (ParserInput m)
forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string ParserInput m
s m (ParserInput m) -> m () -> m ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Char -> Bool) -> m ()
forall (m :: * -> *). InputCharParsing m => (Char -> Bool) -> m ()
notSatisfyChar (LexicalParsing m => Char -> Bool
forall (m :: * -> *). LexicalParsing m => Char -> Bool
isIdentifierFollowChar @m)) m () -> String -> m ()
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> (String
"keyword " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> ParserInput m -> String
forall a. Show a => a -> String
show ParserInput m
s)