GLL.Combinators.MemInterface

Documentation

data SymbParser b

Instances

IsSymbParser SymbParser

IsIMParser SymbParser

HasAlts SymbParser

data IMParser b

Instances

IsSymbParser IMParser

IsIMParser IMParser

HasAlts IMParser

IsSymbParser ((:.) [] IMParser)

IsIMParser ((:.) [] IMParser)

HasAlts ((:.) [] IMParser)

class HasAlts a where

Methods

altsOf :: a b -> ([] :. IMParser) b

Instances

HasAlts IMParser

HasAlts SymbParser

HasAlts ((:.) [] IMParser)

class IsSymbParser a where

Methods

toSymb :: a b -> SymbParser b

Instances

IsSymbParser IMParser

IsSymbParser SymbParser

IsSymbParser ((:.) [] IMParser)

class IsIMParser a where

Methods

toImp :: a b -> IMParser b

Instances

IsIMParser IMParser

IsIMParser SymbParser

IsIMParser ((:.) [] IMParser)

parse :: IsSymbParser s => s a -> [Token] -> IO [a]

The semantic results of a parser, given a string of Tokens

parseString :: IsSymbParser s => s a -> String -> IO [a]

Parse a string of characters

char :: Char -> SymbParser Char

token :: Token -> SymbParser Token

data Token

Constructors

Char Char

EOS

Epsilon

Int (Maybe Int)

Bool (Maybe Bool)

String (Maybe String)

Token String (Maybe String)

Instances

Eq Token

Ord Token

Show Token

epsilon :: SymbParser ()

satisfy :: a -> IMParser a

many :: SymbParser a -> SymbParser [a]

some :: SymbParser a -> SymbParser [a]

optional :: SymbParser a -> SymbParser (Maybe a)

(<::=>) :: HasAlts b => String -> b a -> SymbParser a infixl 2

Use this combinator on all combinators that might have an infinite number of derivations for some input string. A non-terminal has this property if and only if it is left-recursive and would be left-recursive if all the right-hand sides of the productions of the grammar are reversed.

(<:=>) :: HasAlts b => String -> b a -> SymbParser a infixl 2

Use this combinator on all recursive non-terminals

(<$>) :: IsSymbParser s => (a -> b) -> s a -> IMParser b infixl 4

(<$) :: IsSymbParser s => b -> s a -> IMParser b infixl 4

(<*>) :: (IsIMParser i, IsSymbParser s) => i (a -> b) -> s a -> IMParser b infixl 4

(<*) :: (IsIMParser i, IsSymbParser s) => i b -> s a -> IMParser b infixl 4

(<|>) :: (IsIMParser i, HasAlts b) => i a -> b a -> ([] :. IMParser) a infixr 3

data (g :. f) a :: (* -> *) -> (* -> *) -> * -> * infixl 9

Composition of unary type constructors

There are (at least) two useful Monoid instances, so you'll have to pick one and type-specialize it (filling in all or parts of g and/or f).

    -- standard Monoid instance for Applicative applied to Monoid
    instance (Applicative (g :. f), Monoid a) => Monoid ((g :. f) a) where
      { mempty = pure mempty; mappend = liftA2 mappend }
    -- Especially handy when g is a Monoid_f.
    instance Monoid (g (f a)) => Monoid ((g :. f) a) where
      { mempty = O mempty; mappend = inO2 mappend }

Corresponding to the first and second definitions above,

    instance (Applicative g, Monoid_f f) => Monoid_f (g :. f) where
      { mempty_f = O (pure mempty_f); mappend_f = inO2 (liftA2 mappend_f) }
    instance Monoid_f g => Monoid_f (g :. f) where
      { mempty_f = O mempty_f; mappend_f = inO2 mappend_f }

Similarly, there are two useful Functor instances and two useful ContraFunctor instances.

    instance (      Functor g,       Functor f) => Functor (g :. f) where fmap = fmapFF
    instance (ContraFunctor g, ContraFunctor f) => Functor (g :. f) where fmap = fmapCC

    instance (      Functor g, ContraFunctor f) => ContraFunctor (g :. f) where contraFmap = contraFmapFC
    instance (ContraFunctor g,       Functor f) => ContraFunctor (g :. f) where contraFmap = contraFmapCF

However, it's such a bother to define the Functor instances per composition type, I've left the fmapFF case in. If you want the fmapCC one, you're out of luck for now. I'd love to hear a good solution. Maybe someday Haskell will do Prolog-style search for instances, subgoaling the constraints, rather than just matching instance heads.

Instances

(Functor g, Functor f) => Functor ((:.) g f)

(Applicative g, Applicative f) => Applicative ((:.) g f)

(Foldable g, Foldable f, Functor g) => Foldable ((:.) g f)

(Traversable g, Traversable f) => Traversable ((:.) g f)

IsSymbParser ((:.) [] IMParser)

IsIMParser ((:.) [] IMParser)

HasAlts ((:.) [] IMParser)

IsSymbParser ((:.) [] IMParser)

IsIMParser ((:.) [] IMParser)

HasAlts ((:.) [] IMParser)

Eq (g (f a)) => Eq ((:.) g f a)

Show (g (f a)) => Show ((:.) g f a)

memo :: IsSymbParser s => MemoRef [a] -> s a -> SymbParser a

newMemoTable :: IO (MemoRef a)

type MemoRef a = IORef (MemoTable a)

type MemoTable a = IntMap (IntMap a)

use ::= to enforce using parse context (to handle left-recursion)