Safe Haskell | None |
---|
Language.Haskell.Meta.Utils
Description
This module is a staging ground for to-be-organized-and-merged-nicely code.
- cleanNames :: Data a => a -> a
- pretty :: Show a => a -> String
- pp :: (Data a, Ppr a) => a -> String
- ppDoc :: (Data a, Ppr a) => a -> Doc
- gpretty :: Data a => a -> String
- unsafeRunQ :: Q a -> a
- nameToRawCodeStr :: Name -> String
- (|$|) :: ExpQ -> ExpQ -> ExpQ
- (|.|) :: ExpQ -> ExpQ -> ExpQ
- (|->|) :: TypeQ -> TypeQ -> TypeQ
- unForall :: Type -> Type
- functionT :: [TypeQ] -> TypeQ
- mkVarT :: String -> TypeQ
- myNames :: [Name]
- renameThings :: (t1 -> t2 -> t -> (a, t1, t2)) -> t1 -> t2 -> [a] -> [t] -> ([a], t1, t2)
- renameTs :: [(Name, Name)] -> [Name] -> [Type] -> [Type] -> ([Type], [(Name, Name)], [Name])
- renameT :: [(Name, Name)] -> [Name] -> Type -> (Type, [(Name, Name)], [Name])
- normaliseName :: Name -> Name
- applyT :: Type -> Type -> Type
- substT :: [(Name, Type)] -> [Name] -> Type -> Type
- splitCon :: Con -> (Name, [Type])
- strictTypeTy :: StrictType -> Type
- varStrictTypeTy :: VarStrictType -> Type
- conTypes :: Con -> [Type]
- conToConType :: Type -> Con -> Type
- decCons :: Dec -> [Con]
- decTyVars :: Dec -> [TyVarBndr]
- decName :: Dec -> Maybe Name
- foreignName :: Foreign -> Name
- unwindT :: Type -> [Type]
- unwindE :: Exp -> [Exp]
- arityT :: Type -> Int
- typeToName :: Type -> Maybe Name
- nameSpaceOf :: Name -> Maybe NameSpace
- conName :: Con -> Name
- recCName :: Con -> Maybe Name
- dataDCons :: Dec -> [Con]
- fromDataConI :: Info -> Q (Maybe Exp)
- fromTyConI :: Info -> Maybe Dec
- mkFunD :: Name -> [Pat] -> Exp -> Dec
- mkClauseQ :: [PatQ] -> ExpQ -> ClauseQ
- toExpQ :: Lift a => (String -> Q a) -> String -> ExpQ
- toPatQ :: Show a => (String -> Q a) -> String -> PatQ
- showToPatQ :: Show a => a -> PatQ
- eitherQ :: (e -> String) -> Either e a -> Q a
- normalizeT :: Data a => a -> a
Documentation
cleanNames :: Data a => a -> a
pretty :: Show a => a -> String
The type passed in must have a Show
instance which
produces a valid Haskell expression. Returns an empty
String
if this is not the case. This is not TH-specific,
but useful in general.
pp :: (Data a, Ppr a) => a -> String
ppDoc :: (Data a, Ppr a) => a -> Doc
gpretty :: Data a => a -> String
unsafeRunQ :: Q a -> a
unsafeRunQ = unsafePerformIO . runQ
nameToRawCodeStr :: Name -> String
(|$|) :: ExpQ -> ExpQ -> ExpQ
(|.|) :: ExpQ -> ExpQ -> ExpQ
(|->|) :: TypeQ -> TypeQ -> TypeQ
unForall :: Type -> Type
functionT :: [TypeQ] -> TypeQ
mkVarT :: String -> TypeQ
myNames :: [Name]
Infinite list of names composed of lowercase letters
renameThings :: (t1 -> t2 -> t -> (a, t1, t2)) -> t1 -> t2 -> [a] -> [t] -> ([a], t1, t2)
Generalisation of renameTs
renameTs :: [(Name, Name)] -> [Name] -> [Type] -> [Type] -> ([Type], [(Name, Name)], [Name])
renameT applied to a list of types
renameT :: [(Name, Name)] -> [Name] -> Type -> (Type, [(Name, Name)], [Name])
Rename type variables in the Type according to the given association list. Normalise constructor names (remove qualification, etc.) If a name is not found in the association list, replace it with one from the fresh names list, and add this translation to the returned list. The fresh names list should be infinite; myNames is a good example.
normaliseName :: Name -> Name
Remove qualification, etc.
applyT :: Type -> Type -> Type
substT :: [(Name, Type)] -> [Name] -> Type -> Type
splitCon :: Con -> (Name, [Type])
strictTypeTy :: StrictType -> Type
varStrictTypeTy :: VarStrictType -> Type
conTypes :: Con -> [Type]
conToConType :: Type -> Con -> Type
decCons :: Dec -> [Con]
decTyVars :: Dec -> [TyVarBndr]
decName :: Dec -> Maybe Name
foreignName :: Foreign -> Name
unwindT :: Type -> [Type]
unwindE :: Exp -> [Exp]
arityT :: Type -> Int
The arity of a Type.
typeToName :: Type -> Maybe Name
nameSpaceOf :: Name -> Maybe NameSpace
Randomly useful.
conName :: Con -> Name
recCName :: Con -> Maybe Name
dataDCons :: Dec -> [Con]
fromDataConI :: Info -> Q (Maybe Exp)
fromTyConI :: Info -> Maybe Dec
mkFunD :: Name -> [Pat] -> Exp -> Dec
mkClauseQ :: [PatQ] -> ExpQ -> ClauseQ
toExpQ :: Lift a => (String -> Q a) -> String -> ExpQ
The strategy for producing QuasiQuoters which
this datatype aims to facilitate is as follows.
Given a collection of datatypes which make up
the to-be-quasiquoted languages AST, make each
type in this collection an instance of at least
Show
and Lift
. Now, assuming parsePat
and
parseExp
, both of type String -> Q a
(where a
is the top level type of the AST), are the pair of
functions you wish to use for parsing in pattern and
expression context respectively, put them inside
a Quoter
datatype and pass this to quasify.
toPatQ :: Show a => (String -> Q a) -> String -> PatQ
showToPatQ :: Show a => a -> PatQ
eitherQ :: (e -> String) -> Either e a -> Q a
normalizeT :: Data a => a -> a