{-# LANGUAGE FlexibleContexts, FlexibleInstances, GeneralizedNewtypeDeriving, InstanceSigs,
             RankNTypes, ScopedTypeVariables, StandaloneDeriving, TypeFamilies, TypeOperators, UndecidableInstances #-}
{-# OPTIONS -fno-full-laziness #-}
module Text.Grampa.ContextFree.LeftRecursive (Fixed, Parser, SeparatedParser(..),
                                              longest, peg, terminalPEG,
                                              parseSeparated, separated, (<<|>))
where

import Control.Applicative
import Control.Monad (Monad(..), MonadPlus(..))
import Control.Monad.Trans.State.Lazy (State, evalState, get, put)

import Data.Functor.Compose (Compose(..))
import Data.List.NonEmpty (NonEmpty((:|)))
import Data.Maybe (isJust)

import Data.Semigroup (Semigroup(..))
import Data.Monoid (Monoid(mempty), All(..), Any(..))
import Data.Monoid.Null (MonoidNull(null))
import Data.Monoid.Factorial (FactorialMonoid)
import Data.Monoid.Textual (TextualMonoid)
import qualified Data.Monoid.Factorial as Factorial
import qualified Data.Monoid.Textual as Textual
import Data.String (fromString)

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 as Token

import qualified Rank2
import Text.Grampa.Class (GrammarParsing(..), MonoidParsing(..), MultiParsing(..), AmbiguousParsing(..),
                          Lexical(..), Ambiguous(..), ParseResults)
import Text.Grampa.Internal (ResultList(..), ResultsOfLength(..), fromResultList)
import qualified Text.Grampa.ContextFree.SortedMemoizing as Memoizing
import qualified Text.Grampa.PEG.Backtrack.Measured as Backtrack

import Prelude hiding (cycle, null, span, takeWhile)

type Parser = Fixed Memoizing.Parser

type ResultAppend g s = ResultList g s Rank2.~> ResultList g s Rank2.~> ResultList g s

data Fixed p g s a =
   Parser {
      Fixed p g s a -> p g s a
complete, Fixed p g s a -> p g s a
direct, Fixed p g s a -> p g s a
direct0, Fixed p g s a -> p g s a
direct1, Fixed p g s a -> p g s a
indirect :: p g s a,
      Fixed p g s a
-> ResultList g s a -> ResultList g s a -> ResultList g s a
appendResults :: ResultList g s a -> ResultList g s a -> ResultList g s a,
      Fixed p g s a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants :: Rank2.Apply g => g (Const (ParserFlags g)) -> ParserFlags g}
   | DirectParser {
      complete, direct0, direct1 :: p g s a}
   | PositiveDirectParser {
      complete :: p g s a}

data SeparatedParser p g s a = FrontParser (p g s a)
                             | CycleParser {
                                  SeparatedParser p g s a -> p g s a
cycleParser  :: p g s a,
                                  SeparatedParser p g s a -> p g s a
backParser   :: p g s a,
                                  SeparatedParser p g s a -> ResultAppend g s a
appendResultsArrow :: ResultAppend g s a,
                                  SeparatedParser p g s a -> g (Const Bool)
dependencies :: g (Const Bool)}
                             | BackParser {
                                  backParser :: p g s a}

data ParserFlags g = ParserFlags {
   ParserFlags g -> Bool
nullable :: Bool,
   ParserFlags g -> g (Const Bool)
dependsOn :: g (Const Bool)}

deriving instance Show (g (Const Bool)) => Show (ParserFlags g)

data ParserFunctor g s a = ParserResultsFunctor {ParserFunctor g s a -> ResultList g s a
parserResults :: ResultList g s a}
                         | ParserFlagsFunctor {ParserFunctor g s a -> ParserFlags g
parserFlags :: ParserFlags g}

newtype Union (g :: (* -> *) -> *) = Union{Union g -> g (Const Bool)
getUnion :: g (Const Bool)}

--instance Rank2.Applicative g => Monoid (Union g) where
--   mempty = Union (Rank2.pure $ Const False)

instance (Rank2.Apply g, Rank2.Distributive g) => Semigroup (Union g) where
   Union g1 :: g (Const Bool)
g1 <> :: Union g -> Union g -> Union g
<> Union g2 :: g (Const Bool)
g2 = g (Const Bool) -> Union g
forall (g :: (* -> *) -> *). g (Const Bool) -> Union g
Union ((forall a. Const Bool a -> Const Bool a -> Const Bool a)
-> g (Const Bool) -> g (Const Bool) -> g (Const Bool)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
       (r :: k -> *).
Apply g =>
(forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
Rank2.liftA2 forall a. Const Bool a -> Const Bool a -> Const Bool a
union g (Const Bool)
g1 g (Const Bool)
g2)

instance (Rank2.Apply g, Rank2.Distributive g) => Monoid (Union g) where
   mempty :: Union g
mempty = g (Const Bool) -> Union g
forall (g :: (* -> *) -> *). g (Const Bool) -> Union g
Union ((forall a. Const Bool (Any a) -> Const Bool a)
-> Const Bool (g Any) -> g (Const Bool)
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 (Bool -> Const Bool a
forall k a (b :: k). a -> Const a b
Const (Bool -> Const Bool a)
-> (Const Bool (Any a) -> Bool)
-> Const Bool (Any a)
-> Const Bool a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Const Bool (Any a) -> Bool
forall a k (b :: k). Const a b -> a
getConst) (Bool -> Const Bool (g Any)
forall k a (b :: k). a -> Const a b
Const Bool
False))
   mappend :: Union g -> Union g -> Union g
mappend (Union g1 :: g (Const Bool)
g1) (Union g2 :: g (Const Bool)
g2) = g (Const Bool) -> Union g
forall (g :: (* -> *) -> *). g (Const Bool) -> Union g
Union ((forall a. Const Bool a -> Const Bool a -> Const Bool a)
-> g (Const Bool) -> g (Const Bool) -> g (Const Bool)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
       (r :: k -> *).
Apply g =>
(forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
Rank2.liftA2 forall a. Const Bool a -> Const Bool a -> Const Bool a
union g (Const Bool)
g1 g (Const Bool)
g2)

general, general' :: Alternative (p g s) => Fixed p g s a -> Fixed p g s a

general :: Fixed p g s a -> Fixed p g s a
general p :: Fixed p g s a
p = Parser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a
-> p g s a
-> p g s a
-> p g s a
-> p g s a
-> (ResultList g s a -> ResultList g s a -> ResultList g s a)
-> (Apply g => g (Const (ParserFlags g)) -> ParserFlags g)
-> Fixed p g s a
Parser{
   complete :: p g s a
complete= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p,
   direct :: p g s a
direct = Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct Fixed p g s a
p',
   direct0 :: p g s a
direct0= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s a
p',
   direct1 :: p g s a
direct1= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed p g s a
p',
   indirect :: p g s a
indirect= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
indirect Fixed p g s a
p',
   appendResults :: ResultList g s a -> ResultList g s a -> ResultList g s a
appendResults= Fixed p g s a
-> ResultList g s a -> ResultList g s a -> ResultList g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a
-> ResultList g s a -> ResultList g s a -> ResultList g s a
appendResults Fixed p g s a
p',
   cyclicDescendants :: Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants= Fixed p g s a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants Fixed p g s a
p'}
   where p' :: Fixed p g s a
p' = Fixed p g s a -> Fixed p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Alternative (p g s) =>
Fixed p g s a -> Fixed p g s a
general' Fixed p g s a
p

general' :: Fixed p g s a -> Fixed p g s a
general' p :: Fixed p g s a
p@PositiveDirectParser{} = Parser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a
-> p g s a
-> p g s a
-> p g s a
-> p g s a
-> (ResultList g s a -> ResultList g s a -> ResultList g s a)
-> (Apply g => g (Const (ParserFlags g)) -> ParserFlags g)
-> Fixed p g s a
Parser{
   complete :: p g s a
complete= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p,
   direct :: p g s a
direct = Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p,
   direct0 :: p g s a
direct0= p g s a
forall (f :: * -> *) a. Alternative f => f a
empty,
   direct1 :: p g s a
direct1= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p,
   indirect :: p g s a
indirect= p g s a
forall (f :: * -> *) a. Alternative f => f a
empty,
   appendResults :: ResultList g s a -> ResultList g s a -> ResultList g s a
appendResults= ResultList g s a -> ResultList g s a -> ResultList g s a
forall a. Semigroup a => a -> a -> a
(<>),
   cyclicDescendants :: Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants= \cd :: g (Const (ParserFlags g))
cd-> Bool -> g (Const Bool) -> ParserFlags g
forall (g :: (* -> *) -> *).
Bool -> g (Const Bool) -> ParserFlags g
ParserFlags Bool
False (Const Bool a -> Const (ParserFlags g) a -> Const Bool a
forall a b. a -> b -> a
const (Bool -> Const Bool a
forall k a (b :: k). a -> Const a b
Const Bool
False) (forall a. Const (ParserFlags g) a -> Const Bool a)
-> g (Const (ParserFlags g)) -> g (Const Bool)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Functor g =>
(forall (a :: k). p a -> q a) -> g p -> g q
Rank2.<$> g (Const (ParserFlags g))
cd)}
general' p :: Fixed p g s a
p@DirectParser{} = Parser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a
-> p g s a
-> p g s a
-> p g s a
-> p g s a
-> (ResultList g s a -> ResultList g s a -> ResultList g s a)
-> (Apply g => g (Const (ParserFlags g)) -> ParserFlags g)
-> Fixed p g s a
Parser{
   complete :: p g s a
complete= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p,
   direct :: p g s a
direct = Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p,
   direct0 :: p g s a
direct0= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s a
p,
   direct1 :: p g s a
direct1= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed p g s a
p,
   indirect :: p g s a
indirect= p g s a
forall (f :: * -> *) a. Alternative f => f a
empty,
   appendResults :: ResultList g s a -> ResultList g s a -> ResultList g s a
appendResults= ResultList g s a -> ResultList g s a -> ResultList g s a
forall a. Semigroup a => a -> a -> a
(<>),
   cyclicDescendants :: Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants= \cd :: g (Const (ParserFlags g))
cd-> Bool -> g (Const Bool) -> ParserFlags g
forall (g :: (* -> *) -> *).
Bool -> g (Const Bool) -> ParserFlags g
ParserFlags Bool
True (Const Bool a -> Const (ParserFlags g) a -> Const Bool a
forall a b. a -> b -> a
const (Bool -> Const Bool a
forall k a (b :: k). a -> Const a b
Const Bool
False) (forall a. Const (ParserFlags g) a -> Const Bool a)
-> g (Const (ParserFlags g)) -> g (Const Bool)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Functor g =>
(forall (a :: k). p a -> q a) -> g p -> g q
Rank2.<$> g (Const (ParserFlags g))
cd)}
general' p :: Fixed p g s a
p@Parser{} = Fixed p g s a
p

-- | Parser of general context-free grammars, including left recursion.
--
-- @
-- 'parseComplete' :: ("Rank2".'Rank2.Apply' g, "Rank2".'Rank2.Traversable' g, 'FactorialMonoid' s) =>
--                  g (LeftRecursive.'Fixed g s) -> s -> g ('Compose' 'ParseResults' [])
-- @
instance MultiParsing (Fixed Memoizing.Parser) where
   type GrammarConstraint (Fixed Memoizing.Parser) g = (Rank2.Apply g, Rank2.Distributive g, Rank2.Traversable g)
   type ResultFunctor (Fixed Memoizing.Parser) = Compose ParseResults []
   parsePrefix :: (Rank2.Apply g, Rank2.Distributive g, Rank2.Traversable g, FactorialMonoid s) =>
                  g (Parser g s) -> s -> g (Compose (Compose ParseResults []) ((,) s))
   parsePrefix :: g (Parser g s)
-> s -> g (Compose (Compose ParseResults []) ((,) s))
parsePrefix g :: g (Parser g s)
g input :: s
input = (forall a.
 ResultList g s a -> Compose (Compose ParseResults []) ((,) s) a)
-> g (ResultList g s)
-> g (Compose (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 (Compose ParseResults [] (s, a)
-> Compose (Compose ParseResults []) ((,) s) a
forall k k1 (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose (Compose ParseResults [] (s, a)
 -> Compose (Compose ParseResults []) ((,) s) a)
-> (ResultList g s a -> Compose ParseResults [] (s, a))
-> ResultList g s a
-> Compose (Compose ParseResults []) ((,) s) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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))
-> (ResultList g s a -> Either ParseFailure [(s, a)])
-> ResultList g s a
-> Compose ParseResults [] (s, a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> ResultList g s a -> Either ParseFailure [(s, a)]
forall s (g :: (* -> *) -> *) r.
FactorialMonoid s =>
s -> ResultList g s r -> ParseResults [(s, r)]
fromResultList s
input)
                                    ((s, g (ResultList g s)) -> g (ResultList g s)
forall a b. (a, b) -> b
snd ((s, g (ResultList g s)) -> g (ResultList g s))
-> (s, g (ResultList g s)) -> g (ResultList g s)
forall a b. (a -> b) -> a -> b
$ [(s, g (ResultList g s))] -> (s, g (ResultList g s))
forall a. [a] -> a
head ([(s, g (ResultList g s))] -> (s, g (ResultList g s)))
-> [(s, g (ResultList g s))] -> (s, g (ResultList g s))
forall a b. (a -> b) -> a -> b
$ g (Parser g s) -> s -> [(s, g (ResultList g s))]
forall (g :: (* -> *) -> *) s.
(Apply g, Distributive g, Traversable g, FactorialMonoid s) =>
g (Parser g s) -> s -> [(s, g (ResultList g s))]
parseRecursive g (Parser g s)
g s
input)
   {-# INLINE parsePrefix #-}
   parseComplete :: (FactorialMonoid s, Rank2.Apply g, Rank2.Distributive g, Rank2.Traversable g) =>
                    g (Parser g s) -> s -> g (Compose ParseResults [])
   parseComplete :: g (Parser g s) -> s -> g (Compose ParseResults [])
parseComplete g :: g (Parser g s)
g = \input :: s
input-> let close :: g (Parser g s)
close = (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)
forall (m :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *)
       s.
(GrammarParsing m, GrammarConstraint m g, Distributive g) =>
g (m g s)
selfReferring
                              in (forall a. ResultList g s a -> Compose ParseResults [] a)
-> g (ResultList g s) -> g (Compose ParseResults [])
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Functor g =>
(forall (a :: k). p a -> q a) -> g p -> g q
Rank2.fmap (((s, a) -> a
forall a b. (a, b) -> b
snd ((s, a) -> a)
-> Compose ParseResults [] (s, a) -> Compose ParseResults [] a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>) (Compose ParseResults [] (s, a) -> Compose ParseResults [] a)
-> (ResultList g s a -> Compose ParseResults [] (s, a))
-> ResultList g s a
-> Compose ParseResults [] a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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))
-> (ResultList g s a -> Either ParseFailure [(s, a)])
-> ResultList g s a
-> Compose ParseResults [] (s, a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> ResultList g s a -> Either ParseFailure [(s, a)]
forall s (g :: (* -> *) -> *) r.
FactorialMonoid s =>
s -> ResultList g s r -> ParseResults [(s, r)]
fromResultList s
input)
                                            ((s, g (ResultList g s)) -> g (ResultList g s)
forall a b. (a, b) -> b
snd ((s, g (ResultList g s)) -> g (ResultList g s))
-> (s, g (ResultList g s)) -> g (ResultList g s)
forall a b. (a -> b) -> a -> b
$ [(s, g (ResultList g s))] -> (s, g (ResultList g s))
forall a. [a] -> a
head ([(s, g (ResultList g s))] -> (s, g (ResultList g s)))
-> [(s, g (ResultList g s))] -> (s, g (ResultList g s))
forall a b. (a -> b) -> a -> b
$ g (Parser g s)
-> [(s, g (ResultList g s))] -> [(s, g (ResultList g s))]
forall (g :: (* -> *) -> *) s.
Functor g =>
g (Parser g s)
-> [(s, g (ResultList g s))] -> [(s, g (ResultList g s))]
Memoizing.reparseTails g (Parser g s)
close ([(s, g (ResultList g s))] -> [(s, g (ResultList g s))])
-> [(s, g (ResultList g s))] -> [(s, g (ResultList g s))]
forall a b. (a -> b) -> a -> b
$ g (SeparatedParser Parser g s) -> s -> [(s, g (ResultList g s))]
forall (g :: (* -> *) -> *) s.
(Apply g, Foldable g, FactorialMonoid s) =>
g (SeparatedParser Parser g s) -> s -> [(s, g (ResultList g s))]
parseSeparated g (SeparatedParser Parser g s)
g' s
input)
      where g' :: g (SeparatedParser Parser g s)
g' = g (Parser g s) -> g (SeparatedParser Parser g s)
forall (g :: (* -> *) -> *) s.
(Apply g, Distributive g, Traversable g) =>
g (Parser g s) -> g (SeparatedParser Parser g s)
separated g (Parser g s)
g
   {-# INLINE parseComplete #-}

instance GrammarParsing (Fixed Memoizing.Parser) where
   type GrammarFunctor (Fixed Memoizing.Parser) = ParserFunctor
   nonTerminal :: forall g s a. (Rank2.Apply g, Rank2.Distributive g, Rank2.Traversable g)
                  => (g (ParserFunctor g s) -> ParserFunctor g s a) -> Parser g s a
   nonTerminal :: (g (ParserFunctor g s) -> ParserFunctor g s a) -> Parser g s a
nonTerminal f :: g (ParserFunctor g s) -> ParserFunctor g s a
f = Parser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a
-> p g s a
-> p g s a
-> p g s a
-> p g s a
-> (ResultList g s a -> ResultList g s a -> ResultList g s a)
-> (Apply g => g (Const (ParserFlags g)) -> ParserFlags g)
-> Fixed p g s a
Parser{
      complete :: Parser g s a
complete= Parser g s a
ind,
      direct :: Parser g s a
direct= Parser g s a
forall (f :: * -> *) a. Alternative f => f a
empty,
      direct0 :: Parser g s a
direct0= Parser g s a
forall (f :: * -> *) a. Alternative f => f a
empty,
      direct1 :: Parser g s a
direct1= Parser g s a
forall (f :: * -> *) a. Alternative f => f a
empty,
      indirect :: Parser g s a
indirect= Parser g s a
ind,
      appendResults :: ResultList g s a -> ResultList g s a -> ResultList g s a
appendResults= ResultList g s a -> ResultList g s a -> ResultList g s a
forall a. Semigroup a => a -> a -> a
(<>),
      cyclicDescendants :: Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants= ParserFunctor g s a -> ParserFlags g
forall (g :: (* -> *) -> *) s a.
ParserFunctor g s a -> ParserFlags g
parserFlags (ParserFunctor g s a -> ParserFlags g)
-> (g (Const (ParserFlags g)) -> ParserFunctor g s a)
-> g (Const (ParserFlags g))
-> ParserFlags g
forall b c a. (b -> c) -> (a -> b) -> a -> c
. g (ParserFunctor g s) -> ParserFunctor g s a
f (g (ParserFunctor g s) -> ParserFunctor g s a)
-> (g (Const (ParserFlags g)) -> g (ParserFunctor g s))
-> g (Const (ParserFlags g))
-> ParserFunctor g s a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. Const (ParserFlags g) a -> ParserFunctor g s a)
-> g (Const (ParserFlags g)) -> g (ParserFunctor 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 (ParserFlags g -> ParserFunctor g s a
forall (g :: (* -> *) -> *) s a.
ParserFlags g -> ParserFunctor g s a
ParserFlagsFunctor (ParserFlags g -> ParserFunctor g s a)
-> (Const (ParserFlags g) a -> ParserFlags g)
-> Const (ParserFlags g) a
-> ParserFunctor g s a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Const (ParserFlags g) a -> ParserFlags g
forall a k (b :: k). Const a b -> a
getConst) (g (Const (ParserFlags g)) -> g (ParserFunctor g s))
-> (g (Const (ParserFlags g)) -> g (Const (ParserFlags g)))
-> g (Const (ParserFlags g))
-> g (ParserFunctor g s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. g (Const (ParserFlags g)) -> g (Const (ParserFlags g))
addSelf}
      where ind :: Parser g s a
ind = (g (GrammarFunctor Parser g s) -> GrammarFunctor Parser g s a)
-> Parser g s a
forall (m :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
(GrammarParsing m, GrammarConstraint m g) =>
(g (GrammarFunctor m g s) -> GrammarFunctor m g s a) -> m g s a
nonTerminal (ParserFunctor g s a -> ResultList g s a
forall (g :: (* -> *) -> *) s a.
ParserFunctor g s a -> ResultList g s a
parserResults (ParserFunctor g s a -> ResultList g s a)
-> (g (ResultList g s) -> ParserFunctor g s a)
-> g (ResultList g s)
-> ResultList g s a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. g (ParserFunctor g s) -> ParserFunctor g s a
f (g (ParserFunctor g s) -> ParserFunctor g s a)
-> (g (ResultList g s) -> g (ParserFunctor g s))
-> g (ResultList g s)
-> ParserFunctor g s a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. ResultList g s a -> ParserFunctor g s a)
-> g (ResultList g s) -> g (ParserFunctor 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 forall a. ResultList g s a -> ParserFunctor g s a
forall (g :: (* -> *) -> *) s a.
ResultList g s a -> ParserFunctor g s a
ParserResultsFunctor)
            addSelf :: g (Const (ParserFlags g)) -> g (Const (ParserFlags g))
addSelf g :: g (Const (ParserFlags g))
g = (forall a.
 Const (g (Const Bool)) a
 -> Const (ParserFlags g) a -> Const (ParserFlags g) a)
-> g (Const (g (Const Bool)))
-> g (Const (ParserFlags g))
-> g (Const (ParserFlags g))
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
       (r :: k -> *).
Apply g =>
(forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
Rank2.liftA2 forall a.
Const (g (Const Bool)) a
-> Const (ParserFlags g) a -> Const (ParserFlags g) a
adjust g (Const (g (Const Bool)))
forall (g :: (* -> *) -> *).
(Distributive g, Traversable g) =>
g (Const (g (Const Bool)))
bits g (Const (ParserFlags g))
g
            adjust :: forall b. Const (g (Const Bool)) b -> Const (ParserFlags g) b -> Const (ParserFlags g) b
            adjust :: Const (g (Const Bool)) b
-> Const (ParserFlags g) b -> Const (ParserFlags g) b
adjust (Const bit :: g (Const Bool)
bit) (Const (ParserFlags n :: Bool
n d :: g (Const Bool)
d)) =
               ParserFlags g -> Const (ParserFlags g) b
forall k a (b :: k). a -> Const a b
Const ParserFlags :: forall (g :: (* -> *) -> *).
Bool -> g (Const Bool) -> ParserFlags g
ParserFlags{
                  nullable :: Bool
nullable= Bool
n, 
                  dependsOn :: g (Const Bool)
dependsOn= (forall a. Const Bool a -> Const Bool a -> Const Bool a)
-> g (Const Bool) -> g (Const Bool) -> g (Const Bool)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
       (r :: k -> *).
Apply g =>
(forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
Rank2.liftA2 forall a. Const Bool a -> Const Bool a -> Const Bool a
union g (Const Bool)
bit g (Const Bool)
d}
   {-# INLINE nonTerminal #-}
   recursive :: Fixed Parser g s a -> Fixed Parser g s a
recursive = Fixed Parser g s a -> Fixed Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Alternative (p g s) =>
Fixed p g s a -> Fixed p g s a
general

bits :: forall (g :: (* -> *) -> *). (Rank2.Distributive g, Rank2.Traversable g) => g (Const (g (Const Bool)))
bits :: g (Const (g (Const Bool)))
bits = g (Const Int)
start g (Const Int)
-> g (Const (g (Const Bool))) -> g (Const (g (Const Bool)))
forall a b. a -> b -> b
`seq` (forall a. Const Int a -> Const (g (Const Bool)) a)
-> g (Const Int) -> g (Const (g (Const Bool)))
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Functor g =>
(forall (a :: k). p a -> q a) -> g p -> g q
Rank2.fmap forall a. Const Int a -> Const (g (Const Bool)) a
oneBit g (Const Int)
start
   where start :: g (Const Int)
start = State Int (g (Const Int)) -> Int -> g (Const Int)
forall s a. State s a -> s -> a
evalState ((forall a. Maybe a -> StateT Int Identity (Const Int a))
-> g Maybe -> State Int (g (Const Int))
forall k (g :: (k -> *) -> *) (m :: * -> *) (p :: k -> *)
       (q :: k -> *).
(Traversable g, Applicative m) =>
(forall (a :: k). p a -> m (q a)) -> g p -> m (g q)
Rank2.traverse forall a. Maybe a -> StateT Int Identity (Const Int a)
forall (f :: * -> *) a. f a -> State Int (Const Int a)
next (Maybe (g Maybe) -> g Maybe
forall (g :: (* -> *) -> *) (f :: * -> *).
(Distributive g, Monad f) =>
f (g f) -> g f
Rank2.distributeJoin Maybe (g Maybe)
forall a. Maybe a
Nothing)) 0
         oneBit :: Const Int a -> Const (g (Const Bool)) a
         next :: f a -> State Int (Const Int a)
         oneBit :: Const Int a -> Const (g (Const Bool)) a
oneBit (Const i :: Int
i) = g (Const Bool) -> Const (g (Const Bool)) a
forall k a (b :: k). a -> Const a b
Const ((forall a. Const Int a -> Const Bool a)
-> g (Const Int) -> g (Const Bool)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Functor g =>
(forall (a :: k). p a -> q a) -> g p -> g q
Rank2.fmap (Bool -> Const Bool a
forall k a (b :: k). a -> Const a b
Const (Bool -> Const Bool a)
-> (Const Int a -> Bool) -> Const Int a -> Const Bool a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
==) (Int -> Bool) -> (Const Int a -> Int) -> Const Int a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Const Int a -> Int
forall a k (b :: k). Const a b -> a
getConst) g (Const Int)
start)
         next :: f a -> State Int (Const Int a)
next _ = do {Int
i <- StateT Int Identity Int
forall (m :: * -> *) s. Monad m => StateT s m s
get; let {i' :: Int
i' = Int -> Int
forall a. Enum a => a -> a
succ Int
i}; Int -> StateT Int Identity () -> StateT Int Identity ()
forall a b. a -> b -> b
seq Int
i' (Int -> StateT Int Identity ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put Int
i'); Const Int a -> State Int (Const Int a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> Const Int a
forall k a (b :: k). a -> Const a b
Const Int
i)}

instance Functor (p g s) => Functor (Fixed p g s) where
   fmap :: (a -> b) -> Fixed p g s a -> Fixed p g s b
fmap f :: a -> b
f (PositiveDirectParser p :: p g s a
p) = p g s b -> Fixed p g s b
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> Fixed p g s a
PositiveDirectParser ((a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f p g s a
p)
   fmap f :: a -> b
f p :: Fixed p g s a
p@DirectParser{} = DirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> p g s a -> p g s a -> Fixed p g s a
DirectParser{
      complete :: p g s b
complete= (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p),
      direct0 :: p g s b
direct0= (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s a
p),
      direct1 :: p g s b
direct1= (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed p g s a
p)}
   fmap f :: a -> b
f p :: Fixed p g s a
p@Parser{} = Fixed p g s a
p{
      complete :: p g s b
complete= (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p),
      direct :: p g s b
direct= (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct Fixed p g s a
p),
      direct0 :: p g s b
direct0= (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s a
p),
      direct1 :: p g s b
direct1= (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed p g s a
p),
      indirect :: p g s b
indirect= (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
indirect Fixed p g s a
p),
      appendResults :: ResultList g s b -> ResultList g s b -> ResultList g s b
appendResults= ResultList g s b -> ResultList g s b -> ResultList g s b
forall a. Semigroup a => a -> a -> a
(<>)}
   {-# INLINABLE fmap #-}

instance Alternative (p g s) => Applicative (Fixed p g s) where
   pure :: a -> Fixed p g s a
pure a :: a
a = DirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> p g s a -> p g s a -> Fixed p g s a
DirectParser{complete :: p g s a
complete= a -> p g s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
a,
                         direct0 :: p g s a
direct0= a -> p g s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
a,
                         direct1 :: p g s a
direct1= p g s a
forall (f :: * -> *) a. Alternative f => f a
empty}
   p :: Fixed p g s (a -> b)
p@PositiveDirectParser{} <*> :: Fixed p g s (a -> b) -> Fixed p g s a -> Fixed p g s b
<*> q :: Fixed p g s a
q = PositiveDirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> Fixed p g s a
PositiveDirectParser{
      complete :: p g s b
complete= Fixed p g s (a -> b) -> p g s (a -> b)
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s (a -> b)
p p g s (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
q}
   p :: Fixed p g s (a -> b)
p@DirectParser{} <*> q :: Fixed p g s a
q@PositiveDirectParser{} = PositiveDirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> Fixed p g s a
PositiveDirectParser{
      complete :: p g s b
complete= Fixed p g s (a -> b) -> p g s (a -> b)
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s (a -> b)
p p g s (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
q}
   p :: Fixed p g s (a -> b)
p@DirectParser{} <*> q :: Fixed p g s a
q@DirectParser{} = DirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> p g s a -> p g s a -> Fixed p g s a
DirectParser{
      complete :: p g s b
complete= Fixed p g s (a -> b) -> p g s (a -> b)
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s (a -> b)
p p g s (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
q,
      direct0 :: p g s b
direct0= Fixed p g s (a -> b) -> p g s (a -> b)
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s (a -> b)
p p g s (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s a
q,
      direct1 :: p g s b
direct1= Fixed p g s (a -> b) -> p g s (a -> b)
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s (a -> b)
p p g s (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed p g s a
q p g s b -> p g s b -> p g s b
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Fixed p g s (a -> b) -> p g s (a -> b)
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed p g s (a -> b)
p p g s (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
q}
   p :: Fixed p g s (a -> b)
p <*> q :: Fixed p g s a
q@Parser{} = Parser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a
-> p g s a
-> p g s a
-> p g s a
-> p g s a
-> (ResultList g s a -> ResultList g s a -> ResultList g s a)
-> (Apply g => g (Const (ParserFlags g)) -> ParserFlags g)
-> Fixed p g s a
Parser{
      complete :: p g s b
complete= Fixed p g s (a -> b) -> p g s (a -> b)
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s (a -> b)
p' p g s (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
q,
      direct :: p g s b
direct= Fixed p g s (a -> b) -> p g s (a -> b)
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s (a -> b)
p' p g s (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct Fixed p g s a
q p g s b -> p g s b -> p g s b
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Fixed p g s (a -> b) -> p g s (a -> b)
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed p g s (a -> b)
p' p g s (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
q,
      direct0 :: p g s b
direct0= Fixed p g s (a -> b) -> p g s (a -> b)
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s (a -> b)
p' p g s (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s a
q,
      direct1 :: p g s b
direct1= Fixed p g s (a -> b) -> p g s (a -> b)
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s (a -> b)
p' p g s (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed p g s a
q p g s b -> p g s b -> p g s b
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Fixed p g s (a -> b) -> p g s (a -> b)
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed p g s (a -> b)
p' p g s (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
q,
      indirect :: p g s b
indirect= Fixed p g s (a -> b) -> p g s (a -> b)
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s (a -> b)
p' p g s (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
indirect Fixed p g s a
q p g s b -> p g s b -> p g s b
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Fixed p g s (a -> b) -> p g s (a -> b)
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
indirect Fixed p g s (a -> b)
p' p g s (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
q,
      appendResults :: ResultList g s b -> ResultList g s b -> ResultList g s b
appendResults= ResultList g s b -> ResultList g s b -> ResultList g s b
forall a. Semigroup a => a -> a -> a
(<>),
      cyclicDescendants :: Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants= \deps :: g (Const (ParserFlags g))
deps-> let
           pcd :: ParserFlags g
pcd@(ParserFlags pn :: Bool
pn pd :: g (Const Bool)
pd) = Fixed p g s (a -> b) -> g (Const (ParserFlags g)) -> ParserFlags g
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants Fixed p g s (a -> b)
p' g (Const (ParserFlags g))
deps
           ParserFlags qn :: Bool
qn qd :: g (Const Bool)
qd = Fixed p g s a -> g (Const (ParserFlags g)) -> ParserFlags g
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants Fixed p g s a
q g (Const (ParserFlags g))
deps
        in if Bool
pn
           then Bool -> g (Const Bool) -> ParserFlags g
forall (g :: (* -> *) -> *).
Bool -> g (Const Bool) -> ParserFlags g
ParserFlags Bool
qn ((forall a. Const Bool a -> Const Bool a -> Const Bool a)
-> g (Const Bool) -> g (Const Bool) -> g (Const Bool)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
       (r :: k -> *).
Apply g =>
(forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
Rank2.liftA2 forall a. Const Bool a -> Const Bool a -> Const Bool a
union g (Const Bool)
pd g (Const Bool)
qd)
           else ParserFlags g
pcd}
      where p' :: Fixed p g s (a -> b)
p'@Parser{} = Fixed p g s (a -> b) -> Fixed p g s (a -> b)
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Alternative (p g s) =>
Fixed p g s a -> Fixed p g s a
general' Fixed p g s (a -> b)
p
   p :: Fixed p g s (a -> b)
p <*> q :: Fixed p g s a
q = Parser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a
-> p g s a
-> p g s a
-> p g s a
-> p g s a
-> (ResultList g s a -> ResultList g s a -> ResultList g s a)
-> (Apply g => g (Const (ParserFlags g)) -> ParserFlags g)
-> Fixed p g s a
Parser{
      complete :: p g s b
complete= Fixed p g s (a -> b) -> p g s (a -> b)
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s (a -> b)
p' p g s (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
q',
      direct :: p g s b
direct= Fixed p g s (a -> b) -> p g s (a -> b)
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct Fixed p g s (a -> b)
p' p g s (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
q',
      direct0 :: p g s b
direct0= Fixed p g s (a -> b) -> p g s (a -> b)
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s (a -> b)
p' p g s (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s a
q',
      direct1 :: p g s b
direct1= Fixed p g s (a -> b) -> p g s (a -> b)
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s (a -> b)
p' p g s (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed p g s a
q' p g s b -> p g s b -> p g s b
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Fixed p g s (a -> b) -> p g s (a -> b)
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed p g s (a -> b)
p' p g s (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
q',
      indirect :: p g s b
indirect= Fixed p g s (a -> b) -> p g s (a -> b)
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
indirect Fixed p g s (a -> b)
p' p g s (a -> b) -> p g s a -> p g s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
q',
      appendResults :: ResultList g s b -> ResultList g s b -> ResultList g s b
appendResults= ResultList g s b -> ResultList g s b -> ResultList g s b
forall a. Semigroup a => a -> a -> a
(<>),
      cyclicDescendants :: Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants= \deps :: g (Const (ParserFlags g))
deps-> let
           pcd :: ParserFlags g
pcd@(ParserFlags pn :: Bool
pn pd :: g (Const Bool)
pd) = Fixed p g s (a -> b) -> g (Const (ParserFlags g)) -> ParserFlags g
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants Fixed p g s (a -> b)
p' g (Const (ParserFlags g))
deps
           ParserFlags qn :: Bool
qn qd :: g (Const Bool)
qd = Fixed p g s a -> g (Const (ParserFlags g)) -> ParserFlags g
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants Fixed p g s a
q' g (Const (ParserFlags g))
deps
        in if Bool
pn
           then Bool -> g (Const Bool) -> ParserFlags g
forall (g :: (* -> *) -> *).
Bool -> g (Const Bool) -> ParserFlags g
ParserFlags Bool
qn ((forall a. Const Bool a -> Const Bool a -> Const Bool a)
-> g (Const Bool) -> g (Const Bool) -> g (Const Bool)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
       (r :: k -> *).
Apply g =>
(forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
Rank2.liftA2 forall a. Const Bool a -> Const Bool a -> Const Bool a
union g (Const Bool)
pd g (Const Bool)
qd)
           else ParserFlags g
pcd}
      where p' :: Fixed p g s (a -> b)
p'@Parser{} = Fixed p g s (a -> b) -> Fixed p g s (a -> b)
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Alternative (p g s) =>
Fixed p g s a -> Fixed p g s a
general' Fixed p g s (a -> b)
p
            q' :: Fixed p g s a
q'@Parser{} = Fixed p g s a -> Fixed p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Alternative (p g s) =>
Fixed p g s a -> Fixed p g s a
general' Fixed p g s a
q
   {-# INLINABLE pure #-}
   {-# INLINABLE (<*>) #-}

instance Alternative (p g s) => Alternative (Fixed p g s) where
   empty :: Fixed p g s a
empty = PositiveDirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> Fixed p g s a
PositiveDirectParser{complete :: p g s a
complete= p g s a
forall (f :: * -> *) a. Alternative f => f a
empty}
   p :: Fixed p g s a
p@PositiveDirectParser{} <|> :: Fixed p g s a -> Fixed p g s a -> Fixed p g s a
<|> q :: Fixed p g s a
q@PositiveDirectParser{} = PositiveDirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> Fixed p g s a
PositiveDirectParser{complete :: p g s a
complete= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p p g s a -> p g s a -> p g s a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
q}
   p :: Fixed p g s a
p@PositiveDirectParser{} <|> q :: Fixed p g s a
q@DirectParser{} = DirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> p g s a -> p g s a -> Fixed p g s a
DirectParser{
      complete :: p g s a
complete= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p p g s a -> p g s a -> p g s a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
q,
      direct0 :: p g s a
direct0 = Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s a
q,
      direct1 :: p g s a
direct1= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p p g s a -> p g s a -> p g s a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed p g s a
q}
   p :: Fixed p g s a
p@DirectParser{} <|> q :: Fixed p g s a
q@PositiveDirectParser{} = DirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> p g s a -> p g s a -> Fixed p g s a
DirectParser{
      complete :: p g s a
complete= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p p g s a -> p g s a -> p g s a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
q,
      direct0 :: p g s a
direct0 = Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s a
p,
      direct1 :: p g s a
direct1= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed p g s a
p p g s a -> p g s a -> p g s a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
q}
   p :: Fixed p g s a
p@DirectParser{} <|> q :: Fixed p g s a
q@DirectParser{} = DirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> p g s a -> p g s a -> Fixed p g s a
DirectParser{
      complete :: p g s a
complete= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p p g s a -> p g s a -> p g s a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
q,
      direct0 :: p g s a
direct0 = Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s a
p p g s a -> p g s a -> p g s a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s a
q,
      direct1 :: p g s a
direct1= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed p g s a
p p g s a -> p g s a -> p g s a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed p g s a
q}
   p :: Fixed p g s a
p <|> q :: Fixed p g s a
q = Parser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a
-> p g s a
-> p g s a
-> p g s a
-> p g s a
-> (ResultList g s a -> ResultList g s a -> ResultList g s a)
-> (Apply g => g (Const (ParserFlags g)) -> ParserFlags g)
-> Fixed p g s a
Parser{complete :: p g s a
complete= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p' p g s a -> p g s a -> p g s a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
q',
                    direct :: p g s a
direct= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct Fixed p g s a
p' p g s a -> p g s a -> p g s a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct Fixed p g s a
q',
                    direct0 :: p g s a
direct0= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s a
p' p g s a -> p g s a -> p g s a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s a
q',
                    direct1 :: p g s a
direct1= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed p g s a
p' p g s a -> p g s a -> p g s a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed p g s a
q',
                    indirect :: p g s a
indirect= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
indirect Fixed p g s a
p' p g s a -> p g s a -> p g s a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
indirect Fixed p g s a
q',
                    appendResults :: ResultList g s a -> ResultList g s a -> ResultList g s a
appendResults= ResultList g s a -> ResultList g s a -> ResultList g s a
forall a. Semigroup a => a -> a -> a
(<>),
                    cyclicDescendants :: Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants= \deps :: g (Const (ParserFlags g))
deps-> let
                         ParserFlags pn :: Bool
pn pd :: g (Const Bool)
pd = Fixed p g s a -> g (Const (ParserFlags g)) -> ParserFlags g
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants Fixed p g s a
p' g (Const (ParserFlags g))
deps
                         ParserFlags qn :: Bool
qn qd :: g (Const Bool)
qd = Fixed p g s a -> g (Const (ParserFlags g)) -> ParserFlags g
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants Fixed p g s a
q' g (Const (ParserFlags g))
deps
                      in Bool -> g (Const Bool) -> ParserFlags g
forall (g :: (* -> *) -> *).
Bool -> g (Const Bool) -> ParserFlags g
ParserFlags (Bool
pn Bool -> Bool -> Bool
|| Bool
qn) ((forall a. Const Bool a -> Const Bool a -> Const Bool a)
-> g (Const Bool) -> g (Const Bool) -> g (Const Bool)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
       (r :: k -> *).
Apply g =>
(forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
Rank2.liftA2 forall a. Const Bool a -> Const Bool a -> Const Bool a
union g (Const Bool)
pd g (Const Bool)
qd)}
      where p' :: Fixed p g s a
p'@Parser{} = Fixed p g s a -> Fixed p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Alternative (p g s) =>
Fixed p g s a -> Fixed p g s a
general Fixed p g s a
p
            q' :: Fixed p g s a
q'@Parser{} = Fixed p g s a -> Fixed p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Alternative (p g s) =>
Fixed p g s a -> Fixed p g s a
general Fixed p g s a
q
   many :: Fixed p g s a -> Fixed p g s [a]
many (PositiveDirectParser p :: p g s a
p) = DirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> p g s a -> p g s a -> Fixed p g s a
DirectParser{
      complete :: p g s [a]
complete= p g s a -> p g s [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many p g s a
p,
      direct0 :: p g s [a]
direct0= [a] -> p g s [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [],
      direct1 :: p g s [a]
direct1= p g s a -> p g s [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some p g s a
p}
   many p :: Fixed p g s a
p@DirectParser{} = DirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> p g s a -> p g s a -> Fixed p g s a
DirectParser{
      complete :: p g s [a]
complete= p g s a -> p g s [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p),
      direct0 :: p g s [a]
direct0= [a] -> p g s [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [] p g s [a] -> p g s [a] -> p g s [a]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (a -> [a] -> [a]
forall a. a -> [a] -> [a]
:[]) (a -> [a]) -> p g s a -> p g s [a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s a
p,
      direct1 :: p g s [a]
direct1= (:) (a -> [a] -> [a]) -> p g s a -> p g s ([a] -> [a])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed p g s a
p p g s ([a] -> [a]) -> p g s [a] -> p g s [a]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> p g s a -> p g s [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p)}
   many p :: Fixed p g s a
p@Parser{} = Parser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a
-> p g s a
-> p g s a
-> p g s a
-> p g s a
-> (ResultList g s a -> ResultList g s a -> ResultList g s a)
-> (Apply g => g (Const (ParserFlags g)) -> ParserFlags g)
-> Fixed p g s a
Parser{
      complete :: p g s [a]
complete= p g s [a]
mcp,
      direct :: p g s [a]
direct= p g s [a]
d0 p g s [a] -> p g s [a] -> p g s [a]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> p g s [a]
d1,
      direct0 :: p g s [a]
direct0= p g s [a]
d0,
      direct1 :: p g s [a]
direct1= p g s [a]
d1,
      indirect :: p g s [a]
indirect= (:) (a -> [a] -> [a]) -> p g s a -> p g s ([a] -> [a])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
indirect Fixed p g s a
p p g s ([a] -> [a]) -> p g s [a] -> p g s [a]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> p g s [a]
mcp,
      appendResults :: ResultList g s [a] -> ResultList g s [a] -> ResultList g s [a]
appendResults= ResultList g s [a] -> ResultList g s [a] -> ResultList g s [a]
forall a. Semigroup a => a -> a -> a
(<>),
      cyclicDescendants :: Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants= \deps :: g (Const (ParserFlags g))
deps-> (Fixed p g s a -> g (Const (ParserFlags g)) -> ParserFlags g
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants Fixed p g s a
p g (Const (ParserFlags g))
deps){nullable :: Bool
nullable= Bool
True}}
      where d0 :: p g s [a]
d0 = [a] -> p g s [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [] p g s [a] -> p g s [a] -> p g s [a]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (a -> [a] -> [a]
forall a. a -> [a] -> [a]
:[]) (a -> [a]) -> p g s a -> p g s [a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s a
p
            d1 :: p g s [a]
d1 = (:) (a -> [a] -> [a]) -> p g s a -> p g s ([a] -> [a])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed p g s a
p p g s ([a] -> [a]) -> p g s [a] -> p g s [a]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> p g s [a]
mcp
            mcp :: p g s [a]
mcp = p g s a -> p g s [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p)
   some :: Fixed p g s a -> Fixed p g s [a]
some (PositiveDirectParser p :: p g s a
p) = PositiveDirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> Fixed p g s a
PositiveDirectParser{complete :: p g s [a]
complete= p g s a -> p g s [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some p g s a
p}
   some p :: Fixed p g s a
p@DirectParser{} = DirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> p g s a -> p g s a -> Fixed p g s a
DirectParser{
      complete :: p g s [a]
complete= p g s a -> p g s [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p),
      direct0 :: p g s [a]
direct0= (a -> [a] -> [a]
forall a. a -> [a] -> [a]
:[]) (a -> [a]) -> p g s a -> p g s [a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s a
p,
      direct1 :: p g s [a]
direct1= (:) (a -> [a] -> [a]) -> p g s a -> p g s ([a] -> [a])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed p g s a
p p g s ([a] -> [a]) -> p g s [a] -> p g s [a]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> p g s a -> p g s [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p)}
   some p :: Fixed p g s a
p@Parser{} = Parser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a
-> p g s a
-> p g s a
-> p g s a
-> p g s a
-> (ResultList g s a -> ResultList g s a -> ResultList g s a)
-> (Apply g => g (Const (ParserFlags g)) -> ParserFlags g)
-> Fixed p g s a
Parser{
      complete :: p g s [a]
complete= p g s a -> p g s [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p),
      direct :: p g s [a]
direct= p g s [a]
d0 p g s [a] -> p g s [a] -> p g s [a]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> p g s [a]
d1,
      direct0 :: p g s [a]
direct0= p g s [a]
d0,
      direct1 :: p g s [a]
direct1= p g s [a]
d1,
      indirect :: p g s [a]
indirect= (:) (a -> [a] -> [a]) -> p g s a -> p g s ([a] -> [a])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
indirect Fixed p g s a
p p g s ([a] -> [a]) -> p g s [a] -> p g s [a]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> p g s a -> p g s [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p),
      appendResults :: ResultList g s [a] -> ResultList g s [a] -> ResultList g s [a]
appendResults= ResultList g s [a] -> ResultList g s [a] -> ResultList g s [a]
forall a. Semigroup a => a -> a -> a
(<>),
      cyclicDescendants :: Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants= Fixed p g s a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants Fixed p g s a
p}
      where d0 :: p g s [a]
d0 = (a -> [a] -> [a]
forall a. a -> [a] -> [a]
:[]) (a -> [a]) -> p g s a -> p g s [a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s a
p
            d1 :: p g s [a]
d1= (:) (a -> [a] -> [a]) -> p g s a -> p g s ([a] -> [a])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed p g s a
p p g s ([a] -> [a]) -> p g s [a] -> p g s [a]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> p g s a -> p g s [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p)
   {-# INLINABLE (<|>) #-}
   {-# INLINABLE many #-}
   {-# INLINABLE some #-}

infixl 3 <<|>
(<<|>) :: Parser g s a -> Parser g s a -> Parser g s a
p :: Parser g s a
p@DirectParser{} <<|> :: Parser g s a -> Parser g s a -> Parser g s a
<<|> q :: Parser g s a
q@PositiveDirectParser{} = DirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> p g s a -> p g s a -> Fixed p g s a
DirectParser{
   complete :: Parser g s a
complete= Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Parser g s a
p 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
Memoizing.<<|> Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Parser g s a
q,
   direct0 :: Parser g s a
direct0 = Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Parser g s a
p,
   direct1 :: Parser g s a
direct1= Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Parser g s a
p 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
Memoizing.<<|> Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Parser g s a
q}
p :: Parser g s a
p@DirectParser{} <<|> q :: Parser g s a
q@DirectParser{} = DirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> p g s a -> p g s a -> Fixed p g s a
DirectParser{
   complete :: Parser g s a
complete= Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Parser g s a
p 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
Memoizing.<<|> Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Parser g s a
q,
   direct0 :: Parser g s a
direct0 = Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Parser g s a
p 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
Memoizing.<<|> Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Parser g s a
q,
   direct1 :: Parser g s a
direct1= Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Parser g s a
p 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
Memoizing.<<|> Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Parser g s a
q}
p :: Parser g s a
p <<|> q :: Parser g s a
q = Parser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a
-> p g s a
-> p g s a
-> p g s a
-> p g s a
-> (ResultList g s a -> ResultList g s a -> ResultList g s a)
-> (Apply g => g (Const (ParserFlags g)) -> ParserFlags g)
-> Fixed p g s a
Parser{complete :: Parser g s a
complete= Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Parser g s a
p' 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
Memoizing.<<|> Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Parser g s a
q',
                 direct :: Parser g s a
direct= Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct Parser g s a
p' 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
Memoizing.<<|> Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct Parser g s a
q',
                 direct0 :: Parser g s a
direct0= Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Parser g s a
p' 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
Memoizing.<<|> Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Parser g s a
q',
                 direct1 :: Parser g s a
direct1= Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Parser g s a
p' 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
Memoizing.<<|> Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Parser g s a
q',
                 indirect :: Parser g s a
indirect= Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
indirect Parser g s a
p' 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
Memoizing.<<|> Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
indirect Parser g s a
q',
                 appendResults :: ResultList g s a -> ResultList g s a -> ResultList g s a
appendResults= ResultList g s a -> ResultList g s a -> ResultList g s a
forall a. Semigroup a => a -> a -> a
(<>),
                 cyclicDescendants :: Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants= \deps :: g (Const (ParserFlags g))
deps-> let
                         ParserFlags pn :: Bool
pn pd :: g (Const Bool)
pd = Parser g s a -> g (Const (ParserFlags g)) -> ParserFlags g
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants Parser g s a
p' g (Const (ParserFlags g))
deps
                         ParserFlags qn :: Bool
qn qd :: g (Const Bool)
qd = Parser g s a -> g (Const (ParserFlags g)) -> ParserFlags g
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants Parser g s a
q' g (Const (ParserFlags g))
deps
                      in Bool -> g (Const Bool) -> ParserFlags g
forall (g :: (* -> *) -> *).
Bool -> g (Const Bool) -> ParserFlags g
ParserFlags (Bool
pn Bool -> Bool -> Bool
|| Bool
qn) ((forall a. Const Bool a -> Const Bool a -> Const Bool a)
-> g (Const Bool) -> g (Const Bool) -> g (Const Bool)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
       (r :: k -> *).
Apply g =>
(forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
Rank2.liftA2 forall a. Const Bool a -> Const Bool a -> Const Bool a
union g (Const Bool)
pd g (Const Bool)
qd)}
   where p' :: Parser g s a
p'@Parser{} = Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Alternative (p g s) =>
Fixed p g s a -> Fixed p g s a
general Parser g s a
p
         q' :: Parser g s a
q'@Parser{} = Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Alternative (p g s) =>
Fixed p g s a -> Fixed p g s a
general Parser g s a
q

union :: Const Bool x -> Const Bool x -> Const Bool x
union :: Const Bool x -> Const Bool x -> Const Bool x
union (Const False) d :: Const Bool x
d = Const Bool x
d
union (Const True) _ = Bool -> Const Bool x
forall k a (b :: k). a -> Const a b
Const Bool
True

instance (Alternative (p g s), Monad (p g s)) => Monad (Fixed p g s) where
   return :: a -> Fixed p g s a
return = a -> Fixed p g s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
   >> :: Fixed p g s a -> Fixed p g s b -> Fixed p g s b
(>>) = Fixed p g s a -> Fixed p g s b -> Fixed p g s b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
(*>)
   PositiveDirectParser p :: p g s a
p >>= :: Fixed p g s a -> (a -> Fixed p g s b) -> Fixed p g s b
>>= cont :: a -> Fixed p g s b
cont = p g s b -> Fixed p g s b
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> Fixed p g s a
PositiveDirectParser (p g s a
p p g s a -> (a -> p g s b) -> p g s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Fixed p g s b -> p g s b
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete (Fixed p g s b -> p g s b) -> (a -> Fixed p g s b) -> a -> p g s b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Fixed p g s b
cont)
   p :: Fixed p g s a
p@DirectParser{} >>= cont :: a -> Fixed p g s b
cont = Parser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a
-> p g s a
-> p g s a
-> p g s a
-> p g s a
-> (ResultList g s a -> ResultList g s a -> ResultList g s a)
-> (Apply g => g (Const (ParserFlags g)) -> ParserFlags g)
-> Fixed p g s a
Parser{
      complete :: p g s b
complete= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p p g s a -> (a -> p g s b) -> p g s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Fixed p g s b -> p g s b
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete (Fixed p g s b -> p g s b) -> (a -> Fixed p g s b) -> a -> p g s b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Fixed p g s b
cont,
      direct :: p g s b
direct= p g s b
d0 p g s b -> p g s b -> p g s b
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> p g s b
d1,
      direct0 :: p g s b
direct0= p g s b
d0,
      direct1 :: p g s b
direct1= p g s b
d1,
      indirect :: p g s b
indirect= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s a
p p g s a -> (a -> p g s b) -> p g s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Fixed p g s b -> p g s b
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
indirect (Fixed p g s b -> p g s b) -> (a -> Fixed p g s b) -> a -> p g s b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fixed p g s b -> Fixed p g s b
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Alternative (p g s) =>
Fixed p g s a -> Fixed p g s a
general' (Fixed p g s b -> Fixed p g s b)
-> (a -> Fixed p g s b) -> a -> Fixed p g s b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Fixed p g s b
cont,
      appendResults :: ResultList g s b -> ResultList g s b -> ResultList g s b
appendResults= ResultList g s b -> ResultList g s b -> ResultList g s b
forall a. Semigroup a => a -> a -> a
(<>),
      cyclicDescendants :: Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants= \cd :: g (Const (ParserFlags g))
cd-> (Bool -> g (Const Bool) -> ParserFlags g
forall (g :: (* -> *) -> *).
Bool -> g (Const Bool) -> ParserFlags g
ParserFlags Bool
True (g (Const Bool) -> ParserFlags g)
-> g (Const Bool) -> ParserFlags g
forall a b. (a -> b) -> a -> b
$ (forall a. Const (ParserFlags g) a -> Const Bool a)
-> g (Const (ParserFlags g)) -> g (Const Bool)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Functor g =>
(forall (a :: k). p a -> q a) -> g p -> g q
Rank2.fmap (Const Bool a -> Const (ParserFlags g) a -> Const Bool a
forall a b. a -> b -> a
const (Const Bool a -> Const (ParserFlags g) a -> Const Bool a)
-> Const Bool a -> Const (ParserFlags g) a -> Const Bool a
forall a b. (a -> b) -> a -> b
$ Bool -> Const Bool a
forall k a (b :: k). a -> Const a b
Const Bool
True) g (Const (ParserFlags g))
cd)}
      where d0 :: p g s b
d0 = Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s a
p p g s a -> (a -> p g s b) -> p g s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Fixed p g s b -> p g s b
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 (Fixed p g s b -> p g s b) -> (a -> Fixed p g s b) -> a -> p g s b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fixed p g s b -> Fixed p g s b
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Alternative (p g s) =>
Fixed p g s a -> Fixed p g s a
general' (Fixed p g s b -> Fixed p g s b)
-> (a -> Fixed p g s b) -> a -> Fixed p g s b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Fixed p g s b
cont
            d1 :: p g s b
d1 = (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s a
p p g s a -> (a -> p g s b) -> p g s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Fixed p g s b -> p g s b
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 (Fixed p g s b -> p g s b) -> (a -> Fixed p g s b) -> a -> p g s b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fixed p g s b -> Fixed p g s b
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Alternative (p g s) =>
Fixed p g s a -> Fixed p g s a
general' (Fixed p g s b -> Fixed p g s b)
-> (a -> Fixed p g s b) -> a -> Fixed p g s b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Fixed p g s b
cont) p g s b -> p g s b -> p g s b
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed p g s a
p p g s a -> (a -> p g s b) -> p g s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Fixed p g s b -> p g s b
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete (Fixed p g s b -> p g s b) -> (a -> Fixed p g s b) -> a -> p g s b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Fixed p g s b
cont)
   p :: Fixed p g s a
p >>= cont :: a -> Fixed p g s b
cont = Parser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a
-> p g s a
-> p g s a
-> p g s a
-> p g s a
-> (ResultList g s a -> ResultList g s a -> ResultList g s a)
-> (Apply g => g (Const (ParserFlags g)) -> ParserFlags g)
-> Fixed p g s a
Parser{
      complete :: p g s b
complete= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p p g s a -> (a -> p g s b) -> p g s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Fixed p g s b -> p g s b
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete (Fixed p g s b -> p g s b) -> (a -> Fixed p g s b) -> a -> p g s b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Fixed p g s b
cont,
      direct :: p g s b
direct= p g s b
d0 p g s b -> p g s b -> p g s b
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> p g s b
d1,
      direct0 :: p g s b
direct0= p g s b
d0,
      direct1 :: p g s b
direct1= p g s b
d1,
      indirect :: p g s b
indirect= (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
indirect Fixed p g s a
p p g s a -> (a -> p g s b) -> p g s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Fixed p g s b -> p g s b
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete (Fixed p g s b -> p g s b) -> (a -> Fixed p g s b) -> a -> p g s b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Fixed p g s b
cont) p g s b -> p g s b -> p g s b
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s a
p p g s a -> (a -> p g s b) -> p g s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Fixed p g s b -> p g s b
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
indirect (Fixed p g s b -> p g s b) -> (a -> Fixed p g s b) -> a -> p g s b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fixed p g s b -> Fixed p g s b
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Alternative (p g s) =>
Fixed p g s a -> Fixed p g s a
general' (Fixed p g s b -> Fixed p g s b)
-> (a -> Fixed p g s b) -> a -> Fixed p g s b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Fixed p g s b
cont),
      appendResults :: ResultList g s b -> ResultList g s b -> ResultList g s b
appendResults= ResultList g s b -> ResultList g s b -> ResultList g s b
forall a. Semigroup a => a -> a -> a
(<>),
      cyclicDescendants :: Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants= \cd :: g (Const (ParserFlags g))
cd->
         let pcd :: ParserFlags g
pcd@(ParserFlags pn :: Bool
pn _) = Fixed p g s a -> g (Const (ParserFlags g)) -> ParserFlags g
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants Fixed p g s a
p' g (Const (ParserFlags g))
cd
         in if Bool
pn
            then Bool -> g (Const Bool) -> ParserFlags g
forall (g :: (* -> *) -> *).
Bool -> g (Const Bool) -> ParserFlags g
ParserFlags Bool
True ((forall a. Const (ParserFlags g) a -> Const Bool a)
-> g (Const (ParserFlags g)) -> g (Const Bool)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Functor g =>
(forall (a :: k). p a -> q a) -> g p -> g q
Rank2.fmap (Const Bool a -> Const (ParserFlags g) a -> Const Bool a
forall a b. a -> b -> a
const (Const Bool a -> Const (ParserFlags g) a -> Const Bool a)
-> Const Bool a -> Const (ParserFlags g) a -> Const Bool a
forall a b. (a -> b) -> a -> b
$ Bool -> Const Bool a
forall k a (b :: k). a -> Const a b
Const Bool
True) g (Const (ParserFlags g))
cd)
            else ParserFlags g
pcd}
      where d0 :: p g s b
d0 = Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s a
p p g s a -> (a -> p g s b) -> p g s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Fixed p g s b -> p g s b
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 (Fixed p g s b -> p g s b) -> (a -> Fixed p g s b) -> a -> p g s b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fixed p g s b -> Fixed p g s b
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Alternative (p g s) =>
Fixed p g s a -> Fixed p g s a
general' (Fixed p g s b -> Fixed p g s b)
-> (a -> Fixed p g s b) -> a -> Fixed p g s b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Fixed p g s b
cont
            d1 :: p g s b
d1 = (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s a
p p g s a -> (a -> p g s b) -> p g s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Fixed p g s b -> p g s b
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 (Fixed p g s b -> p g s b) -> (a -> Fixed p g s b) -> a -> p g s b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fixed p g s b -> Fixed p g s b
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Alternative (p g s) =>
Fixed p g s a -> Fixed p g s a
general' (Fixed p g s b -> Fixed p g s b)
-> (a -> Fixed p g s b) -> a -> Fixed p g s b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Fixed p g s b
cont) p g s b -> p g s b -> p g s b
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed p g s a
p p g s a -> (a -> p g s b) -> p g s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Fixed p g s b -> p g s b
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete (Fixed p g s b -> p g s b) -> (a -> Fixed p g s b) -> a -> p g s b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Fixed p g s b
cont)
            p' :: Fixed p g s a
p'@Parser{} = Fixed p g s a -> Fixed p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Alternative (p g s) =>
Fixed p g s a -> Fixed p g s a
general' Fixed p g s a
p

instance MonadPlus (p g s) => MonadPlus (Fixed p g s) where
   mzero :: Fixed p g s a
mzero = Fixed p g s a
forall (f :: * -> *) a. Alternative f => f a
empty
   mplus :: Fixed p g s a -> Fixed p g s a -> Fixed p g s a
mplus = Fixed p g s a -> Fixed p g s a -> Fixed p g s a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
(<|>)

instance (Alternative (p g s), Semigroup x) => Semigroup (Fixed p g s x) where
   <> :: Fixed p g s x -> Fixed p g s x -> Fixed p g s x
(<>) = (x -> x -> x) -> Fixed p g s x -> Fixed p g s x -> Fixed p 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 (Alternative (p g s), Monoid x) => Monoid (Fixed p g s x) where
   mempty :: Fixed p g s x
mempty = x -> Fixed p g s x
forall (f :: * -> *) a. Applicative f => a -> f a
pure x
forall a. Monoid a => a
mempty
   mappend :: Fixed p g s x -> Fixed p g s x -> Fixed p g s x
mappend = (x -> x -> x) -> Fixed p g s x -> Fixed p g s x -> Fixed p 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

primitive :: String -> p g s a -> p g s a -> p g s a -> Fixed p g s a
primitive :: String -> p g s a -> p g s a -> p g s a -> Fixed p g s a
primitive _name :: String
_name d0 :: p g s a
d0 d1 :: p g s a
d1 d :: p g s a
d = DirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> p g s a -> p g s a -> Fixed p g s a
DirectParser{complete :: p g s a
complete= p g s a
d,
                                       direct0 :: p g s a
direct0= p g s a
d0,
                                       direct1 :: p g s a
direct1= p g s a
d1}
{-# INLINE primitive #-}

positivePrimitive :: String -> p g s a -> Fixed p g s a
positivePrimitive :: String -> p g s a -> Fixed p g s a
positivePrimitive _name :: String
_name p :: p g s a
p = PositiveDirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> Fixed p g s a
PositiveDirectParser{complete :: p g s a
complete= p g s a
p}
{-# INLINE positivePrimitive #-}

instance (Parsing (p g s), MonoidParsing (Fixed p g)) => Parsing (Fixed p g s) where
   eof :: Fixed p g s ()
eof = String -> p g s () -> p g s () -> p g s () -> Fixed p g s ()
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> p g s a -> p g s a -> Fixed p g s a
primitive "eof" p g s ()
forall (m :: * -> *). Parsing m => m ()
eof p g s ()
forall (f :: * -> *) a. Alternative f => f a
empty p g s ()
forall (m :: * -> *). Parsing m => m ()
eof
   try :: Fixed p g s a -> Fixed p g s a
try (PositiveDirectParser p :: p g s a
p) = p g s a -> Fixed p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> Fixed p g s a
PositiveDirectParser (p g s a -> p g s a
forall (m :: * -> *) a. Parsing m => m a -> m a
try p g s a
p)
   try p :: Fixed p g s a
p@DirectParser{} = DirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> p g s a -> p g s a -> Fixed p g s a
DirectParser{
      complete :: p g s a
complete= p g s a -> p g s a
forall (m :: * -> *) a. Parsing m => m a -> m a
try (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p),
      direct0 :: p g s a
direct0= p g s a -> p g s a
forall (m :: * -> *) a. Parsing m => m a -> m a
try (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s a
p),
      direct1 :: p g s a
direct1= p g s a -> p g s a
forall (m :: * -> *) a. Parsing m => m a -> m a
try (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed p g s a
p)}
   try p :: Fixed p g s a
p@Parser{} = Fixed p g s a
p{
      complete :: p g s a
complete= p g s a -> p g s a
forall (m :: * -> *) a. Parsing m => m a -> m a
try (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p),
      direct :: p g s a
direct= p g s a -> p g s a
forall (m :: * -> *) a. Parsing m => m a -> m a
try (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct Fixed p g s a
p),
      direct0 :: p g s a
direct0= p g s a -> p g s a
forall (m :: * -> *) a. Parsing m => m a -> m a
try (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s a
p),
      direct1 :: p g s a
direct1= p g s a -> p g s a
forall (m :: * -> *) a. Parsing m => m a -> m a
try (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed p g s a
p),
      indirect :: p g s a
indirect= p g s a -> p g s a
forall (m :: * -> *) a. Parsing m => m a -> m a
try (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
indirect Fixed p g s a
p)}
   PositiveDirectParser p :: p g s a
p <?> :: Fixed p g s a -> String -> Fixed p g s a
<?> msg :: String
msg = p g s a -> Fixed p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> Fixed p g s a
PositiveDirectParser (p g s a
p p g s a -> String -> p g s a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
msg)
   p :: Fixed p g s a
p@DirectParser{} <?> msg :: String
msg = DirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> p g s a -> p g s a -> Fixed p g s a
DirectParser{
      complete :: p g s a
complete= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p p g s a -> String -> p g s a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
msg,
      direct0 :: p g s a
direct0= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s a
p p g s a -> String -> p g s a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
msg,
      direct1 :: p g s a
direct1= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed p g s a
p p g s a -> String -> p g s a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
msg}
   p :: Fixed p g s a
p@Parser{} <?> msg :: String
msg = Fixed p g s a
p{
      complete :: p g s a
complete= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p p g s a -> String -> p g s a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
msg,
      direct :: p g s a
direct= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct Fixed p g s a
p p g s a -> String -> p g s a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
msg,
      direct0 :: p g s a
direct0= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed p g s a
p p g s a -> String -> p g s a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
msg,
      direct1 :: p g s a
direct1= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed p g s a
p p g s a -> String -> p g s a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
msg,
      indirect :: p g s a
indirect= Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
indirect Fixed p g s a
p p g s a -> String -> p g s a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
msg}
   notFollowedBy :: Fixed p g s a -> Fixed p g s ()
notFollowedBy p :: Fixed p g s a
p@PositiveDirectParser{} = DirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> p g s a -> p g s a -> Fixed p g s a
DirectParser{
      complete :: p g s ()
complete= p g s a -> p g s ()
forall (m :: * -> *) a. (Parsing m, Show a) => m a -> m ()
notFollowedBy (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p),
      direct0 :: p g s ()
direct0= p g s a -> p g s ()
forall (m :: * -> *) a. (Parsing m, Show a) => m a -> m ()
notFollowedBy (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p),
      direct1 :: p g s ()
direct1= p g s ()
forall (f :: * -> *) a. Alternative f => f a
empty}
   notFollowedBy p :: Fixed p g s a
p@DirectParser{} = DirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> p g s a -> p g s a -> Fixed p g s a
DirectParser{
      complete :: p g s ()
complete= p g s a -> p g s ()
forall (m :: * -> *) a. (Parsing m, Show a) => m a -> m ()
notFollowedBy (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p),
      direct0 :: p g s ()
direct0= p g s a -> p g s ()
forall (m :: * -> *) a. (Parsing m, Show a) => m a -> m ()
notFollowedBy (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p),
      direct1 :: p g s ()
direct1= p g s ()
forall (f :: * -> *) a. Alternative f => f a
empty}
   notFollowedBy p :: Fixed p g s a
p@Parser{} = Parser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a
-> p g s a
-> p g s a
-> p g s a
-> p g s a
-> (ResultList g s a -> ResultList g s a -> ResultList g s a)
-> (Apply g => g (Const (ParserFlags g)) -> ParserFlags g)
-> Fixed p g s a
Parser{
      complete :: p g s ()
complete= p g s a -> p g s ()
forall (m :: * -> *) a. (Parsing m, Show a) => m a -> m ()
notFollowedBy (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p),
      direct :: p g s ()
direct= p g s a -> p g s ()
forall (m :: * -> *) a. (Parsing m, Show a) => m a -> m ()
notFollowedBy (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct Fixed p g s a
p),
      direct0 :: p g s ()
direct0= p g s a -> p g s ()
forall (m :: * -> *) a. (Parsing m, Show a) => m a -> m ()
notFollowedBy (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct Fixed p g s a
p),
      direct1 :: p g s ()
direct1= p g s ()
forall (f :: * -> *) a. Alternative f => f a
empty,
      appendResults :: ResultList g s () -> ResultList g s () -> ResultList g s ()
appendResults= ResultList g s () -> ResultList g s () -> ResultList g s ()
forall a. Semigroup a => a -> a -> a
(<>),
      indirect :: p g s ()
indirect= p g s a -> p g s ()
forall (m :: * -> *) a. (Parsing m, Show a) => m a -> m ()
notFollowedBy (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
indirect Fixed p g s a
p),
      cyclicDescendants :: Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants= \deps :: g (Const (ParserFlags g))
deps-> (Fixed p g s a -> g (Const (ParserFlags g)) -> ParserFlags g
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants Fixed p g s a
p g (Const (ParserFlags g))
deps){nullable :: Bool
nullable= Bool
True}}
   unexpected :: String -> Fixed p g s a
unexpected msg :: String
msg = String -> p g s a -> Fixed p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> Fixed p g s a
positivePrimitive "unexpected" (String -> p g s a
forall (m :: * -> *) a. Parsing m => String -> m a
unexpected String
msg)
   skipMany :: Fixed p g s a -> Fixed p g s ()
skipMany p :: Fixed p g s a
p = Fixed p g s () -> Fixed p g s ()
forall (m :: * -> * -> *) a s.
(MonoidParsing m, Monoid a) =>
m s a -> m s a
concatMany (() () -> Fixed p g s a -> Fixed p g s ()
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Fixed p g s a
p)

instance (LookAheadParsing (p g s), MonoidParsing (Fixed p g)) => LookAheadParsing (Fixed p g s) where
   lookAhead :: Fixed p g s a -> Fixed p g s a
lookAhead p :: Fixed p g s a
p@PositiveDirectParser{} = DirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> p g s a -> p g s a -> Fixed p g s a
DirectParser{
      complete :: p g s a
complete= p g s a -> p g s a
forall (m :: * -> *) a. LookAheadParsing m => m a -> m a
lookAhead (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p),
      direct0 :: p g s a
direct0= p g s a -> p g s a
forall (m :: * -> *) a. LookAheadParsing m => m a -> m a
lookAhead (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p),
      direct1 :: p g s a
direct1= p g s a
forall (f :: * -> *) a. Alternative f => f a
empty}
   lookAhead p :: Fixed p g s a
p@DirectParser{} = DirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> p g s a -> p g s a -> Fixed p g s a
DirectParser{
      complete :: p g s a
complete= p g s a -> p g s a
forall (m :: * -> *) a. LookAheadParsing m => m a -> m a
lookAhead (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p),
      direct0 :: p g s a
direct0= p g s a -> p g s a
forall (m :: * -> *) a. LookAheadParsing m => m a -> m a
lookAhead (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p),
      direct1 :: p g s a
direct1= p g s a
forall (f :: * -> *) a. Alternative f => f a
empty}
   lookAhead p :: Fixed p g s a
p@Parser{} = Parser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a
-> p g s a
-> p g s a
-> p g s a
-> p g s a
-> (ResultList g s a -> ResultList g s a -> ResultList g s a)
-> (Apply g => g (Const (ParserFlags g)) -> ParserFlags g)
-> Fixed p g s a
Parser{
      complete :: p g s a
complete= p g s a -> p g s a
forall (m :: * -> *) a. LookAheadParsing m => m a -> m a
lookAhead (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed p g s a
p),
      direct :: p g s a
direct= p g s a -> p g s a
forall (m :: * -> *) a. LookAheadParsing m => m a -> m a
lookAhead (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct Fixed p g s a
p),
      direct0 :: p g s a
direct0= p g s a -> p g s a
forall (m :: * -> *) a. LookAheadParsing m => m a -> m a
lookAhead (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct Fixed p g s a
p),
      direct1 :: p g s a
direct1= p g s a
forall (f :: * -> *) a. Alternative f => f a
empty,
      appendResults :: ResultList g s a -> ResultList g s a -> ResultList g s a
appendResults= Fixed p g s a
-> ResultList g s a -> ResultList g s a -> ResultList g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a
-> ResultList g s a -> ResultList g s a -> ResultList g s a
appendResults Fixed p g s a
p,
      indirect :: p g s a
indirect= p g s a -> p g s a
forall (m :: * -> *) a. LookAheadParsing m => m a -> m a
lookAhead (Fixed p g s a -> p g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
indirect Fixed p g s a
p),
      cyclicDescendants :: Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants= \deps :: g (Const (ParserFlags g))
deps-> (Fixed p g s a -> g (Const (ParserFlags g)) -> ParserFlags g
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants Fixed p g s a
p g (Const (ParserFlags g))
deps){nullable :: Bool
nullable= Bool
True}}

instance MonoidParsing (Fixed Memoizing.Parser g) where
   endOfInput :: Fixed Parser g s ()
endOfInput = String
-> Parser g s ()
-> Parser g s ()
-> Parser g s ()
-> Fixed Parser g s ()
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> p g s a -> p g s a -> Fixed p g s a
primitive "endOfInput" Parser g s ()
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
m s ()
endOfInput Parser g s ()
forall (f :: * -> *) a. Alternative f => f a
empty Parser g s ()
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
m s ()
endOfInput
   getInput :: Fixed Parser g s s
getInput = String
-> Parser g s s
-> Parser g s s
-> Parser g s s
-> Fixed Parser g s s
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> p g s a -> p g s a -> Fixed p g s a
primitive "getInput" Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
m s s
getInput Parser g s s
forall (f :: * -> *) a. Alternative f => f a
empty Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
m s s
getInput
   anyToken :: Fixed Parser g s s
anyToken = String -> Parser g s s -> Fixed Parser g s s
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> Fixed p g s a
positivePrimitive "anyToken" Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
m s s
anyToken
   satisfy :: (s -> Bool) -> Fixed Parser g s s
satisfy predicate :: s -> Bool
predicate = String -> Parser g s s -> Fixed Parser g s s
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> Fixed p g s a
positivePrimitive "satisfy" ((s -> Bool) -> Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
(s -> Bool) -> m s s
satisfy s -> Bool
predicate)
   satisfyChar :: (Char -> Bool) -> Fixed Parser g s Char
satisfyChar predicate :: Char -> Bool
predicate = String -> Parser g s Char -> Fixed Parser g s Char
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> Fixed p g s a
positivePrimitive "satisfyChar" ((Char -> Bool) -> Parser g s Char
forall (m :: * -> * -> *) s.
(MonoidParsing m, TextualMonoid s) =>
(Char -> Bool) -> m s Char
satisfyChar Char -> Bool
predicate)
   satisfyCharInput :: (Char -> Bool) -> Fixed Parser g s s
satisfyCharInput predicate :: Char -> Bool
predicate = String -> Parser g s s -> Fixed Parser g s s
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> Fixed p g s a
positivePrimitive "satisfyCharInput" ((Char -> Bool) -> Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, TextualMonoid s) =>
(Char -> Bool) -> m s s
satisfyCharInput Char -> Bool
predicate)
   notSatisfy :: (s -> Bool) -> Fixed Parser g s ()
notSatisfy predicate :: s -> Bool
predicate = String
-> Parser g s ()
-> Parser g s ()
-> Parser g s ()
-> Fixed Parser g s ()
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> p g s a -> p g s a -> Fixed p g s a
primitive "notSatisfy" ((s -> Bool) -> Parser g s ()
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
(s -> Bool) -> m s ()
notSatisfy s -> Bool
predicate) Parser g s ()
forall (f :: * -> *) a. Alternative f => f a
empty ((s -> Bool) -> Parser g s ()
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
(s -> Bool) -> m s ()
notSatisfy s -> Bool
predicate)
   notSatisfyChar :: (Char -> Bool) -> Fixed Parser g s ()
notSatisfyChar predicate :: Char -> Bool
predicate = String
-> Parser g s ()
-> Parser g s ()
-> Parser g s ()
-> Fixed Parser g s ()
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> p g s a -> p g s a -> Fixed p g s a
primitive "notSatisfyChar" ((Char -> Bool) -> Parser g s ()
forall (m :: * -> * -> *) s.
(MonoidParsing m, TextualMonoid s) =>
(Char -> Bool) -> m s ()
notSatisfyChar Char -> Bool
predicate) Parser g s ()
forall (f :: * -> *) a. Alternative f => f a
empty ((Char -> Bool) -> Parser g s ()
forall (m :: * -> * -> *) s.
(MonoidParsing m, TextualMonoid s) =>
(Char -> Bool) -> m s ()
notSatisfyChar Char -> Bool
predicate)
   scan :: s -> (s -> t -> Maybe s) -> Fixed Parser g t t
scan s0 :: s
s0 f :: s -> t -> Maybe s
f = String
-> Parser g t t
-> Parser g t t
-> Parser g t t
-> Fixed Parser g t t
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> p g s a -> p g s a -> Fixed p g s a
primitive "scan" (t
forall a. Monoid a => a
mempty t -> Parser g t () -> Parser g t t
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (t -> Bool) -> Parser g t ()
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
(s -> Bool) -> m s ()
notSatisfy t -> Bool
test) (Parser g t t -> Parser g t t
forall (m :: * -> *) a. LookAheadParsing m => m a -> m a
lookAhead ((t -> Bool) -> Parser g t t
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
(s -> Bool) -> m s s
satisfy t -> Bool
test) Parser g t t -> Parser g t t -> Parser g t t
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser g t t
p) Parser g t t
p
      where p :: Parser g t t
p = s -> (s -> t -> Maybe s) -> Parser g t t
forall (m :: * -> * -> *) t s.
(MonoidParsing m, FactorialMonoid t) =>
s -> (s -> t -> Maybe s) -> m t t
scan s
s0 s -> t -> Maybe s
f
            test :: t -> Bool
test = Maybe s -> Bool
forall a. Maybe a -> Bool
isJust (Maybe s -> Bool) -> (t -> Maybe s) -> t -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> t -> Maybe s
f s
s0
   scanChars :: s -> (s -> Char -> Maybe s) -> Fixed Parser g t t
scanChars s0 :: s
s0 f :: s -> Char -> Maybe s
f = String
-> Parser g t t
-> Parser g t t
-> Parser g t t
-> Fixed Parser g t t
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> p g s a -> p g s a -> Fixed p g s a
primitive "scanChars" (t
forall a. Monoid a => a
mempty t -> Parser g t () -> Parser g t t
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (Char -> Bool) -> Parser g t ()
forall (m :: * -> * -> *) s.
(MonoidParsing m, TextualMonoid s) =>
(Char -> Bool) -> m s ()
notSatisfyChar Char -> Bool
test) (Parser g t Char -> Parser g t Char
forall (m :: * -> *) a. LookAheadParsing m => m a -> m a
lookAhead ((Char -> Bool) -> Parser g t Char
forall (m :: * -> * -> *) s.
(MonoidParsing m, TextualMonoid s) =>
(Char -> Bool) -> m s Char
satisfyChar Char -> Bool
test) Parser g t Char -> Parser g t t -> Parser g t t
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser g t t
p) Parser g t t
p
      where p :: Parser g t t
p = s -> (s -> Char -> Maybe s) -> Parser g t t
forall (m :: * -> * -> *) t s.
(MonoidParsing m, TextualMonoid t) =>
s -> (s -> Char -> Maybe s) -> m t t
scanChars s
s0 s -> Char -> Maybe s
f
            test :: Char -> Bool
test = Maybe s -> Bool
forall a. Maybe a -> Bool
isJust (Maybe s -> Bool) -> (Char -> Maybe s) -> Char -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> Char -> Maybe s
f s
s0
   string :: s -> Fixed Parser g s s
string s :: s
s
      | s -> Bool
forall m. MonoidNull m => m -> Bool
null s
s = String
-> Parser g s s
-> Parser g s s
-> Parser g s s
-> Fixed Parser g s s
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> p g s a -> p g s a -> Fixed p g s a
primitive ("(string " String -> ShowS
forall a. [a] -> [a] -> [a]
++ s -> ShowS
forall a. Show a => a -> ShowS
shows s
s ")") (s -> Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s, LeftReductiveMonoid s,
 Show s) =>
s -> m s s
string s
s) Parser g s s
forall (f :: * -> *) a. Alternative f => f a
empty (s -> Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s, LeftReductiveMonoid s,
 Show s) =>
s -> m s s
string s
s)
      | Bool
otherwise = String -> Parser g s s -> Fixed Parser g s s
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> Fixed p g s a
positivePrimitive ("(string " String -> ShowS
forall a. [a] -> [a] -> [a]
++ s -> ShowS
forall a. Show a => a -> ShowS
shows s
s ")") (s -> Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s, LeftReductiveMonoid s,
 Show s) =>
s -> m s s
string s
s)
   takeWhile :: (s -> Bool) -> Fixed Parser g s s
takeWhile predicate :: s -> Bool
predicate = String
-> Parser g s s
-> Parser g s s
-> Parser g s s
-> Fixed Parser g s s
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> p g s a -> p g s a -> Fixed p g s a
primitive "takeWhile" (s
forall a. Monoid a => a
mempty s -> Parser g s () -> Parser g s s
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (s -> Bool) -> Parser g s ()
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
(s -> Bool) -> m s ()
notSatisfy s -> Bool
predicate)
                                               ((s -> Bool) -> Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
(s -> Bool) -> m s s
takeWhile1 s -> Bool
predicate) ((s -> Bool) -> Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
(s -> Bool) -> m s s
takeWhile s -> Bool
predicate)
   takeWhile1 :: (s -> Bool) -> Fixed Parser g s s
takeWhile1 predicate :: s -> Bool
predicate = String -> Parser g s s -> Fixed Parser g s s
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> Fixed p g s a
positivePrimitive "takeWhile1" ((s -> Bool) -> Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
(s -> Bool) -> m s s
takeWhile1 s -> Bool
predicate)
   takeCharsWhile :: (Char -> Bool) -> Fixed Parser g s s
takeCharsWhile predicate :: Char -> Bool
predicate = String
-> Parser g s s
-> Parser g s s
-> Parser g s s
-> Fixed Parser g s s
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> p g s a -> p g s a -> Fixed p g s a
primitive "takeCharsWhile" (s
forall a. Monoid a => a
mempty s -> Parser g s () -> Parser g s s
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (Char -> Bool) -> Parser g s ()
forall (m :: * -> * -> *) s.
(MonoidParsing m, TextualMonoid s) =>
(Char -> Bool) -> m s ()
notSatisfyChar Char -> Bool
predicate)
                                                         ((Char -> Bool) -> Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, TextualMonoid s) =>
(Char -> Bool) -> m s s
takeCharsWhile1 Char -> Bool
predicate) ((Char -> Bool) -> Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, TextualMonoid s) =>
(Char -> Bool) -> m s s
takeCharsWhile Char -> Bool
predicate)
   takeCharsWhile1 :: (Char -> Bool) -> Fixed Parser g s s
takeCharsWhile1 predicate :: Char -> Bool
predicate = String -> Parser g s s -> Fixed Parser g s s
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> Fixed p g s a
positivePrimitive "takeCharsWhile1" ((Char -> Bool) -> Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, TextualMonoid s) =>
(Char -> Bool) -> m s s
takeCharsWhile1 Char -> Bool
predicate)
   concatMany :: Fixed Parser g s a -> Fixed Parser g s a
concatMany p :: Fixed Parser g s a
p@PositiveDirectParser{} = DirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> p g s a -> p g s a -> Fixed p g s a
DirectParser{
      complete :: Parser g s a
complete= Parser g s a
cmp,
      direct0 :: Parser g s a
direct0= Parser g s a
d0,
      direct1 :: Parser g s a
direct1= Parser g s a
d1}
      where d0 :: Parser g s a
d0 = a -> Parser g s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
forall a. Monoid a => a
mempty
            d1 :: Parser g s a
d1 = a -> a -> a
forall a. Monoid a => a -> a -> a
mappend (a -> a -> a) -> Parser g s a -> Parser g s (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed Parser g s a
p Parser g s (a -> a) -> Parser g s a -> Parser g s a
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g s a
cmp
            cmp :: Parser g s a
cmp = Parser g s a -> Parser g s a
forall (m :: * -> * -> *) a s.
(MonoidParsing m, Monoid a) =>
m s a -> m s a
concatMany (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed Parser g s a
p)
   concatMany p :: Fixed Parser g s a
p@DirectParser{} = DirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> p g s a -> p g s a -> Fixed p g s a
DirectParser{
      complete :: Parser g s a
complete= Parser g s a
cmp,
      direct0 :: Parser g s a
direct0= Parser g s a
d0,
      direct1 :: Parser g s a
direct1= Parser g s a
d1}
      where d0 :: Parser g s a
d0 = a -> Parser g s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
forall a. Monoid a => a
mempty Parser g s a -> Parser g s a -> Parser g s a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed Parser g s a
p
            d1 :: Parser g s a
d1 = a -> a -> a
forall a. Monoid a => a -> a -> a
mappend (a -> a -> a) -> Parser g s a -> Parser g s (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed Parser g s a
p Parser g s (a -> a) -> Parser g s a -> Parser g s a
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g s a
cmp
            cmp :: Parser g s a
cmp = Parser g s a -> Parser g s a
forall (m :: * -> * -> *) a s.
(MonoidParsing m, Monoid a) =>
m s a -> m s a
concatMany (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed Parser g s a
p)
   concatMany p :: Fixed Parser g s a
p@Parser{} = Parser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a
-> p g s a
-> p g s a
-> p g s a
-> p g s a
-> (ResultList g s a -> ResultList g s a -> ResultList g s a)
-> (Apply g => g (Const (ParserFlags g)) -> ParserFlags g)
-> Fixed p g s a
Parser{
      complete :: Parser g s a
complete= Parser g s a
cmp,
      direct :: Parser g s a
direct= Parser g s a
d0 Parser g s a -> Parser g s a -> Parser g s a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g s a
d1,
      direct0 :: Parser g s a
direct0= Parser g s a
d0,
      direct1 :: Parser g s a
direct1= Parser g s a
d1,
      indirect :: Parser g s a
indirect= a -> a -> a
forall a. Monoid a => a -> a -> a
mappend (a -> a -> a) -> Parser g s a -> Parser g s (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
indirect Fixed Parser g s a
p Parser g s (a -> a) -> Parser g s a -> Parser g s a
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g s a
cmp,
      appendResults :: ResultList g s a -> ResultList g s a -> ResultList g s a
appendResults= ResultList g s a -> ResultList g s a -> ResultList g s a
forall a. Monoid a => a -> a -> a
mappend,
      cyclicDescendants :: Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants= \deps :: g (Const (ParserFlags g))
deps-> (Fixed Parser g s a -> g (Const (ParserFlags g)) -> ParserFlags g
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants Fixed Parser g s a
p g (Const (ParserFlags g))
deps){nullable :: Bool
nullable= Bool
True}}
      where d0 :: Parser g s a
d0 = a -> Parser g s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
forall a. Monoid a => a
mempty Parser g s a -> Parser g s a -> Parser g s a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed Parser g s a
p
            d1 :: Parser g s a
d1 = a -> a -> a
forall a. Monoid a => a -> a -> a
mappend (a -> a -> a) -> Parser g s a -> Parser g s (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed Parser g s a
p Parser g s (a -> a) -> Parser g s a -> Parser g s a
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g s a
cmp
            cmp :: Parser g s a
cmp = Parser g s a -> Parser g s a
forall (m :: * -> * -> *) a s.
(MonoidParsing m, Monoid a) =>
m s a -> m s a
concatMany (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed Parser g s a
p)
   {-# INLINABLE string #-}
   {-# INLINABLE concatMany #-}

instance MonoidParsing (Fixed Backtrack.Parser g) where
   endOfInput :: Fixed Parser g s ()
endOfInput = String
-> Parser g s ()
-> Parser g s ()
-> Parser g s ()
-> Fixed Parser g s ()
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> p g s a -> p g s a -> Fixed p g s a
primitive "endOfInput" Parser g s ()
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
m s ()
endOfInput Parser g s ()
forall (f :: * -> *) a. Alternative f => f a
empty Parser g s ()
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
m s ()
endOfInput
   getInput :: Fixed Parser g s s
getInput = String
-> Parser g s s
-> Parser g s s
-> Parser g s s
-> Fixed Parser g s s
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> p g s a -> p g s a -> Fixed p g s a
primitive "getInput" Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
m s s
getInput Parser g s s
forall (f :: * -> *) a. Alternative f => f a
empty Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
m s s
getInput
   anyToken :: Fixed Parser g s s
anyToken = String -> Parser g s s -> Fixed Parser g s s
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> Fixed p g s a
positivePrimitive "anyToken" Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
m s s
anyToken
   satisfy :: (s -> Bool) -> Fixed Parser g s s
satisfy predicate :: s -> Bool
predicate = String -> Parser g s s -> Fixed Parser g s s
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> Fixed p g s a
positivePrimitive "satisfy" ((s -> Bool) -> Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
(s -> Bool) -> m s s
satisfy s -> Bool
predicate)
   satisfyChar :: (Char -> Bool) -> Fixed Parser g s Char
satisfyChar predicate :: Char -> Bool
predicate = String -> Parser g s Char -> Fixed Parser g s Char
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> Fixed p g s a
positivePrimitive "satisfyChar" ((Char -> Bool) -> Parser g s Char
forall (m :: * -> * -> *) s.
(MonoidParsing m, TextualMonoid s) =>
(Char -> Bool) -> m s Char
satisfyChar Char -> Bool
predicate)
   satisfyCharInput :: (Char -> Bool) -> Fixed Parser g s s
satisfyCharInput predicate :: Char -> Bool
predicate = String -> Parser g s s -> Fixed Parser g s s
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> Fixed p g s a
positivePrimitive "satisfyCharInput" ((Char -> Bool) -> Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, TextualMonoid s) =>
(Char -> Bool) -> m s s
satisfyCharInput Char -> Bool
predicate)
   notSatisfy :: (s -> Bool) -> Fixed Parser g s ()
notSatisfy predicate :: s -> Bool
predicate = String
-> Parser g s ()
-> Parser g s ()
-> Parser g s ()
-> Fixed Parser g s ()
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> p g s a -> p g s a -> Fixed p g s a
primitive "notSatisfy" ((s -> Bool) -> Parser g s ()
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
(s -> Bool) -> m s ()
notSatisfy s -> Bool
predicate) Parser g s ()
forall (f :: * -> *) a. Alternative f => f a
empty ((s -> Bool) -> Parser g s ()
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
(s -> Bool) -> m s ()
notSatisfy s -> Bool
predicate)
   notSatisfyChar :: (Char -> Bool) -> Fixed Parser g s ()
notSatisfyChar predicate :: Char -> Bool
predicate = String
-> Parser g s ()
-> Parser g s ()
-> Parser g s ()
-> Fixed Parser g s ()
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> p g s a -> p g s a -> Fixed p g s a
primitive "notSatisfyChar" ((Char -> Bool) -> Parser g s ()
forall (m :: * -> * -> *) s.
(MonoidParsing m, TextualMonoid s) =>
(Char -> Bool) -> m s ()
notSatisfyChar Char -> Bool
predicate) Parser g s ()
forall (f :: * -> *) a. Alternative f => f a
empty ((Char -> Bool) -> Parser g s ()
forall (m :: * -> * -> *) s.
(MonoidParsing m, TextualMonoid s) =>
(Char -> Bool) -> m s ()
notSatisfyChar Char -> Bool
predicate)
   scan :: s -> (s -> t -> Maybe s) -> Fixed Parser g t t
scan s0 :: s
s0 f :: s -> t -> Maybe s
f = String
-> Parser g t t
-> Parser g t t
-> Parser g t t
-> Fixed Parser g t t
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> p g s a -> p g s a -> Fixed p g s a
primitive "scan" (t
forall a. Monoid a => a
mempty t -> Parser g t () -> Parser g t t
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (t -> Bool) -> Parser g t ()
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
(s -> Bool) -> m s ()
notSatisfy t -> Bool
test) (Parser g t t -> Parser g t t
forall (m :: * -> *) a. LookAheadParsing m => m a -> m a
lookAhead ((t -> Bool) -> Parser g t t
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
(s -> Bool) -> m s s
satisfy t -> Bool
test) Parser g t t -> Parser g t t -> Parser g t t
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser g t t
p) Parser g t t
p
      where p :: Parser g t t
p = s -> (s -> t -> Maybe s) -> Parser g t t
forall (m :: * -> * -> *) t s.
(MonoidParsing m, FactorialMonoid t) =>
s -> (s -> t -> Maybe s) -> m t t
scan s
s0 s -> t -> Maybe s
f
            test :: t -> Bool
test = Maybe s -> Bool
forall a. Maybe a -> Bool
isJust (Maybe s -> Bool) -> (t -> Maybe s) -> t -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> t -> Maybe s
f s
s0
   scanChars :: s -> (s -> Char -> Maybe s) -> Fixed Parser g t t
scanChars s0 :: s
s0 f :: s -> Char -> Maybe s
f = String
-> Parser g t t
-> Parser g t t
-> Parser g t t
-> Fixed Parser g t t
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> p g s a -> p g s a -> Fixed p g s a
primitive "scanChars" (t
forall a. Monoid a => a
mempty t -> Parser g t () -> Parser g t t
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (Char -> Bool) -> Parser g t ()
forall (m :: * -> * -> *) s.
(MonoidParsing m, TextualMonoid s) =>
(Char -> Bool) -> m s ()
notSatisfyChar Char -> Bool
test) (Parser g t Char -> Parser g t Char
forall (m :: * -> *) a. LookAheadParsing m => m a -> m a
lookAhead ((Char -> Bool) -> Parser g t Char
forall (m :: * -> * -> *) s.
(MonoidParsing m, TextualMonoid s) =>
(Char -> Bool) -> m s Char
satisfyChar Char -> Bool
test) Parser g t Char -> Parser g t t -> Parser g t t
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser g t t
p) Parser g t t
p
      where p :: Parser g t t
p = s -> (s -> Char -> Maybe s) -> Parser g t t
forall (m :: * -> * -> *) t s.
(MonoidParsing m, TextualMonoid t) =>
s -> (s -> Char -> Maybe s) -> m t t
scanChars s
s0 s -> Char -> Maybe s
f
            test :: Char -> Bool
test = Maybe s -> Bool
forall a. Maybe a -> Bool
isJust (Maybe s -> Bool) -> (Char -> Maybe s) -> Char -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> Char -> Maybe s
f s
s0
   string :: s -> Fixed Parser g s s
string s :: s
s
      | s -> Bool
forall m. MonoidNull m => m -> Bool
null s
s = String
-> Parser g s s
-> Parser g s s
-> Parser g s s
-> Fixed Parser g s s
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> p g s a -> p g s a -> Fixed p g s a
primitive ("(string " String -> ShowS
forall a. [a] -> [a] -> [a]
++ s -> ShowS
forall a. Show a => a -> ShowS
shows s
s ")") (s -> Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s, LeftReductiveMonoid s,
 Show s) =>
s -> m s s
string s
s) Parser g s s
forall (f :: * -> *) a. Alternative f => f a
empty (s -> Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s, LeftReductiveMonoid s,
 Show s) =>
s -> m s s
string s
s)
      | Bool
otherwise = String -> Parser g s s -> Fixed Parser g s s
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> Fixed p g s a
positivePrimitive ("(string " String -> ShowS
forall a. [a] -> [a] -> [a]
++ s -> ShowS
forall a. Show a => a -> ShowS
shows s
s ")") (s -> Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s, LeftReductiveMonoid s,
 Show s) =>
s -> m s s
string s
s)
   takeWhile :: (s -> Bool) -> Fixed Parser g s s
takeWhile predicate :: s -> Bool
predicate = String
-> Parser g s s
-> Parser g s s
-> Parser g s s
-> Fixed Parser g s s
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> p g s a -> p g s a -> Fixed p g s a
primitive "takeWhile" (s
forall a. Monoid a => a
mempty s -> Parser g s () -> Parser g s s
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (s -> Bool) -> Parser g s ()
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
(s -> Bool) -> m s ()
notSatisfy s -> Bool
predicate)
                                               ((s -> Bool) -> Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
(s -> Bool) -> m s s
takeWhile1 s -> Bool
predicate) ((s -> Bool) -> Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
(s -> Bool) -> m s s
takeWhile s -> Bool
predicate)
   takeWhile1 :: (s -> Bool) -> Fixed Parser g s s
takeWhile1 predicate :: s -> Bool
predicate = String -> Parser g s s -> Fixed Parser g s s
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> Fixed p g s a
positivePrimitive "takeWhile1" ((s -> Bool) -> Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, FactorialMonoid s) =>
(s -> Bool) -> m s s
takeWhile1 s -> Bool
predicate)
   takeCharsWhile :: (Char -> Bool) -> Fixed Parser g s s
takeCharsWhile predicate :: Char -> Bool
predicate = String
-> Parser g s s
-> Parser g s s
-> Parser g s s
-> Fixed Parser g s s
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> p g s a -> p g s a -> Fixed p g s a
primitive "takeCharsWhile" (s
forall a. Monoid a => a
mempty s -> Parser g s () -> Parser g s s
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (Char -> Bool) -> Parser g s ()
forall (m :: * -> * -> *) s.
(MonoidParsing m, TextualMonoid s) =>
(Char -> Bool) -> m s ()
notSatisfyChar Char -> Bool
predicate)
                                                         ((Char -> Bool) -> Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, TextualMonoid s) =>
(Char -> Bool) -> m s s
takeCharsWhile1 Char -> Bool
predicate) ((Char -> Bool) -> Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, TextualMonoid s) =>
(Char -> Bool) -> m s s
takeCharsWhile Char -> Bool
predicate)
   takeCharsWhile1 :: (Char -> Bool) -> Fixed Parser g s s
takeCharsWhile1 predicate :: Char -> Bool
predicate = String -> Parser g s s -> Fixed Parser g s s
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
String -> p g s a -> Fixed p g s a
positivePrimitive "takeCharsWhile1" ((Char -> Bool) -> Parser g s s
forall (m :: * -> * -> *) s.
(MonoidParsing m, TextualMonoid s) =>
(Char -> Bool) -> m s s
takeCharsWhile1 Char -> Bool
predicate)
   concatMany :: Fixed Parser g s a -> Fixed Parser g s a
concatMany p :: Fixed Parser g s a
p@PositiveDirectParser{} = DirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> p g s a -> p g s a -> Fixed p g s a
DirectParser{
      complete :: Parser g s a
complete= Parser g s a
cmp,
      direct0 :: Parser g s a
direct0= Parser g s a
d0,
      direct1 :: Parser g s a
direct1= Parser g s a
d1}
      where d0 :: Parser g s a
d0 = a -> Parser g s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
forall a. Monoid a => a
mempty
            d1 :: Parser g s a
d1 = a -> a -> a
forall a. Monoid a => a -> a -> a
mappend (a -> a -> a) -> Parser g s a -> Parser g s (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed Parser g s a
p Parser g s (a -> a) -> Parser g s a -> Parser g s a
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g s a
cmp
            cmp :: Parser g s a
cmp = Parser g s a -> Parser g s a
forall (m :: * -> * -> *) a s.
(MonoidParsing m, Monoid a) =>
m s a -> m s a
concatMany (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed Parser g s a
p)
   concatMany p :: Fixed Parser g s a
p@DirectParser{} = DirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> p g s a -> p g s a -> Fixed p g s a
DirectParser{
      complete :: Parser g s a
complete= Parser g s a
cmp,
      direct0 :: Parser g s a
direct0= Parser g s a
d0,
      direct1 :: Parser g s a
direct1= Parser g s a
d1}
      where d0 :: Parser g s a
d0 = a -> Parser g s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
forall a. Monoid a => a
mempty 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
`Backtrack.alt` Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed Parser g s a
p
            d1 :: Parser g s a
d1 = a -> a -> a
forall a. Monoid a => a -> a -> a
mappend (a -> a -> a) -> Parser g s a -> Parser g s (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed Parser g s a
p Parser g s (a -> a) -> Parser g s a -> Parser g s a
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g s a
cmp
            cmp :: Parser g s a
cmp = Parser g s a -> Parser g s a
forall (m :: * -> * -> *) a s.
(MonoidParsing m, Monoid a) =>
m s a -> m s a
concatMany (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed Parser g s a
p)
   concatMany p :: Fixed Parser g s a
p@Parser{} = Parser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a
-> p g s a
-> p g s a
-> p g s a
-> p g s a
-> (ResultList g s a -> ResultList g s a -> ResultList g s a)
-> (Apply g => g (Const (ParserFlags g)) -> ParserFlags g)
-> Fixed p g s a
Parser{
      complete :: Parser g s a
complete= Parser g s a
cmp,
      direct :: Parser g s a
direct= Parser g s a
d0 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
`Backtrack.alt` Parser g s a
d1,
      direct0 :: Parser g s a
direct0= Parser g s a
d0,
      direct1 :: Parser g s a
direct1= Parser g s a
d1,
      indirect :: Parser g s a
indirect= a -> a -> a
forall a. Monoid a => a -> a -> a
mappend (a -> a -> a) -> Parser g s a -> Parser g s (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
indirect Fixed Parser g s a
p Parser g s (a -> a) -> Parser g s a -> Parser g s a
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g s a
cmp,
      appendResults :: ResultList g s a -> ResultList g s a -> ResultList g s a
appendResults= ResultList g s a -> ResultList g s a -> ResultList g s a
forall a. Monoid a => a -> a -> a
mappend,
      cyclicDescendants :: Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants= \deps :: g (Const (ParserFlags g))
deps-> (Fixed Parser g s a -> g (Const (ParserFlags g)) -> ParserFlags g
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants Fixed Parser g s a
p g (Const (ParserFlags g))
deps){nullable :: Bool
nullable= Bool
True}}
      where d0 :: Parser g s a
d0 = a -> Parser g s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
forall a. Monoid a => a
mempty 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
`Backtrack.alt` Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed Parser g s a
p
            d1 :: Parser g s a
d1 = a -> a -> a
forall a. Monoid a => a -> a -> a
mappend (a -> a -> a) -> Parser g s a -> Parser g s (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed Parser g s a
p Parser g s (a -> a) -> Parser g s a -> Parser g s a
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g s a
cmp
            cmp :: Parser g s a
cmp = Parser g s a -> Parser g s a
forall (m :: * -> * -> *) a s.
(MonoidParsing m, Monoid a) =>
m s a -> m s a
concatMany (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed Parser g s a
p)
   {-# INLINABLE string #-}
   {-# INLINABLE concatMany #-}

instance (Parsing (p g s), MonoidParsing (Fixed p g), Show s, TextualMonoid s) => CharParsing (Fixed p g s) where
   satisfy :: (Char -> Bool) -> Fixed p g s Char
satisfy = (Char -> Bool) -> Fixed p g s Char
forall (m :: * -> * -> *) s.
(MonoidParsing m, TextualMonoid s) =>
(Char -> Bool) -> m s Char
satisfyChar
   string :: String -> Fixed p 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) -> Fixed p g s s -> Fixed p g s String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> Fixed p 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 -> Fixed p g s Char
char = (Char -> Bool) -> Fixed p g s Char
forall (m :: * -> * -> *) s.
(MonoidParsing m, TextualMonoid s) =>
(Char -> Bool) -> m s Char
satisfyChar ((Char -> Bool) -> Fixed p g s Char)
-> (Char -> Char -> Bool) -> Char -> Fixed p 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 -> Fixed p g s Char
notChar = (Char -> Bool) -> Fixed p g s Char
forall (m :: * -> * -> *) s.
(MonoidParsing m, TextualMonoid s) =>
(Char -> Bool) -> m s Char
satisfyChar ((Char -> Bool) -> Fixed p g s Char)
-> (Char -> Char -> Bool) -> Char -> Fixed p g s Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
(/=)
   anyChar :: Fixed p g s Char
anyChar = (Char -> Bool) -> Fixed p 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 -> Fixed p 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) -> Fixed p g s s -> Fixed p g s Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> Fixed p 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 (Fixed Backtrack.Parser) g s, Show s, TextualMonoid s) =>
         TokenParsing (Fixed Backtrack.Parser g s) where
   someSpace :: Fixed Parser g s ()
someSpace = Fixed Parser g s ()
forall (g :: (* -> *) -> *) (m :: ((* -> *) -> *) -> * -> * -> *)
       s.
(Lexical g, LexicalConstraint m g s) =>
m g s ()
someLexicalSpace
   semi :: Fixed Parser g s Char
semi = Fixed Parser g s Char
forall (g :: (* -> *) -> *) (m :: ((* -> *) -> *) -> * -> * -> *)
       s.
(Lexical g, LexicalConstraint m g s) =>
m g s Char
lexicalSemicolon
   token :: Fixed Parser g s a -> Fixed Parser g s a
token = Fixed Parser g s a -> Fixed 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 (Lexical g, LexicalConstraint (Fixed Memoizing.Parser) g s, Show s, TextualMonoid s) =>
         TokenParsing (Fixed Memoizing.Parser g s) where
   someSpace :: Fixed Parser g s ()
someSpace = Fixed Parser g s ()
forall (g :: (* -> *) -> *) (m :: ((* -> *) -> *) -> * -> * -> *)
       s.
(Lexical g, LexicalConstraint m g s) =>
m g s ()
someLexicalSpace
   semi :: Fixed Parser g s Char
semi = Fixed Parser g s Char
forall (g :: (* -> *) -> *) (m :: ((* -> *) -> *) -> * -> * -> *)
       s.
(Lexical g, LexicalConstraint m g s) =>
m g s Char
lexicalSemicolon
   token :: Fixed Parser g s a -> Fixed Parser g s a
token = Fixed Parser g s a -> Fixed 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 AmbiguousParsing (Fixed Memoizing.Parser g s) where
   ambiguous :: Fixed Parser g s a -> Fixed Parser g s (Ambiguous a)
ambiguous (PositiveDirectParser p :: Parser g s a
p) = Parser g s (Ambiguous a) -> Fixed Parser g s (Ambiguous a)
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> Fixed p g s a
PositiveDirectParser (Parser g s a -> Parser g s (Ambiguous a)
forall (m :: * -> *) a.
AmbiguousParsing m =>
m a -> m (Ambiguous a)
ambiguous Parser g s a
p)
   ambiguous p :: Fixed Parser g s a
p@DirectParser{} = DirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> p g s a -> p g s a -> Fixed p g s a
DirectParser{complete :: Parser g s (Ambiguous a)
complete= Parser g s a -> Parser g s (Ambiguous a)
forall (m :: * -> *) a.
AmbiguousParsing m =>
m a -> m (Ambiguous a)
ambiguous (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed Parser g s a
p),
                                             direct0 :: Parser g s (Ambiguous a)
direct0=  Parser g s a -> Parser g s (Ambiguous a)
forall (m :: * -> *) a.
AmbiguousParsing m =>
m a -> m (Ambiguous a)
ambiguous (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed Parser g s a
p),
                                             direct1 :: Parser g s (Ambiguous a)
direct1=  Parser g s a -> Parser g s (Ambiguous a)
forall (m :: * -> *) a.
AmbiguousParsing m =>
m a -> m (Ambiguous a)
ambiguous (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed Parser g s a
p)}
   ambiguous p :: Fixed Parser g s a
p@Parser{} = Parser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a
-> p g s a
-> p g s a
-> p g s a
-> p g s a
-> (ResultList g s a -> ResultList g s a -> ResultList g s a)
-> (Apply g => g (Const (ParserFlags g)) -> ParserFlags g)
-> Fixed p g s a
Parser{complete :: Parser g s (Ambiguous a)
complete= Parser g s a -> Parser g s (Ambiguous a)
forall (m :: * -> *) a.
AmbiguousParsing m =>
m a -> m (Ambiguous a)
ambiguous (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed Parser g s a
p),
                                 direct :: Parser g s (Ambiguous a)
direct=   Parser g s a -> Parser g s (Ambiguous a)
forall (m :: * -> *) a.
AmbiguousParsing m =>
m a -> m (Ambiguous a)
ambiguous (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct Fixed Parser g s a
p),
                                 direct0 :: Parser g s (Ambiguous a)
direct0=  Parser g s a -> Parser g s (Ambiguous a)
forall (m :: * -> *) a.
AmbiguousParsing m =>
m a -> m (Ambiguous a)
ambiguous (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed Parser g s a
p),
                                 direct1 :: Parser g s (Ambiguous a)
direct1=  Parser g s a -> Parser g s (Ambiguous a)
forall (m :: * -> *) a.
AmbiguousParsing m =>
m a -> m (Ambiguous a)
ambiguous (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed Parser g s a
p),
                                 indirect :: Parser g s (Ambiguous a)
indirect= Parser g s a -> Parser g s (Ambiguous a)
forall (m :: * -> *) a.
AmbiguousParsing m =>
m a -> m (Ambiguous a)
ambiguous (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
indirect Fixed Parser g s a
p),
                                 appendResults :: ResultList g s (Ambiguous a)
-> ResultList g s (Ambiguous a) -> ResultList g s (Ambiguous a)
appendResults= ResultList g s (Ambiguous a)
-> ResultList g s (Ambiguous a) -> ResultList g s (Ambiguous a)
forall (g :: (* -> *) -> *) s a.
ResultList g s (Ambiguous a)
-> ResultList g s (Ambiguous a) -> ResultList g s (Ambiguous a)
appendAmbiguous,
                                 cyclicDescendants :: Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants= Fixed Parser g s a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants Fixed Parser g s a
p}
      where appendAmbiguous :: ResultList g s (Ambiguous a)
-> ResultList g s (Ambiguous a) -> ResultList g s (Ambiguous a)
appendAmbiguous (ResultList rl1 :: [ResultsOfLength g s (Ambiguous a)]
rl1 f1 :: FailureInfo
f1) (ResultList rl2 :: [ResultsOfLength g s (Ambiguous a)]
rl2 f2 :: FailureInfo
f2) = [ResultsOfLength g s (Ambiguous a)]
-> FailureInfo -> ResultList g s (Ambiguous a)
forall (g :: (* -> *) -> *) s r.
[ResultsOfLength g s r] -> FailureInfo -> ResultList g s r
ResultList ([ResultsOfLength g s (Ambiguous a)]
-> [ResultsOfLength g s (Ambiguous a)]
-> [ResultsOfLength g s (Ambiguous a)]
forall (g :: (* -> *) -> *) s a.
[ResultsOfLength g s (Ambiguous a)]
-> [ResultsOfLength g s (Ambiguous a)]
-> [ResultsOfLength g s (Ambiguous a)]
join [ResultsOfLength g s (Ambiguous a)]
rl1 [ResultsOfLength g s (Ambiguous a)]
rl2) (FailureInfo
f1 FailureInfo -> FailureInfo -> FailureInfo
forall a. Semigroup a => a -> a -> a
<> FailureInfo
f2)
            join :: [ResultsOfLength g s (Ambiguous a)]
-> [ResultsOfLength g s (Ambiguous a)]
-> [ResultsOfLength g s (Ambiguous a)]
join [] rl :: [ResultsOfLength g s (Ambiguous a)]
rl = [ResultsOfLength g s (Ambiguous a)]
rl
            join rl :: [ResultsOfLength g s (Ambiguous a)]
rl [] = [ResultsOfLength g s (Ambiguous a)]
rl
            join rl1' :: [ResultsOfLength g s (Ambiguous a)]
rl1'@(rol1 :: ResultsOfLength g s (Ambiguous a)
rol1@(ResultsOfLength l1 :: Int
l1 s1 :: [(s, g (ResultList g s))]
s1 r1 :: NonEmpty (Ambiguous a)
r1) : rest1 :: [ResultsOfLength g s (Ambiguous a)]
rest1) rl2' :: [ResultsOfLength g s (Ambiguous a)]
rl2'@(rol2 :: ResultsOfLength g s (Ambiguous a)
rol2@(ResultsOfLength l2 :: Int
l2 _ r2 :: NonEmpty (Ambiguous a)
r2) : rest2 :: [ResultsOfLength g s (Ambiguous a)]
rest2)
               | Int
l1 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
l2 = ResultsOfLength g s (Ambiguous a)
rol1 ResultsOfLength g s (Ambiguous a)
-> [ResultsOfLength g s (Ambiguous a)]
-> [ResultsOfLength g s (Ambiguous a)]
forall a. a -> [a] -> [a]
: [ResultsOfLength g s (Ambiguous a)]
-> [ResultsOfLength g s (Ambiguous a)]
-> [ResultsOfLength g s (Ambiguous a)]
join [ResultsOfLength g s (Ambiguous a)]
rest1 [ResultsOfLength g s (Ambiguous a)]
rl2'
               | Int
l1 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
l2 = ResultsOfLength g s (Ambiguous a)
rol2 ResultsOfLength g s (Ambiguous a)
-> [ResultsOfLength g s (Ambiguous a)]
-> [ResultsOfLength g s (Ambiguous a)]
forall a. a -> [a] -> [a]
: [ResultsOfLength g s (Ambiguous a)]
-> [ResultsOfLength g s (Ambiguous a)]
-> [ResultsOfLength g s (Ambiguous a)]
join [ResultsOfLength g s (Ambiguous a)]
rl1' [ResultsOfLength g s (Ambiguous a)]
rest2
               | Ambiguous ar1 :: NonEmpty a
ar1 :| [] <- NonEmpty (Ambiguous a)
r1,
                 Ambiguous ar2 :: NonEmpty a
ar2 :| [] <- NonEmpty (Ambiguous a)
r2 =
                    Int
-> [(s, g (ResultList g s))]
-> NonEmpty (Ambiguous a)
-> ResultsOfLength g s (Ambiguous a)
forall (g :: (* -> *) -> *) s r.
Int
-> [(s, g (ResultList g s))] -> NonEmpty r -> ResultsOfLength g s r
ResultsOfLength Int
l1 [(s, g (ResultList g s))]
s1 (NonEmpty a -> Ambiguous a
forall a. NonEmpty a -> Ambiguous a
Ambiguous (NonEmpty a
ar1 NonEmpty a -> NonEmpty a -> NonEmpty a
forall a. Semigroup a => a -> a -> a
<> NonEmpty a
ar2) Ambiguous a -> [Ambiguous a] -> NonEmpty (Ambiguous a)
forall a. a -> [a] -> NonEmpty a
:| []) ResultsOfLength g s (Ambiguous a)
-> [ResultsOfLength g s (Ambiguous a)]
-> [ResultsOfLength g s (Ambiguous a)]
forall a. a -> [a] -> [a]
: [ResultsOfLength g s (Ambiguous a)]
-> [ResultsOfLength g s (Ambiguous a)]
-> [ResultsOfLength g s (Ambiguous a)]
join [ResultsOfLength g s (Ambiguous a)]
rest1 [ResultsOfLength g s (Ambiguous a)]
rest2
               | Bool
otherwise = String -> [ResultsOfLength g s (Ambiguous a)]
forall a. HasCallStack => String -> a
error "Ambiguous results should be grouped as a single value"
   {-# INLINABLE ambiguous #-}

-- | Turns a context-free parser into a backtracking PEG parser that consumes the longest possible prefix of the list
-- of input tails, opposite of 'peg'
longest :: Fixed Memoizing.Parser g s a -> Fixed Backtrack.Parser g [(s, g (ResultList g s))] a
longest :: Fixed Parser g s a -> Fixed Parser g [(s, g (ResultList g s))] a
longest (PositiveDirectParser p :: Parser g s a
p) = Parser g [(s, g (ResultList g s))] a
-> Fixed Parser g [(s, g (ResultList g s))] a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> Fixed p g s a
PositiveDirectParser (Parser g s a -> Parser g [(s, g (ResultList g s))] a
forall (g :: (* -> *) -> *) s a.
Parser g s a -> Parser g [(s, g (ResultList g s))] a
Memoizing.longest Parser g s a
p)
longest p :: Fixed Parser g s a
p@DirectParser{} = DirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> p g s a -> p g s a -> Fixed p g s a
DirectParser{complete :: Parser g [(s, g (ResultList g s))] a
complete= Parser g s a -> Parser g [(s, g (ResultList g s))] a
forall (g :: (* -> *) -> *) s a.
Parser g s a -> Parser g [(s, g (ResultList g s))] a
Memoizing.longest (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed Parser g s a
p),
                                        direct0 :: Parser g [(s, g (ResultList g s))] a
direct0=  Parser g s a -> Parser g [(s, g (ResultList g s))] a
forall (g :: (* -> *) -> *) s a.
Parser g s a -> Parser g [(s, g (ResultList g s))] a
Memoizing.longest (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed Parser g s a
p),
                                        direct1 :: Parser g [(s, g (ResultList g s))] a
direct1=  Parser g s a -> Parser g [(s, g (ResultList g s))] a
forall (g :: (* -> *) -> *) s a.
Parser g s a -> Parser g [(s, g (ResultList g s))] a
Memoizing.longest (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed Parser g s a
p)}
longest p :: Fixed Parser g s a
p@Parser{} = Parser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a
-> p g s a
-> p g s a
-> p g s a
-> p g s a
-> (ResultList g s a -> ResultList g s a -> ResultList g s a)
-> (Apply g => g (Const (ParserFlags g)) -> ParserFlags g)
-> Fixed p g s a
Parser{complete :: Parser g [(s, g (ResultList g s))] a
complete= Parser g s a -> Parser g [(s, g (ResultList g s))] a
forall (g :: (* -> *) -> *) s a.
Parser g s a -> Parser g [(s, g (ResultList g s))] a
Memoizing.longest (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed Parser g s a
p),
                            direct :: Parser g [(s, g (ResultList g s))] a
direct=  Parser g s a -> Parser g [(s, g (ResultList g s))] a
forall (g :: (* -> *) -> *) s a.
Parser g s a -> Parser g [(s, g (ResultList g s))] a
Memoizing.longest (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct Fixed Parser g s a
p),
                            direct0 :: Parser g [(s, g (ResultList g s))] a
direct0=  Parser g s a -> Parser g [(s, g (ResultList g s))] a
forall (g :: (* -> *) -> *) s a.
Parser g s a -> Parser g [(s, g (ResultList g s))] a
Memoizing.longest (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed Parser g s a
p),
                            direct1 :: Parser g [(s, g (ResultList g s))] a
direct1=  Parser g s a -> Parser g [(s, g (ResultList g s))] a
forall (g :: (* -> *) -> *) s a.
Parser g s a -> Parser g [(s, g (ResultList g s))] a
Memoizing.longest (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed Parser g s a
p),
                            indirect :: Parser g [(s, g (ResultList g s))] a
indirect=  Parser g s a -> Parser g [(s, g (ResultList g s))] a
forall (g :: (* -> *) -> *) s a.
Parser g s a -> Parser g [(s, g (ResultList g s))] a
Memoizing.longest (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
indirect Fixed Parser g s a
p),
                            appendResults :: ResultList g [(s, g (ResultList g s))] a
-> ResultList g [(s, g (ResultList g s))] a
-> ResultList g [(s, g (ResultList g s))] a
appendResults= ResultList g [(s, g (ResultList g s))] a
-> ResultList g [(s, g (ResultList g s))] a
-> ResultList g [(s, g (ResultList g s))] a
forall a. Semigroup a => a -> a -> a
(<>),
                            cyclicDescendants :: Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants= Fixed Parser g s a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants Fixed Parser g s a
p}

-- | Turns a backtracking PEG parser of the list of input tails into a context-free parser, opposite of 'longest'
peg :: Fixed Backtrack.Parser g [(s, g (ResultList g s))] a -> Fixed Memoizing.Parser g s a
peg :: Fixed Parser g [(s, g (ResultList g s))] a -> Fixed Parser g s a
peg (PositiveDirectParser p :: Parser g [(s, g (ResultList g s))] a
p) = Parser g s a -> Fixed Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> Fixed p g s a
PositiveDirectParser (Parser g [(s, g (ResultList g s))] a -> Parser g s a
forall (g :: (* -> *) -> *) s a.
Parser g [(s, g (ResultList g s))] a -> Parser g s a
Memoizing.peg Parser g [(s, g (ResultList g s))] a
p)
peg p :: Fixed Parser g [(s, g (ResultList g s))] a
p@DirectParser{} = DirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> p g s a -> p g s a -> Fixed p g s a
DirectParser{complete :: Parser g s a
complete= Parser g [(s, g (ResultList g s))] a -> Parser g s a
forall (g :: (* -> *) -> *) s a.
Parser g [(s, g (ResultList g s))] a -> Parser g s a
Memoizing.peg (Fixed Parser g [(s, g (ResultList g s))] a
-> Parser g [(s, g (ResultList g s))] a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed Parser g [(s, g (ResultList g s))] a
p),
                                        direct0 :: Parser g s a
direct0=  Parser g [(s, g (ResultList g s))] a -> Parser g s a
forall (g :: (* -> *) -> *) s a.
Parser g [(s, g (ResultList g s))] a -> Parser g s a
Memoizing.peg (Fixed Parser g [(s, g (ResultList g s))] a
-> Parser g [(s, g (ResultList g s))] a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed Parser g [(s, g (ResultList g s))] a
p),
                                        direct1 :: Parser g s a
direct1=  Parser g [(s, g (ResultList g s))] a -> Parser g s a
forall (g :: (* -> *) -> *) s a.
Parser g [(s, g (ResultList g s))] a -> Parser g s a
Memoizing.peg (Fixed Parser g [(s, g (ResultList g s))] a
-> Parser g [(s, g (ResultList g s))] a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed Parser g [(s, g (ResultList g s))] a
p)}
peg p :: Fixed Parser g [(s, g (ResultList g s))] a
p@Parser{} = Parser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a
-> p g s a
-> p g s a
-> p g s a
-> p g s a
-> (ResultList g s a -> ResultList g s a -> ResultList g s a)
-> (Apply g => g (Const (ParserFlags g)) -> ParserFlags g)
-> Fixed p g s a
Parser{complete :: Parser g s a
complete= Parser g [(s, g (ResultList g s))] a -> Parser g s a
forall (g :: (* -> *) -> *) s a.
Parser g [(s, g (ResultList g s))] a -> Parser g s a
Memoizing.peg (Fixed Parser g [(s, g (ResultList g s))] a
-> Parser g [(s, g (ResultList g s))] a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed Parser g [(s, g (ResultList g s))] a
p),
                        direct :: Parser g s a
direct=  Parser g [(s, g (ResultList g s))] a -> Parser g s a
forall (g :: (* -> *) -> *) s a.
Parser g [(s, g (ResultList g s))] a -> Parser g s a
Memoizing.peg (Fixed Parser g [(s, g (ResultList g s))] a
-> Parser g [(s, g (ResultList g s))] a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct Fixed Parser g [(s, g (ResultList g s))] a
p),
                        direct0 :: Parser g s a
direct0=  Parser g [(s, g (ResultList g s))] a -> Parser g s a
forall (g :: (* -> *) -> *) s a.
Parser g [(s, g (ResultList g s))] a -> Parser g s a
Memoizing.peg (Fixed Parser g [(s, g (ResultList g s))] a
-> Parser g [(s, g (ResultList g s))] a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed Parser g [(s, g (ResultList g s))] a
p),
                        direct1 :: Parser g s a
direct1=  Parser g [(s, g (ResultList g s))] a -> Parser g s a
forall (g :: (* -> *) -> *) s a.
Parser g [(s, g (ResultList g s))] a -> Parser g s a
Memoizing.peg (Fixed Parser g [(s, g (ResultList g s))] a
-> Parser g [(s, g (ResultList g s))] a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed Parser g [(s, g (ResultList g s))] a
p),
                        indirect :: Parser g s a
indirect=  Parser g [(s, g (ResultList g s))] a -> Parser g s a
forall (g :: (* -> *) -> *) s a.
Parser g [(s, g (ResultList g s))] a -> Parser g s a
Memoizing.peg (Fixed Parser g [(s, g (ResultList g s))] a
-> Parser g [(s, g (ResultList g s))] a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
indirect Fixed Parser g [(s, g (ResultList g s))] a
p),
                        appendResults :: ResultList g s a -> ResultList g s a -> ResultList g s a
appendResults= ResultList g s a -> ResultList g s a -> ResultList g s a
forall a. Semigroup a => a -> a -> a
(<>),
                        cyclicDescendants :: Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants= Fixed Parser g [(s, g (ResultList g s))] a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants Fixed Parser g [(s, g (ResultList g s))] a
p}

-- | Turns a backtracking PEG parser into a context-free parser
terminalPEG :: Monoid s => Fixed Backtrack.Parser g s a -> Fixed Memoizing.Parser g s a
terminalPEG :: Fixed Parser g s a -> Fixed Parser g s a
terminalPEG (PositiveDirectParser p :: Parser g s a
p) = Parser g s a -> Fixed Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> Fixed p g s a
PositiveDirectParser (Parser g s a -> Parser g s a
forall s (g :: (* -> *) -> *) a.
Monoid s =>
Parser g s a -> Parser g s a
Memoizing.terminalPEG Parser g s a
p)
terminalPEG p :: Fixed Parser g s a
p@DirectParser{} = DirectParser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> p g s a -> p g s a -> Fixed p g s a
DirectParser{complete :: Parser g s a
complete= Parser g s a -> Parser g s a
forall s (g :: (* -> *) -> *) a.
Monoid s =>
Parser g s a -> Parser g s a
Memoizing.terminalPEG (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed Parser g s a
p),
                                            direct0 :: Parser g s a
direct0=  Parser g s a -> Parser g s a
forall s (g :: (* -> *) -> *) a.
Monoid s =>
Parser g s a -> Parser g s a
Memoizing.terminalPEG (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed Parser g s a
p),
                                            direct1 :: Parser g s a
direct1=  Parser g s a -> Parser g s a
forall s (g :: (* -> *) -> *) a.
Monoid s =>
Parser g s a -> Parser g s a
Memoizing.terminalPEG (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed Parser g s a
p)}
terminalPEG p :: Fixed Parser g s a
p@Parser{} = Parser :: forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a
-> p g s a
-> p g s a
-> p g s a
-> p g s a
-> (ResultList g s a -> ResultList g s a -> ResultList g s a)
-> (Apply g => g (Const (ParserFlags g)) -> ParserFlags g)
-> Fixed p g s a
Parser{complete :: Parser g s a
complete= Parser g s a -> Parser g s a
forall s (g :: (* -> *) -> *) a.
Monoid s =>
Parser g s a -> Parser g s a
Memoizing.terminalPEG (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Fixed Parser g s a
p),
                                direct :: Parser g s a
direct=  Parser g s a -> Parser g s a
forall s (g :: (* -> *) -> *) a.
Monoid s =>
Parser g s a -> Parser g s a
Memoizing.terminalPEG (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct Fixed Parser g s a
p),
                                direct0 :: Parser g s a
direct0=  Parser g s a -> Parser g s a
forall s (g :: (* -> *) -> *) a.
Monoid s =>
Parser g s a -> Parser g s a
Memoizing.terminalPEG (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct0 Fixed Parser g s a
p),
                                direct1 :: Parser g s a
direct1=  Parser g s a -> Parser g s a
forall s (g :: (* -> *) -> *) a.
Monoid s =>
Parser g s a -> Parser g s a
Memoizing.terminalPEG (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct1 Fixed Parser g s a
p),
                                indirect :: Parser g s a
indirect=  Parser g s a -> Parser g s a
forall s (g :: (* -> *) -> *) a.
Monoid s =>
Parser g s a -> Parser g s a
Memoizing.terminalPEG (Fixed Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
indirect Fixed Parser g s a
p),
                                appendResults :: ResultList g s a -> ResultList g s a -> ResultList g s a
appendResults= ResultList g s a -> ResultList g s a -> ResultList g s a
forall a. Semigroup a => a -> a -> a
(<>),
                                cyclicDescendants :: Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants= Fixed Parser g s a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants Fixed Parser g s a
p}

parseRecursive :: forall g s. (Rank2.Apply g, Rank2.Distributive g, Rank2.Traversable g, FactorialMonoid s) =>
                  g (Parser g s) -> s -> [(s, g (ResultList g s))]
parseRecursive :: g (Parser g s) -> s -> [(s, g (ResultList g s))]
parseRecursive = g (SeparatedParser Parser g s) -> s -> [(s, g (ResultList g s))]
forall (g :: (* -> *) -> *) s.
(Apply g, Foldable g, FactorialMonoid s) =>
g (SeparatedParser Parser g s) -> s -> [(s, g (ResultList g s))]
parseSeparated (g (SeparatedParser Parser g s) -> s -> [(s, g (ResultList g s))])
-> (g (Parser g s) -> g (SeparatedParser Parser g s))
-> g (Parser g s)
-> s
-> [(s, g (ResultList g s))]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. g (Parser g s) -> g (SeparatedParser Parser g s)
forall (g :: (* -> *) -> *) s.
(Apply g, Distributive g, Traversable g) =>
g (Parser g s) -> g (SeparatedParser Parser g s)
separated
{-# INLINE parseRecursive #-}

separated :: forall g s. (Rank2.Apply g, Rank2.Distributive g, Rank2.Traversable g) =>
             g (Parser g s) -> g (SeparatedParser Memoizing.Parser g s)
separated :: g (Parser g s) -> g (SeparatedParser Parser g s)
separated g :: g (Parser g s)
g = (forall a.
 Const Bool a
 -> Const Bool a
 -> Const (g (Const Bool)) a
 -> Parser g s a
 -> SeparatedParser Parser g s a)
-> g (Const Bool)
-> g (Const Bool)
-> g (Const (g (Const Bool)))
-> g (Parser g s)
-> g (SeparatedParser Parser g s)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
       (r :: k -> *) (s :: k -> *) (t :: k -> *).
Apply g =>
(forall (a :: k). p a -> q a -> r a -> s a -> t a)
-> g p -> g q -> g r -> g s -> g t
Rank2.liftA4 forall a.
Const Bool a
-> Const Bool a
-> Const (g (Const Bool)) a
-> Parser g s a
-> SeparatedParser Parser g s a
reseparate g (Const Bool)
circulars g (Const Bool)
cycleFollowers g (Const (g (Const Bool)))
descendants g (Parser g s)
g
   where descendants :: g (Const (g (Const Bool)))
         cycleFollowers, circulars :: g (Const Bool)
         cyclicDescendantses :: g (Const (ParserFlags g))
         leftRecursive :: forall a. Const (g (Const Bool)) a -> Const (ParserFlags g) a -> Const Bool a
         leftRecursiveDeps :: forall a. Const Bool a -> Const (ParserFlags g) a -> Const (g (Const Bool)) a
         reseparate :: forall a. Const Bool a -> Const Bool a -> Const (g (Const Bool)) a -> Parser g s a
                    -> SeparatedParser Memoizing.Parser g s a
         reseparate :: Const Bool a
-> Const Bool a
-> Const (g (Const Bool)) a
-> Parser g s a
-> SeparatedParser Parser g s a
reseparate (Const circular :: Bool
circular) (Const follower :: Bool
follower) (Const deps :: g (Const Bool)
deps) p :: Parser g s a
p
            | Bool
circular Bool -> Bool -> Bool
|| Bool
leader Bool -> Bool -> Bool
&& Bool
follower =
              Parser g s a
-> Parser g s a
-> ResultAppend g s a
-> g (Const Bool)
-> SeparatedParser Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a
-> p g s a
-> ResultAppend g s a
-> g (Const Bool)
-> SeparatedParser p g s a
CycleParser (Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
indirect Parser g s a
p) (Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
direct Parser g s a
p) ((ResultList g s a -> Arrow (ResultList g s) (ResultList g s) a)
-> ResultAppend g s a
forall k (p :: k -> *) (q :: k -> *) (a :: k).
(p a -> q a) -> Arrow p q a
Rank2.Arrow ((ResultList g s a -> ResultList g s a)
-> Arrow (ResultList g s) (ResultList g s) a
forall k (p :: k -> *) (q :: k -> *) (a :: k).
(p a -> q a) -> Arrow p q a
Rank2.Arrow ((ResultList g s a -> ResultList g s a)
 -> Arrow (ResultList g s) (ResultList g s) a)
-> (ResultList g s a -> ResultList g s a -> ResultList g s a)
-> ResultList g s a
-> Arrow (ResultList g s) (ResultList g s) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Parser g s a
-> ResultList g s a -> ResultList g s a -> ResultList g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a
-> ResultList g s a -> ResultList g s a -> ResultList g s a
appendResults Parser g s a
p)) g (Const Bool)
deps
            | Bool
follower = Parser g s a -> SeparatedParser Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> SeparatedParser p g s a
BackParser (Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Parser g s a
p)
            | Bool
otherwise = Parser g s a -> SeparatedParser Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
p g s a -> SeparatedParser p g s a
FrontParser (Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a -> p g s a
complete Parser g s a
p)
            where leader :: Bool
leader = Any -> Bool
getAny ((forall a. Const Bool a -> Any) -> g (Const Bool) -> Any
forall k (g :: (k -> *) -> *) m (p :: k -> *).
(Foldable g, Monoid m) =>
(forall (a :: k). p a -> m) -> g p -> m
Rank2.foldMap (Bool -> Any
Any (Bool -> Any) -> (Const Bool a -> Bool) -> Const Bool a -> Any
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Const Bool a -> Bool
forall a k (b :: k). Const a b -> a
getConst) (g (Const Bool) -> Any) -> g (Const Bool) -> Any
forall a b. (a -> b) -> a -> b
$ (forall a. Const Bool a -> Const Bool a -> Const Bool a)
-> g (Const Bool) -> g (Const Bool) -> g (Const Bool)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
       (r :: k -> *).
Apply g =>
(forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
Rank2.liftA2 forall a. Const Bool a -> Const Bool a -> Const Bool a
forall b b b. Const Bool b -> Const Bool b -> Const Bool b
intersection g (Const Bool)
circulars g (Const Bool)
deps)
         descendants :: g (Const (g (Const Bool)))
descendants = (forall a. Const (ParserFlags g) a -> Const (g (Const Bool)) a)
-> g (Const (ParserFlags g)) -> g (Const (g (Const Bool)))
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Functor g =>
(forall (a :: k). p a -> q a) -> g p -> g q
Rank2.fmap (g (Const Bool) -> Const (g (Const Bool)) a
forall k a (b :: k). a -> Const a b
Const (g (Const Bool) -> Const (g (Const Bool)) a)
-> (Const (ParserFlags g) a -> g (Const Bool))
-> Const (ParserFlags g) a
-> Const (g (Const Bool)) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParserFlags g -> g (Const Bool)
forall (g :: (* -> *) -> *). ParserFlags g -> g (Const Bool)
dependsOn (ParserFlags g -> g (Const Bool))
-> (Const (ParserFlags g) a -> ParserFlags g)
-> Const (ParserFlags g) a
-> g (Const Bool)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Const (ParserFlags g) a -> ParserFlags g
forall a k (b :: k). Const a b -> a
getConst) g (Const (ParserFlags g))
cyclicDescendantses
         cyclicDescendantses :: g (Const (ParserFlags g))
cyclicDescendantses = g (Const (g (Const (ParserFlags g)) -> ParserFlags g))
-> g (Const (ParserFlags g))
forall (g :: (* -> *) -> *).
(Apply g, Traversable g) =>
g (Const (g (Const (ParserFlags g)) -> ParserFlags g))
-> g (Const (ParserFlags g))
fixDescendants ((forall a.
 Parser g s a
 -> Const (g (Const (ParserFlags g)) -> ParserFlags g) a)
-> g (Parser g s)
-> g (Const (g (Const (ParserFlags g)) -> ParserFlags g))
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Functor g =>
(forall (a :: k). p a -> q a) -> g p -> g q
Rank2.fmap ((g (Const (ParserFlags g)) -> ParserFlags g)
-> Const (g (Const (ParserFlags g)) -> ParserFlags g) a
forall k a (b :: k). a -> Const a b
Const ((g (Const (ParserFlags g)) -> ParserFlags g)
 -> Const (g (Const (ParserFlags g)) -> ParserFlags g) a)
-> (Fixed Parser g s a
    -> g (Const (ParserFlags g)) -> ParserFlags g)
-> Fixed Parser g s a
-> Const (g (Const (ParserFlags g)) -> ParserFlags g) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fixed Parser g s a -> g (Const (ParserFlags g)) -> ParserFlags g
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Fixed p g s a
-> Apply g => g (Const (ParserFlags g)) -> ParserFlags g
cyclicDescendants (Fixed Parser g s a -> g (Const (ParserFlags g)) -> ParserFlags g)
-> (Fixed Parser g s a -> Fixed Parser g s a)
-> Fixed Parser g s a
-> g (Const (ParserFlags g))
-> ParserFlags g
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fixed Parser g s a -> Fixed Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
Alternative (p g s) =>
Fixed p g s a -> Fixed p g s a
general) g (Parser g s)
g)
         circulars :: g (Const Bool)
circulars = (forall a.
 Const (g (Const Bool)) a
 -> Const (ParserFlags g) a -> Const Bool a)
-> g (Const (g (Const Bool)))
-> g (Const (ParserFlags g))
-> g (Const Bool)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
       (r :: k -> *).
Apply g =>
(forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
Rank2.liftA2 forall a.
Const (g (Const Bool)) a -> Const (ParserFlags g) a -> Const Bool a
leftRecursive g (Const (g (Const Bool)))
forall (g :: (* -> *) -> *).
(Distributive g, Traversable g) =>
g (Const (g (Const Bool)))
bits g (Const (ParserFlags g))
cyclicDescendantses
         cycleFollowers :: g (Const Bool)
cycleFollowers = Union g -> g (Const Bool)
forall (g :: (* -> *) -> *). Union g -> g (Const Bool)
getUnion ((forall a. Const (g (Const Bool)) a -> Union g)
-> g (Const (g (Const Bool))) -> Union g
forall k (g :: (k -> *) -> *) m (p :: k -> *).
(Foldable g, Monoid m) =>
(forall (a :: k). p a -> m) -> g p -> m
Rank2.foldMap (g (Const Bool) -> Union g
forall (g :: (* -> *) -> *). g (Const Bool) -> Union g
Union (g (Const Bool) -> Union g)
-> (Const (g (Const Bool)) a -> g (Const Bool))
-> Const (g (Const Bool)) a
-> Union g
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Const (g (Const Bool)) a -> g (Const Bool)
forall a k (b :: k). Const a b -> a
getConst) (g (Const (g (Const Bool))) -> Union g)
-> g (Const (g (Const Bool))) -> Union g
forall a b. (a -> b) -> a -> b
$
                                    (forall a.
 Const Bool a
 -> Const (ParserFlags g) a -> Const (g (Const Bool)) a)
-> g (Const Bool)
-> g (Const (ParserFlags g))
-> g (Const (g (Const Bool)))
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
       (r :: k -> *).
Apply g =>
(forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
Rank2.liftA2 forall a.
Const Bool a -> Const (ParserFlags g) a -> Const (g (Const Bool)) a
leftRecursiveDeps g (Const Bool)
circulars g (Const (ParserFlags g))
cyclicDescendantses)
         leftRecursive :: Const (g (Const Bool)) a -> Const (ParserFlags g) a -> Const Bool a
leftRecursive (Const bit :: g (Const Bool)
bit) (Const flags :: ParserFlags g
flags) =
            Bool -> Const Bool a
forall k a (b :: k). a -> Const a b
Const (Any -> Bool
getAny (Any -> Bool) -> Any -> Bool
forall a b. (a -> b) -> a -> b
$ (forall a. Const Bool a -> Any) -> g (Const Bool) -> Any
forall k (g :: (k -> *) -> *) m (p :: k -> *).
(Foldable g, Monoid m) =>
(forall (a :: k). p a -> m) -> g p -> m
Rank2.foldMap (Bool -> Any
Any (Bool -> Any) -> (Const Bool a -> Bool) -> Const Bool a -> Any
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Const Bool a -> Bool
forall a k (b :: k). Const a b -> a
getConst) (g (Const Bool) -> Any) -> g (Const Bool) -> Any
forall a b. (a -> b) -> a -> b
$ (forall a. Const Bool a -> Const Bool a -> Const Bool a)
-> g (Const Bool) -> g (Const Bool) -> g (Const Bool)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
       (r :: k -> *).
Apply g =>
(forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
Rank2.liftA2 forall a. Const Bool a -> Const Bool a -> Const Bool a
forall b b b. Const Bool b -> Const Bool b -> Const Bool b
intersection g (Const Bool)
bit (g (Const Bool) -> g (Const Bool))
-> g (Const Bool) -> g (Const Bool)
forall a b. (a -> b) -> a -> b
$ ParserFlags g -> g (Const Bool)
forall (g :: (* -> *) -> *). ParserFlags g -> g (Const Bool)
dependsOn ParserFlags g
flags)
         leftRecursiveDeps :: Const Bool a -> Const (ParserFlags g) a -> Const (g (Const Bool)) a
leftRecursiveDeps (Const True) (Const flags :: ParserFlags g
flags) = g (Const Bool) -> Const (g (Const Bool)) a
forall k a (b :: k). a -> Const a b
Const (ParserFlags g -> g (Const Bool)
forall (g :: (* -> *) -> *). ParserFlags g -> g (Const Bool)
dependsOn ParserFlags g
flags)
         leftRecursiveDeps (Const False) (Const flags :: ParserFlags g
flags) = g (Const Bool) -> Const (g (Const Bool)) a
forall k a (b :: k). a -> Const a b
Const ((forall a. Const Bool a -> Const Bool a)
-> g (Const Bool) -> g (Const Bool)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Functor g =>
(forall (a :: k). p a -> q a) -> g p -> g q
Rank2.fmap (Const Bool a -> Const Bool a -> Const Bool a
forall a b. a -> b -> a
const (Const Bool a -> Const Bool a -> Const Bool a)
-> Const Bool a -> Const Bool a -> Const Bool a
forall a b. (a -> b) -> a -> b
$ Bool -> Const Bool a
forall k a (b :: k). a -> Const a b
Const Bool
False) (ParserFlags g -> g (Const Bool)
forall (g :: (* -> *) -> *). ParserFlags g -> g (Const Bool)
dependsOn ParserFlags g
flags))
         intersection :: Const Bool b -> Const Bool b -> Const Bool b
intersection (Const a :: Bool
a) (Const b :: Bool
b) = Bool -> Const Bool b
forall k a (b :: k). a -> Const a b
Const (Bool
a Bool -> Bool -> Bool
&& Bool
b)
{-# INLINABLE separated #-}

fixDescendants :: forall g. (Rank2.Apply g, Rank2.Traversable g)
                     => g (Const (g (Const (ParserFlags g)) -> (ParserFlags g))) -> g (Const (ParserFlags g))
fixDescendants :: g (Const (g (Const (ParserFlags g)) -> ParserFlags g))
-> g (Const (ParserFlags g))
fixDescendants gf :: g (Const (g (Const (ParserFlags g)) -> ParserFlags g))
gf = g (Const (ParserFlags g)) -> g (Const (ParserFlags g))
go g (Const (ParserFlags g))
initial
   where go :: g (Const (ParserFlags g)) -> g (Const (ParserFlags g))
         go :: g (Const (ParserFlags g)) -> g (Const (ParserFlags g))
go cd :: g (Const (ParserFlags g))
cd
            | All -> Bool
getAll ((forall a. Const Bool a -> All) -> g (Const Bool) -> All
forall k (g :: (k -> *) -> *) m (p :: k -> *).
(Foldable g, Monoid m) =>
(forall (a :: k). p a -> m) -> g p -> m
Rank2.foldMap (Bool -> All
All (Bool -> All) -> (Const Bool a -> Bool) -> Const Bool a -> All
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Const Bool a -> Bool
forall a k (b :: k). Const a b -> a
getConst) (g (Const Bool) -> All) -> g (Const Bool) -> All
forall a b. (a -> b) -> a -> b
$ (forall a.
 Const (ParserFlags g) a -> Const (ParserFlags g) a -> Const Bool a)
-> g (Const (ParserFlags g))
-> g (Const (ParserFlags g))
-> g (Const Bool)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
       (r :: k -> *).
Apply g =>
(forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
Rank2.liftA2 forall a.
Const (ParserFlags g) a -> Const (ParserFlags g) a -> Const Bool a
forall (g :: (* -> *) -> *) b b b.
(Foldable g, Apply g) =>
Const (ParserFlags g) b -> Const (ParserFlags g) b -> Const Bool b
agree g (Const (ParserFlags g))
cd g (Const (ParserFlags g))
cd') = g (Const (ParserFlags g))
cd
            | Bool
otherwise = g (Const (ParserFlags g)) -> g (Const (ParserFlags g))
go g (Const (ParserFlags g))
cd'
            where cd' :: g (Const (ParserFlags g))
cd' = (forall a.
 Const (ParserFlags g) a
 -> Const (ParserFlags g) a -> Const (ParserFlags g) a)
-> g (Const (ParserFlags g))
-> g (Const (ParserFlags g))
-> g (Const (ParserFlags g))
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
       (r :: k -> *).
Apply g =>
(forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
Rank2.liftA2 forall a.
Const (ParserFlags g) a
-> Const (ParserFlags g) a -> Const (ParserFlags g) a
forall (g :: (* -> *) -> *) b b b.
Apply g =>
Const (ParserFlags g) b
-> Const (ParserFlags g) b -> Const (ParserFlags g) b
depsUnion g (Const (ParserFlags g))
cd ((forall a.
 Const (g (Const (ParserFlags g)) -> ParserFlags g) a
 -> Const (ParserFlags g) a)
-> g (Const (g (Const (ParserFlags g)) -> ParserFlags g))
-> g (Const (ParserFlags g))
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Functor g =>
(forall (a :: k). p a -> q a) -> g p -> g q
Rank2.fmap (\(Const f)-> ParserFlags g -> Const (ParserFlags g) a
forall k a (b :: k). a -> Const a b
Const (g (Const (ParserFlags g)) -> ParserFlags g
f g (Const (ParserFlags g))
cd)) g (Const (g (Const (ParserFlags g)) -> ParserFlags g))
gf)
         agree :: Const (ParserFlags g) b -> Const (ParserFlags g) b -> Const Bool b
agree (Const (ParserFlags _xn :: Bool
_xn xd :: g (Const Bool)
xd)) (Const (ParserFlags _yn :: Bool
_yn yd :: g (Const Bool)
yd)) =
            Bool -> Const Bool b
forall k a (b :: k). a -> Const a b
Const (All -> Bool
getAll ((forall a. Const Bool a -> All) -> g (Const Bool) -> All
forall k (g :: (k -> *) -> *) m (p :: k -> *).
(Foldable g, Monoid m) =>
(forall (a :: k). p a -> m) -> g p -> m
Rank2.foldMap (Bool -> All
All (Bool -> All) -> (Const Bool a -> Bool) -> Const Bool a -> All
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Const Bool a -> Bool
forall a k (b :: k). Const a b -> a
getConst) ((forall a. Const Bool a -> Const Bool a -> Const Bool a)
-> g (Const Bool) -> g (Const Bool) -> g (Const Bool)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
       (r :: k -> *).
Apply g =>
(forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
Rank2.liftA2 forall a. Const Bool a -> Const Bool a -> Const Bool a
forall a b b b. Eq a => Const a b -> Const a b -> Const Bool b
agree' g (Const Bool)
xd g (Const Bool)
yd)))
         agree' :: Const a b -> Const a b -> Const Bool b
agree' (Const x :: a
x) (Const y :: a
y) = Bool -> Const Bool b
forall k a (b :: k). a -> Const a b
Const (a
x a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
y)
         depsUnion :: Const (ParserFlags g) b
-> Const (ParserFlags g) b -> Const (ParserFlags g) b
depsUnion (Const ParserFlags{dependsOn :: forall (g :: (* -> *) -> *). ParserFlags g -> g (Const Bool)
dependsOn= g (Const Bool)
old}) (Const (ParserFlags n :: Bool
n new :: g (Const Bool)
new)) = 
            ParserFlags g -> Const (ParserFlags g) b
forall k a (b :: k). a -> Const a b
Const (Bool -> g (Const Bool) -> ParserFlags g
forall (g :: (* -> *) -> *).
Bool -> g (Const Bool) -> ParserFlags g
ParserFlags Bool
n (g (Const Bool) -> ParserFlags g)
-> g (Const Bool) -> ParserFlags g
forall a b. (a -> b) -> a -> b
$ (forall a. Const Bool a -> Const Bool a -> Const Bool a)
-> g (Const Bool) -> g (Const Bool) -> g (Const Bool)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
       (r :: k -> *).
Apply g =>
(forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
Rank2.liftA2 forall a. Const Bool a -> Const Bool a -> Const Bool a
union g (Const Bool)
old g (Const Bool)
new)
         initial :: g (Const (ParserFlags g))
initial = (forall a.
 Const (g (Const (ParserFlags g)) -> ParserFlags g) a
 -> Const Bool a -> Const (ParserFlags g) a)
-> g (Const (g (Const (ParserFlags g)) -> ParserFlags g))
-> g (Const Bool)
-> g (Const (ParserFlags g))
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
       (r :: k -> *).
Apply g =>
(forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
Rank2.liftA2 (\_ (Const n)-> ParserFlags g -> Const (ParserFlags g) a
forall k a (b :: k). a -> Const a b
Const (Bool -> g (Const Bool) -> ParserFlags g
forall (g :: (* -> *) -> *).
Bool -> g (Const Bool) -> ParserFlags g
ParserFlags Bool
n (Const Bool a
-> Const (g (Const (ParserFlags g)) -> ParserFlags g) a
-> Const Bool a
forall a b. a -> b -> a
const (Bool -> Const Bool a
forall k a (b :: k). a -> Const a b
Const Bool
False) (forall a.
 Const (g (Const (ParserFlags g)) -> ParserFlags g) a
 -> Const Bool a)
-> g (Const (g (Const (ParserFlags g)) -> ParserFlags g))
-> g (Const Bool)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Functor g =>
(forall (a :: k). p a -> q a) -> g p -> g q
Rank2.<$> g (Const (g (Const (ParserFlags g)) -> ParserFlags g))
gf))) g (Const (g (Const (ParserFlags g)) -> ParserFlags g))
gf g (Const Bool)
nullabilities
         nullabilities :: g (Const Bool)
nullabilities = g (Const (g (Const (ParserFlags g)) -> ParserFlags g))
-> g (Const Bool)
forall (g :: (* -> *) -> *).
(Apply g, Traversable g) =>
g (Const (g (Const (ParserFlags g)) -> ParserFlags g))
-> g (Const Bool)
fixNullabilities g (Const (g (Const (ParserFlags g)) -> ParserFlags g))
gf
{-# INLINABLE fixDescendants #-}

fixNullabilities :: forall g. (Rank2.Apply g, Rank2.Traversable g)
                    => g (Const (g (Const (ParserFlags g)) -> (ParserFlags g))) -> g (Const Bool)
fixNullabilities :: g (Const (g (Const (ParserFlags g)) -> ParserFlags g))
-> g (Const Bool)
fixNullabilities gf :: g (Const (g (Const (ParserFlags g)) -> ParserFlags g))
gf = (forall a. Const (ParserFlags g) a -> Const Bool a)
-> g (Const (ParserFlags g)) -> g (Const Bool)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Functor g =>
(forall (a :: k). p a -> q a) -> g p -> g q
Rank2.fmap (Bool -> Const Bool a
forall k a (b :: k). a -> Const a b
Const (Bool -> Const Bool a)
-> (Const (ParserFlags g) a -> Bool)
-> Const (ParserFlags g) a
-> Const Bool a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParserFlags g -> Bool
forall (g :: (* -> *) -> *). ParserFlags g -> Bool
nullable (ParserFlags g -> Bool)
-> (Const (ParserFlags g) a -> ParserFlags g)
-> Const (ParserFlags g) a
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Const (ParserFlags g) a -> ParserFlags g
forall a k (b :: k). Const a b -> a
getConst) (g (Const (ParserFlags g)) -> g (Const (ParserFlags g))
go g (Const (ParserFlags g))
initial)
   where go :: g (Const (ParserFlags g)) -> g (Const (ParserFlags g))
         go :: g (Const (ParserFlags g)) -> g (Const (ParserFlags g))
go cd :: g (Const (ParserFlags g))
cd
            | All -> Bool
getAll ((forall a. Const Bool a -> All) -> g (Const Bool) -> All
forall k (g :: (k -> *) -> *) m (p :: k -> *).
(Foldable g, Monoid m) =>
(forall (a :: k). p a -> m) -> g p -> m
Rank2.foldMap (Bool -> All
All (Bool -> All) -> (Const Bool a -> Bool) -> Const Bool a -> All
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Const Bool a -> Bool
forall a k (b :: k). Const a b -> a
getConst) (g (Const Bool) -> All) -> g (Const Bool) -> All
forall a b. (a -> b) -> a -> b
$ (forall a.
 Const (ParserFlags g) a -> Const (ParserFlags g) a -> Const Bool a)
-> g (Const (ParserFlags g))
-> g (Const (ParserFlags g))
-> g (Const Bool)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
       (r :: k -> *).
Apply g =>
(forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
Rank2.liftA2 forall a.
Const (ParserFlags g) a -> Const (ParserFlags g) a -> Const Bool a
forall (g :: (* -> *) -> *) b (g :: (* -> *) -> *) b b.
Const (ParserFlags g) b -> Const (ParserFlags g) b -> Const Bool b
agree g (Const (ParserFlags g))
cd g (Const (ParserFlags g))
cd') = g (Const (ParserFlags g))
cd
            | Bool
otherwise = g (Const (ParserFlags g)) -> g (Const (ParserFlags g))
go g (Const (ParserFlags g))
cd'
            where cd' :: g (Const (ParserFlags g))
cd' = (forall a.
 Const (g (Const (ParserFlags g)) -> ParserFlags g) a
 -> Const (ParserFlags g) a)
-> g (Const (g (Const (ParserFlags g)) -> ParserFlags g))
-> g (Const (ParserFlags g))
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Functor g =>
(forall (a :: k). p a -> q a) -> g p -> g q
Rank2.fmap (\(Const f)-> ParserFlags g -> Const (ParserFlags g) a
forall k a (b :: k). a -> Const a b
Const (g (Const (ParserFlags g)) -> ParserFlags g
f g (Const (ParserFlags g))
cd)) g (Const (g (Const (ParserFlags g)) -> ParserFlags g))
gf
         agree :: Const (ParserFlags g) b -> Const (ParserFlags g) b -> Const Bool b
agree (Const flags1 :: ParserFlags g
flags1) (Const flags2 :: ParserFlags g
flags2) = Bool -> Const Bool b
forall k a (b :: k). a -> Const a b
Const (ParserFlags g -> Bool
forall (g :: (* -> *) -> *). ParserFlags g -> Bool
nullable ParserFlags g
flags1 Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== ParserFlags g -> Bool
forall (g :: (* -> *) -> *). ParserFlags g -> Bool
nullable ParserFlags g
flags2)
         initial :: g (Const (ParserFlags g))
initial = Const (ParserFlags g) a
-> Const (g (Const (ParserFlags g)) -> ParserFlags g) a
-> Const (ParserFlags g) a
forall a b. a -> b -> a
const (ParserFlags g -> Const (ParserFlags g) a
forall k a (b :: k). a -> Const a b
Const (Bool -> g (Const Bool) -> ParserFlags g
forall (g :: (* -> *) -> *).
Bool -> g (Const Bool) -> ParserFlags g
ParserFlags Bool
True (Const Bool a
-> Const (g (Const (ParserFlags g)) -> ParserFlags g) a
-> Const Bool a
forall a b. a -> b -> a
const (Bool -> Const Bool a
forall k a (b :: k). a -> Const a b
Const Bool
False) (forall a.
 Const (g (Const (ParserFlags g)) -> ParserFlags g) a
 -> Const Bool a)
-> g (Const (g (Const (ParserFlags g)) -> ParserFlags g))
-> g (Const Bool)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Functor g =>
(forall (a :: k). p a -> q a) -> g p -> g q
Rank2.<$> g (Const (g (Const (ParserFlags g)) -> ParserFlags g))
gf))) (forall a.
 Const (g (Const (ParserFlags g)) -> ParserFlags g) a
 -> Const (ParserFlags g) a)
-> g (Const (g (Const (ParserFlags g)) -> ParserFlags g))
-> g (Const (ParserFlags g))
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Functor g =>
(forall (a :: k). p a -> q a) -> g p -> g q
Rank2.<$> g (Const (g (Const (ParserFlags g)) -> ParserFlags g))
gf
{-# INLINABLE fixNullabilities #-}

-- | Parse the given input using a context-free grammar separated into two parts: the first specifying all the
-- left-recursive productions, the second all others. The first function argument specifies the left-recursive
-- dependencies among the grammar productions.
parseSeparated :: forall g s. (Rank2.Apply g, Rank2.Foldable g, FactorialMonoid s) =>
                  g (SeparatedParser Memoizing.Parser g s) -> s -> [(s, g (ResultList g s))]
parseSeparated :: g (SeparatedParser Parser g s) -> s -> [(s, g (ResultList g s))]
parseSeparated parsers :: g (SeparatedParser Parser g s)
parsers input :: s
input = (s -> [(s, g (ResultList g s))] -> [(s, g (ResultList g s))])
-> [(s, g (ResultList g s))] -> [s] -> [(s, g (ResultList g s))]
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr s -> [(s, g (ResultList g s))] -> [(s, g (ResultList g s))]
parseTail [] (s -> [s]
forall m. FactorialMonoid m => m -> [m]
Factorial.tails s
input)
   where parseTail :: s -> [(s, g (ResultList g s))] -> [(s, g (ResultList g s))]
parseTail s :: s
s parsedTail :: [(s, g (ResultList g s))]
parsedTail = [(s, g (ResultList g s))]
parsed
            where parsed :: [(s, g (ResultList g s))]
parsed = (s
s,g (ResultList g s)
d'')(s, g (ResultList g s))
-> [(s, g (ResultList g s))] -> [(s, g (ResultList g s))]
forall a. a -> [a] -> [a]
:[(s, g (ResultList g s))]
parsedTail
                  d :: g (ResultList g s)
d      = (forall a. Parser g s a -> ResultList g s a)
-> g (Parser g s) -> g (ResultList 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 ((([(s, g (ResultList g s))] -> ResultList g s a)
-> [(s, g (ResultList g s))] -> ResultList g s a
forall a b. (a -> b) -> a -> b
$ (s
s,g (ResultList g s)
d)(s, g (ResultList g s))
-> [(s, g (ResultList g s))] -> [(s, g (ResultList g s))]
forall a. a -> [a] -> [a]
:[(s, g (ResultList g s))]
parsedTail) (([(s, g (ResultList g s))] -> ResultList g s a)
 -> ResultList g s a)
-> (Parser g s a -> [(s, g (ResultList g s))] -> ResultList g s a)
-> Parser g s a
-> ResultList g s a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Parser g s a -> [(s, g (ResultList g s))] -> ResultList g s a
forall (g :: (* -> *) -> *) s r.
Parser g s r -> [(s, g (ResultList g s))] -> ResultList g s r
Memoizing.applyParser) g (Parser g s)
directs
                  d' :: g (ResultList g s)
d'     = s
-> [(s, g (ResultList g s))]
-> g (ResultList g s)
-> g (ResultList g s)
fixRecursive s
s [(s, g (ResultList g s))]
parsedTail g (ResultList g s)
d
                  d'' :: g (ResultList g s)
d''    = (forall a.
 SeparatedParser Parser g s a
 -> ResultList g s a -> ResultList g s a)
-> g (SeparatedParser Parser g s)
-> g (ResultList g s)
-> g (ResultList g s)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
       (r :: k -> *).
Apply g =>
(forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
Rank2.liftA2 forall a.
SeparatedParser Parser g s a
-> ResultList g s a -> ResultList g s a
f g (SeparatedParser Parser g s)
parsers g (ResultList g s)
d'
                  f :: forall a. SeparatedParser Memoizing.Parser g s a -> ResultList g s a -> ResultList g s a
                  f :: SeparatedParser Parser g s a
-> ResultList g s a -> ResultList g s a
f (FrontParser p :: Parser g s a
p) _ = Parser g s a -> [(s, g (ResultList g s))] -> ResultList g s a
forall (g :: (* -> *) -> *) s r.
Parser g s r -> [(s, g (ResultList g s))] -> ResultList g s r
Memoizing.applyParser Parser g s a
p ((s
s,g (ResultList g s)
d'')(s, g (ResultList g s))
-> [(s, g (ResultList g s))] -> [(s, g (ResultList g s))]
forall a. a -> [a] -> [a]
:[(s, g (ResultList g s))]
parsedTail)
                  f _ result :: ResultList g s a
result = ResultList g s a
result
         fixRecursive :: s -> [(s, g (ResultList g s))] -> g (ResultList g s) -> g (ResultList g s)
         whileAnyContinues :: (g (ResultList g s) -> g (ResultList g s))
                           -> (g (ResultList g s) -> g (ResultList g s))
                           -> g (ResultList g s) -> g (ResultList g s) -> g (ResultList g s)
         recurseTotal :: s -> g (ResultList g s Rank2.~> ResultList g s) -> [(s, g (ResultList g s))]
                      -> g (ResultList g s)
                      -> g (ResultList g s)
         recurseMarginal :: s -> [(s, g (ResultList g s))]
                      -> g (ResultList g s)
                      -> g (ResultList g s)
         maybeDependencies :: g (Const (Maybe (g (Const Bool))))
         maybeDependency :: SeparatedParser Memoizing.Parser g s r -> Const (Maybe (g (Const Bool))) r
         appends :: g (ResultAppend g s)
         parserAppend :: SeparatedParser Memoizing.Parser g s r -> ResultAppend g s r

         directs :: g (Parser g s)
directs = (forall a. SeparatedParser Parser g s a -> Parser g s a)
-> g (SeparatedParser 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 forall a. SeparatedParser Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
SeparatedParser p g s a -> p g s a
backParser g (SeparatedParser Parser g s)
parsers
         indirects :: g (Parser g s)
indirects = (forall a. SeparatedParser Parser g s a -> Parser g s a)
-> g (SeparatedParser 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 (\p :: SeparatedParser Parser g s a
p-> case SeparatedParser Parser g s a
p of {CycleParser{}-> SeparatedParser Parser g s a -> Parser g s a
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
SeparatedParser p g s a -> p g s a
cycleParser SeparatedParser Parser g s a
p; _ -> Parser g s a
forall (f :: * -> *) a. Alternative f => f a
empty}) g (SeparatedParser Parser g s)
parsers
         appends :: g (ResultAppend g s)
appends = (forall a. SeparatedParser Parser g s a -> ResultAppend g s a)
-> g (SeparatedParser Parser g s) -> g (ResultAppend 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 forall a. SeparatedParser Parser g s a -> ResultAppend g s a
parserAppend g (SeparatedParser Parser g s)
parsers
         parserAppend :: SeparatedParser Parser g s r -> ResultAppend g s r
parserAppend p :: SeparatedParser Parser g s r
p@CycleParser{} = SeparatedParser Parser g s r -> ResultAppend g s r
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
SeparatedParser p g s a -> ResultAppend g s a
appendResultsArrow SeparatedParser Parser g s r
p
         parserAppend _ = (ResultList g s r -> Arrow (ResultList g s) (ResultList g s) r)
-> ResultAppend g s r
forall k (p :: k -> *) (q :: k -> *) (a :: k).
(p a -> q a) -> Arrow p q a
Rank2.Arrow ((ResultList g s r -> ResultList g s r)
-> Arrow (ResultList g s) (ResultList g s) r
forall k (p :: k -> *) (q :: k -> *) (a :: k).
(p a -> q a) -> Arrow p q a
Rank2.Arrow ((ResultList g s r -> ResultList g s r)
 -> Arrow (ResultList g s) (ResultList g s) r)
-> (ResultList g s r -> ResultList g s r -> ResultList g s r)
-> ResultList g s r
-> Arrow (ResultList g s) (ResultList g s) r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ResultList g s r -> ResultList g s r -> ResultList g s r
forall a. Semigroup a => a -> a -> a
(<>))
         maybeDependencies :: g (Const (Maybe (g (Const Bool))))
maybeDependencies = (forall a.
 SeparatedParser Parser g s a -> Const (Maybe (g (Const Bool))) a)
-> g (SeparatedParser Parser g s)
-> g (Const (Maybe (g (Const Bool))))
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Functor g =>
(forall (a :: k). p a -> q a) -> g p -> g q
Rank2.fmap forall a.
SeparatedParser Parser g s a -> Const (Maybe (g (Const Bool))) a
maybeDependency g (SeparatedParser Parser g s)
parsers
         maybeDependency :: SeparatedParser Parser g s r -> Const (Maybe (g (Const Bool))) r
maybeDependency p :: SeparatedParser Parser g s r
p@CycleParser{} = Maybe (g (Const Bool)) -> Const (Maybe (g (Const Bool))) r
forall k a (b :: k). a -> Const a b
Const (g (Const Bool) -> Maybe (g (Const Bool))
forall a. a -> Maybe a
Just (g (Const Bool) -> Maybe (g (Const Bool)))
-> g (Const Bool) -> Maybe (g (Const Bool))
forall a b. (a -> b) -> a -> b
$ SeparatedParser Parser g s r -> g (Const Bool)
forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       a.
SeparatedParser p g s a -> g (Const Bool)
dependencies SeparatedParser Parser g s r
p)
         maybeDependency _ = Maybe (g (Const Bool)) -> Const (Maybe (g (Const Bool))) r
forall k a (b :: k). a -> Const a b
Const Maybe (g (Const Bool))
forall a. Maybe a
Nothing

         fixRecursive :: s
-> [(s, g (ResultList g s))]
-> g (ResultList g s)
-> g (ResultList g s)
fixRecursive s :: s
s parsedTail :: [(s, g (ResultList g s))]
parsedTail initial :: g (ResultList g s)
initial =
            (g (ResultList g s) -> g (ResultList g s))
-> (g (ResultList g s) -> g (ResultList g s))
-> g (ResultList g s)
-> g (ResultList g s)
-> g (ResultList g s)
whileAnyContinues (s
-> g (ResultList g s ~> ResultList g s)
-> [(s, g (ResultList g s))]
-> g (ResultList g s)
-> g (ResultList g s)
recurseTotal s
s (g (ResultAppend g s)
appends g (ResultAppend g s)
-> g (ResultList g s) -> g (ResultList g s ~> ResultList g s)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Apply g =>
g (p ~> q) -> g p -> g q
Rank2.<*> g (ResultList g s)
initial) [(s, g (ResultList g s))]
parsedTail)
                              (s
-> [(s, g (ResultList g s))]
-> g (ResultList g s)
-> g (ResultList g s)
recurseMarginal s
s [(s, g (ResultList g s))]
parsedTail)
                              g (ResultList g s)
initial g (ResultList g s)
initial

         whileAnyContinues :: (g (ResultList g s) -> g (ResultList g s))
-> (g (ResultList g s) -> g (ResultList g s))
-> g (ResultList g s)
-> g (ResultList g s)
-> g (ResultList g s)
whileAnyContinues ft :: g (ResultList g s) -> g (ResultList g s)
ft fm :: g (ResultList g s) -> g (ResultList g s)
fm total :: g (ResultList g s)
total marginal :: g (ResultList g s)
marginal =
            (forall a.
 Const (Maybe (g (Const Bool))) a
 -> ResultList g s a -> ResultList g s a -> ResultList g s a)
-> g (Const (Maybe (g (Const Bool))))
-> g (ResultList g s)
-> g (ResultList g s)
-> g (ResultList g s)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
       (r :: k -> *) (s :: k -> *).
Apply g =>
(forall (a :: k). p a -> q a -> r a -> s a)
-> g p -> g q -> g r -> g s
Rank2.liftA3 forall a.
Const (Maybe (g (Const Bool))) a
-> ResultList g s a -> ResultList g s a -> ResultList g s a
choiceWhile g (Const (Maybe (g (Const Bool))))
maybeDependencies g (ResultList g s)
total ((g (ResultList g s) -> g (ResultList g s))
-> (g (ResultList g s) -> g (ResultList g s))
-> g (ResultList g s)
-> g (ResultList g s)
-> g (ResultList g s)
whileAnyContinues g (ResultList g s) -> g (ResultList g s)
ft g (ResultList g s) -> g (ResultList g s)
fm (g (ResultList g s) -> g (ResultList g s)
ft g (ResultList g s)
total) (g (ResultList g s) -> g (ResultList g s)
fm g (ResultList g s)
marginal))
            where choiceWhile :: Const (Maybe (g (Const Bool))) x
                              -> ResultList g s x -> ResultList g s x
                              -> ResultList g s x
                  choiceWhile :: Const (Maybe (g (Const Bool))) x
-> ResultList g s x -> ResultList g s x -> ResultList g s x
choiceWhile (Const Nothing) t :: ResultList g s x
t _ = ResultList g s x
t
                  choiceWhile (Const (Just deps :: g (Const Bool)
deps)) t :: ResultList g s x
t t' :: ResultList g s x
t'
                     | Any -> Bool
getAny ((forall a. Const Bool a -> Any) -> g (Const Bool) -> Any
forall k (g :: (k -> *) -> *) m (p :: k -> *).
(Foldable g, Monoid m) =>
(forall (a :: k). p a -> m) -> g p -> m
Rank2.foldMap (Bool -> Any
Any (Bool -> Any) -> (Const Bool a -> Bool) -> Const Bool a -> Any
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Const Bool a -> Bool
forall a k (b :: k). Const a b -> a
getConst) ((forall a. Const Bool a -> ResultList g s a -> Const Bool a)
-> g (Const Bool) -> g (ResultList g s) -> g (Const Bool)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
       (r :: k -> *).
Apply g =>
(forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
Rank2.liftA2 forall a. Const Bool a -> ResultList g s a -> Const Bool a
combine g (Const Bool)
deps g (ResultList g s)
marginal)) = ResultList g s x
t'
                     | ResultList [] (Memoizing.FailureInfo _ expected :: [String]
expected) <- ResultList g s x
t =
                        let ResultList _ (Memoizing.FailureInfo pos :: Int
pos expected' :: [String]
expected') =
                               if Any -> Bool
getAny ((forall a. Const Bool a -> Any) -> g (Const Bool) -> Any
forall k (g :: (k -> *) -> *) m (p :: k -> *).
(Foldable g, Monoid m) =>
(forall (a :: k). p a -> m) -> g p -> m
Rank2.foldMap (Bool -> Any
Any (Bool -> Any) -> (Const Bool a -> Bool) -> Const Bool a -> Any
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Const Bool a -> Bool
forall a k (b :: k). Const a b -> a
getConst) (g (Const Bool) -> Any) -> g (Const Bool) -> Any
forall a b. (a -> b) -> a -> b
$
                                          (forall a. Const Bool a -> ResultList g s a -> Const Bool a)
-> g (Const Bool) -> g (ResultList g s) -> g (Const Bool)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
       (r :: k -> *).
Apply g =>
(forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
Rank2.liftA2 ([String] -> Const Bool a -> ResultList g s a -> Const Bool a
forall x.
[String] -> Const Bool x -> ResultList g s x -> Const Bool x
combineFailures [String]
expected) g (Const Bool)
deps g (ResultList g s)
marginal)
                                  then ResultList g s x
t' else ResultList g s x
t
                        in [ResultsOfLength g s x] -> FailureInfo -> ResultList g s x
forall (g :: (* -> *) -> *) s r.
[ResultsOfLength g s r] -> FailureInfo -> ResultList g s r
ResultList [] (Int -> [String] -> FailureInfo
Memoizing.FailureInfo Int
pos [String]
expected')
                     | Bool
otherwise = ResultList g s x
t
                     where combine :: Const Bool x -> ResultList g s x -> Const Bool x
                           combineFailures :: [String] -> Const Bool x -> ResultList g s x -> Const Bool x
                           combine :: Const Bool x -> ResultList g s x -> Const Bool x
combine (Const False) _ = Bool -> Const Bool x
forall k a (b :: k). a -> Const a b
Const Bool
False
                           combine (Const True) (ResultList [] _) = Bool -> Const Bool x
forall k a (b :: k). a -> Const a b
Const Bool
False
                           combine (Const True) _ = Bool -> Const Bool x
forall k a (b :: k). a -> Const a b
Const Bool
True
                           combineFailures :: [String] -> Const Bool x -> ResultList g s x -> Const Bool x
combineFailures _ (Const False) _ = Bool -> Const Bool x
forall k a (b :: k). a -> Const a b
Const Bool
False
                           combineFailures expected :: [String]
expected (Const True) (ResultList _ (Memoizing.FailureInfo _ expected' :: [String]
expected'))
                              = Bool -> Const Bool x
forall k a (b :: k). a -> Const a b
Const ((String -> Bool) -> [String] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (String -> [String] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [String]
expected) [String]
expected')

         recurseTotal :: s
-> g (ResultList g s ~> ResultList g s)
-> [(s, g (ResultList g s))]
-> g (ResultList g s)
-> g (ResultList g s)
recurseTotal s :: s
s initialAppends :: g (ResultList g s ~> ResultList g s)
initialAppends parsedTail :: [(s, g (ResultList g s))]
parsedTail total :: g (ResultList g s)
total = (forall a.
 (~>) (ResultList g s) (ResultList g s) a
 -> Parser g s a -> ResultList g s a)
-> g (ResultList g s ~> ResultList g s)
-> g (Parser g s)
-> g (ResultList g s)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *)
       (r :: k -> *).
Apply g =>
(forall (a :: k). p a -> q a -> r a) -> g p -> g q -> g r
Rank2.liftA2 forall a.
(~>) (ResultList g s) (ResultList g s) a
-> Parser g s a -> ResultList g s a
reparse g (ResultList g s ~> ResultList g s)
initialAppends g (Parser g s)
indirects
            where reparse :: (ResultList g s Rank2.~> ResultList g s) a -> Memoizing.Parser g s a -> ResultList g s a
                  reparse :: (~>) (ResultList g s) (ResultList g s) a
-> Parser g s a -> ResultList g s a
reparse append :: (~>) (ResultList g s) (ResultList g s) a
append p :: Parser g s a
p = (~>) (ResultList g s) (ResultList g s) a
-> ResultList g s a -> ResultList g s a
forall k (p :: k -> *) (q :: k -> *) (a :: k).
Arrow p q a -> p a -> q a
Rank2.apply (~>) (ResultList g s) (ResultList g s) a
append (Parser g s a -> [(s, g (ResultList g s))] -> ResultList g s a
forall (g :: (* -> *) -> *) s r.
Parser g s r -> [(s, g (ResultList g s))] -> ResultList g s r
Memoizing.applyParser Parser g s a
p ([(s, g (ResultList g s))] -> ResultList g s a)
-> [(s, g (ResultList g s))] -> ResultList g s a
forall a b. (a -> b) -> a -> b
$ (s
s, g (ResultList g s)
total) (s, g (ResultList g s))
-> [(s, g (ResultList g s))] -> [(s, g (ResultList g s))]
forall a. a -> [a] -> [a]
: [(s, g (ResultList g s))]
parsedTail)
         recurseMarginal :: s
-> [(s, g (ResultList g s))]
-> g (ResultList g s)
-> g (ResultList g s)
recurseMarginal s :: s
s parsedTail :: [(s, g (ResultList g s))]
parsedTail marginal :: g (ResultList g s)
marginal =
            (Parser g s a -> [(s, g (ResultList g s))] -> ResultList g s a)
-> [(s, g (ResultList g s))] -> Parser g s a -> ResultList g s a
forall a b c. (a -> b -> c) -> b -> a -> c
flip Parser g s a -> [(s, g (ResultList g s))] -> ResultList g s a
forall (g :: (* -> *) -> *) s r.
Parser g s r -> [(s, g (ResultList g s))] -> ResultList g s r
Memoizing.applyParser ((s
s, g (ResultList g s)
marginal) (s, g (ResultList g s))
-> [(s, g (ResultList g s))] -> [(s, g (ResultList g s))]
forall a. a -> [a] -> [a]
: [(s, g (ResultList g s))]
parsedTail) (forall a. Parser g s a -> ResultList g s a)
-> g (Parser g s) -> g (ResultList g s)
forall k (g :: (k -> *) -> *) (p :: k -> *) (q :: k -> *).
Functor g =>
(forall (a :: k). p a -> q a) -> g p -> g q
Rank2.<$> g (Parser g s)
indirects
{-# NOINLINE parseSeparated #-}