{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE ImpredicativeTypes #-}
{-# LANGUAGE UndecidableInstances #-}

-- | This module defines a "Text.Megaparsec" backend for format descriptors. To that
-- effect, this module introduces a type class 'MonadParsec' modeled after
-- Megarparsec's own type class, so that format descriptors can take advantage
-- of Megaparsec features.
--
-- The 'MonadParsec' class in this module isn't exactly the same as the one from
-- Megaparsec (mainly because it needs to be implementable on pretty-printers as
-- well). As such, some of the code in this module is similar or identical to
-- Megaparsec, many of the docstrings are taken directly from Megaparsec as
-- well.
module Text.Pup.Backend.Megaparsec
  ( -- * Concrete backend
    Backend,
    run,
    BackendGen (..),

    -- * Megaparsec-specific format descriptors
    MonadParsec (..),

    -- * Reexports
    module Text.Pup.Class,
  )
where

import Control.Additive
import Control.Applicative
import Control.Monad
import Control.Monad.Indexed qualified as Indexed
import Control.Monad.Indexed.Cont2 qualified as Cont2
import Data.Kind
import Data.Set (Set)
import Text.Megaparsec qualified as Megaparsec
import Text.Megaparsec.Char qualified as Megaparsec.Char
import Text.Pup.Class

type Backend err s = BackendGen (Megaparsec.Parsec err s)

type BackendGen :: (Type -> Type) -> Type -> Type -> Type -> Type
newtype BackendGen m r r' a = MkBackend (Indexed.IgnoreIndices m r r' a)
  deriving newtype
    ( (forall a b.
 (a -> b) -> BackendGen m r r' a -> BackendGen m r r' b)
-> (forall a b. a -> BackendGen m r r' b -> BackendGen m r r' a)
-> Functor (BackendGen m r r')
forall a b. a -> BackendGen m r r' b -> BackendGen m r r' a
forall a b. (a -> b) -> BackendGen m r r' a -> BackendGen m r r' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
forall (m :: * -> *) r r' a b.
Functor m =>
a -> BackendGen m r r' b -> BackendGen m r r' a
forall (m :: * -> *) r r' a b.
Functor m =>
(a -> b) -> BackendGen m r r' a -> BackendGen m r r' b
$cfmap :: forall (m :: * -> *) r r' a b.
Functor m =>
(a -> b) -> BackendGen m r r' a -> BackendGen m r r' b
fmap :: forall a b. (a -> b) -> BackendGen m r r' a -> BackendGen m r r' b
$c<$ :: forall (m :: * -> *) r r' a b.
Functor m =>
a -> BackendGen m r r' b -> BackendGen m r r' a
<$ :: forall a b. a -> BackendGen m r r' b -> BackendGen m r r' a
Functor,
      Functor (BackendGen m r r')
Functor (BackendGen m r r') =>
(forall a. a -> BackendGen m r r' a)
-> (forall a b.
    BackendGen m r r' (a -> b)
    -> BackendGen m r r' a -> BackendGen m r r' b)
-> (forall a b c.
    (a -> b -> c)
    -> BackendGen m r r' a
    -> BackendGen m r r' b
    -> BackendGen m r r' c)
-> (forall a b.
    BackendGen m r r' a -> BackendGen m r r' b -> BackendGen m r r' b)
-> (forall a b.
    BackendGen m r r' a -> BackendGen m r r' b -> BackendGen m r r' a)
-> Applicative (BackendGen m r r')
forall a. a -> BackendGen m r r' a
forall a b.
BackendGen m r r' a -> BackendGen m r r' b -> BackendGen m r r' a
forall a b.
BackendGen m r r' a -> BackendGen m r r' b -> BackendGen m r r' b
forall a b.
BackendGen m r r' (a -> b)
-> BackendGen m r r' a -> BackendGen m r r' b
forall a b c.
(a -> b -> c)
-> BackendGen m r r' a
-> BackendGen m r r' b
-> BackendGen m r r' c
forall (f :: * -> *).
Functor f =>
(forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
forall (m :: * -> *) r r'.
Applicative m =>
Functor (BackendGen m r r')
forall (m :: * -> *) r r' a.
Applicative m =>
a -> BackendGen m r r' a
forall (m :: * -> *) r r' a b.
Applicative m =>
BackendGen m r r' a -> BackendGen m r r' b -> BackendGen m r r' a
forall (m :: * -> *) r r' a b.
Applicative m =>
BackendGen m r r' a -> BackendGen m r r' b -> BackendGen m r r' b
forall (m :: * -> *) r r' a b.
Applicative m =>
BackendGen m r r' (a -> b)
-> BackendGen m r r' a -> BackendGen m r r' b
forall (m :: * -> *) r r' a b c.
Applicative m =>
(a -> b -> c)
-> BackendGen m r r' a
-> BackendGen m r r' b
-> BackendGen m r r' c
$cpure :: forall (m :: * -> *) r r' a.
Applicative m =>
a -> BackendGen m r r' a
pure :: forall a. a -> BackendGen m r r' a
$c<*> :: forall (m :: * -> *) r r' a b.
Applicative m =>
BackendGen m r r' (a -> b)
-> BackendGen m r r' a -> BackendGen m r r' b
<*> :: forall a b.
BackendGen m r r' (a -> b)
-> BackendGen m r r' a -> BackendGen m r r' b
$cliftA2 :: forall (m :: * -> *) r r' a b c.
Applicative m =>
(a -> b -> c)
-> BackendGen m r r' a
-> BackendGen m r r' b
-> BackendGen m r r' c
liftA2 :: forall a b c.
(a -> b -> c)
-> BackendGen m r r' a
-> BackendGen m r r' b
-> BackendGen m r r' c
$c*> :: forall (m :: * -> *) r r' a b.
Applicative m =>
BackendGen m r r' a -> BackendGen m r r' b -> BackendGen m r r' b
*> :: forall a b.
BackendGen m r r' a -> BackendGen m r r' b -> BackendGen m r r' b
$c<* :: forall (m :: * -> *) r r' a b.
Applicative m =>
BackendGen m r r' a -> BackendGen m r r' b -> BackendGen m r r' a
<* :: forall a b.
BackendGen m r r' a -> BackendGen m r r' b -> BackendGen m r r' a
Applicative,
      Applicative (BackendGen m r r')
Applicative (BackendGen m r r') =>
(forall a. BackendGen m r r' a)
-> (forall a.
    BackendGen m r r' a -> BackendGen m r r' a -> BackendGen m r r' a)
-> (forall a. BackendGen m r r' a -> BackendGen m r r' [a])
-> (forall a. BackendGen m r r' a -> BackendGen m r r' [a])
-> Alternative (BackendGen m r r')
forall a. BackendGen m r r' a
forall a. BackendGen m r r' a -> BackendGen m r r' [a]
forall a.
BackendGen m r r' a -> BackendGen m r r' a -> BackendGen m r r' a
forall (f :: * -> *).
Applicative f =>
(forall a. f a)
-> (forall a. f a -> f a -> f a)
-> (forall a. f a -> f [a])
-> (forall a. f a -> f [a])
-> Alternative f
forall (m :: * -> *) r r'.
Alternative m =>
Applicative (BackendGen m r r')
forall (m :: * -> *) r r' a. Alternative m => BackendGen m r r' a
forall (m :: * -> *) r r' a.
Alternative m =>
BackendGen m r r' a -> BackendGen m r r' [a]
forall (m :: * -> *) r r' a.
Alternative m =>
BackendGen m r r' a -> BackendGen m r r' a -> BackendGen m r r' a
$cempty :: forall (m :: * -> *) r r' a. Alternative m => BackendGen m r r' a
empty :: forall a. BackendGen m r r' a
$c<|> :: forall (m :: * -> *) r r' a.
Alternative m =>
BackendGen m r r' a -> BackendGen m r r' a -> BackendGen m r r' a
<|> :: forall a.
BackendGen m r r' a -> BackendGen m r r' a -> BackendGen m r r' a
$csome :: forall (m :: * -> *) r r' a.
Alternative m =>
BackendGen m r r' a -> BackendGen m r r' [a]
some :: forall a. BackendGen m r r' a -> BackendGen m r r' [a]
$cmany :: forall (m :: * -> *) r r' a.
Alternative m =>
BackendGen m r r' a -> BackendGen m r r' [a]
many :: forall a. BackendGen m r r' a -> BackendGen m r r' [a]
Alternative,
      Applicative (BackendGen m r r')
Applicative (BackendGen m r r') =>
(forall a b.
 BackendGen m r r' a
 -> (a -> BackendGen m r r' b) -> BackendGen m r r' b)
-> (forall a b.
    BackendGen m r r' a -> BackendGen m r r' b -> BackendGen m r r' b)
-> (forall a. a -> BackendGen m r r' a)
-> Monad (BackendGen m r r')
forall a. a -> BackendGen m r r' a
forall a b.
BackendGen m r r' a -> BackendGen m r r' b -> BackendGen m r r' b
forall a b.
BackendGen m r r' a
-> (a -> BackendGen m r r' b) -> BackendGen m r r' b
forall (m :: * -> *).
Applicative m =>
(forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
forall (m :: * -> *) r r'.
Monad m =>
Applicative (BackendGen m r r')
forall (m :: * -> *) r r' a. Monad m => a -> BackendGen m r r' a
forall (m :: * -> *) r r' a b.
Monad m =>
BackendGen m r r' a -> BackendGen m r r' b -> BackendGen m r r' b
forall (m :: * -> *) r r' a b.
Monad m =>
BackendGen m r r' a
-> (a -> BackendGen m r r' b) -> BackendGen m r r' b
$c>>= :: forall (m :: * -> *) r r' a b.
Monad m =>
BackendGen m r r' a
-> (a -> BackendGen m r r' b) -> BackendGen m r r' b
>>= :: forall a b.
BackendGen m r r' a
-> (a -> BackendGen m r r' b) -> BackendGen m r r' b
$c>> :: forall (m :: * -> *) r r' a b.
Monad m =>
BackendGen m r r' a -> BackendGen m r r' b -> BackendGen m r r' b
>> :: forall a b.
BackendGen m r r' a -> BackendGen m r r' b -> BackendGen m r r' b
$creturn :: forall (m :: * -> *) r r' a. Monad m => a -> BackendGen m r r' a
return :: forall a. a -> BackendGen m r r' a
Monad,
      Monad (BackendGen m r r')
Alternative (BackendGen m r r')
(Alternative (BackendGen m r r'), Monad (BackendGen m r r')) =>
(forall a. BackendGen m r r' a)
-> (forall a.
    BackendGen m r r' a -> BackendGen m r r' a -> BackendGen m r r' a)
-> MonadPlus (BackendGen m r r')
forall a. BackendGen m r r' a
forall a.
BackendGen m r r' a -> BackendGen m r r' a -> BackendGen m r r' a
forall (m :: * -> *).
(Alternative m, Monad m) =>
(forall a. m a) -> (forall a. m a -> m a -> m a) -> MonadPlus m
forall (m :: * -> *) r r'. MonadPlus m => Monad (BackendGen m r r')
forall (m :: * -> *) r r'.
MonadPlus m =>
Alternative (BackendGen m r r')
forall (m :: * -> *) r r' a. MonadPlus m => BackendGen m r r' a
forall (m :: * -> *) r r' a.
MonadPlus m =>
BackendGen m r r' a -> BackendGen m r r' a -> BackendGen m r r' a
$cmzero :: forall (m :: * -> *) r r' a. MonadPlus m => BackendGen m r r' a
mzero :: forall a. BackendGen m r r' a
$cmplus :: forall (m :: * -> *) r r' a.
MonadPlus m =>
BackendGen m r r' a -> BackendGen m r r' a -> BackendGen m r r' a
mplus :: forall a.
BackendGen m r r' a -> BackendGen m r r' a -> BackendGen m r r' a
MonadPlus,
      (forall i j. Functor (BackendGen m i j),
 forall i. Applicative (BackendGen m i i)) =>
(forall a i. a -> BackendGen m i i a)
-> (forall i j a b k1.
    BackendGen m i j (a -> b)
    -> BackendGen m j k1 a -> BackendGen m i k1 b)
-> (forall a b c i j k1.
    (a -> b -> c)
    -> BackendGen m i j a
    -> BackendGen m j k1 b
    -> BackendGen m i k1 c)
-> (forall i j a k1 b.
    BackendGen m i j a -> BackendGen m j k1 b -> BackendGen m i k1 b)
-> (forall i j a k1 b.
    BackendGen m i j a -> BackendGen m j k1 b -> BackendGen m i k1 a)
-> Applicative (BackendGen m)
forall i. Applicative (BackendGen m i i)
forall i j. Functor (BackendGen m i j)
forall a i. a -> BackendGen m i i a
forall i j a k1 b.
BackendGen m i j a -> BackendGen m j k1 b -> BackendGen m i k1 a
forall i j a k1 b.
BackendGen m i j a -> BackendGen m j k1 b -> BackendGen m i k1 b
forall i j a b k1.
BackendGen m i j (a -> b)
-> BackendGen m j k1 a -> BackendGen m i k1 b
forall a b c i j k1.
(a -> b -> c)
-> BackendGen m i j a -> BackendGen m j k1 b -> BackendGen m i k1 c
forall {k} (f :: k -> k -> * -> *).
(forall (i :: k) (j :: k). Functor (f i j),
 forall (i :: k). Applicative (f i i)) =>
(forall a (i :: k). a -> f i i a)
-> (forall (i :: k) (j :: k) a b (k1 :: k).
    f i j (a -> b) -> f j k1 a -> f i k1 b)
-> (forall a b c (i :: k) (j :: k) (k1 :: k).
    (a -> b -> c) -> f i j a -> f j k1 b -> f i k1 c)
-> (forall (i :: k) (j :: k) a (k1 :: k) b.
    f i j a -> f j k1 b -> f i k1 b)
-> (forall (i :: k) (j :: k) a (k1 :: k) b.
    f i j a -> f j k1 b -> f i k1 a)
-> Applicative f
forall (m :: * -> *) i.
Applicative m =>
Applicative (BackendGen m i i)
forall (m :: * -> *) i j.
Applicative m =>
Functor (BackendGen m i j)
forall (m :: * -> *) a i. Applicative m => a -> BackendGen m i i a
forall (m :: * -> *) i j a k1 b.
Applicative m =>
BackendGen m i j a -> BackendGen m j k1 b -> BackendGen m i k1 a
forall (m :: * -> *) i j a k1 b.
Applicative m =>
BackendGen m i j a -> BackendGen m j k1 b -> BackendGen m i k1 b
forall (m :: * -> *) i j a b k1.
Applicative m =>
BackendGen m i j (a -> b)
-> BackendGen m j k1 a -> BackendGen m i k1 b
forall (m :: * -> *) a b c i j k1.
Applicative m =>
(a -> b -> c)
-> BackendGen m i j a -> BackendGen m j k1 b -> BackendGen m i k1 c
$cpure :: forall (m :: * -> *) a i. Applicative m => a -> BackendGen m i i a
pure :: forall a i. a -> BackendGen m i i a
$c<*> :: forall (m :: * -> *) i j a b k1.
Applicative m =>
BackendGen m i j (a -> b)
-> BackendGen m j k1 a -> BackendGen m i k1 b
<*> :: forall i j a b k1.
BackendGen m i j (a -> b)
-> BackendGen m j k1 a -> BackendGen m i k1 b
$cliftA2 :: forall (m :: * -> *) a b c i j k1.
Applicative m =>
(a -> b -> c)
-> BackendGen m i j a -> BackendGen m j k1 b -> BackendGen m i k1 c
liftA2 :: forall a b c i j k1.
(a -> b -> c)
-> BackendGen m i j a -> BackendGen m j k1 b -> BackendGen m i k1 c
$c*> :: forall (m :: * -> *) i j a k1 b.
Applicative m =>
BackendGen m i j a -> BackendGen m j k1 b -> BackendGen m i k1 b
*> :: forall i j a k1 b.
BackendGen m i j a -> BackendGen m j k1 b -> BackendGen m i k1 b
$c<* :: forall (m :: * -> *) i j a k1 b.
Applicative m =>
BackendGen m i j a -> BackendGen m j k1 b -> BackendGen m i k1 a
<* :: forall i j a k1 b.
BackendGen m i j a -> BackendGen m j k1 b -> BackendGen m i k1 a
Indexed.Applicative,
      Applicative (BackendGen m)
(Applicative (BackendGen m), forall i. Monad (BackendGen m i i)) =>
(forall i j a k1 b.
 BackendGen m i j a
 -> (a -> BackendGen m j k1 b) -> BackendGen m i k1 b)
-> Monad (BackendGen m)
forall i. Monad (BackendGen m i i)
forall i j a k1 b.
BackendGen m i j a
-> (a -> BackendGen m j k1 b) -> BackendGen m i k1 b
forall {k} (m :: k -> k -> * -> *).
(Applicative m, forall (i :: k). Monad (m i i)) =>
(forall (i :: k) (j :: k) a (k1 :: k) b.
 m i j a -> (a -> m j k1 b) -> m i k1 b)
-> Monad m
forall (m :: * -> *). Monad m => Applicative (BackendGen m)
forall (m :: * -> *) i. Monad m => Monad (BackendGen m i i)
forall (m :: * -> *) i j a k1 b.
Monad m =>
BackendGen m i j a
-> (a -> BackendGen m j k1 b) -> BackendGen m i k1 b
$c>>= :: forall (m :: * -> *) i j a k1 b.
Monad m =>
BackendGen m i j a
-> (a -> BackendGen m j k1 b) -> BackendGen m i k1 b
>>= :: forall i j a k1 b.
BackendGen m i j a
-> (a -> BackendGen m j k1 b) -> BackendGen m i k1 b
Indexed.Monad,
      (forall r' r r''.
 ((r' -> r') -> r -> BackendGen m r r'' r'')
 -> BackendGen m r r' ())
-> Stacked (BackendGen m)
forall r' r r''.
((r' -> r') -> r -> BackendGen m r r'' r'') -> BackendGen m r r' ()
forall (m :: * -> *) r' r r''.
Applicative m =>
((r' -> r') -> r -> BackendGen m r r'' r'') -> BackendGen m r r' ()
forall (m :: * -> * -> * -> *).
(forall r' r r''. ((r' -> r') -> r -> m r r'' r'') -> m r r' ())
-> Stacked m
$cshift_ :: forall (m :: * -> *) r' r r''.
Applicative m =>
((r' -> r') -> r -> BackendGen m r r'' r'') -> BackendGen m r r' ()
shift_ :: forall r' r r''.
((r' -> r') -> r -> BackendGen m r r'' r'') -> BackendGen m r r' ()
Cont2.Stacked
    )

deriving newtype instance (Alternative m) => Additive (BackendGen m r r' a)

run :: (Megaparsec.ShowErrorComponent err, Megaparsec.VisualStream s, Megaparsec.TraversableStream s) => Backend err s r r' a -> String -> s -> Either String a
run :: forall err s r r' a.
(ShowErrorComponent err, VisualStream s, TraversableStream s) =>
Backend err s r r' a -> String -> s -> Either String a
run (MkBackend (Indexed.IgnoreIndices Parsec err s a
prse)) String
name s
input =
  case Parsec err s a -> String -> s -> Either (ParseErrorBundle s err) a
forall e s a.
Parsec e s a -> String -> s -> Either (ParseErrorBundle s e) a
Megaparsec.runParser Parsec err s a
prse String
name s
input of
    Left ParseErrorBundle s err
err -> String -> Either String a
forall a b. a -> Either a b
Left (String -> Either String a) -> String -> Either String a
forall a b. (a -> b) -> a -> b
$ ParseErrorBundle s err -> String
forall s e.
(VisualStream s, TraversableStream s, ShowErrorComponent e) =>
ParseErrorBundle s e -> String
Megaparsec.errorBundlePretty ParseErrorBundle s err
err
    Right a
a -> a -> Either String a
forall a b. b -> Either a b
Right a
a

instance (MonadFail m) => Indexed.Fail (BackendGen m) where
  fail :: forall i j a. String -> BackendGen m i j a
fail String
msg = IgnoreIndices m i j a -> BackendGen m i j a
forall (m :: * -> *) r r' a.
IgnoreIndices m r r' a -> BackendGen m r r' a
MkBackend (IgnoreIndices m i j a -> BackendGen m i j a)
-> (m a -> IgnoreIndices m i j a) -> m a -> BackendGen m i j a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> IgnoreIndices m i j a
forall {k} {k1} {k2} (m :: k -> *) (i :: k1) (j :: k2) (a :: k).
m a -> IgnoreIndices m i j a
Indexed.IgnoreIndices (m a -> BackendGen m i j a) -> m a -> BackendGen m i j a
forall a b. (a -> b) -> a -> b
$ String -> m a
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
msg

instance (Megaparsec.MonadParsec err s m, tok ~ Megaparsec.Token s, chunk ~ Megaparsec.Tokens s, Eq tok, Eq chunk) => Tokens tok chunk (BackendGen m) where
  eof :: forall r. BackendGen m r r ()
eof = IgnoreIndices m r r () -> BackendGen m r r ()
forall (m :: * -> *) r r' a.
IgnoreIndices m r r' a -> BackendGen m r r' a
MkBackend (IgnoreIndices m r r () -> BackendGen m r r ())
-> (m () -> IgnoreIndices m r r ()) -> m () -> BackendGen m r r ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m () -> IgnoreIndices m r r ()
forall {k} {k1} {k2} (m :: k -> *) (i :: k1) (j :: k2) (a :: k).
m a -> IgnoreIndices m i j a
Indexed.IgnoreIndices (m () -> BackendGen m r r ()) -> m () -> BackendGen m r r ()
forall a b. (a -> b) -> a -> b
$ m ()
forall e s (m :: * -> *). MonadParsec e s m => m ()
Megaparsec.eof
  satisfy :: forall r. (tok -> Bool) -> BackendGen m (tok -> r) r tok
satisfy tok -> Bool
p = IgnoreIndices m (tok -> r) r tok -> BackendGen m (tok -> r) r tok
forall (m :: * -> *) r r' a.
IgnoreIndices m r r' a -> BackendGen m r r' a
MkBackend (IgnoreIndices m (tok -> r) r tok -> BackendGen m (tok -> r) r tok)
-> (m tok -> IgnoreIndices m (tok -> r) r tok)
-> m tok
-> BackendGen m (tok -> r) r tok
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m tok -> IgnoreIndices m (tok -> r) r tok
forall {k} {k1} {k2} (m :: k -> *) (i :: k1) (j :: k2) (a :: k).
m a -> IgnoreIndices m i j a
Indexed.IgnoreIndices (m tok -> BackendGen m (tok -> r) r tok)
-> m tok -> BackendGen m (tok -> r) r tok
forall a b. (a -> b) -> a -> b
$ (Token s -> Bool) -> m (Token s)
forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
Megaparsec.satisfy tok -> Bool
Token s -> Bool
p
  single :: forall r. tok -> BackendGen m r r tok
single tok
t = IgnoreIndices m r r tok -> BackendGen m r r tok
forall (m :: * -> *) r r' a.
IgnoreIndices m r r' a -> BackendGen m r r' a
MkBackend (IgnoreIndices m r r tok -> BackendGen m r r tok)
-> (m tok -> IgnoreIndices m r r tok)
-> m tok
-> BackendGen m r r tok
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m tok -> IgnoreIndices m r r tok
forall {k} {k1} {k2} (m :: k -> *) (i :: k1) (j :: k2) (a :: k).
m a -> IgnoreIndices m i j a
Indexed.IgnoreIndices (m tok -> BackendGen m r r tok) -> m tok -> BackendGen m r r tok
forall a b. (a -> b) -> a -> b
$ Token s -> m (Token s)
forall e s (m :: * -> *).
MonadParsec e s m =>
Token s -> m (Token s)
Megaparsec.single tok
Token s
t
  label :: forall r r' a. String -> BackendGen m r r' a -> BackendGen m r r' a
label String
s (MkBackend (Indexed.IgnoreIndices m a
a)) = IgnoreIndices m r r' a -> BackendGen m r r' a
forall (m :: * -> *) r r' a.
IgnoreIndices m r r' a -> BackendGen m r r' a
MkBackend (IgnoreIndices m r r' a -> BackendGen m r r' a)
-> (m a -> IgnoreIndices m r r' a) -> m a -> BackendGen m r r' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> IgnoreIndices m r r' a
forall {k} {k1} {k2} (m :: k -> *) (i :: k1) (j :: k2) (a :: k).
m a -> IgnoreIndices m i j a
Indexed.IgnoreIndices (m a -> BackendGen m r r' a) -> m a -> BackendGen m r r' a
forall a b. (a -> b) -> a -> b
$ String -> m a -> m a
forall a. String -> m a -> m a
forall e s (m :: * -> *) a.
MonadParsec e s m =>
String -> m a -> m a
Megaparsec.label String
s m a
a
  hidden :: forall r r' a. BackendGen m r r' a -> BackendGen m r r' a
hidden (MkBackend (Indexed.IgnoreIndices m a
a)) = IgnoreIndices m r r' a -> BackendGen m r r' a
forall (m :: * -> *) r r' a.
IgnoreIndices m r r' a -> BackendGen m r r' a
MkBackend (IgnoreIndices m r r' a -> BackendGen m r r' a)
-> (m a -> IgnoreIndices m r r' a) -> m a -> BackendGen m r r' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> IgnoreIndices m r r' a
forall {k} {k1} {k2} (m :: k -> *) (i :: k1) (j :: k2) (a :: k).
m a -> IgnoreIndices m i j a
Indexed.IgnoreIndices (m a -> BackendGen m r r' a) -> m a -> BackendGen m r r' a
forall a b. (a -> b) -> a -> b
$ m a -> m a
forall a. m a -> m a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
Megaparsec.hidden m a
a
  tokens :: forall r.
(chunk -> chunk -> Bool)
-> chunk -> BackendGen m (chunk -> r) r chunk
tokens chunk -> chunk -> Bool
f chunk
s = IgnoreIndices m (chunk -> r) r chunk
-> BackendGen m (chunk -> r) r chunk
forall (m :: * -> *) r r' a.
IgnoreIndices m r r' a -> BackendGen m r r' a
MkBackend (IgnoreIndices m (chunk -> r) r chunk
 -> BackendGen m (chunk -> r) r chunk)
-> (m chunk -> IgnoreIndices m (chunk -> r) r chunk)
-> m chunk
-> BackendGen m (chunk -> r) r chunk
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m chunk -> IgnoreIndices m (chunk -> r) r chunk
forall {k} {k1} {k2} (m :: k -> *) (i :: k1) (j :: k2) (a :: k).
m a -> IgnoreIndices m i j a
Indexed.IgnoreIndices (m chunk -> BackendGen m (chunk -> r) r chunk)
-> m chunk -> BackendGen m (chunk -> r) r chunk
forall a b. (a -> b) -> a -> b
$ (Tokens s -> Tokens s -> Bool) -> Tokens s -> m (Tokens s)
forall e s (m :: * -> *).
MonadParsec e s m =>
(Tokens s -> Tokens s -> Bool) -> Tokens s -> m (Tokens s)
Megaparsec.tokens chunk -> chunk -> Bool
Tokens s -> Tokens s -> Bool
f chunk
Tokens s
s
  takeWhileP :: forall r.
Maybe String -> (tok -> Bool) -> BackendGen m (chunk -> r) r chunk
takeWhileP Maybe String
s tok -> Bool
f = IgnoreIndices m (chunk -> r) r chunk
-> BackendGen m (chunk -> r) r chunk
forall (m :: * -> *) r r' a.
IgnoreIndices m r r' a -> BackendGen m r r' a
MkBackend (IgnoreIndices m (chunk -> r) r chunk
 -> BackendGen m (chunk -> r) r chunk)
-> (m chunk -> IgnoreIndices m (chunk -> r) r chunk)
-> m chunk
-> BackendGen m (chunk -> r) r chunk
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m chunk -> IgnoreIndices m (chunk -> r) r chunk
forall {k} {k1} {k2} (m :: k -> *) (i :: k1) (j :: k2) (a :: k).
m a -> IgnoreIndices m i j a
Indexed.IgnoreIndices (m chunk -> BackendGen m (chunk -> r) r chunk)
-> m chunk -> BackendGen m (chunk -> r) r chunk
forall a b. (a -> b) -> a -> b
$ Maybe String -> (Token s -> Bool) -> m (Tokens s)
forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe String -> (Token s -> Bool) -> m (Tokens s)
Megaparsec.takeWhileP Maybe String
s tok -> Bool
Token s -> Bool
f
  takeWhile1P :: forall r.
Maybe String -> (tok -> Bool) -> BackendGen m (chunk -> r) r chunk
takeWhile1P Maybe String
s tok -> Bool
f = IgnoreIndices m (chunk -> r) r chunk
-> BackendGen m (chunk -> r) r chunk
forall (m :: * -> *) r r' a.
IgnoreIndices m r r' a -> BackendGen m r r' a
MkBackend (IgnoreIndices m (chunk -> r) r chunk
 -> BackendGen m (chunk -> r) r chunk)
-> (m chunk -> IgnoreIndices m (chunk -> r) r chunk)
-> m chunk
-> BackendGen m (chunk -> r) r chunk
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m chunk -> IgnoreIndices m (chunk -> r) r chunk
forall {k} {k1} {k2} (m :: k -> *) (i :: k1) (j :: k2) (a :: k).
m a -> IgnoreIndices m i j a
Indexed.IgnoreIndices (m chunk -> BackendGen m (chunk -> r) r chunk)
-> m chunk -> BackendGen m (chunk -> r) r chunk
forall a b. (a -> b) -> a -> b
$ Maybe String -> (Token s -> Bool) -> m (Tokens s)
forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe String -> (Token s -> Bool) -> m (Tokens s)
Megaparsec.takeWhile1P Maybe String
s tok -> Bool
Token s -> Bool
f
  takeP :: forall r. Maybe String -> Int -> BackendGen m (chunk -> r) r chunk
takeP Maybe String
s Int
n = IgnoreIndices m (chunk -> r) r chunk
-> BackendGen m (chunk -> r) r chunk
forall (m :: * -> *) r r' a.
IgnoreIndices m r r' a -> BackendGen m r r' a
MkBackend (IgnoreIndices m (chunk -> r) r chunk
 -> BackendGen m (chunk -> r) r chunk)
-> (m chunk -> IgnoreIndices m (chunk -> r) r chunk)
-> m chunk
-> BackendGen m (chunk -> r) r chunk
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m chunk -> IgnoreIndices m (chunk -> r) r chunk
forall {k} {k1} {k2} (m :: k -> *) (i :: k1) (j :: k2) (a :: k).
m a -> IgnoreIndices m i j a
Indexed.IgnoreIndices (m chunk -> BackendGen m (chunk -> r) r chunk)
-> m chunk -> BackendGen m (chunk -> r) r chunk
forall a b. (a -> b) -> a -> b
$ Maybe String -> Int -> m (Tokens s)
forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe String -> Int -> m (Tokens s)
Megaparsec.takeP Maybe String
s Int
n

instance (Megaparsec.MonadParsec err s m, Megaparsec.Token s ~ Char) => Breaks (BackendGen m) where
  space :: forall r. BackendGen m r r ()
space = IgnoreIndices m r r () -> BackendGen m r r ()
forall (m :: * -> *) r r' a.
IgnoreIndices m r r' a -> BackendGen m r r' a
MkBackend (IgnoreIndices m r r () -> BackendGen m r r ())
-> (m () -> IgnoreIndices m r r ()) -> m () -> BackendGen m r r ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m () -> IgnoreIndices m r r ()
forall {k} {k1} {k2} (m :: k -> *) (i :: k1) (j :: k2) (a :: k).
m a -> IgnoreIndices m i j a
Indexed.IgnoreIndices (m () -> BackendGen m r r ()) -> m () -> BackendGen m r r ()
forall a b. (a -> b) -> a -> b
$ m ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
Megaparsec.Char.space
  space1 :: forall r. BackendGen m r r ()
space1 = IgnoreIndices m r r () -> BackendGen m r r ()
forall (m :: * -> *) r r' a.
IgnoreIndices m r r' a -> BackendGen m r r' a
MkBackend (IgnoreIndices m r r () -> BackendGen m r r ())
-> (m () -> IgnoreIndices m r r ()) -> m () -> BackendGen m r r ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m () -> IgnoreIndices m r r ()
forall {k} {k1} {k2} (m :: k -> *) (i :: k1) (j :: k2) (a :: k).
m a -> IgnoreIndices m i j a
Indexed.IgnoreIndices (m () -> BackendGen m r r ()) -> m () -> BackendGen m r r ()
forall a b. (a -> b) -> a -> b
$ m ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
Megaparsec.Char.space1
  hardline :: forall r. BackendGen m r r ()
hardline = IgnoreIndices m r r () -> BackendGen m r r ()
forall (m :: * -> *) r r' a.
IgnoreIndices m r r' a -> BackendGen m r r' a
MkBackend (IgnoreIndices m r r () -> BackendGen m r r ())
-> (m () -> IgnoreIndices m r r ()) -> m () -> BackendGen m r r ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m () -> IgnoreIndices m r r ()
forall {k} {k1} {k2} (m :: k -> *) (i :: k1) (j :: k2) (a :: k).
m a -> IgnoreIndices m i j a
Indexed.IgnoreIndices (m () -> BackendGen m r r ()) -> m () -> BackendGen m r r ()
forall a b. (a -> b) -> a -> b
$ m (Token s) -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void m (Token s)
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Token s)
Megaparsec.Char.newline

deriving via (Trivial (BackendGen m)) instance (Megaparsec.MonadParsec err s m, Megaparsec.Token s ~ Char) => WadlerLeijen (BackendGen m)

deriving via (Trivial (BackendGen m)) instance Annotations ann (BackendGen m)

instance (Megaparsec.MonadParsec err s m) => LookAhead (BackendGen m) where
  lookAhead :: forall a r. BackendGen m (a -> r) r a -> BackendGen m (a -> r) r a
lookAhead (MkBackend (Indexed.IgnoreIndices m a
a)) = IgnoreIndices m (a -> r) r a -> BackendGen m (a -> r) r a
forall (m :: * -> *) r r' a.
IgnoreIndices m r r' a -> BackendGen m r r' a
MkBackend (IgnoreIndices m (a -> r) r a -> BackendGen m (a -> r) r a)
-> (m a -> IgnoreIndices m (a -> r) r a)
-> m a
-> BackendGen m (a -> r) r a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> IgnoreIndices m (a -> r) r a
forall {k} {k1} {k2} (m :: k -> *) (i :: k1) (j :: k2) (a :: k).
m a -> IgnoreIndices m i j a
Indexed.IgnoreIndices (m a -> BackendGen m (a -> r) r a)
-> m a -> BackendGen m (a -> r) r a
forall a b. (a -> b) -> a -> b
$ m a -> m a
forall a. m a -> m a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
Megaparsec.lookAhead m a
a
  notFollowedBy :: forall r a. BackendGen m r r a -> BackendGen m r r ()
notFollowedBy (MkBackend (Indexed.IgnoreIndices m a
a)) = IgnoreIndices m r r () -> BackendGen m r r ()
forall (m :: * -> *) r r' a.
IgnoreIndices m r r' a -> BackendGen m r r' a
MkBackend (IgnoreIndices m r r () -> BackendGen m r r ())
-> (m () -> IgnoreIndices m r r ()) -> m () -> BackendGen m r r ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m () -> IgnoreIndices m r r ()
forall {k} {k1} {k2} (m :: k -> *) (i :: k1) (j :: k2) (a :: k).
m a -> IgnoreIndices m i j a
Indexed.IgnoreIndices (m () -> BackendGen m r r ()) -> m () -> BackendGen m r r ()
forall a b. (a -> b) -> a -> b
$ m a -> m ()
forall a. m a -> m ()
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m ()
Megaparsec.notFollowedBy m a
a

-- | A Megaparsec-style class for format descriptors. Inheriting from
-- Megaparsec, it is somewhat parsing-oriented.
--
-- The documentation of individual methods is taken from
-- 'Megaparsec.MonadParsec'.
--
-- Note: some primitive from 'Megaparsec.MonadParsec', in particular
-- reflection/escape hatch primitives, are omitted from this class because they
-- aren't implementable for printers. If you need them, you want to act at the
-- parsec level, not the Pup level.
class (Megaparsec.Stream s, Indexed.MonadPlus m, Cont2.Stacked m, Tokens (Megaparsec.Token s) (Megaparsec.Tokens s) m, LookAhead m) => MonadParsec s m | m -> s where
  -- | The parser @'try' p@ behaves like the parser @p@, except that it
  -- backtracks the parser state when @p@ fails (either consuming input or
  -- not).
  --
  -- This combinator is used whenever arbitrary look ahead is needed. Since
  -- it pretends that it hasn't consumed any input when @p@ fails, the
  -- ('A.<|>') combinator will try its second alternative even if the first
  -- parser failed while consuming input.
  --
  -- For example, here is a parser that is supposed to parse the word “let”
  -- or the word “lexical”:
  --
  -- >>> parseTest (string "let" <|> string "lexical") "lexical"
  -- 1:1:
  -- unexpected "lex"
  -- expecting "let"
  --
  -- What happens here? The first parser consumes “le” and fails (because it
  -- doesn't see a “t”). The second parser, however, isn't tried, since the
  -- first parser has already consumed some input! 'try' fixes this behavior
  -- and allows backtracking to work:
  --
  -- >>> parseTest (try (string "let") <|> string "lexical") "lexical"
  -- "lexical"
  --
  -- 'try' also improves error messages in case of overlapping alternatives,
  -- because Megaparsec's hint system can be used:
  --
  -- >>> parseTest (try (string "let") <|> string "lexical") "le"
  -- 1:1:
  -- unexpected "le"
  -- expecting "let" or "lexical"
  --
  -- __Note__ that as of Megaparsec 4.4.0, 'Text.Megaparsec.Char.string'
  -- backtracks automatically (see 'tokens'), so it does not need 'try'.
  -- However, the examples above demonstrate the idea behind 'try' so well
  -- that it was decided to keep them. You still need to use 'try' when your
  -- alternatives are complex, composite parsers.
  try :: m r r' a -> m r r' a

  -- | The parser @'token' test expected@ accepts tokens for which the
  -- matching function @test@ returns 'Just' results. If 'Nothing' is
  -- returned the @expected@ set is used to report the items that were
  -- expected.
  --
  -- For example, the 'Text.Megaparsec.satisfy' parser is implemented as:
  --
  -- > satisfy f = token testToken Set.empty
  -- >   where
  -- >     testToken x = if f x then Just x else Nothing
  token ::
    -- | Matching function for the token to parse
    (Megaparsec.Token s -> Maybe a) ->
    -- | Used in the error message to mention the items that were expected
    Set (Megaparsec.ErrorItem (Megaparsec.Token s)) ->
    -- | Printing function for the token
    (a -> Megaparsec.Token s) ->
    m (a -> r) r a

---------------------------------------------------------------------------
--
-- Building a MonadParsec
--
---------------------------------------------------------------------------

instance (Megaparsec.MonadParsec e s m) => ParseErrors (Megaparsec.ParseError s e) (BackendGen m) where
  parseError :: forall r r' a. ParseError s e -> BackendGen m r r' a
parseError = IgnoreIndices m r r' a -> BackendGen m r r' a
forall (m :: * -> *) r r' a.
IgnoreIndices m r r' a -> BackendGen m r r' a
MkBackend (IgnoreIndices m r r' a -> BackendGen m r r' a)
-> (ParseError s e -> IgnoreIndices m r r' a)
-> ParseError s e
-> BackendGen m r r' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> IgnoreIndices m r r' a
forall {k} {k1} {k2} (m :: k -> *) (i :: k1) (j :: k2) (a :: k).
m a -> IgnoreIndices m i j a
Indexed.IgnoreIndices (m a -> IgnoreIndices m r r' a)
-> (ParseError s e -> m a)
-> ParseError s e
-> IgnoreIndices m r r' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParseError s e -> m a
forall a. ParseError s e -> m a
forall e s (m :: * -> *) a.
MonadParsec e s m =>
ParseError s e -> m a
Megaparsec.parseError
  withRecovery :: forall r r' a.
(ParseError s e -> BackendGen m r r' a)
-> BackendGen m r r' a -> BackendGen m r r' a
withRecovery ParseError s e -> BackendGen m r r' a
f (MkBackend (Indexed.IgnoreIndices m a
a)) = IgnoreIndices m r r' a -> BackendGen m r r' a
forall (m :: * -> *) r r' a.
IgnoreIndices m r r' a -> BackendGen m r r' a
MkBackend (IgnoreIndices m r r' a -> BackendGen m r r' a)
-> (m a -> IgnoreIndices m r r' a) -> m a -> BackendGen m r r' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> IgnoreIndices m r r' a
forall {k} {k1} {k2} (m :: k -> *) (i :: k1) (j :: k2) (a :: k).
m a -> IgnoreIndices m i j a
Indexed.IgnoreIndices (m a -> BackendGen m r r' a) -> m a -> BackendGen m r r' a
forall a b. (a -> b) -> a -> b
$ (ParseError s e -> m a) -> m a -> m a
forall a. (ParseError s e -> m a) -> m a -> m a
forall e s (m :: * -> *) a.
MonadParsec e s m =>
(ParseError s e -> m a) -> m a -> m a
Megaparsec.withRecovery (IgnoreIndices m r r' a -> m a
forall {k1} {k2} {k3} (m :: k1 -> *) (i :: k2) (j :: k3) (a :: k1).
IgnoreIndices m i j a -> m a
Indexed.unIgnoreIndices (IgnoreIndices m r r' a -> m a)
-> (ParseError s e -> IgnoreIndices m r r' a)
-> ParseError s e
-> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\(MkBackend IgnoreIndices m r r' a
p) -> IgnoreIndices m r r' a
p) (BackendGen m r r' a -> IgnoreIndices m r r' a)
-> (ParseError s e -> BackendGen m r r' a)
-> ParseError s e
-> IgnoreIndices m r r' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParseError s e -> BackendGen m r r' a
f) m a
a
  observing :: forall b r a.
BackendGen m (b -> r) r a
-> BackendGen
     m (Either (ParseError s e) b -> r) r (Either (ParseError s e) a)
observing (MkBackend (Indexed.IgnoreIndices m a
a)) = IgnoreIndices
  m (Either (ParseError s e) b -> r) r (Either (ParseError s e) a)
-> BackendGen
     m (Either (ParseError s e) b -> r) r (Either (ParseError s e) a)
forall (m :: * -> *) r r' a.
IgnoreIndices m r r' a -> BackendGen m r r' a
MkBackend (IgnoreIndices
   m (Either (ParseError s e) b -> r) r (Either (ParseError s e) a)
 -> BackendGen
      m (Either (ParseError s e) b -> r) r (Either (ParseError s e) a))
-> (m (Either (ParseError s e) a)
    -> IgnoreIndices
         m (Either (ParseError s e) b -> r) r (Either (ParseError s e) a))
-> m (Either (ParseError s e) a)
-> BackendGen
     m (Either (ParseError s e) b -> r) r (Either (ParseError s e) a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m (Either (ParseError s e) a)
-> IgnoreIndices
     m (Either (ParseError s e) b -> r) r (Either (ParseError s e) a)
forall {k} {k1} {k2} (m :: k -> *) (i :: k1) (j :: k2) (a :: k).
m a -> IgnoreIndices m i j a
Indexed.IgnoreIndices (m (Either (ParseError s e) a)
 -> BackendGen
      m (Either (ParseError s e) b -> r) r (Either (ParseError s e) a))
-> m (Either (ParseError s e) a)
-> BackendGen
     m (Either (ParseError s e) b -> r) r (Either (ParseError s e) a)
forall a b. (a -> b) -> a -> b
$ m a -> m (Either (ParseError s e) a)
forall a. m a -> m (Either (ParseError s e) a)
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> m (Either (ParseError s e) a)
Megaparsec.observing (m a -> m a
forall a. m a -> m a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
Megaparsec.try m a
a)

instance (Megaparsec.MonadParsec e s m, Megaparsec.Stream s) => MonadParsec s (BackendGen m) where
  try :: forall r r' a. BackendGen m r r' a -> BackendGen m r r' a
try (MkBackend (Indexed.IgnoreIndices m a
a)) = IgnoreIndices m r r' a -> BackendGen m r r' a
forall (m :: * -> *) r r' a.
IgnoreIndices m r r' a -> BackendGen m r r' a
MkBackend (IgnoreIndices m r r' a -> BackendGen m r r' a)
-> (m a -> IgnoreIndices m r r' a) -> m a -> BackendGen m r r' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> IgnoreIndices m r r' a
forall {k} {k1} {k2} (m :: k -> *) (i :: k1) (j :: k2) (a :: k).
m a -> IgnoreIndices m i j a
Indexed.IgnoreIndices (m a -> BackendGen m r r' a) -> m a -> BackendGen m r r' a
forall a b. (a -> b) -> a -> b
$ m a -> m a
forall a. m a -> m a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
Megaparsec.try m a
a
  token :: forall a r.
(Token s -> Maybe a)
-> Set (ErrorItem (Token s))
-> (a -> Token s)
-> BackendGen m (a -> r) r a
token Token s -> Maybe a
p Set (ErrorItem (Token s))
s a -> Token s
_pr = IgnoreIndices m (a -> r) r a -> BackendGen m (a -> r) r a
forall (m :: * -> *) r r' a.
IgnoreIndices m r r' a -> BackendGen m r r' a
MkBackend (IgnoreIndices m (a -> r) r a -> BackendGen m (a -> r) r a)
-> (m a -> IgnoreIndices m (a -> r) r a)
-> m a
-> BackendGen m (a -> r) r a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> IgnoreIndices m (a -> r) r a
forall {k} {k1} {k2} (m :: k -> *) (i :: k1) (j :: k2) (a :: k).
m a -> IgnoreIndices m i j a
Indexed.IgnoreIndices (m a -> BackendGen m (a -> r) r a)
-> m a -> BackendGen m (a -> r) r a
forall a b. (a -> b) -> a -> b
$ (Token s -> Maybe a) -> Set (ErrorItem (Token s)) -> m a
forall a. (Token s -> Maybe a) -> Set (ErrorItem (Token s)) -> m a
forall e s (m :: * -> *) a.
MonadParsec e s m =>
(Token s -> Maybe a) -> Set (ErrorItem (Token s)) -> m a
Megaparsec.token Token s -> Maybe a
p Set (ErrorItem (Token s))
s

instance (MonadParsec s m1, MonadParsec s m2) => MonadParsec s (m1 Indexed.:*: m2) where
  try :: forall r r' a. (:*:) m1 m2 r r' a -> (:*:) m1 m2 r r' a
try (m1 r r' a
a Indexed.:*: m2 r r' a
b) = m1 r r' a -> m1 r r' a
forall r r' a. m1 r r' a -> m1 r r' a
forall s (m :: * -> * -> * -> *) r r' a.
MonadParsec s m =>
m r r' a -> m r r' a
try m1 r r' a
a m1 r r' a -> m2 r r' a -> (:*:) m1 m2 r r' a
forall {k} {k1} {k2} (f :: k -> k1 -> k2 -> *)
       (g :: k -> k1 -> k2 -> *) (i :: k) (j :: k1) (a :: k2).
f i j a -> g i j a -> (:*:) f g i j a
Indexed.:*: m2 r r' a -> m2 r r' a
forall r r' a. m2 r r' a -> m2 r r' a
forall s (m :: * -> * -> * -> *) r r' a.
MonadParsec s m =>
m r r' a -> m r r' a
try m2 r r' a
b
  token :: forall a r.
(Token s -> Maybe a)
-> Set (ErrorItem (Token s))
-> (a -> Token s)
-> (:*:) m1 m2 (a -> r) r a
token Token s -> Maybe a
p Set (ErrorItem (Token s))
s a -> Token s
pr = (Token s -> Maybe a)
-> Set (ErrorItem (Token s)) -> (a -> Token s) -> m1 (a -> r) r a
forall a r.
(Token s -> Maybe a)
-> Set (ErrorItem (Token s)) -> (a -> Token s) -> m1 (a -> r) r a
forall s (m :: * -> * -> * -> *) a r.
MonadParsec s m =>
(Token s -> Maybe a)
-> Set (ErrorItem (Token s)) -> (a -> Token s) -> m (a -> r) r a
token Token s -> Maybe a
p Set (ErrorItem (Token s))
s a -> Token s
pr m1 (a -> r) r a -> m2 (a -> r) r a -> (:*:) m1 m2 (a -> r) r a
forall {k} {k1} {k2} (f :: k -> k1 -> k2 -> *)
       (g :: k -> k1 -> k2 -> *) (i :: k) (j :: k1) (a :: k2).
f i j a -> g i j a -> (:*:) f g i j a
Indexed.:*: (Token s -> Maybe a)
-> Set (ErrorItem (Token s)) -> (a -> Token s) -> m2 (a -> r) r a
forall a r.
(Token s -> Maybe a)
-> Set (ErrorItem (Token s)) -> (a -> Token s) -> m2 (a -> r) r a
forall s (m :: * -> * -> * -> *) a r.
MonadParsec s m =>
(Token s -> Maybe a)
-> Set (ErrorItem (Token s)) -> (a -> Token s) -> m (a -> r) r a
token Token s -> Maybe a
p Set (ErrorItem (Token s))
s a -> Token s
pr