Text.Grampa.ContextFree.Memoizing

Documentation

data FailureInfo

Constructors

FailureInfo Word64 [String]

Instances

Eq FailureInfo

Methods

(==) :: FailureInfo -> FailureInfo -> Bool

(/=) :: FailureInfo -> FailureInfo -> Bool

Show FailureInfo

Methods

showsPrec :: Int -> FailureInfo -> ShowS

show :: FailureInfo -> String

showList :: [FailureInfo] -> ShowS

Semigroup FailureInfo

Methods

(<>) :: FailureInfo -> FailureInfo -> FailureInfo

sconcat :: NonEmpty FailureInfo -> FailureInfo

stimes :: Integral b => b -> FailureInfo -> FailureInfo

Monoid FailureInfo

Methods

mempty :: FailureInfo

mappend :: FailureInfo -> FailureInfo -> FailureInfo

mconcat :: [FailureInfo] -> FailureInfo

data ResultList g s r

Constructors

ResultList !(BinTree (ResultInfo g s r)) !FailureInfo

Instances

Functor (ResultList g s)

Methods

fmap :: (a -> b) -> ResultList g s a -> ResultList g s b

(<$) :: a -> ResultList g s b -> ResultList g s a

Show1 (ResultList g s)

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> ResultList g s a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [ResultList g s a] -> ShowS

Show r => Show (ResultList g s r)

Methods

showsPrec :: Int -> ResultList g s r -> ShowS

show :: ResultList g s r -> String

showList :: [ResultList g s r] -> ShowS

Semigroup (ResultList g s r)

Methods

(<>) :: ResultList g s r -> ResultList g s r -> ResultList g s r

sconcat :: NonEmpty (ResultList g s r) -> ResultList g s r

stimes :: Integral b => b -> ResultList g s r -> ResultList g s r

Monoid (ResultList g s r)

Methods

mempty :: ResultList g s r

mappend :: ResultList g s r -> ResultList g s r -> ResultList g s r

mconcat :: [ResultList g s r] -> ResultList g s r

newtype Parser g s r

Parser for a context-free grammar with packrat-like sharing of parse results. It does not support left-recursive grammars.

Constructors

Parser

Fields

• applyParser :: [(s, g (ResultList g s))] -> ResultList g s r

Instances

GrammarParsing Parser

Associated Types

type GrammarFunctor (Parser :: ((* -> *) -> *) -> * -> * -> *) :: ((* -> *) -> *) -> * -> * -> *

Methods

nonTerminal :: GrammarConstraint Parser g => (g (GrammarFunctor Parser g s) -> GrammarFunctor Parser g s a) -> Parser g s a

selfReferring :: (GrammarConstraint Parser g, Distributive * g) => g (Parser g s)

fixGrammar :: (GrammarConstraint Parser g, Distributive * g) => (g (Parser g s) -> g (Parser g s)) -> g (Parser g s)

recursive :: Parser g s a -> Parser g s a

MultiParsing Parser

Memoizing parser guarantees O(n²) performance for grammars with unambiguous productions, but provides no left recursion support.

parseComplete :: (Rank2.Functor g, FactorialMonoid s) =>
                 g (Memoizing.Parser g s) -> s -> g (Compose ParseResults [])

Associated Types

type ResultFunctor (Parser :: ((* -> *) -> *) -> * -> * -> *) :: * -> *

type GrammarConstraint (Parser :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) :: Constraint

Methods

parseComplete :: (GrammarConstraint Parser g, FactorialMonoid s) => g (Parser g s) -> s -> g (ResultFunctor Parser)

parsePrefix :: (GrammarConstraint Parser g, FactorialMonoid s) => g (Parser g s) -> s -> g (Compose * * (ResultFunctor Parser) ((,) s))

MonoidParsing (Parser g)

Methods

endOfInput :: FactorialMonoid s => Parser g s ()

getInput :: FactorialMonoid s => Parser g s s

anyToken :: FactorialMonoid s => Parser g s s

satisfy :: FactorialMonoid s => (s -> Bool) -> Parser g s s

satisfyChar :: TextualMonoid s => (Char -> Bool) -> Parser g s Char

satisfyCharInput :: TextualMonoid s => (Char -> Bool) -> Parser g s s

notSatisfy :: FactorialMonoid s => (s -> Bool) -> Parser g s ()

notSatisfyChar :: TextualMonoid s => (Char -> Bool) -> Parser g s ()

scan :: FactorialMonoid t => s -> (s -> t -> Maybe s) -> Parser g t t

scanChars :: TextualMonoid t => s -> (s -> Char -> Maybe s) -> Parser g t t

string :: (FactorialMonoid s, LeftReductiveMonoid s, Show s) => s -> Parser g s s

takeWhile :: FactorialMonoid s => (s -> Bool) -> Parser g s s

takeWhile1 :: FactorialMonoid s => (s -> Bool) -> Parser g s s

takeCharsWhile :: TextualMonoid s => (Char -> Bool) -> Parser g s s

takeCharsWhile1 :: TextualMonoid s => (Char -> Bool) -> Parser g s s

concatMany :: Monoid a => Parser g s a -> Parser g s a

Monad (Parser g i)

Methods

(>>=) :: Parser g i a -> (a -> Parser g i b) -> Parser g i b

(>>) :: Parser g i a -> Parser g i b -> Parser g i b

return :: a -> Parser g i a

fail :: String -> Parser g i a

Functor (Parser g i)

Methods

fmap :: (a -> b) -> Parser g i a -> Parser g i b

(<$) :: a -> Parser g i b -> Parser g i a

Applicative (Parser g i)

Methods

pure :: a -> Parser g i a

(<*>) :: Parser g i (a -> b) -> Parser g i a -> Parser g i b

liftA2 :: (a -> b -> c) -> Parser g i a -> Parser g i b -> Parser g i c

(*>) :: Parser g i a -> Parser g i b -> Parser g i b

(<*) :: Parser g i a -> Parser g i b -> Parser g i a

Alternative (Parser g i)

Methods

empty :: Parser g i a

(<|>) :: Parser g i a -> Parser g i a -> Parser g i a

some :: Parser g i a -> Parser g i [a]

many :: Parser g i a -> Parser g i [a]

MonadPlus (Parser g s)

Methods

mzero :: Parser g s a

mplus :: Parser g s a -> Parser g s a -> Parser g s a

(Lexical g, LexicalConstraint Parser g s, Show s, TextualMonoid s) => TokenParsing (Parser g s)

Methods

someSpace :: Parser g s ()

nesting :: Parser g s a -> Parser g s a

semi :: Parser g s Char

highlight :: Highlight -> Parser g s a -> Parser g s a

token :: Parser g s a -> Parser g s a

MonoidNull s => LookAheadParsing (Parser g s)

Methods

lookAhead :: Parser g s a -> Parser g s a

(Show s, TextualMonoid s) => CharParsing (Parser g s)

Methods

satisfy :: (Char -> Bool) -> Parser g s Char

char :: Char -> Parser g s Char

notChar :: Char -> Parser g s Char

anyChar :: Parser g s Char

string :: String -> Parser g s String

text :: Text -> Parser g s Text

MonoidNull s => Parsing (Parser g s)

Methods

try :: Parser g s a -> Parser g s a

(<?>) :: Parser g s a -> String -> Parser g s a

skipMany :: Parser g s a -> Parser g s ()

skipSome :: Parser g s a -> Parser g s ()

unexpected :: String -> Parser g s a

eof :: Parser g s ()

notFollowedBy :: Show a => Parser g s a -> Parser g s ()

Semigroup x => Semigroup (Parser g s x)

Methods

(<>) :: Parser g s x -> Parser g s x -> Parser g s x

sconcat :: NonEmpty (Parser g s x) -> Parser g s x

stimes :: Integral b => b -> Parser g s x -> Parser g s x

Monoid x => Monoid (Parser g s x)

Methods

mempty :: Parser g s x

mappend :: Parser g s x -> Parser g s x -> Parser g s x

mconcat :: [Parser g s x] -> Parser g s x

type GrammarFunctor Parser

type GrammarFunctor Parser = ResultList

type ResultFunctor Parser

type ResultFunctor Parser = Compose * * ParseResults []

type GrammarConstraint Parser g

type GrammarConstraint Parser g = Functor * g

data BinTree a

Constructors

Fork !(BinTree a) !(BinTree a)

Leaf !a

EmptyTree

Instances

Functor BinTree

Methods

fmap :: (a -> b) -> BinTree a -> BinTree b

(<$) :: a -> BinTree b -> BinTree a

Foldable BinTree

Methods

fold :: Monoid m => BinTree m -> m

foldMap :: Monoid m => (a -> m) -> BinTree a -> m

foldr :: (a -> b -> b) -> b -> BinTree a -> b

foldr' :: (a -> b -> b) -> b -> BinTree a -> b

foldl :: (b -> a -> b) -> b -> BinTree a -> b

foldl' :: (b -> a -> b) -> b -> BinTree a -> b

foldr1 :: (a -> a -> a) -> BinTree a -> a

foldl1 :: (a -> a -> a) -> BinTree a -> a

toList :: BinTree a -> [a]

null :: BinTree a -> Bool

length :: BinTree a -> Int

elem :: Eq a => a -> BinTree a -> Bool

maximum :: Ord a => BinTree a -> a

minimum :: Ord a => BinTree a -> a

sum :: Num a => BinTree a -> a

product :: Num a => BinTree a -> a

Show a => Show (BinTree a)

Methods

showsPrec :: Int -> BinTree a -> ShowS

show :: BinTree a -> String

showList :: [BinTree a] -> ShowS

Semigroup (BinTree a)

Methods

(<>) :: BinTree a -> BinTree a -> BinTree a

sconcat :: NonEmpty (BinTree a) -> BinTree a

stimes :: Integral b => b -> BinTree a -> BinTree a

Monoid (BinTree a)

Methods

mempty :: BinTree a

mappend :: BinTree a -> BinTree a -> BinTree a

mconcat :: [BinTree a] -> BinTree a

(<<|>) :: Parser g s a -> Parser g s a -> Parser g s a infixl 3

fromResultList :: FactorialMonoid s => s -> ResultList g s r -> ParseResults [(s, r)]

reparseTails :: Functor g => g (Parser g s) -> [(s, g (ResultList g s))] -> [(s, g (ResultList g s))]

longest :: Parser g s a -> Parser g [(s, g (ResultList g s))] a

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

peg :: Parser g [(s, g (ResultList g s))] a -> Parser g s a

Turns a backtracking PEG parser of the list of input tails into a context-free parser, opposite of longest

terminalPEG :: Monoid s => Parser g s a -> Parser g s a

Turns a backtracking PEG parser into a context-free parser