Language.Haskell.TH.Helper

These small short-named functions are intended to make the construction of abstranct syntax trees less tedious.

Special folds for the guessing

applyWith :: Exp -> [Exp] -> Exp

foldr1With :: Exp -> [Exp] -> Exp

foldl1With :: Exp -> [Exp] -> Exp

Syntax elements

sclause :: [Pat] -> Exp -> Clause

A simple clause, without where or guards.

defclause :: Int -> Exp -> Clause

A default clause with N arguments.

sval :: Pat -> Exp -> Dec

A simple Val clause

case' :: Exp -> [(Pat, Exp)] -> Exp

(->:) :: String -> Exp -> Exp

instance_none :: String -> DataDef -> [Dec] -> Dec

We provide 3 standard instance constructors instance_default requires C for each free type variable instance_none requires no context instance_context requires a given context

instance_default :: String -> DataDef -> [Dec] -> Dec

instance_context :: [String] -> String -> DataDef -> [Dec] -> Dec

simple_instance :: String -> DataDef -> [Dec] -> [Dec]

Build an instance of a class for a data type, using the heuristic that the type is itself required on all type arguments.

generic_instance :: String -> DataDef -> [Type] -> [Dec] -> [Dec]

Build an instance of a class for a data type, using the class at the given types

sigN :: String -> Type -> Dec

Build a type signature declaration with a string name

funN :: String -> [Clause] -> Dec

Build a fundecl with a string name

Pattern vs Value abstraction

class Eq nm => NameLike nm where

Methods

toName :: nm -> Name

Instances

NameLike String

NameLike Name

class Valcon a where

The class used to overload lifting operations. To reduce code duplication, we overload the wrapped constructors (and everything else, but that's irrelevant) to work in patterns, expressions, and types.

Methods

lK :: NameLike nm => nm -> [a] -> a

Build an application node, with a name for a head and a provided list of arguments.

vr :: NameLike nm => nm -> a

Reference a named variable.

raw_lit :: Lit -> a

Lift a TH Lit

tup :: [a] -> a

Tupling

lst :: [a] -> a

Listing

Instances

Valcon Exp

Valcon Pat

Valcon Type

app :: Exp -> [Exp] -> Exp

Build an application node without a given head

class LitC a where

This class is used to overload literal construction based on the type of the literal.

Methods

lit :: Valcon p => a -> p

Instances

LitC Char

LitC Integer

LitC ()

LitC a => LitC [a]

(LitC a, LitC b) => LitC (a, b)

(LitC a, LitC b, LitC c) => LitC (a, b, c)

Constructor abstraction

dataVars :: DataDef -> [Type]

vars :: Valcon a => Char -> Int -> [a]

Common pattern: list of a familiy of variables

vrn :: Valcon a => Char -> Int -> a

Variable based on a letter + number

ctv :: Valcon a => CtorDef -> Char -> [a]

Make a list of variables, one for each argument to a constructor

ctp :: Valcon a => CtorDef -> Char -> a

Make a simple pattern to bind a constructor

ctc :: Valcon a => CtorDef -> a

Reference the constructor itself

Lift a constructor over a fixed number of arguments.

l0 :: (NameLike nm, Valcon a) => nm -> a

l1 :: (NameLike nm, Valcon a) => nm -> a -> a

l2 :: (NameLike nm, Valcon a) => nm -> a -> a -> a

Pre-lifted versions of common operations

true :: Valcon a => a

nil :: Valcon a => a

false :: Valcon a => a

hNil' :: Type

hZero' :: Type

unit :: Exp

id' :: Exp

cons :: Valcon a => a -> a -> a

box :: Valcon a => a -> a

return' :: Exp -> Exp

const' :: Exp -> Exp

hSucc' :: Type -> Type

(==:) :: Exp -> Exp -> Exp

(>:) :: Exp -> Exp -> Exp

ap' :: Exp -> Exp -> Exp

(.:) :: Exp -> Exp -> Exp

(>>:) :: Exp -> Exp -> Exp

(>>=:) :: Exp -> Exp -> Exp

(++:) :: Exp -> Exp -> Exp

(&&:) :: Exp -> Exp -> Exp

hCons' :: Type -> Type -> Type

(&&::) :: [Exp] -> Exp

Build a chain of expressions, with an appropriate terminal sequence__ does not require a unit at the end (all others are optimised automatically)

(.::) :: [Exp] -> Exp

Build a chain of expressions, with an appropriate terminal sequence__ does not require a unit at the end (all others are optimised automatically)

sequence__ :: [Exp] -> Exp

Build a chain of expressions, with an appropriate terminal sequence__ does not require a unit at the end (all others are optimised automatically)

(>>::) :: [Exp] -> Exp

Build a chain of expressions, with an appropriate terminal sequence__ does not require a unit at the end (all others are optimised automatically)

(++::) :: [Exp] -> Exp

Build a chain of expressions, with an appropriate terminal sequence__ does not require a unit at the end (all others are optimised automatically)

liftmk :: Exp -> [Exp] -> Exp

K-way liftM