-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | A parser generator
--   
--   Ptera is haskell libraries and toolchains for generating parser.
@package ptera
@version 0.1.0.0

module Language.Parser.Ptera.Data.HEnum
type T = HEnum
newtype HEnum (as :: [k])
UnsafeHEnum :: Int -> HEnum (as :: [k])
[$sel:unsafeHEnum:UnsafeHEnum] :: HEnum (as :: [k]) -> Int
henum :: forall a as. Membership as a -> HEnum as
henumA :: forall a as. Member as a => HEnum as
unHEnum :: forall a as. Membership as a -> HEnum as -> Bool
instance forall k (as :: [k]). GHC.Show.Show (Language.Parser.Ptera.Data.HEnum.HEnum as)
instance forall k (as :: [k]). GHC.Classes.Eq (Language.Parser.Ptera.Data.HEnum.HEnum as)

module Language.Parser.Ptera.Scanner
type T = Scanner
class Monad m => Scanner posMark elem m | m -> posMark, m -> elem
consumeInput :: Scanner posMark elem m => m (Maybe elem)
getPosMark :: Scanner posMark elem m => m posMark
seekToPosMark :: Scanner posMark elem m => posMark -> m ()
scanMode :: Scanner posMark elem m => ScanMode posMark -> m ()
data ScanMode posMark
ScanModeNoBack :: ScanMode posMark
ScanModeNeedBack :: posMark -> ScanMode posMark
newtype ListScanner e a
ListScanner :: State [e] a -> ListScanner e a
[$sel:unListScanner:ListScanner] :: ListScanner e a -> State [e] a
runListScanner :: ListScanner e a -> [e] -> a
instance GHC.Show.Show posMark => GHC.Show.Show (Language.Parser.Ptera.Scanner.ScanMode posMark)
instance GHC.Classes.Eq posMark => GHC.Classes.Eq (Language.Parser.Ptera.Scanner.ScanMode posMark)
instance GHC.Base.Monad (Language.Parser.Ptera.Scanner.ListScanner e)
instance GHC.Base.Applicative (Language.Parser.Ptera.Scanner.ListScanner e)
instance GHC.Base.Functor (Language.Parser.Ptera.Scanner.ListScanner e)
instance Language.Parser.Ptera.Scanner.Scanner [e] e (Language.Parser.Ptera.Scanner.ListScanner e)

module Language.Parser.Ptera.Syntax.SafeGrammar
type T = Grammar
newtype Grammar action rules tokens elem initials
UnsafeGrammar :: FixedGrammar StartPoint NonTerminal Terminal elem StringLit (Maybe ()) action -> Grammar action rules tokens elem initials
[$sel:unsafeGrammar:UnsafeGrammar] :: Grammar action rules tokens elem initials -> FixedGrammar StartPoint NonTerminal Terminal elem StringLit (Maybe ()) action
type family TokensTag (tokens :: Type) :: [Symbol]
type family RulesTag (rules :: Type) :: [Symbol]
type family RuleExprType (rules :: Type) :: Type -> Type
class GrammarToken tokens elem
tokenToTerminal :: GrammarToken tokens elem => Proxy tokens -> elem -> T (TokensTag tokens)
fixGrammar :: forall initials action rules tokens elem. MemberInitials rules initials => Rules rules => RuleExprType rules ~ RuleExpr action rules tokens elem => rules -> Grammar action rules tokens elem initials
type StartPoint = Int
type Terminal = Int
type NonTerminal = Int
class (KnownSymbol v, HasField v rules ((RuleExprType rules) (RuleExprReturnType rules v))) => HasRuleExprField rules v where {
    type family RuleExprReturnType rules v :: Type;
}
nonTerminalName :: HasRuleExprField rules v => rules -> proxy v -> String
class MemberInitials rules initials
memberInitials :: MemberInitials rules initials => T (DictF (HasRuleExprField rules)) initials
class Rules rules
generateRules :: Rules rules => T (DictF (HasRuleExprField rules)) (RulesTag rules)
genStartPoint :: forall initials v. Membership initials v -> StartPoint
newtype RuleExpr action rules tokens elem a
RuleExpr :: [Alt action rules tokens elem a] -> RuleExpr action rules tokens elem a
[$sel:unRuleExpr:RuleExpr] :: RuleExpr action rules tokens elem a -> [Alt action rules tokens elem a]
newtype Alt action rules tokens elem a
UnsafeAlt :: Alt IntermNonTerminal Terminal elem (Maybe ()) action a -> Alt action rules tokens elem a
[$sel:unsafeAlt:UnsafeAlt] :: Alt action rules tokens elem a -> Alt IntermNonTerminal Terminal elem (Maybe ()) action a
newtype Expr rules tokens elem us
UnsafeExpr :: Expr IntermNonTerminal Terminal elem us -> Expr rules tokens elem us
[$sel:unsafeExpr:UnsafeExpr] :: Expr rules tokens elem us -> Expr IntermNonTerminal Terminal elem us
ruleExpr :: [Alt action rules tokens elem a] -> RuleExpr action rules tokens elem a
(<^>) :: Expr rules tokens elem us1 -> Expr rules tokens elem us2 -> Expr rules tokens elem (Concat us1 us2)
infixr 5 <^>
(<:>) :: Expr rules tokens elem us -> action us a -> Alt action rules tokens elem a
infixl 4 <:>
eps :: action '[] a -> Alt action rules tokens elem a
var :: KnownSymbol v => proxy v -> Expr rules tokens elem '[RuleExprReturnType rules v]
varA :: forall v rules tokens elem. KnownSymbol v => Expr rules tokens elem '[RuleExprReturnType rules v]
tok :: Membership (TokensTag tokens) t -> Expr rules tokens elem '[elem]
class TokensMember tokens t
tokensMembership :: TokensMember tokens t => Proxy# '(tokens, t) -> Membership (TokensTag tokens) t
tokA :: forall t rules tokens elem. TokensMember tokens t => Expr rules tokens elem '[elem]

module Language.Parser.Ptera.Syntax
type T ctx = GrammarM ctx

-- | Constraint representing the fact that the field <tt>x</tt> belongs to
--   the record type <tt>r</tt> and has field type <tt>a</tt>. This will be
--   solved automatically, but manual instances may be provided as well.
class HasField (x :: k) r a | x r -> a

-- | Selector function to extract the field from the record.
getField :: HasField x r a => r -> a
class (KnownSymbol v, HasField v rules ((RuleExprType rules) (RuleExprReturnType rules v))) => HasRuleExprField rules v where {
    type family RuleExprReturnType rules v :: Type;
}
nonTerminalName :: HasRuleExprField rules v => rules -> proxy v -> String
type family TokensTag (tokens :: Type) :: [Symbol]
type family RulesTag (rules :: Type) :: [Symbol]
type family RuleExprType (rules :: Type) :: Type -> Type
type GrammarM ctx = Grammar (SemActM ctx)
class MemberInitials rules initials
memberInitials :: MemberInitials rules initials => T (DictF (HasRuleExprField rules)) initials
class Rules rules
generateRules :: Rules rules => T (DictF (HasRuleExprField rules)) (RulesTag rules)
class GrammarToken tokens elem
tokenToTerminal :: GrammarToken tokens elem => Proxy tokens -> elem -> T (TokensTag tokens)
type RuleExprM ctx = RuleExpr (SemActM ctx)
type AltM ctx = Alt (SemActM ctx)
data Expr rules tokens elem us
data HFList (a :: k -> Type) (b :: [k])
[HFNil] :: forall k (a :: k -> Type). HFList a ('[] :: [k])
[HFCons] :: forall k (a :: k -> Type) (x :: k) (xs :: [k]). a x -> HFList a xs -> HFList a (x : xs)
data DictF (a :: k -> Constraint) (b :: k)
[DictF] :: forall k (a :: k -> Constraint) (b :: k). a b => DictF a b
type HList = T Identity
pattern HNil :: HList '[]
pattern (:*) :: u -> HList us -> HList (u : us)
infixr 6 :*
newtype SemActM ctx us a
SemActM :: (HList us -> ActionTask ctx a) -> SemActM ctx us a
[$sel:semanticAction:SemActM] :: SemActM ctx us a -> HList us -> ActionTask ctx a
semActM :: (HList us -> ActionTask ctx a) -> SemActM ctx us a
newtype ActionTask ctx a
ActionTask :: (ctx -> ActionTaskResult ctx a) -> ActionTask ctx a
[$sel:runActionTask:ActionTask] :: ActionTask ctx a -> ctx -> ActionTaskResult ctx a
data ActionTaskResult ctx a
ActionTaskFail :: ActionTaskResult ctx a
ActionTaskResult :: a -> ActionTaskResult ctx a
ActionTaskModifyResult :: ctx -> a -> ActionTaskResult ctx a
getAction :: ActionTask ctx ctx
modifyAction :: (ctx -> ctx) -> ActionTask ctx ()
failAction :: ActionTask ctx a
type Grammar = GrammarM ()
type RuleExpr = RuleExprM ()
type Alt = AltM ()
type SemAct = SemActM ()
semAct :: (HList us -> a) -> SemActM ctx us a
fixGrammar :: forall initials action rules tokens elem. MemberInitials rules initials => Rules rules => RuleExprType rules ~ RuleExpr action rules tokens elem => rules -> Grammar action rules tokens elem initials
ruleExpr :: [Alt action rules tokens elem a] -> RuleExpr action rules tokens elem a
(<^>) :: Expr rules tokens elem us1 -> Expr rules tokens elem us2 -> Expr rules tokens elem (Concat us1 us2)
infixr 5 <^>
(<:>) :: Expr rules tokens elem us -> (HList us -> a) -> AltM ctx rules tokens elem a
infixl 4 <:>
eps :: (HList '[] -> a) -> AltM ctx rules tokens elem a
(<::>) :: Expr rules tokens elem us -> (HList us -> ActionTask ctx a) -> AltM ctx rules tokens elem a
infixl 4 <::>
epsM :: (HList '[] -> ActionTask ctx a) -> AltM ctx rules tokens elem a
var :: KnownSymbol v => proxy v -> Expr rules tokens elem '[RuleExprReturnType rules v]
varA :: forall v rules tokens elem. KnownSymbol v => Expr rules tokens elem '[RuleExprReturnType rules v]
tok :: Membership (TokensTag tokens) t -> Expr rules tokens elem '[elem]
class TokensMember tokens t
tokensMembership :: TokensMember tokens t => Proxy# '(tokens, t) -> Membership (TokensTag tokens) t
tokA :: forall t rules tokens elem. TokensMember tokens t => Expr rules tokens elem '[elem]
instance GHC.Base.Functor (Language.Parser.Ptera.Syntax.ActionTaskResult ctx)
instance (GHC.Show.Show a, GHC.Show.Show ctx) => GHC.Show.Show (Language.Parser.Ptera.Syntax.ActionTaskResult ctx a)
instance (GHC.Classes.Eq a, GHC.Classes.Eq ctx) => GHC.Classes.Eq (Language.Parser.Ptera.Syntax.ActionTaskResult ctx a)
instance GHC.Base.Functor (Language.Parser.Ptera.Syntax.ActionTask ctx)
instance GHC.Base.Functor (Language.Parser.Ptera.Syntax.SemActM ctx us)
instance GHC.Base.Applicative (Language.Parser.Ptera.Syntax.ActionTask ctx)
instance GHC.Base.Monad (Language.Parser.Ptera.Syntax.ActionTask ctx)

module Language.Parser.Ptera.Runner.Parser
type T = RunnerParser
type StartNum = Int
type StateNum = Int
type TokenNum = Int
type VarNum = Int
type AltNum = Int
data AltKind
AltSeq :: AltKind
AltNot :: AltKind
AltAnd :: AltKind
data RunnerParser ctx elem altHelp
RunnerParser :: (StartNum -> Maybe StateNum) -> (elem -> TokenNum) -> (StateNum -> TokenNum -> Trans) -> (AltNum -> AltKind) -> (StateNum -> [(AltNum, Int)]) -> (AltNum -> (StringLit, Maybe altHelp)) -> (AltNum -> ActionM ctx) -> RunnerParser ctx elem altHelp
[$sel:parserInitial:RunnerParser] :: RunnerParser ctx elem altHelp -> StartNum -> Maybe StateNum
[$sel:parserGetTokenNum:RunnerParser] :: RunnerParser ctx elem altHelp -> elem -> TokenNum
[$sel:parserTrans:RunnerParser] :: RunnerParser ctx elem altHelp -> StateNum -> TokenNum -> Trans
[$sel:parserAltKind:RunnerParser] :: RunnerParser ctx elem altHelp -> AltNum -> AltKind
[$sel:parserStateHelp:RunnerParser] :: RunnerParser ctx elem altHelp -> StateNum -> [(AltNum, Int)]
[$sel:parserAltHelp:RunnerParser] :: RunnerParser ctx elem altHelp -> AltNum -> (StringLit, Maybe altHelp)
[$sel:parserAction:RunnerParser] :: RunnerParser ctx elem altHelp -> AltNum -> ActionM ctx
class GrammarToken tokens elem
tokenToTerminal :: GrammarToken tokens elem => Proxy tokens -> elem -> T (TokensTag tokens)
newtype ActionM ctx
ActionM :: ([ReduceArgument] -> ActionTask ctx ReduceArgument) -> ActionM ctx
[$sel:runActionM:ActionM] :: ActionM ctx -> [ReduceArgument] -> ActionTask ctx ReduceArgument
data ReduceArgument
[ReduceArgument] :: a -> ReduceArgument
newtype ActionTask ctx a
ActionTask :: (ctx -> ActionTaskResult ctx a) -> ActionTask ctx a
[$sel:runActionTask:ActionTask] :: ActionTask ctx a -> ctx -> ActionTaskResult ctx a
getAction :: ActionTask ctx ctx
modifyAction :: (ctx -> ctx) -> ActionTask ctx ()
failAction :: ActionTask ctx a
data Trans
Trans :: StateNum -> [TransOp] -> Trans
[$sel:transState:Trans] :: Trans -> StateNum
[$sel:transOps:Trans] :: Trans -> [TransOp]
data TransOp
TransOpEnter :: VarNum -> Bool -> StateNum -> TransOp
TransOpPushBackpoint :: StateNum -> TransOp
TransOpHandleNot :: AltNum -> TransOp
TransOpShift :: TransOp
TransOpReduce :: AltNum -> TransOp
eosToken :: TokenNum
instance GHC.Show.Show Language.Parser.Ptera.Runner.Parser.TransOp
instance GHC.Classes.Eq Language.Parser.Ptera.Runner.Parser.TransOp
instance GHC.Show.Show Language.Parser.Ptera.Runner.Parser.Trans
instance GHC.Classes.Eq Language.Parser.Ptera.Runner.Parser.Trans

module Language.Parser.Ptera.Runner.RunT
type T = RunT
newtype RunT ctx posMark elem altHelp m a
RunT :: StateT (Context ctx posMark elem altHelp) m a -> RunT ctx posMark elem altHelp m a
[$sel:unRunT:RunT] :: RunT ctx posMark elem altHelp m a -> StateT (Context ctx posMark elem altHelp) m a
runT :: forall ctx posMark elem altHelp m a. T posMark elem m => RunT ctx posMark elem altHelp m (ParseResult posMark altHelp a)
data ParseResult posMark altHelp a
Parsed :: a -> ParseResult posMark altHelp a
ParseFailed :: posMark -> FailedReason altHelp -> ParseResult posMark altHelp a
data Context ctx posMark elem altHelp
Context :: T ctx elem altHelp -> StateNum -> [Item posMark ctx] -> Maybe (Position, posMark, TokenNum, Maybe elem) -> Position -> Maybe (Position, posMark, FailedReason altHelp) -> T Position (IntMap (MemoItem posMark)) -> Int -> ctx -> Context ctx posMark elem altHelp
[$sel:ctxParser:Context] :: Context ctx posMark elem altHelp -> T ctx elem altHelp
[$sel:ctxState:Context] :: Context ctx posMark elem altHelp -> StateNum
[$sel:ctxItemStack:Context] :: Context ctx posMark elem altHelp -> [Item posMark ctx]
[$sel:ctxLookAHeadToken:Context] :: Context ctx posMark elem altHelp -> Maybe (Position, posMark, TokenNum, Maybe elem)
[$sel:ctxNextPosition:Context] :: Context ctx posMark elem altHelp -> Position
[$sel:ctxDeepestError:Context] :: Context ctx posMark elem altHelp -> Maybe (Position, posMark, FailedReason altHelp)
[$sel:ctxMemoTable:Context] :: Context ctx posMark elem altHelp -> T Position (IntMap (MemoItem posMark))
[$sel:ctxNeedBackItemsCount:Context] :: Context ctx posMark elem altHelp -> Int
[$sel:ctxCustomContext:Context] :: Context ctx posMark elem altHelp -> ctx
initialContext :: T ctx elem altHelp -> ctx -> StartNum -> Maybe (Context ctx posMark elem altHelp)
newtype Position
Position :: Int -> Position
instance GHC.Base.Functor Language.Parser.Ptera.Runner.RunT.FailedReason
instance GHC.Show.Show altHelp => GHC.Show.Show (Language.Parser.Ptera.Runner.RunT.FailedReason altHelp)
instance GHC.Base.Functor (Language.Parser.Ptera.Runner.RunT.ParseResult posMark altHelp)
instance (GHC.Show.Show a, GHC.Show.Show posMark, GHC.Show.Show altHelp) => GHC.Show.Show (Language.Parser.Ptera.Runner.RunT.ParseResult posMark altHelp a)
instance Language.Parser.Ptera.Data.Alignable.Alignable Language.Parser.Ptera.Runner.RunT.Position
instance GHC.Show.Show Language.Parser.Ptera.Runner.RunT.Position
instance GHC.Classes.Ord Language.Parser.Ptera.Runner.RunT.Position
instance GHC.Classes.Eq Language.Parser.Ptera.Runner.RunT.Position
instance GHC.Base.Monad m => GHC.Base.Monad (Language.Parser.Ptera.Runner.RunT.RunT ctx posMark elem altHelp m)
instance GHC.Base.Monad m => GHC.Base.Applicative (Language.Parser.Ptera.Runner.RunT.RunT ctx posMark elem altHelp m)
instance GHC.Base.Functor m => GHC.Base.Functor (Language.Parser.Ptera.Runner.RunT.RunT ctx posMark elem altHelp m)
instance GHC.Show.Show Language.Parser.Ptera.Runner.RunT.RunningResult
instance GHC.Classes.Eq Language.Parser.Ptera.Runner.RunT.RunningResult
instance Control.Monad.Trans.Class.MonadTrans (Language.Parser.Ptera.Runner.RunT.RunT ctx posMark elem altHelp)

module Language.Parser.Ptera.Pipeline.SRB2Parser
type Action ctx = Action (SemActM ctx)
srb2Parser :: forall ctx tokens elem altHelp. GrammarToken tokens elem => Proxy tokens -> T Int StringLit (Maybe altHelp) (Action ctx) -> T ctx elem altHelp
buildTrans :: Int -> MState -> Trans
buildStateHelp :: [AltItem] -> [(AltNum, Int)]
transOp :: TransOp -> TransOp
runAction :: Action ctx -> ActionM ctx

module Language.Parser.Ptera.Runner
type T = RunnerM
newtype RunnerM ctx rules elem initials
UnsafeRunnerM :: T ctx elem () -> RunnerM ctx rules elem initials
[$sel:unRunnerM:UnsafeRunnerM] :: RunnerM ctx rules elem initials -> T ctx elem ()
type Result posMark = ParseResult posMark ()
data ParseResult posMark altHelp a
Parsed :: a -> ParseResult posMark altHelp a
ParseFailed :: posMark -> FailedReason altHelp -> ParseResult posMark altHelp a
runParserM :: forall v initials ctx posMark m rules elem proxy. Member initials v => T posMark elem m => proxy v -> RunnerM ctx rules elem initials -> ctx -> m (Result posMark (RuleExprReturnType rules v))
runParser :: forall v initials posMark m rules elem proxy. Member initials v => T posMark elem m => proxy v -> Runner rules elem initials -> m (Result posMark (RuleExprReturnType rules v))

module Language.Parser.Ptera.Pipeline.SafeGrammar2SRB
safeGrammar2Srb :: T action rules tokens elem initials -> Either [StringLit] (T Int StringLit (Maybe ()) (Action action))

module Language.Parser.Ptera.Pipeline.Grammar2Runner
grammar2Runner :: forall initials ctx rules tokens elem. GrammarToken tokens elem => GrammarM ctx rules tokens elem initials -> Either [StringLit] (T ctx rules elem initials)

module Language.Parser.Ptera

-- | Constraint representing the fact that the field <tt>x</tt> belongs to
--   the record type <tt>r</tt> and has field type <tt>a</tt>. This will be
--   solved automatically, but manual instances may be provided as well.
class HasField (x :: k) r a | x r -> a

-- | Selector function to extract the field from the record.
getField :: HasField x r a => r -> a
data HFList (a :: k -> Type) (b :: [k])
[HFNil] :: forall k (a :: k -> Type). HFList a ('[] :: [k])
[HFCons] :: forall k (a :: k -> Type) (x :: k) (xs :: [k]). a x -> HFList a xs -> HFList a (x : xs)
data DictF (a :: k -> Constraint) (b :: k)
[DictF] :: forall k (a :: k -> Constraint) (b :: k). a b => DictF a b
class TokensMember tokens t
tokensMembership :: TokensMember tokens t => Proxy# '(tokens, t) -> Membership (TokensTag tokens) t
data Expr rules tokens elem us
class Rules rules
generateRules :: Rules rules => T (DictF (HasRuleExprField rules)) (RulesTag rules)
class MemberInitials rules initials
memberInitials :: MemberInitials rules initials => T (DictF (HasRuleExprField rules)) initials
class (KnownSymbol v, HasField v rules ((RuleExprType rules) (RuleExprReturnType rules v))) => HasRuleExprField rules v where {
    type family RuleExprReturnType rules v :: Type;
}
nonTerminalName :: HasRuleExprField rules v => rules -> proxy v -> String
class GrammarToken tokens elem
tokenToTerminal :: GrammarToken tokens elem => Proxy tokens -> elem -> T (TokensTag tokens)
type family RuleExprType (rules :: Type) :: Type -> Type
type family RulesTag (rules :: Type) :: [Symbol]
type family TokensTag (tokens :: Type) :: [Symbol]
fixGrammar :: forall initials action rules tokens elem. MemberInitials rules initials => Rules rules => RuleExprType rules ~ RuleExpr action rules tokens elem => rules -> Grammar action rules tokens elem initials
ruleExpr :: [Alt action rules tokens elem a] -> RuleExpr action rules tokens elem a
(<^>) :: Expr rules tokens elem us1 -> Expr rules tokens elem us2 -> Expr rules tokens elem (Concat us1 us2)
infixr 5 <^>
var :: KnownSymbol v => proxy v -> Expr rules tokens elem '[RuleExprReturnType rules v]
varA :: forall v rules tokens elem. KnownSymbol v => Expr rules tokens elem '[RuleExprReturnType rules v]
tok :: Membership (TokensTag tokens) t -> Expr rules tokens elem '[elem]
tokA :: forall t rules tokens elem. TokensMember tokens t => Expr rules tokens elem '[elem]
data ActionTaskResult ctx a
ActionTaskFail :: ActionTaskResult ctx a
ActionTaskResult :: a -> ActionTaskResult ctx a
ActionTaskModifyResult :: ctx -> a -> ActionTaskResult ctx a
newtype ActionTask ctx a
ActionTask :: (ctx -> ActionTaskResult ctx a) -> ActionTask ctx a
[$sel:runActionTask:ActionTask] :: ActionTask ctx a -> ctx -> ActionTaskResult ctx a
type SemAct = SemActM ()
newtype SemActM ctx us a
SemActM :: (HList us -> ActionTask ctx a) -> SemActM ctx us a
[$sel:semanticAction:SemActM] :: SemActM ctx us a -> HList us -> ActionTask ctx a
type HList = T Identity
type Alt = AltM ()
type RuleExpr = RuleExprM ()
type Grammar = GrammarM ()
type AltM ctx = Alt (SemActM ctx)
type RuleExprM ctx = RuleExpr (SemActM ctx)
type GrammarM ctx = Grammar (SemActM ctx)
pattern (:*) :: u -> HList us -> HList (u : us)
infixr 6 :*
pattern HNil :: HList '[]
(<:>) :: Expr rules tokens elem us -> (HList us -> a) -> AltM ctx rules tokens elem a
infixl 4 <:>
eps :: (HList '[] -> a) -> AltM ctx rules tokens elem a
(<::>) :: Expr rules tokens elem us -> (HList us -> ActionTask ctx a) -> AltM ctx rules tokens elem a
infixl 4 <::>
epsM :: (HList '[] -> ActionTask ctx a) -> AltM ctx rules tokens elem a
getAction :: ActionTask ctx ctx
modifyAction :: (ctx -> ctx) -> ActionTask ctx ()
failAction :: ActionTask ctx a
data ParseResult posMark altHelp a
Parsed :: a -> ParseResult posMark altHelp a
ParseFailed :: posMark -> FailedReason altHelp -> ParseResult posMark altHelp a
type Result posMark = ParseResult posMark ()
runParser :: forall v initials posMark m rules elem proxy. Member initials v => T posMark elem m => proxy v -> Runner rules elem initials -> m (Result posMark (RuleExprReturnType rules v))
newtype ListScanner e a
ListScanner :: State [e] a -> ListScanner e a
[$sel:unListScanner:ListScanner] :: ListScanner e a -> State [e] a
data ScanMode posMark
ScanModeNoBack :: ScanMode posMark
ScanModeNeedBack :: posMark -> ScanMode posMark
class Monad m => Scanner posMark elem m | m -> posMark, m -> elem
consumeInput :: Scanner posMark elem m => m (Maybe elem)
getPosMark :: Scanner posMark elem m => m posMark
seekToPosMark :: Scanner posMark elem m => posMark -> m ()
scanMode :: Scanner posMark elem m => ScanMode posMark -> m ()
runListScanner :: ListScanner e a -> [e] -> a
type Parser = T
genRunner :: GrammarToken tokens elem => GrammarM ctx rules tokens elem initials -> Either [StringLit] (Parser ctx rules elem initials)