Documentation

Methods

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

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

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

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

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

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

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

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

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

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

null :: Module' a -> Bool #

length :: Module' a -> Int #

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

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

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

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

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

Methods

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

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

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

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

Methods

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

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

Methods

hasPosition :: Module -> BNFC'Position Source #

Methods

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

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

toConstr :: Module' a -> Constr #

dataTypeOf :: Module' a -> DataType #

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

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

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

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

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

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

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

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

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

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

Methods

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

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

Methods

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

readList :: ReadS [Module' a] #

readPrec :: ReadPrec (Module' a) #

readListPrec :: ReadPrec [Module' a] #

Methods

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

show :: Module' a -> String #

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

Methods

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

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

Methods

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

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

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

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

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

max :: Module' a -> Module' a -> Module' a #

min :: Module' a -> Module' a -> Module' a #

Methods

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

Methods

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

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

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

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

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

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

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

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

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

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

null :: HoleIdent' a -> Bool #

length :: HoleIdent' a -> Int #

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

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

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

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

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

Methods

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

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

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

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

Methods

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

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

Methods

hasPosition :: HoleIdent -> BNFC'Position Source #

Methods

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

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

toConstr :: HoleIdent' a -> Constr #

dataTypeOf :: HoleIdent' a -> DataType #

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

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

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

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

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

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

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

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

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

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

Methods

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

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

Methods

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

readList :: ReadS [HoleIdent' a] #

readPrec :: ReadPrec (HoleIdent' a) #

readListPrec :: ReadPrec [HoleIdent' a] #

Methods

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

show :: HoleIdent' a -> String #

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

Methods

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

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

Methods

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

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

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

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

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

max :: HoleIdent' a -> HoleIdent' a -> HoleIdent' a #

min :: HoleIdent' a -> HoleIdent' a -> HoleIdent' a #

Methods

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

Methods

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

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

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

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

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

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

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

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

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

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

null :: VarIdent' a -> Bool #

length :: VarIdent' a -> Int #

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

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

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

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

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

Methods

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

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

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

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

Methods

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

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

Methods

hasPosition :: VarIdent -> BNFC'Position Source #

Methods

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

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

toConstr :: VarIdent' a -> Constr #

dataTypeOf :: VarIdent' a -> DataType #

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

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

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

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

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

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

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

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

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

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

Methods

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

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

Methods

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

readList :: ReadS [VarIdent' a] #

readPrec :: ReadPrec (VarIdent' a) #

readListPrec :: ReadPrec [VarIdent' a] #

Methods

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

show :: VarIdent' a -> String #

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

Methods

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

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

Methods

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

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

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

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

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

max :: VarIdent' a -> VarIdent' a -> VarIdent' a #

min :: VarIdent' a -> VarIdent' a -> VarIdent' a #

Methods

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

Methods

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

Methods

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

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

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

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

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

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

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

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

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

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

null :: LanguageDecl' a -> Bool #

length :: LanguageDecl' a -> Int #

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

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

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

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

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

Methods

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

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

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

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

Methods

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

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

Methods

hasPosition :: LanguageDecl -> BNFC'Position Source #

Methods

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

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

toConstr :: LanguageDecl' a -> Constr #

dataTypeOf :: LanguageDecl' a -> DataType #

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

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

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

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

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

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

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

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

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

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

Methods

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

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

Methods

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

readList :: ReadS [LanguageDecl' a] #

readPrec :: ReadPrec (LanguageDecl' a) #

readListPrec :: ReadPrec [LanguageDecl' a] #

Methods

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

show :: LanguageDecl' a -> String #

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

Methods

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

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

Methods

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

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

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

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

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

max :: LanguageDecl' a -> LanguageDecl' a -> LanguageDecl' a #

min :: LanguageDecl' a -> LanguageDecl' a -> LanguageDecl' a #

Methods

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

Methods

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

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

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

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

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

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

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

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

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

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

null :: Language' a -> Bool #

length :: Language' a -> Int #

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

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

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

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

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

Methods

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

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

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

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

Methods

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

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

Methods

hasPosition :: Language -> BNFC'Position Source #

Methods

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

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

toConstr :: Language' a -> Constr #

dataTypeOf :: Language' a -> DataType #

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

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

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

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

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

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

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

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

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

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

Methods

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

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

Methods

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

readList :: ReadS [Language' a] #

readPrec :: ReadPrec (Language' a) #

readListPrec :: ReadPrec [Language' a] #

Methods

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

show :: Language' a -> String #

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

Methods

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

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

Methods

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

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

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

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

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

max :: Language' a -> Language' a -> Language' a #

min :: Language' a -> Language' a -> Language' a #

Methods

prt :: Int -> Language' 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 => DeclUsedVars' m -> m #

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

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

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

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

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

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

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

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

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

null :: DeclUsedVars' a -> Bool #

length :: DeclUsedVars' a -> Int #

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

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

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

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

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

Methods

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

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

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

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

Methods

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

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

Methods

hasPosition :: DeclUsedVars -> BNFC'Position Source #

Methods

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

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

toConstr :: DeclUsedVars' a -> Constr #

dataTypeOf :: DeclUsedVars' a -> DataType #

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

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

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

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

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

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

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

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

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

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

Methods

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

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

Methods

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

readList :: ReadS [DeclUsedVars' a] #

readPrec :: ReadPrec (DeclUsedVars' a) #

readListPrec :: ReadPrec [DeclUsedVars' a] #

Methods

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

show :: DeclUsedVars' a -> String #

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

Methods

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

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

Methods

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

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

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

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

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

max :: DeclUsedVars' a -> DeclUsedVars' a -> DeclUsedVars' a #

min :: DeclUsedVars' a -> DeclUsedVars' a -> DeclUsedVars' a #

Methods

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

Methods

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

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

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

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

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

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

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

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

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

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

null :: SectionName' a -> Bool #

length :: SectionName' a -> Int #

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

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

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

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

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

Methods

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

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

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

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

Methods

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

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

Methods

hasPosition :: SectionName -> BNFC'Position Source #

Methods

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

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

toConstr :: SectionName' a -> Constr #

dataTypeOf :: SectionName' a -> DataType #

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

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

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

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

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

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

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

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

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

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

Methods

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

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

Methods

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

readList :: ReadS [SectionName' a] #

readPrec :: ReadPrec (SectionName' a) #

readListPrec :: ReadPrec [SectionName' a] #

Methods

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

show :: SectionName' a -> String #

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

Methods

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

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

Methods

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

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

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

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

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

max :: SectionName' a -> SectionName' a -> SectionName' a #

min :: SectionName' a -> SectionName' a -> SectionName' a #

Methods

prt :: Int -> SectionName' 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

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

Methods

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

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

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

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

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

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

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

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

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

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

null :: Param' a -> Bool #

length :: Param' a -> Int #

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

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

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

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

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

Methods

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

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

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

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

Methods

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

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

Methods

hasPosition :: Param -> BNFC'Position Source #

Methods

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

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

toConstr :: Param' a -> Constr #

dataTypeOf :: Param' a -> DataType #

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

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

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

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

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

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

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

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

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

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