Safe Haskell | Safe |
---|---|

Language | Haskell2010 |

Language.Haskell.TH.Lib contains lots of useful helper functions for generating and manipulating Template Haskell terms

## Synopsis

- type InfoQ = Q Info
- type ExpQ = Q Exp
- type TExpQ a = Q (TExp a)
- type DecQ = Q Dec
- type DecsQ = Q [Dec]
- type ConQ = Q Con
- type TypeQ = Q Type
- type KindQ = Q Kind
- type TyVarBndrQ = Q TyVarBndr
- type TyLitQ = Q TyLit
- type CxtQ = Q Cxt
- type PredQ = Q Pred
- type DerivClauseQ = Q DerivClause
- type MatchQ = Q Match
- type ClauseQ = Q Clause
- type BodyQ = Q Body
- type GuardQ = Q Guard
- type StmtQ = Q Stmt
- type RangeQ = Q Range
- type SourceStrictnessQ = Q SourceStrictness
- type SourceUnpackednessQ = Q SourceUnpackedness
- type BangQ = Q Bang
- type BangTypeQ = Q BangType
- type VarBangTypeQ = Q VarBangType
- type StrictTypeQ = Q StrictType
- type VarStrictTypeQ = Q VarStrictType
- type FieldExpQ = Q FieldExp
- type PatQ = Q Pat
- type FieldPatQ = Q FieldPat
- type RuleBndrQ = Q RuleBndr
- type TySynEqnQ = Q TySynEqn
- type PatSynDirQ = Q PatSynDir
- type PatSynArgsQ = Q PatSynArgs
- type FamilyResultSigQ = Q FamilyResultSig
- type DerivStrategyQ = Q DerivStrategy
- intPrimL :: Integer -> Lit
- wordPrimL :: Integer -> Lit
- floatPrimL :: Rational -> Lit
- doublePrimL :: Rational -> Lit
- integerL :: Integer -> Lit
- rationalL :: Rational -> Lit
- charL :: Char -> Lit
- stringL :: String -> Lit
- stringPrimL :: [Word8] -> Lit
- charPrimL :: Char -> Lit
- litP :: Lit -> PatQ
- varP :: Name -> PatQ
- tupP :: [PatQ] -> PatQ
- unboxedTupP :: [PatQ] -> PatQ
- unboxedSumP :: PatQ -> SumAlt -> SumArity -> PatQ
- conP :: Name -> [PatQ] -> PatQ
- uInfixP :: PatQ -> Name -> PatQ -> PatQ
- parensP :: PatQ -> PatQ
- infixP :: PatQ -> Name -> PatQ -> PatQ
- tildeP :: PatQ -> PatQ
- bangP :: PatQ -> PatQ
- asP :: Name -> PatQ -> PatQ
- wildP :: PatQ
- recP :: Name -> [FieldPatQ] -> PatQ
- listP :: [PatQ] -> PatQ
- sigP :: PatQ -> TypeQ -> PatQ
- viewP :: ExpQ -> PatQ -> PatQ
- fieldPat :: Name -> PatQ -> FieldPatQ
- normalB :: ExpQ -> BodyQ
- guardedB :: [Q (Guard, Exp)] -> BodyQ
- normalG :: ExpQ -> GuardQ
- normalGE :: ExpQ -> ExpQ -> Q (Guard, Exp)
- patG :: [StmtQ] -> GuardQ
- patGE :: [StmtQ] -> ExpQ -> Q (Guard, Exp)
- match :: PatQ -> BodyQ -> [DecQ] -> MatchQ
- clause :: [PatQ] -> BodyQ -> [DecQ] -> ClauseQ
- dyn :: String -> ExpQ
- varE :: Name -> ExpQ
- unboundVarE :: Name -> ExpQ
- labelE :: String -> ExpQ
- conE :: Name -> ExpQ
- litE :: Lit -> ExpQ
- appE :: ExpQ -> ExpQ -> ExpQ
- appTypeE :: ExpQ -> TypeQ -> ExpQ
- uInfixE :: ExpQ -> ExpQ -> ExpQ -> ExpQ
- parensE :: ExpQ -> ExpQ
- staticE :: ExpQ -> ExpQ
- infixE :: Maybe ExpQ -> ExpQ -> Maybe ExpQ -> ExpQ
- infixApp :: ExpQ -> ExpQ -> ExpQ -> ExpQ
- sectionL :: ExpQ -> ExpQ -> ExpQ
- sectionR :: ExpQ -> ExpQ -> ExpQ
- lamE :: [PatQ] -> ExpQ -> ExpQ
- lam1E :: PatQ -> ExpQ -> ExpQ
- lamCaseE :: [MatchQ] -> ExpQ
- tupE :: [ExpQ] -> ExpQ
- unboxedTupE :: [ExpQ] -> ExpQ
- unboxedSumE :: ExpQ -> SumAlt -> SumArity -> ExpQ
- condE :: ExpQ -> ExpQ -> ExpQ -> ExpQ
- multiIfE :: [Q (Guard, Exp)] -> ExpQ
- letE :: [DecQ] -> ExpQ -> ExpQ
- caseE :: ExpQ -> [MatchQ] -> ExpQ
- appsE :: [ExpQ] -> ExpQ
- listE :: [ExpQ] -> ExpQ
- sigE :: ExpQ -> TypeQ -> ExpQ
- recConE :: Name -> [Q (Name, Exp)] -> ExpQ
- recUpdE :: ExpQ -> [Q (Name, Exp)] -> ExpQ
- stringE :: String -> ExpQ
- fieldExp :: Name -> ExpQ -> Q (Name, Exp)
- fromE :: ExpQ -> ExpQ
- fromThenE :: ExpQ -> ExpQ -> ExpQ
- fromToE :: ExpQ -> ExpQ -> ExpQ
- fromThenToE :: ExpQ -> ExpQ -> ExpQ -> ExpQ
- arithSeqE :: RangeQ -> ExpQ
- fromR :: ExpQ -> RangeQ
- fromThenR :: ExpQ -> ExpQ -> RangeQ
- fromToR :: ExpQ -> ExpQ -> RangeQ
- fromThenToR :: ExpQ -> ExpQ -> ExpQ -> RangeQ
- doE :: [StmtQ] -> ExpQ
- compE :: [StmtQ] -> ExpQ
- bindS :: PatQ -> ExpQ -> StmtQ
- letS :: [DecQ] -> StmtQ
- noBindS :: ExpQ -> StmtQ
- parS :: [[StmtQ]] -> StmtQ
- forallT :: [TyVarBndr] -> CxtQ -> TypeQ -> TypeQ
- varT :: Name -> TypeQ
- conT :: Name -> TypeQ
- appT :: TypeQ -> TypeQ -> TypeQ
- arrowT :: TypeQ
- infixT :: TypeQ -> Name -> TypeQ -> TypeQ
- uInfixT :: TypeQ -> Name -> TypeQ -> TypeQ
- parensT :: TypeQ -> TypeQ
- equalityT :: TypeQ
- listT :: TypeQ
- tupleT :: Int -> TypeQ
- unboxedTupleT :: Int -> TypeQ
- unboxedSumT :: SumArity -> TypeQ
- sigT :: TypeQ -> Kind -> TypeQ
- litT :: TyLitQ -> TypeQ
- wildCardT :: TypeQ
- promotedT :: Name -> TypeQ
- promotedTupleT :: Int -> TypeQ
- promotedNilT :: TypeQ
- promotedConsT :: TypeQ
- numTyLit :: Integer -> TyLitQ
- strTyLit :: String -> TyLitQ
- noSourceUnpackedness :: SourceUnpackednessQ
- sourceNoUnpack :: SourceUnpackednessQ
- sourceUnpack :: SourceUnpackednessQ
- noSourceStrictness :: SourceStrictnessQ
- sourceLazy :: SourceStrictnessQ
- sourceStrict :: SourceStrictnessQ
- isStrict :: Q Strict
- notStrict :: Q Strict
- unpacked :: Q Strict
- bang :: SourceUnpackednessQ -> SourceStrictnessQ -> BangQ
- bangType :: BangQ -> TypeQ -> BangTypeQ
- varBangType :: Name -> BangTypeQ -> VarBangTypeQ
- strictType :: Q Strict -> TypeQ -> StrictTypeQ
- varStrictType :: Name -> StrictTypeQ -> VarStrictTypeQ
- cxt :: [PredQ] -> CxtQ
- classP :: Name -> [Q Type] -> Q Pred
- equalP :: TypeQ -> TypeQ -> PredQ
- normalC :: Name -> [BangTypeQ] -> ConQ
- recC :: Name -> [VarBangTypeQ] -> ConQ
- infixC :: Q (Bang, Type) -> Name -> Q (Bang, Type) -> ConQ
- forallC :: [TyVarBndr] -> CxtQ -> ConQ -> ConQ
- gadtC :: [Name] -> [StrictTypeQ] -> TypeQ -> ConQ
- recGadtC :: [Name] -> [VarStrictTypeQ] -> TypeQ -> ConQ
- varK :: Name -> Kind
- conK :: Name -> Kind
- tupleK :: Int -> Kind
- arrowK :: Kind
- listK :: Kind
- appK :: Kind -> Kind -> Kind
- starK :: Kind
- constraintK :: Kind
- plainTV :: Name -> TyVarBndr
- kindedTV :: Name -> Kind -> TyVarBndr
- nominalR :: Role
- representationalR :: Role
- phantomR :: Role
- inferR :: Role
- valD :: PatQ -> BodyQ -> [DecQ] -> DecQ
- funD :: Name -> [ClauseQ] -> DecQ
- tySynD :: Name -> [TyVarBndr] -> TypeQ -> DecQ
- dataD :: CxtQ -> Name -> [TyVarBndr] -> Maybe Kind -> [ConQ] -> [DerivClauseQ] -> DecQ
- newtypeD :: CxtQ -> Name -> [TyVarBndr] -> Maybe Kind -> ConQ -> [DerivClauseQ] -> DecQ
- derivClause :: Maybe DerivStrategy -> [PredQ] -> DerivClauseQ
- data DerivClause = DerivClause (Maybe DerivStrategy) Cxt
- stockStrategy :: DerivStrategyQ
- anyclassStrategy :: DerivStrategyQ
- newtypeStrategy :: DerivStrategyQ
- viaStrategy :: TypeQ -> DerivStrategyQ
- data DerivStrategy
- classD :: CxtQ -> Name -> [TyVarBndr] -> [FunDep] -> [DecQ] -> DecQ
- instanceD :: CxtQ -> TypeQ -> [DecQ] -> DecQ
- instanceWithOverlapD :: Maybe Overlap -> CxtQ -> TypeQ -> [DecQ] -> DecQ
- data Overlap
- sigD :: Name -> TypeQ -> DecQ
- standaloneDerivD :: CxtQ -> TypeQ -> DecQ
- standaloneDerivWithStrategyD :: Maybe DerivStrategy -> CxtQ -> TypeQ -> DecQ
- defaultSigD :: Name -> TypeQ -> DecQ
- roleAnnotD :: Name -> [Role] -> DecQ
- dataFamilyD :: Name -> [TyVarBndr] -> Maybe Kind -> DecQ
- openTypeFamilyD :: Name -> [TyVarBndr] -> FamilyResultSig -> Maybe InjectivityAnn -> DecQ
- closedTypeFamilyD :: Name -> [TyVarBndr] -> FamilyResultSig -> Maybe InjectivityAnn -> [TySynEqnQ] -> DecQ
- dataInstD :: CxtQ -> Name -> [TypeQ] -> Maybe Kind -> [ConQ] -> [DerivClauseQ] -> DecQ
- newtypeInstD :: CxtQ -> Name -> [TypeQ] -> Maybe Kind -> ConQ -> [DerivClauseQ] -> DecQ
- tySynInstD :: Name -> TySynEqnQ -> DecQ
- tySynEqn :: [TypeQ] -> TypeQ -> TySynEqnQ
- injectivityAnn :: Name -> [Name] -> InjectivityAnn
- noSig :: FamilyResultSig
- kindSig :: Kind -> FamilyResultSig
- tyVarSig :: TyVarBndr -> FamilyResultSig
- infixLD :: Int -> Name -> DecQ
- infixRD :: Int -> Name -> DecQ
- infixND :: Int -> Name -> DecQ
- cCall :: Callconv
- stdCall :: Callconv
- cApi :: Callconv
- prim :: Callconv
- javaScript :: Callconv
- unsafe :: Safety
- safe :: Safety
- interruptible :: Safety
- forImpD :: Callconv -> Safety -> String -> Name -> TypeQ -> DecQ
- funDep :: [Name] -> [Name] -> FunDep
- ruleVar :: Name -> RuleBndrQ
- typedRuleVar :: Name -> TypeQ -> RuleBndrQ
- valueAnnotation :: Name -> AnnTarget
- typeAnnotation :: Name -> AnnTarget
- moduleAnnotation :: AnnTarget
- pragInlD :: Name -> Inline -> RuleMatch -> Phases -> DecQ
- pragSpecD :: Name -> TypeQ -> Phases -> DecQ
- pragSpecInlD :: Name -> TypeQ -> Inline -> Phases -> DecQ
- pragSpecInstD :: TypeQ -> DecQ
- pragRuleD :: String -> [RuleBndrQ] -> ExpQ -> ExpQ -> Phases -> DecQ
- pragAnnD :: AnnTarget -> ExpQ -> DecQ
- pragLineD :: Int -> String -> DecQ
- pragCompleteD :: [Name] -> Maybe Name -> DecQ
- patSynD :: Name -> PatSynArgsQ -> PatSynDirQ -> PatQ -> DecQ
- patSynSigD :: Name -> TypeQ -> DecQ
- unidir :: PatSynDirQ
- implBidir :: PatSynDirQ
- explBidir :: [ClauseQ] -> PatSynDirQ
- prefixPatSyn :: [Name] -> PatSynArgsQ
- infixPatSyn :: Name -> Name -> PatSynArgsQ
- recordPatSyn :: [Name] -> PatSynArgsQ
- thisModule :: Q Module

# Library functions

## Abbreviations

type TyVarBndrQ = Q TyVarBndr Source #

type DerivClauseQ = Q DerivClause Source #

type SourceStrictnessQ = Q SourceStrictness Source #

type VarBangTypeQ = Q VarBangType Source #

type StrictTypeQ = Q StrictType Source #

type VarStrictTypeQ = Q VarStrictType Source #

type PatSynDirQ = Q PatSynDir Source #

type PatSynArgsQ = Q PatSynArgs Source #

type FamilyResultSigQ = Q FamilyResultSig Source #

type DerivStrategyQ = Q DerivStrategy Source #

## Constructors lifted to

`Q`

### Literals

floatPrimL :: Rational -> Lit Source #

doublePrimL :: Rational -> Lit Source #

stringPrimL :: [Word8] -> Lit Source #

### Patterns

unboxedTupP :: [PatQ] -> PatQ Source #

### Pattern Guards

### Expressions

unboundVarE :: Name -> ExpQ Source #

unboxedTupE :: [ExpQ] -> ExpQ Source #

#### Ranges

#### Ranges with more indirection

#### Statements

### Types

unboxedTupleT :: Int -> TypeQ Source #

unboxedSumT :: SumArity -> TypeQ Source #

promotedTupleT :: Int -> TypeQ Source #

promotedNilT :: TypeQ Source #

#### Type literals

#### Strictness

Deprecated: Use `bang`

. See https://ghc.haskell.org/trac/ghc/wiki/Migration/8.0. Example usage: 'bang noSourceUnpackedness sourceStrict'

notStrict :: Q Strict Source #

Deprecated: Use `bang`

. See https://ghc.haskell.org/trac/ghc/wiki/Migration/8.0. Example usage: 'bang noSourceUnpackedness noSourceStrictness'

Deprecated: Use `bang`

. See https://ghc.haskell.org/trac/ghc/wiki/Migration/8.0. Example usage: 'bang sourceUnpack sourceStrict'

bang :: SourceUnpackednessQ -> SourceStrictnessQ -> BangQ Source #

varBangType :: Name -> BangTypeQ -> VarBangTypeQ Source #

strictType :: Q Strict -> TypeQ -> StrictTypeQ Source #

Deprecated: As of `template-haskell-2.11.0.0`

, `StrictType`

has been replaced by `BangType`

. Please use `bangType`

instead.

varStrictType :: Name -> StrictTypeQ -> VarStrictTypeQ Source #

Deprecated: As of `template-haskell-2.11.0.0`

, `VarStrictType`

has been replaced by `VarBangType`

. Please use `varBangType`

instead.

#### Class Contexts

equalP :: TypeQ -> TypeQ -> PredQ Source #

Deprecated: As of template-haskell-2.10, constraint predicates (Pred) are just types (Type), in keeping with ConstraintKinds. Please see `equalityT`

.

#### Constructors

### Kinds

constraintK :: Kind Source #

### Type variable binders

### Roles

### Top Level Declarations

#### Data

derivClause :: Maybe DerivStrategy -> [PredQ] -> DerivClauseQ Source #

data DerivClause Source #

A single `deriving`

clause at the end of a datatype.

DerivClause (Maybe DerivStrategy) Cxt | { deriving stock (Eq, Ord) } |

## Instances

viaStrategy :: TypeQ -> DerivStrategyQ Source #

data DerivStrategy Source #

What the user explicitly requests when deriving an instance.

StockStrategy | A "standard" derived instance |

AnyclassStrategy | -XDeriveAnyClass |

NewtypeStrategy | -XGeneralizedNewtypeDeriving |

ViaStrategy Type | -XDerivingVia |

## Instances

#### Class

Varieties of allowed instance overlap.

Overlappable | May be overlapped by more specific instances |

Overlapping | May overlap a more general instance |

Overlaps | Both |

Incoherent | Both |

## Instances

Eq Overlap Source # | |

Data Overlap Source # | |

Defined in Language.Haskell.TH.Syntax gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Overlap -> c Overlap # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Overlap # toConstr :: Overlap -> Constr # dataTypeOf :: Overlap -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Overlap) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Overlap) # gmapT :: (forall b. Data b => b -> b) -> Overlap -> Overlap # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Overlap -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Overlap -> r # gmapQ :: (forall d. Data d => d -> u) -> Overlap -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Overlap -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Overlap -> m Overlap # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Overlap -> m Overlap # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Overlap -> m Overlap # | |

Ord Overlap Source # | |

Show Overlap Source # | |

Generic Overlap Source # | |

type Rep Overlap Source # | |

Defined in Language.Haskell.TH.Syntax type Rep Overlap = D1 (MetaData "Overlap" "Language.Haskell.TH.Syntax" "template-haskell" False) ((C1 (MetaCons "Overlappable" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "Overlapping" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "Overlaps" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "Incoherent" PrefixI False) (U1 :: Type -> Type))) |

standaloneDerivWithStrategyD :: Maybe DerivStrategy -> CxtQ -> TypeQ -> DecQ Source #

#### Role annotations

#### Type Family / Data Family

openTypeFamilyD :: Name -> [TyVarBndr] -> FamilyResultSig -> Maybe InjectivityAnn -> DecQ Source #

closedTypeFamilyD :: Name -> [TyVarBndr] -> FamilyResultSig -> Maybe InjectivityAnn -> [TySynEqnQ] -> DecQ Source #

injectivityAnn :: Name -> [Name] -> InjectivityAnn Source #

kindSig :: Kind -> FamilyResultSig Source #

tyVarSig :: TyVarBndr -> FamilyResultSig Source #

#### Fixity

#### Foreign Function Interface (FFI)

#### Functional dependencies

#### Pragmas

valueAnnotation :: Name -> AnnTarget Source #

typeAnnotation :: Name -> AnnTarget Source #

pragSpecInstD :: TypeQ -> DecQ Source #

#### Pattern Synonyms

patSynD :: Name -> PatSynArgsQ -> PatSynDirQ -> PatQ -> DecQ Source #

Pattern synonym declaration

unidir :: PatSynDirQ Source #

explBidir :: [ClauseQ] -> PatSynDirQ Source #

prefixPatSyn :: [Name] -> PatSynArgsQ Source #

infixPatSyn :: Name -> Name -> PatSynArgsQ Source #

recordPatSyn :: [Name] -> PatSynArgsQ Source #

## Reify

thisModule :: Q Module Source #

Return the Module at the place of splicing. Can be used as an
input for `reifyModule`

.