Documentation

Methods

fmap :: (a -> b) -> EField a -> EField b #

(<$) :: a -> EField b -> EField a #

Methods

fold :: Monoid m => EField m -> m #

foldMap :: Monoid m => (a -> m) -> EField a -> m #

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

foldr :: (a -> b -> b) -> b -> EField a -> b #

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

foldl :: (b -> a -> b) -> b -> EField a -> b #

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

foldr1 :: (a -> a -> a) -> EField a -> a #

foldl1 :: (a -> a -> a) -> EField a -> a #

toList :: EField a -> [a] #

null :: EField a -> Bool #

length :: EField a -> Int #

elem :: Eq a => a -> EField a -> Bool #

maximum :: Ord a => EField a -> a #

minimum :: Ord a => EField a -> a #

sum :: Num a => EField a -> a #

product :: Num a => EField a -> a #

Methods

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

sequenceA :: Applicative f => EField (f a) -> f (EField a) #

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

sequence :: Monad m => EField (m a) -> m (EField a) #

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> EField a -> ShowS #

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [EField a] -> ShowS #

Methods

lift :: EField a -> Q Exp #

liftTyped :: EField a -> Q (TExp (EField a)) #

Methods

(==) :: EField a -> EField a -> Bool #

(/=) :: EField a -> EField a -> Bool #

Methods

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

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

toConstr :: EField a -> Constr #

dataTypeOf :: EField a -> DataType #

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

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

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

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

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

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

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

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

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

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

Methods

readsPrec :: Int -> ReadS (EField a) #

readList :: ReadS [EField a] #

readPrec :: ReadPrec (EField a) #

readListPrec :: ReadPrec [EField a] #

Methods

showsPrec :: Int -> EField a -> ShowS #

show :: EField a -> String #

showList :: [EField a] -> ShowS #

Methods

from :: EField a -> Rep (EField a) x #

to :: Rep (EField a) x -> EField a #

Methods

aeq' :: AlphaCtx -> EField a -> EField a -> Bool #

fvAny' :: (Contravariant f, Applicative f) => AlphaCtx -> (AnyName -> f AnyName) -> EField a -> f (EField a) #

close :: AlphaCtx -> NamePatFind -> EField a -> EField a #

open :: AlphaCtx -> NthPatFind -> EField a -> EField a #

isPat :: EField a -> DisjointSet AnyName #

isTerm :: EField a -> All #

isEmbed :: EField a -> Bool #

nthPatFind :: EField a -> NthPatFind #

namePatFind :: EField a -> NamePatFind #

swaps' :: AlphaCtx -> Perm AnyName -> EField a -> EField a #

lfreshen' :: LFresh m => AlphaCtx -> EField a -> (EField a -> Perm AnyName -> m b) -> m b #

freshen' :: Fresh m => AlphaCtx -> EField a -> m (EField a, Perm AnyName) #

acompare' :: AlphaCtx -> EField a -> EField a -> Ordering #

Methods

fmap :: (a -> b) -> ExprF a -> ExprF b #

(<$) :: a -> ExprF b -> ExprF a #

Methods

fold :: Monoid m => ExprF m -> m #

foldMap :: Monoid m => (a -> m) -> ExprF a -> m #

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

foldr :: (a -> b -> b) -> b -> ExprF a -> b #

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

foldl :: (b -> a -> b) -> b -> ExprF a -> b #

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

foldr1 :: (a -> a -> a) -> ExprF a -> a #

foldl1 :: (a -> a -> a) -> ExprF a -> a #

toList :: ExprF a -> [a] #

null :: ExprF a -> Bool #

length :: ExprF a -> Int #

elem :: Eq a => a -> ExprF a -> Bool #

maximum :: Ord a => ExprF a -> a #

minimum :: Ord a => ExprF a -> a #

sum :: Num a => ExprF a -> a #

product :: Num a => ExprF a -> a #

Methods

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

sequenceA :: Applicative f => ExprF (f a) -> f (ExprF a) #

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

sequence :: Monad m => ExprF (m a) -> m (ExprF a) #

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> ExprF a -> ShowS #

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [ExprF a] -> ShowS #

Methods

lift :: Expr -> Q Exp #

liftTyped :: Expr -> Q (TExp Expr) #

Methods

lift :: ExprF a -> Q Exp #

liftTyped :: ExprF a -> Q (TExp (ExprF a)) #

Methods

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

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

toConstr :: ExprF a -> Constr #

dataTypeOf :: ExprF a -> DataType #

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

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

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

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

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

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

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

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

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

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

Methods

showsPrec :: Int -> ExprF a -> ShowS #

show :: ExprF a -> String #

showList :: [ExprF a] -> ShowS #

Methods

from :: ExprF a -> Rep (ExprF a) x #

to :: Rep (ExprF a) x -> ExprF a #

Methods

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

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

Methods

showsPrec :: Int -> Import -> ShowS #

show :: Import -> String #

showList :: [Import] -> ShowS #