Documentation

Methods

fold :: Monoid m => Program' m -> m #

foldMap :: Monoid m => (a -> m) -> Program' a -> m #

foldMap' :: Monoid m => (a -> m) -> Program' a -> m #

foldr :: (a -> b -> b) -> b -> Program' a -> b #

foldr' :: (a -> b -> b) -> b -> Program' a -> b #

foldl :: (b -> a -> b) -> b -> Program' a -> b #

foldl' :: (b -> a -> b) -> b -> Program' a -> b #

foldr1 :: (a -> a -> a) -> Program' a -> a #

foldl1 :: (a -> a -> a) -> Program' a -> a #

toList :: Program' a -> [a] #

null :: Program' a -> Bool #

length :: Program' a -> Int #

elem :: Eq a => a -> Program' a -> Bool #

maximum :: Ord a => Program' a -> a #

minimum :: Ord a => Program' a -> a #

sum :: Num a => Program' a -> a #

product :: Num a => Program' a -> a #

Methods

traverse :: Applicative f => (a -> f b) -> Program' a -> f (Program' b) #

sequenceA :: Applicative f => Program' (f a) -> f (Program' a) #

mapM :: Monad m => (a -> m b) -> Program' a -> m (Program' b) #

sequence :: Monad m => Program' (m a) -> m (Program' a) #

Methods

fmap :: (a -> b) -> Program' a -> Program' b #

(<$) :: a -> Program' b -> Program' a #

Methods

hasPosition :: Program -> BNFC'Position Source #

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Program' a -> c (Program' a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Program' a) #

toConstr :: Program' a -> Constr #

dataTypeOf :: Program' a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Program' a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Program' a)) #

gmapT :: (forall b. Data b => b -> b) -> Program' a -> Program' a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Program' a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Program' a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Program' a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Program' a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Program' a -> m (Program' a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Program' a -> m (Program' a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Program' a -> m (Program' a) #

Methods

from :: Program' a -> Rep (Program' a) x #

to :: Rep (Program' a) x -> Program' a #

Methods

readsPrec :: Int -> ReadS (Program' a) #

readList :: ReadS [Program' a] #

readPrec :: ReadPrec (Program' a) #

readListPrec :: ReadPrec [Program' a] #

Methods

showsPrec :: Int -> Program' a -> ShowS #

show :: Program' a -> String #

showList :: [Program' a] -> ShowS #

Methods

(==) :: Program' a -> Program' a -> Bool #

(/=) :: Program' a -> Program' a -> Bool #

Methods

compare :: Program' a -> Program' a -> Ordering #

(<) :: Program' a -> Program' a -> Bool #

(<=) :: Program' a -> Program' a -> Bool #

(>) :: Program' a -> Program' a -> Bool #

(>=) :: Program' a -> Program' a -> Bool #

max :: Program' a -> Program' a -> Program' a #

min :: Program' a -> Program' a -> Program' a #

Methods

prt :: Int -> Program' a -> Doc Source #

Methods

fold :: Monoid m => Command' m -> m #

foldMap :: Monoid m => (a -> m) -> Command' a -> m #

foldMap' :: Monoid m => (a -> m) -> Command' a -> m #

foldr :: (a -> b -> b) -> b -> Command' a -> b #

foldr' :: (a -> b -> b) -> b -> Command' a -> b #

foldl :: (b -> a -> b) -> b -> Command' a -> b #

foldl' :: (b -> a -> b) -> b -> Command' a -> b #

foldr1 :: (a -> a -> a) -> Command' a -> a #

foldl1 :: (a -> a -> a) -> Command' a -> a #

toList :: Command' a -> [a] #

null :: Command' a -> Bool #

length :: Command' a -> Int #

elem :: Eq a => a -> Command' a -> Bool #

maximum :: Ord a => Command' a -> a #

minimum :: Ord a => Command' a -> a #

sum :: Num a => Command' a -> a #

product :: Num a => Command' a -> a #

Methods

traverse :: Applicative f => (a -> f b) -> Command' a -> f (Command' b) #

sequenceA :: Applicative f => Command' (f a) -> f (Command' a) #

mapM :: Monad m => (a -> m b) -> Command' a -> m (Command' b) #

sequence :: Monad m => Command' (m a) -> m (Command' a) #

Methods

fmap :: (a -> b) -> Command' a -> Command' b #

(<$) :: a -> Command' b -> Command' a #

Methods

hasPosition :: Command -> BNFC'Position Source #

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Command' a -> c (Command' a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Command' a) #

toConstr :: Command' a -> Constr #

dataTypeOf :: Command' a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Command' a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Command' a)) #

gmapT :: (forall b. Data b => b -> b) -> Command' a -> Command' a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Command' a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Command' a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Command' a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Command' a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Command' a -> m (Command' a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Command' a -> m (Command' a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Command' a -> m (Command' a) #

Methods

from :: Command' a -> Rep (Command' a) x #

to :: Rep (Command' a) x -> Command' a #

Methods

readsPrec :: Int -> ReadS (Command' a) #

readList :: ReadS [Command' a] #

readPrec :: ReadPrec (Command' a) #

readListPrec :: ReadPrec [Command' a] #

Methods

showsPrec :: Int -> Command' a -> ShowS #

show :: Command' a -> String #

showList :: [Command' a] -> ShowS #

Methods

(==) :: Command' a -> Command' a -> Bool #

(/=) :: Command' a -> Command' a -> Bool #

Methods

compare :: Command' a -> Command' a -> Ordering #

(<) :: Command' a -> Command' a -> Bool #

(<=) :: Command' a -> Command' a -> Bool #

(>) :: Command' a -> Command' a -> Bool #

(>=) :: Command' a -> Command' a -> Bool #

max :: Command' a -> Command' a -> Command' a #

min :: Command' a -> Command' a -> Command' a #

Methods

prt :: Int -> Command' a -> Doc Source #

Methods

prt :: Int -> [Command' a] -> Doc Source #

Methods

fold :: Monoid m => Term' m -> m #

foldMap :: Monoid m => (a -> m) -> Term' a -> m #

foldMap' :: Monoid m => (a -> m) -> Term' a -> m #

foldr :: (a -> b -> b) -> b -> Term' a -> b #

foldr' :: (a -> b -> b) -> b -> Term' a -> b #

foldl :: (b -> a -> b) -> b -> Term' a -> b #

foldl' :: (b -> a -> b) -> b -> Term' a -> b #

foldr1 :: (a -> a -> a) -> Term' a -> a #

foldl1 :: (a -> a -> a) -> Term' a -> a #

toList :: Term' a -> [a] #

null :: Term' a -> Bool #

length :: Term' a -> Int #

elem :: Eq a => a -> Term' a -> Bool #

maximum :: Ord a => Term' a -> a #

minimum :: Ord a => Term' a -> a #

sum :: Num a => Term' a -> a #

product :: Num a => Term' a -> a #

Methods

traverse :: Applicative f => (a -> f b) -> Term' a -> f (Term' b) #

sequenceA :: Applicative f => Term' (f a) -> f (Term' a) #

mapM :: Monad m => (a -> m b) -> Term' a -> m (Term' b) #

sequence :: Monad m => Term' (m a) -> m (Term' a) #

Methods

fmap :: (a -> b) -> Term' a -> Term' b #

(<$) :: a -> Term' b -> Term' a #

Methods

hasPosition :: Term -> BNFC'Position Source #

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Term' a -> c (Term' a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Term' a) #

toConstr :: Term' a -> Constr #

dataTypeOf :: Term' a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Term' a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Term' a)) #

gmapT :: (forall b. Data b => b -> b) -> Term' a -> Term' a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Term' a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Term' a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Term' a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Term' a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Term' a -> m (Term' a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Term' a -> m (Term' a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Term' a -> m (Term' a) #

Methods

from :: Term' a -> Rep (Term' a) x #

to :: Rep (Term' a) x -> Term' a #

Methods

readsPrec :: Int -> ReadS (Term' a) #

readList :: ReadS [Term' a] #

readPrec :: ReadPrec (Term' a) #

readListPrec :: ReadPrec [Term' a] #

Methods

showsPrec :: Int -> Term' a -> ShowS #

show :: Term' a -> String #

showList :: [Term' a] -> ShowS #

Methods

(==) :: Term' a -> Term' a -> Bool #

(/=) :: Term' a -> Term' a -> Bool #

Methods

compare :: Term' a -> Term' a -> Ordering #

(<) :: Term' a -> Term' a -> Bool #

(<=) :: Term' a -> Term' a -> Bool #

(>) :: Term' a -> Term' a -> Bool #

(>=) :: Term' a -> Term' a -> Bool #

max :: Term' a -> Term' a -> Term' a #

min :: Term' a -> Term' a -> Term' a #

Methods

prt :: Int -> Term' a -> Doc Source #

Methods

fold :: Monoid m => ScopedTerm' m -> m #

foldMap :: Monoid m => (a -> m) -> ScopedTerm' a -> m #

foldMap' :: Monoid m => (a -> m) -> ScopedTerm' a -> m #

foldr :: (a -> b -> b) -> b -> ScopedTerm' a -> b #

foldr' :: (a -> b -> b) -> b -> ScopedTerm' a -> b #

foldl :: (b -> a -> b) -> b -> ScopedTerm' a -> b #

foldl' :: (b -> a -> b) -> b -> ScopedTerm' a -> b #

foldr1 :: (a -> a -> a) -> ScopedTerm' a -> a #

foldl1 :: (a -> a -> a) -> ScopedTerm' a -> a #

toList :: ScopedTerm' a -> [a] #

null :: ScopedTerm' a -> Bool #

length :: ScopedTerm' a -> Int #

elem :: Eq a => a -> ScopedTerm' a -> Bool #

maximum :: Ord a => ScopedTerm' a -> a #

minimum :: Ord a => ScopedTerm' a -> a #

sum :: Num a => ScopedTerm' a -> a #

product :: Num a => ScopedTerm' a -> a #

Methods

traverse :: Applicative f => (a -> f b) -> ScopedTerm' a -> f (ScopedTerm' b) #

sequenceA :: Applicative f => ScopedTerm' (f a) -> f (ScopedTerm' a) #

mapM :: Monad m => (a -> m b) -> ScopedTerm' a -> m (ScopedTerm' b) #

sequence :: Monad m => ScopedTerm' (m a) -> m (ScopedTerm' a) #

Methods

fmap :: (a -> b) -> ScopedTerm' a -> ScopedTerm' b #

(<$) :: a -> ScopedTerm' b -> ScopedTerm' a #

Methods

hasPosition :: ScopedTerm -> BNFC'Position Source #

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ScopedTerm' a -> c (ScopedTerm' a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ScopedTerm' a) #

toConstr :: ScopedTerm' a -> Constr #

dataTypeOf :: ScopedTerm' a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ScopedTerm' a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ScopedTerm' a)) #

gmapT :: (forall b. Data b => b -> b) -> ScopedTerm' a -> ScopedTerm' a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ScopedTerm' a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ScopedTerm' a -> r #

gmapQ :: (forall d. Data d => d -> u) -> ScopedTerm' a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ScopedTerm' a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ScopedTerm' a -> m (ScopedTerm' a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ScopedTerm' a -> m (ScopedTerm' a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ScopedTerm' a -> m (ScopedTerm' a) #

Methods

from :: ScopedTerm' a -> Rep (ScopedTerm' a) x #

to :: Rep (ScopedTerm' a) x -> ScopedTerm' a #

Methods

readsPrec :: Int -> ReadS (ScopedTerm' a) #

readList :: ReadS [ScopedTerm' a] #

readPrec :: ReadPrec (ScopedTerm' a) #

readListPrec :: ReadPrec [ScopedTerm' a] #

Methods

showsPrec :: Int -> ScopedTerm' a -> ShowS #

show :: ScopedTerm' a -> String #

showList :: [ScopedTerm' a] -> ShowS #

Methods

(==) :: ScopedTerm' a -> ScopedTerm' a -> Bool #

(/=) :: ScopedTerm' a -> ScopedTerm' a -> Bool #

Methods

compare :: ScopedTerm' a -> ScopedTerm' a -> Ordering #

(<) :: ScopedTerm' a -> ScopedTerm' a -> Bool #

(<=) :: ScopedTerm' a -> ScopedTerm' a -> Bool #

(>) :: ScopedTerm' a -> ScopedTerm' a -> Bool #

(>=) :: ScopedTerm' a -> ScopedTerm' a -> Bool #

max :: ScopedTerm' a -> ScopedTerm' a -> ScopedTerm' a #

min :: ScopedTerm' a -> ScopedTerm' a -> ScopedTerm' a #

Methods

prt :: Int -> ScopedTerm' a -> Doc Source #

Methods

fold :: Monoid m => Pattern' m -> m #

foldMap :: Monoid m => (a -> m) -> Pattern' a -> m #

foldMap' :: Monoid m => (a -> m) -> Pattern' a -> m #

foldr :: (a -> b -> b) -> b -> Pattern' a -> b #

foldr' :: (a -> b -> b) -> b -> Pattern' a -> b #

foldl :: (b -> a -> b) -> b -> Pattern' a -> b #

foldl' :: (b -> a -> b) -> b -> Pattern' a -> b #

foldr1 :: (a -> a -> a) -> Pattern' a -> a #

foldl1 :: (a -> a -> a) -> Pattern' a -> a #

toList :: Pattern' a -> [a] #

null :: Pattern' a -> Bool #

length :: Pattern' a -> Int #

elem :: Eq a => a -> Pattern' a -> Bool #

maximum :: Ord a => Pattern' a -> a #

minimum :: Ord a => Pattern' a -> a #

sum :: Num a => Pattern' a -> a #

product :: Num a => Pattern' a -> a #

Methods

traverse :: Applicative f => (a -> f b) -> Pattern' a -> f (Pattern' b) #

sequenceA :: Applicative f => Pattern' (f a) -> f (Pattern' a) #

mapM :: Monad m => (a -> m b) -> Pattern' a -> m (Pattern' b) #

sequence :: Monad m => Pattern' (m a) -> m (Pattern' a) #

Methods

fmap :: (a -> b) -> Pattern' a -> Pattern' b #

(<$) :: a -> Pattern' b -> Pattern' a #

Methods

hasPosition :: Pattern -> BNFC'Position Source #

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Pattern' a -> c (Pattern' a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Pattern' a) #

toConstr :: Pattern' a -> Constr #

dataTypeOf :: Pattern' a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Pattern' a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Pattern' a)) #

gmapT :: (forall b. Data b => b -> b) -> Pattern' a -> Pattern' a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pattern' a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pattern' a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Pattern' a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Pattern' a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Pattern' a -> m (Pattern' a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Pattern' a -> m (Pattern' a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Pattern' a -> m (Pattern' a) #

Methods

from :: Pattern' a -> Rep (Pattern' a) x #

to :: Rep (Pattern' a) x -> Pattern' a #

Methods

readsPrec :: Int -> ReadS (Pattern' a) #

readList :: ReadS [Pattern' a] #

readPrec :: ReadPrec (Pattern' a) #

readListPrec :: ReadPrec [Pattern' a] #

Methods

showsPrec :: Int -> Pattern' a -> ShowS #

show :: Pattern' a -> String #

showList :: [Pattern' a] -> ShowS #

Methods

(==) :: Pattern' a -> Pattern' a -> Bool #

(/=) :: Pattern' a -> Pattern' a -> Bool #

Methods

compare :: Pattern' a -> Pattern' a -> Ordering #

(<) :: Pattern' a -> Pattern' a -> Bool #

(<=) :: Pattern' a -> Pattern' a -> Bool #

(>) :: Pattern' a -> Pattern' a -> Bool #

(>=) :: Pattern' a -> Pattern' a -> Bool #

max :: Pattern' a -> Pattern' a -> Pattern' a #

min :: Pattern' a -> Pattern' a -> Pattern' a #

Methods

prt :: Int -> Pattern' a -> Doc Source #

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VarIdent -> c VarIdent #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VarIdent #

toConstr :: VarIdent -> Constr #

dataTypeOf :: VarIdent -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c VarIdent) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarIdent) #

gmapT :: (forall b. Data b => b -> b) -> VarIdent -> VarIdent #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VarIdent -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VarIdent -> r #

gmapQ :: (forall d. Data d => d -> u) -> VarIdent -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> VarIdent -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> VarIdent -> m VarIdent #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VarIdent -> m VarIdent #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VarIdent -> m VarIdent #

Methods

fromString :: String -> VarIdent #

Methods

from :: VarIdent -> Rep VarIdent x #

to :: Rep VarIdent x -> VarIdent #

Methods

readsPrec :: Int -> ReadS VarIdent #

readList :: ReadS [VarIdent] #

readPrec :: ReadPrec VarIdent #

readListPrec :: ReadPrec [VarIdent] #

Methods

showsPrec :: Int -> VarIdent -> ShowS #

show :: VarIdent -> String #

showList :: [VarIdent] -> ShowS #

Methods

(==) :: VarIdent -> VarIdent -> Bool #

(/=) :: VarIdent -> VarIdent -> Bool #

Methods

compare :: VarIdent -> VarIdent -> Ordering #

(<) :: VarIdent -> VarIdent -> Bool #

(<=) :: VarIdent -> VarIdent -> Bool #

(>) :: VarIdent -> VarIdent -> Bool #

(>=) :: VarIdent -> VarIdent -> Bool #

max :: VarIdent -> VarIdent -> VarIdent #

min :: VarIdent -> VarIdent -> VarIdent #

Methods

prt :: Int -> VarIdent -> Doc Source #

Methods

hasPosition :: Command -> BNFC'Position Source #

Methods

hasPosition :: Pattern -> BNFC'Position Source #

Methods

hasPosition :: Program -> BNFC'Position Source #

Methods

hasPosition :: ScopedTerm -> BNFC'Position Source #

Methods

hasPosition :: Term -> BNFC'Position Source #