Language.Haskell.TH.Utils

Documentation

appExp :: [ExpQ] -> ExpQ

Apply a list of expression | > [(+), 1, 2] to (+) 1 2

appExp' :: [Exp] -> Exp

appConT :: [TypeQ] -> TypeQ

Apply a type constructor | > convert [a, b, c] to a b c like appExp

> pprint $ appConT' (map ConT [''(,), ''Int , ''Bool])
"GHC.Tuple.(,) GHC.Types.Int GHC.Types.Bool" --i.e. (Int,Bool)

appConT' :: [Type] -> Type

curryType :: [TypeQ] -> TypeQ

convert [a, b, c] to a -> b -> c

> pprint $ curryType' (map ConT [''Int , ''Int , ''Bool])
"GHC.Types.Int -> GHC.Types.Int -> GHC.Types.Bool"

curryType' :: [Type] -> Type

genBT :: String -> Int -> Q ([TyVarBndr], [TypeQ])

> genBT' "a" 3
([PlainTV a1,PlainTV a2,PlainTV a3],[VarT a1,VarT a2,VarT a3])

Generate a list of type Bind and Type

genBT' :: String -> Int -> ([TyVarBndr], [Type])

genPE :: String -> Int -> Q ([PatQ], [ExpQ])

> genPE' "a" 3
([VarP a1,VarP a2,VarP a3],[VarE a1,VarE a2,VarE a3])

Related patterns and expressions

genPE' :: String -> Int -> ([Pat], [Exp])

appKinds :: [Kind] -> Kind

Apply a list of kinds, like appConT

curryKind :: [Kind] -> Kind

convert [k1,k2,k3] to k1 -> k2 -> k3,like 'curryType'

getTypeNames :: Type -> [Name]

Get type Names recursively

getTVBName :: TyVarBndr -> Name

Get type var bind name

getCompositeType :: Con -> [Name]

Get all names recursively from a constructor

getConName :: Con -> Name

Get name from constructors

seqTuple2 :: (Q a, Q b) -> Q (a, b)

sequence-like functons on tuples

seqTuple3 :: (Q a, Q b, Q c) -> Q (a, b, c)

seqTuple4 :: (Q a, Q b, Q c, Q d) -> Q (a, b, c, d)

rename :: Q Name -> (String -> String) -> Q Name

rename' :: Name -> (String -> String) -> Name

Rename a Name

rename'' :: Name -> (String -> String) -> Q Name

nameToExp

Arguments

:: (String -> String)

Function to change name.

-> Name

-> Q Exp

data Foo = Foo { foo :: Int }
> $(nameToExp (++"1") 'foo)
"foo1"       

printQ :: Show a => Q a -> IO ()

Print AST