Language.Haskell.TH.Utils

Some auxiliary functions that might be needed when using template Haskell

Documentation

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

Rename a Name

rename' :: Name -> (String -> String) -> 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"       

appExp :: [ExpQ] -> ExpQ

Apply a list of expression

[(+), 1, 2] to (+) 1 2
appExp' [VarE '(+) , (LitE (IntegerL 1)), (LitE (IntegerL 2))]
>AppE (AppE (VarE GHC.Num.+) (LitE (IntegerL 1))) (LitE (IntegerL 2))

appExp' :: [Exp] -> Exp

unappExp :: ExpQ -> Q [Exp]

unappExp' :: Exp -> [Exp]

appConT :: [TypeQ] -> TypeQ

Apply a type constructor like appExp

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

appConT' :: [Type] -> Type

unappConT :: TypeQ -> Q [Type]

Unapply a constructor application to a list of types

unappConT' :: Type -> [Type]

Unapply a constructor application to a list of types

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

uncurryType :: TypeQ -> Q [Type]

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

> uncurryType' (ForallT [PlainTV (mkName "a")] [] (AppT (AppT ArrowT (VarT (mkName "a"))) (ConT ''Int)))
> [VarT a,ConT GHC.Types.Int]

uncurryType' :: 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])

Generate a list of type Bind and Type without Q

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

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

Generate related patterns and expressions

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

Generate related patterns and expressions without Q

appKind :: [Kind] -> Kind

Apply a list of kinds, like appConT

unappKind :: Kind -> [Kind]

Like unappConT

curryKind :: [Kind] -> Kind

Like curryType but on kind level

uncurryKind :: Kind -> [Kind]

Like uncurryType

getTypeNames :: Type -> [Name]

Get type Names recursively, You can transform it to set if you want.

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

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

sequence-like functons on tuples

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

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

unsequence :: Q [a] -> Q [Q a]

Unsequence Q [a] to [Q a], but you never get rid of the outer Q

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

Print AST of the code.

pprintQ :: Ppr a => Q a -> IO ()

Pretty print spliced code

printiQ :: Out a => Q a -> IO ()

Print AST with indentions. There are also other exported functions from genericpretty library. See Out.

runQ [| (1+1) * 5|] >>= pp -- or use
printiQ  [| (1+1) * 5|]
InfixE (Just InfixE (Just LitE (IntegerL 1))
                  (VarE (Name (OccName "+")
                              (NameG' VarName
                                       (PkgName "base")
                                       (ModName "GHC.Num"))))
                   (Just LitE (IntegerL 1)))
      (VarE (Name (OccName "*")
                  (NameG' VarName
                          (PkgName "base")
                          (ModName "GHC.Num"))))
      (Just LitE (IntegerL 5))

printi :: Out a => a -> IO ()

Print AST with identions

exported GenericPretty package

module Text.PrettyPrint.GenericPretty