haskell / 9 / libraries / template-haskell-2.19.0.0 / language-haskell-th-syntax.html

Language.Haskell.TH.Syntax

Copyright (c) The University of Glasgow 2003
License BSD-style (see the file libraries/base/LICENSE)
Maintainer libraries@haskell.org
Stability experimental
Portability portable
Safe Haskell Trustworthy
Language Haskell2010

Description

Abstract syntax definitions for Template Haskell.

data Foreign Source

Instances
Instances details
Data Foreign Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Foreign -> c Foreign Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Foreign Source

toConstr :: Foreign -> Constr Source

dataTypeOf :: Foreign -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Foreign) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Foreign) Source

gmapT :: (forall b. Data b => b -> b) -> Foreign -> Foreign Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Foreign -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Foreign -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Foreign -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Foreign -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Foreign -> m Foreign Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Foreign -> m Foreign Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Foreign -> m Foreign Source

Generic Foreign Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Foreign :: Type -> Type Source

Methods

from :: Foreign -> Rep Foreign x Source

to :: Rep Foreign x -> Foreign Source

Show Foreign Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq Foreign Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ord Foreign Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ppr Foreign Source
Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: Foreign -> Doc Source

ppr_list :: [Foreign] -> Doc Source

type Rep Foreign Source
Instance details

Defined in Language.Haskell.TH.Syntax

data Type Source

Constructors

ForallT [TyVarBndr Specificity] Cxt Type
forall <vars>. <ctxt> => <type>
ForallVisT [TyVarBndr ()] Type
forall <vars> -> <type>
AppT Type Type
T a b
AppKindT Type Kind
T @k t
SigT Type Kind
t :: k
VarT Name
a
ConT Name
T
PromotedT Name
'T
InfixT Type Name Type
T + T
UInfixT Type Name Type
T + T

See Language.Haskell.TH.Syntax

PromotedInfixT Type Name Type
T :+: T
PromotedUInfixT Type Name Type
T :+: T

See Language.Haskell.TH.Syntax

ParensT Type
(T)
TupleT Int
(,), (,,), etc.
UnboxedTupleT Int
(#,#), (#,,#), etc.
UnboxedSumT SumArity
(#|#), (#||#), etc.
ArrowT
->
MulArrowT
%n ->

Generalised arrow type with multiplicity argument

EqualityT
~
ListT
[]
PromotedTupleT Int
'(), '(,), '(,,), etc.
PromotedNilT
'[]
PromotedConsT
(':)
StarT
*
ConstraintT
Constraint
LitT TyLit
0,1,2, etc.
WildCardT
_
ImplicitParamT String Type
?x :: t
Instances
Instances details
Data Type Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Type -> c Type Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Type Source

toConstr :: Type -> Constr Source

dataTypeOf :: Type -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Type) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type) Source

gmapT :: (forall b. Data b => b -> b) -> Type -> Type Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Type -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Type -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Type -> m Type Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type Source

Generic Type Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Type :: Type -> Type Source

Methods

from :: Type -> Rep Type x Source

to :: Rep Type x -> Type Source

Show Type Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq Type Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Type -> Type -> Bool Source

(/=) :: Type -> Type -> Bool Source

Ord Type Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Type -> Type -> Ordering Source

(<) :: Type -> Type -> Bool Source

(<=) :: Type -> Type -> Bool Source

(>) :: Type -> Type -> Bool Source

(>=) :: Type -> Type -> Bool Source

max :: Type -> Type -> Type Source

min :: Type -> Type -> Type Source

Ppr Type Source
Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: Type -> Doc Source

ppr_list :: [Type] -> Doc Source

type Rep Type Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep Type = D1 ('MetaData "Type" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((((C1 ('MetaCons "ForallT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TyVarBndr Specificity]) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Cxt) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) :+: (C1 ('MetaCons "ForallVisT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TyVarBndr ()]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :+: C1 ('MetaCons "AppT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)))) :+: ((C1 ('MetaCons "AppKindT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Kind)) :+: C1 ('MetaCons "SigT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Kind))) :+: (C1 ('MetaCons "VarT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)) :+: C1 ('MetaCons "ConT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name))))) :+: ((C1 ('MetaCons "PromotedT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)) :+: (C1 ('MetaCons "InfixT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) :+: C1 ('MetaCons "UInfixT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))))) :+: ((C1 ('MetaCons "PromotedInfixT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) :+: C1 ('MetaCons "PromotedUInfixT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)))) :+: (C1 ('MetaCons "ParensT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :+: C1 ('MetaCons "TupleT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int)))))) :+: (((C1 ('MetaCons "UnboxedTupleT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int)) :+: (C1 ('MetaCons "UnboxedSumT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SumArity)) :+: C1 ('MetaCons "ArrowT" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "MulArrowT" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "EqualityT" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "ListT" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PromotedTupleT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int))))) :+: ((C1 ('MetaCons "PromotedNilT" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "PromotedConsT" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "StarT" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "ConstraintT" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "LitT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 TyLit))) :+: (C1 ('MetaCons "WildCardT" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ImplicitParamT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)))))))

data Module Source

Obtained from reifyModule and thisModule.

Constructors

Instances
Instances details
Data Module Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Module -> c Module Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Module Source

toConstr :: Module -> Constr Source

dataTypeOf :: Module -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Module) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module) Source

gmapT :: (forall b. Data b => b -> b) -> Module -> Module Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Module -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Module -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Module -> m Module Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module Source

Generic Module Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Module :: Type -> Type Source

Methods

from :: Module -> Rep Module x Source

to :: Rep Module x -> Module Source

Show Module Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq Module Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Module -> Module -> Bool Source

(/=) :: Module -> Module -> Bool Source

Ord Module Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ppr Module Source
Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: Module -> Doc Source

ppr_list :: [Module] -> Doc Source

type Rep Module Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Unlifted = Bool Source

In PrimTyConI, is the type constructor unlifted?

data DecidedStrictness Source

Unlike SourceStrictness and SourceUnpackedness, DecidedStrictness refers to the strictness that the compiler chooses for a data constructor field, which may be different from what is written in source code. See reifyConStrictness for more information.

Instances
Instances details
Data DecidedStrictness Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DecidedStrictness -> c DecidedStrictness Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DecidedStrictness Source

toConstr :: DecidedStrictness -> Constr Source

dataTypeOf :: DecidedStrictness -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DecidedStrictness) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DecidedStrictness) Source

gmapT :: (forall b. Data b => b -> b) -> DecidedStrictness -> DecidedStrictness Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r Source

gmapQ :: (forall d. Data d => d -> u) -> DecidedStrictness -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> DecidedStrictness -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness Source

Generic DecidedStrictness Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep DecidedStrictness :: Type -> Type Source

Show DecidedStrictness Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq DecidedStrictness Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ord DecidedStrictness Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ppr DecidedStrictness Source
Instance details

Defined in Language.Haskell.TH.Ppr

type Rep DecidedStrictness Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep DecidedStrictness = D1 ('MetaData "DecidedStrictness" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "DecidedLazy" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "DecidedStrict" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DecidedUnpack" 'PrefixI 'False) (U1 :: Type -> Type)))

data SourceStrictness Source

Constructors

Instances
Instances details
Data SourceStrictness Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceStrictness -> c SourceStrictness Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceStrictness Source

toConstr :: SourceStrictness -> Constr Source

dataTypeOf :: SourceStrictness -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SourceStrictness) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceStrictness) Source

gmapT :: (forall b. Data b => b -> b) -> SourceStrictness -> SourceStrictness Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r Source

gmapQ :: (forall d. Data d => d -> u) -> SourceStrictness -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceStrictness -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness Source

Generic SourceStrictness Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep SourceStrictness :: Type -> Type Source

Show SourceStrictness Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq SourceStrictness Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ord SourceStrictness Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ppr SourceStrictness Source
Instance details

Defined in Language.Haskell.TH.Ppr

type Rep SourceStrictness Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep SourceStrictness = D1 ('MetaData "SourceStrictness" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "NoSourceStrictness" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "SourceLazy" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SourceStrict" 'PrefixI 'False) (U1 :: Type -> Type)))

data SourceUnpackedness Source

Constructors

NoSourceUnpackedness
C a
SourceNoUnpack
C { {-# NOUNPACK #-} } a
SourceUnpack
C { {-# UNPACK #-} } a
Instances
Instances details
Data SourceUnpackedness Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceUnpackedness -> c SourceUnpackedness Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceUnpackedness Source

toConstr :: SourceUnpackedness -> Constr Source

dataTypeOf :: SourceUnpackedness -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SourceUnpackedness) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceUnpackedness) Source

gmapT :: (forall b. Data b => b -> b) -> SourceUnpackedness -> SourceUnpackedness Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r Source

gmapQ :: (forall d. Data d => d -> u) -> SourceUnpackedness -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceUnpackedness -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness Source

Generic SourceUnpackedness Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep SourceUnpackedness :: Type -> Type Source

Show SourceUnpackedness Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq SourceUnpackedness Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ord SourceUnpackedness Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ppr SourceUnpackedness Source
Instance details

Defined in Language.Haskell.TH.Ppr

type Rep SourceUnpackedness Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep SourceUnpackedness = D1 ('MetaData "SourceUnpackedness" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "NoSourceUnpackedness" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "SourceNoUnpack" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SourceUnpack" 'PrefixI 'False) (U1 :: Type -> Type)))

data Fixity Source

Constructors

Instances
Instances details
Data Fixity Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Fixity -> c Fixity Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Fixity Source

toConstr :: Fixity -> Constr Source

dataTypeOf :: Fixity -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Fixity) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity) Source

gmapT :: (forall b. Data b => b -> b) -> Fixity -> Fixity Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Fixity -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Fixity -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity Source

Generic Fixity Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Fixity :: Type -> Type Source

Methods

from :: Fixity -> Rep Fixity x Source

to :: Rep Fixity x -> Fixity Source

Show Fixity Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq Fixity Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Fixity -> Fixity -> Bool Source

(/=) :: Fixity -> Fixity -> Bool Source

Ord Fixity Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep Fixity Source
Instance details

Defined in Language.Haskell.TH.Syntax

data Con Source

A single data constructor.

The constructors for Con can roughly be divided up into two categories: those for constructors with "vanilla" syntax (NormalC, RecC, and InfixC), and those for constructors with GADT syntax (GadtC and RecGadtC). The ForallC constructor, which quantifies additional type variables and class contexts, can surround either variety of constructor. However, the type variables that it quantifies are different depending on what constructor syntax is used:

  • If a ForallC surrounds a constructor with vanilla syntax, then the ForallC will only quantify existential type variables. For example:
  data Foo a = forall b. MkFoo a b
  

In MkFoo, ForallC will quantify b, but not a.

  • If a ForallC surrounds a constructor with GADT syntax, then the ForallC will quantify all type variables used in the constructor. For example:
  data Bar a b where
    MkBar :: (a ~ b) => c -> MkBar a b
  

In MkBar, ForallC will quantify a, b, and c.

Multiplicity annotations for data types are currently not supported in Template Haskell (i.e. all fields represented by Template Haskell will be linear).

Constructors

NormalC Name [BangType]
C Int a
RecC Name [VarBangType]
C { v :: Int, w :: a }
InfixC BangType Name BangType
Int :+ a
ForallC [TyVarBndr Specificity] Cxt Con
forall a. Eq a => C [a]
GadtC [Name] [BangType] Type
C :: a -> b -> T b Int
RecGadtC [Name] [VarBangType] Type
C :: { v :: Int } -> T b Int
Instances
Instances details
Data Con Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Con -> c Con Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Con Source

toConstr :: Con -> Constr Source

dataTypeOf :: Con -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Con) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Con) Source

gmapT :: (forall b. Data b => b -> b) -> Con -> Con Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Con -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Con -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Con -> m Con Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Con -> m Con Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Con -> m Con Source

Generic Con Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Con :: Type -> Type Source

Methods

from :: Con -> Rep Con x Source

to :: Rep Con x -> Con Source

Show Con Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Con -> ShowS Source

show :: Con -> String Source

showList :: [Con] -> ShowS Source

Eq Con Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Con -> Con -> Bool Source

(/=) :: Con -> Con -> Bool Source

Ord Con Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Con -> Con -> Ordering Source

(<) :: Con -> Con -> Bool Source

(<=) :: Con -> Con -> Bool Source

(>) :: Con -> Con -> Bool Source

(>=) :: Con -> Con -> Bool Source

max :: Con -> Con -> Con Source

min :: Con -> Con -> Con Source

Ppr Con Source
Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: Con -> Doc Source

ppr_list :: [Con] -> Doc Source

type Rep Con Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep Con = D1 ('MetaData "Con" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((C1 ('MetaCons "NormalC" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [BangType])) :+: (C1 ('MetaCons "RecC" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [VarBangType])) :+: C1 ('MetaCons "InfixC" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 BangType) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 BangType))))) :+: (C1 ('MetaCons "ForallC" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TyVarBndr Specificity]) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Cxt) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Con))) :+: (C1 ('MetaCons "GadtC" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name]) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [BangType]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) :+: C1 ('MetaCons "RecGadtC" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name]) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [VarBangType]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))))))

type Strict = Bang Source

As of template-haskell-2.11.0.0, Strict has been replaced by Bang.

newtype Q a Source

Constructors

Q

Fields

Instances
Instances details
MonadFail Q Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

fail :: String -> Q a Source

MonadFix Q Source

If the function passed to mfix inspects its argument, the resulting action will throw a FixIOException.

Since: template-haskell-2.17.0.0

Instance details

Defined in Language.Haskell.TH.Syntax

Methods

mfix :: (a -> Q a) -> Q a Source

MonadIO Q Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

liftIO :: IO a -> Q a Source

Applicative Q Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

pure :: a -> Q a Source

(<*>) :: Q (a -> b) -> Q a -> Q b Source

liftA2 :: (a -> b -> c) -> Q a -> Q b -> Q c Source

(*>) :: Q a -> Q b -> Q b Source

(<*) :: Q a -> Q b -> Q a Source

Functor Q Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

fmap :: (a -> b) -> Q a -> Q b Source

(<$) :: a -> Q b -> Q a Source

Monad Q Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(>>=) :: Q a -> (a -> Q b) -> Q b Source

(>>) :: Q a -> Q b -> Q b Source

return :: a -> Q a Source

Quasi Q Source
Instance details

Defined in Language.Haskell.TH.Syntax

Quote Q Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

newName :: String -> Q Name Source

Monoid a => Monoid (Q a) Source

Since: template-haskell-2.17.0.0

Instance details

Defined in Language.Haskell.TH.Syntax

Methods

mempty :: Q a Source

mappend :: Q a -> Q a -> Q a Source

mconcat :: [Q a] -> Q a Source

Semigroup a => Semigroup (Q a) Source

Since: template-haskell-2.17.0.0

Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(<>) :: Q a -> Q a -> Q a Source

sconcat :: NonEmpty (Q a) -> Q a Source

stimes :: Integral b => b -> Q a -> Q a Source

class Monad m => Quote m where Source

The Quote class implements the minimal interface which is necessary for desugaring quotations.

  • The Monad m superclass is needed to stitch together the different AST fragments.
  • newName is used when desugaring binding structures such as lambdas to generate fresh names.

Therefore the type of an untyped quotation in GHC is `Quote m => m Exp`

For many years the type of a quotation was fixed to be `Q Exp` but by more precisely specifying the minimal interface it enables the Exp to be extracted purely from the quotation without interacting with Q.

Methods

newName :: String -> m Name Source

Generate a fresh name, which cannot be captured.

For example, this:

f = $(do
    nm1 <- newName "x"
    let nm2 = mkName "x"
    return (LamE [VarP nm1] (LamE [VarP nm2] (VarE nm1)))
   )

will produce the splice

f = \x0 -> \x -> x0

In particular, the occurrence VarE nm1 refers to the binding VarP nm1, and is not captured by the binding VarP nm2.

Although names generated by newName cannot be captured, they can capture other names. For example, this:

g = $(do
  nm1 <- newName "x"
  let nm2 = mkName "x"
  return (LamE [VarP nm2] (LamE [VarP nm1] (VarE nm2)))
 )

will produce the splice

g = \x -> \x0 -> x0

since the occurrence VarE nm2 is captured by the innermost binding of x, namely VarP nm1.

Instances
Instances details
Quote IO Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

newName :: String -> IO Name Source

Quote Q Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

newName :: String -> Q Name Source

data Loc Source

Instances
Instances details
Data Loc Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Loc -> c Loc Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Loc Source

toConstr :: Loc -> Constr Source

dataTypeOf :: Loc -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Loc) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Loc) Source

gmapT :: (forall b. Data b => b -> b) -> Loc -> Loc Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Loc -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Loc -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Loc -> m Loc Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Loc -> m Loc Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Loc -> m Loc Source

Generic Loc Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Loc :: Type -> Type Source

Methods

from :: Loc -> Rep Loc x Source

to :: Rep Loc x -> Loc Source

Show Loc Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Loc -> ShowS Source

show :: Loc -> String Source

showList :: [Loc] -> ShowS Source

Eq Loc Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Loc -> Loc -> Bool Source

(/=) :: Loc -> Loc -> Bool Source

Ord Loc Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Loc -> Loc -> Ordering Source

(<) :: Loc -> Loc -> Bool Source

(<=) :: Loc -> Loc -> Bool Source

(>) :: Loc -> Loc -> Bool Source

(>=) :: Loc -> Loc -> Bool Source

max :: Loc -> Loc -> Loc Source

min :: Loc -> Loc -> Loc Source

Ppr Loc Source
Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: Loc -> Doc Source

ppr_list :: [Loc] -> Doc Source

type Rep Loc Source
Instance details

Defined in Language.Haskell.TH.Syntax

data Info Source

Obtained from reify in the Q Monad.

Constructors

ClassI Dec [InstanceDec]

A class, with a list of its visible instances

ClassOpI Name Type ParentName

A class method

TyConI Dec

A "plain" type constructor. "Fancier" type constructors are returned using PrimTyConI or FamilyI as appropriate. At present, this reified declaration will never have derived instances attached to it (if you wish to check for an instance, see reifyInstances).

FamilyI Dec [InstanceDec]

A type or data family, with a list of its visible instances. A closed type family is returned with 0 instances.

PrimTyConI Name Arity Unlifted

A "primitive" type constructor, which can't be expressed with a Dec. Examples: (->), Int#.

DataConI Name Type ParentName

A data constructor

PatSynI Name PatSynType

A pattern synonym

VarI Name Type (Maybe Dec)

A "value" variable (as opposed to a type variable, see TyVarI).

The Maybe Dec field contains Just the declaration which defined the variable - including the RHS of the declaration - or else Nothing, in the case where the RHS is unavailable to the compiler. At present, this value is always Nothing: returning the RHS has not yet been implemented because of lack of interest.

TyVarI Name Type

A type variable.

The Type field contains the type which underlies the variable. At present, this is always VarT theName, but future changes may permit refinement of this.

Instances
Instances details
Data Info Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Info -> c Info Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Info Source

toConstr :: Info -> Constr Source

dataTypeOf :: Info -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Info) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Info) Source

gmapT :: (forall b. Data b => b -> b) -> Info -> Info Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Info -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Info -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Info -> m Info Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Info -> m Info Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Info -> m Info Source

Generic Info Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Info :: Type -> Type Source

Methods

from :: Info -> Rep Info x Source

to :: Rep Info x -> Info Source

Show Info Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq Info Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Info -> Info -> Bool Source

(/=) :: Info -> Info -> Bool Source

Ord Info Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Info -> Info -> Ordering Source

(<) :: Info -> Info -> Bool Source

(<=) :: Info -> Info -> Bool Source

(>) :: Info -> Info -> Bool Source

(>=) :: Info -> Info -> Bool Source

max :: Info -> Info -> Info Source

min :: Info -> Info -> Info Source

Ppr Info Source
Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: Info -> Doc Source

ppr_list :: [Info] -> Doc Source

type Rep Info Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep Info = D1 ('MetaData "Info" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (((C1 ('MetaCons "ClassI" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Dec) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [InstanceDec])) :+: C1 ('MetaCons "ClassOpI" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ParentName)))) :+: (C1 ('MetaCons "TyConI" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Dec)) :+: C1 ('MetaCons "FamilyI" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Dec) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [InstanceDec])))) :+: ((C1 ('MetaCons "PrimTyConI" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Arity) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Unlifted))) :+: C1 ('MetaCons "DataConI" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ParentName)))) :+: (C1 ('MetaCons "PatSynI" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 PatSynType)) :+: (C1 ('MetaCons "VarI" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Dec)))) :+: C1 ('MetaCons "TyVarI" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))))))

data ModuleInfo Source

Obtained from reifyModule in the Q Monad.

Constructors

ModuleInfo [Module]

Contains the import list of the module.

Instances
Instances details
Data ModuleInfo Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModuleInfo -> c ModuleInfo Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ModuleInfo Source

toConstr :: ModuleInfo -> Constr Source

dataTypeOf :: ModuleInfo -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ModuleInfo) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleInfo) Source

gmapT :: (forall b. Data b => b -> b) -> ModuleInfo -> ModuleInfo Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r Source

gmapQ :: (forall d. Data d => d -> u) -> ModuleInfo -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> ModuleInfo -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo Source

Generic ModuleInfo Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep ModuleInfo :: Type -> Type Source

Show ModuleInfo Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq ModuleInfo Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ord ModuleInfo Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ppr ModuleInfo Source
Instance details

Defined in Language.Haskell.TH.Ppr

type Rep ModuleInfo Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep ModuleInfo = D1 ('MetaData "ModuleInfo" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "ModuleInfo" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Module])))

type InstanceDec = Dec Source

InstanceDec describes a single instance of a class or type function. It is just a Dec, but guaranteed to be one of the following:

type ParentName = Name Source

In ClassOpI and DataConI, name of the parent class or type

type SumAlt = Int Source

In UnboxedSumE and UnboxedSumP, the number associated with a particular data constructor. SumAlts are one-indexed and should never exceed the value of its corresponding SumArity. For example:

type SumArity = Int Source

In UnboxedSumE, UnboxedSumT, and UnboxedSumP, the total number of SumAlts. For example, (#|#) has a SumArity of 2.

type Arity = Int Source

In PrimTyConI, arity of the type constructor

data AnnLookup Source

Annotation target for reifyAnnotations

Instances
Instances details
Data AnnLookup Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnLookup -> c AnnLookup Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnLookup Source

toConstr :: AnnLookup -> Constr Source

dataTypeOf :: AnnLookup -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnLookup) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnLookup) Source

gmapT :: (forall b. Data b => b -> b) -> AnnLookup -> AnnLookup Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnLookup -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnLookup -> r Source

gmapQ :: (forall d. Data d => d -> u) -> AnnLookup -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnLookup -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup Source

Generic AnnLookup Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep AnnLookup :: Type -> Type Source

Show AnnLookup Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq AnnLookup Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ord AnnLookup Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep AnnLookup Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep AnnLookup = D1 ('MetaData "AnnLookup" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "AnnLookupModule" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Module)) :+: C1 ('MetaCons "AnnLookupName" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)))

newtype TExp (a :: TYPE (r :: RuntimeRep)) Source

Represents an expression which has type a. Built on top of Exp, typed expressions allow for type-safe splicing via:

  • typed quotes, written as [|| ... ||] where ... is an expression; if that expression has type a, then the quotation has type Q (TExp a)
  • typed splices inside of typed quotes, written as $$(...) where ... is an arbitrary expression of type Q (TExp a)

Traditional expression quotes and splices let us construct ill-typed expressions:

>>> fmap ppr $ runQ [| True == $( [| "foo" |] ) |]
GHC.Types.True GHC.Classes.== "foo"
>>> GHC.Types.True GHC.Classes.== "foo"
<interactive> error:
    • Couldn't match expected type ‘Bool’ with actual type ‘[Char]’
    • In the second argument of ‘(==)’, namely ‘"foo"’
      In the expression: True == "foo"
      In an equation for ‘it’: it = True == "foo"

With typed expressions, the type error occurs when constructing the Template Haskell expression:

>>> fmap ppr $ runQ [|| True == $$( [|| "foo" ||] ) ||]
<interactive> error:
    • Couldn't match type ‘[Char]’ with ‘Bool’
      Expected type: Q (TExp Bool)
        Actual type: Q (TExp [Char])
    • In the Template Haskell quotation [|| "foo" ||]
      In the expression: [|| "foo" ||]
      In the Template Haskell splice $$([|| "foo" ||])

Representation-polymorphic since template-haskell-2.16.0.0.

Constructors

TExp

Fields

  • unType :: Exp

    Underlying untyped Template Haskell expression

newtype Code m (a :: TYPE (r :: RuntimeRep)) Source

Constructors

Code

Fields

data Name Source

An abstract type representing names in the syntax tree.

Names can be constructed in several ways, which come with different name-capture guarantees (see Language.Haskell.TH.Syntax for an explanation of name capture):

  • the built-in syntax 'f and ''T can be used to construct names, The expression 'f gives a Name which refers to the value f currently in scope, and ''T gives a Name which refers to the type T currently in scope. These names can never be captured.
  • lookupValueName and lookupTypeName are similar to 'f and ''T respectively, but the Names are looked up at the point where the current splice is being run. These names can never be captured.
  • newName monadically generates a new name, which can never be captured.
  • mkName generates a capturable name.

Names constructed using newName and mkName may be used in bindings (such as let x = ... or x -> ...), but names constructed using lookupValueName, lookupTypeName, 'f, ''T may not.

Constructors

Instances
Instances details
Data Name Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Name -> c Name Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Name Source

toConstr :: Name -> Constr Source

dataTypeOf :: Name -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Name) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name) Source

gmapT :: (forall b. Data b => b -> b) -> Name -> Name Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Name -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Name -> m Name Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name Source

Generic Name Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Name :: Type -> Type Source

Methods

from :: Name -> Rep Name x Source

to :: Rep Name x -> Name Source

Show Name Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq Name Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Name -> Name -> Bool Source

(/=) :: Name -> Name -> Bool Source

Ord Name Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Name -> Name -> Ordering Source

(<) :: Name -> Name -> Bool Source

(<=) :: Name -> Name -> Bool Source

(>) :: Name -> Name -> Bool Source

(>=) :: Name -> Name -> Bool Source

max :: Name -> Name -> Name Source

min :: Name -> Name -> Name Source

Ppr Name Source
Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: Name -> Doc Source

ppr_list :: [Name] -> Doc Source

type Rep Name Source
Instance details

Defined in Language.Haskell.TH.Syntax

data NameSpace Source

Constructors

VarName

Variables

DataName

Data constructors

TcClsName

Type constructors and classes; Haskell has them in the same name space for now.

Instances
Instances details
Data NameSpace Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NameSpace -> c NameSpace Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NameSpace Source

toConstr :: NameSpace -> Constr Source

dataTypeOf :: NameSpace -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NameSpace) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameSpace) Source

gmapT :: (forall b. Data b => b -> b) -> NameSpace -> NameSpace Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NameSpace -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NameSpace -> r Source

gmapQ :: (forall d. Data d => d -> u) -> NameSpace -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> NameSpace -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace Source

Generic NameSpace Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep NameSpace :: Type -> Type Source

Show NameSpace Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq NameSpace Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ord NameSpace Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep NameSpace Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep NameSpace = D1 ('MetaData "NameSpace" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "VarName" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "DataName" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TcClsName" 'PrefixI 'False) (U1 :: Type -> Type)))

data Dec Source

Constructors

FunD Name [Clause]
{ f p1 p2 = b where decs }
ValD Pat Body [Dec]
{ p = b where decs }
DataD Cxt Name [TyVarBndr ()] (Maybe Kind) [Con] [DerivClause]
{ data Cxt x => T x = A x | B (T x)
       deriving (Z,W)
       deriving stock Eq }
NewtypeD Cxt Name [TyVarBndr ()] (Maybe Kind) Con [DerivClause]
{ newtype Cxt x => T x = A (B x)
       deriving (Z,W Q)
       deriving stock Eq }
TySynD Name [TyVarBndr ()] Type
{ type T x = (x,x) }
ClassD Cxt Name [TyVarBndr ()] [FunDep] [Dec]
{ class Eq a => Ord a where ds }
InstanceD (Maybe Overlap) Cxt Type [Dec]
{ instance {-# OVERLAPS #-}
        Show w => Show [w] where ds }
SigD Name Type
{ length :: [a] -> Int }
KiSigD Name Kind
{ type TypeRep :: k -> Type }
ForeignD Foreign
{ foreign import ... }
{ foreign export ... }
InfixD Fixity Name
{ infix 3 foo }
DefaultD [Type]
{ default (Integer, Double) }
PragmaD

pragmas

Fields

  • Pragma
    { {-# INLINE [1] foo #-} }
DataFamilyD

data families (may also appear in [Dec] of ClassD and InstanceD)

Fields

DataInstD Cxt (Maybe [TyVarBndr ()]) Type (Maybe Kind) [Con] [DerivClause]
{ data instance Cxt x => T [x]
       = A x | B (T x)
       deriving (Z,W)
       deriving stock Eq }
NewtypeInstD Cxt (Maybe [TyVarBndr ()]) Type (Maybe Kind) Con [DerivClause]
{ newtype instance Cxt x => T [x]
        = A (B x)
        deriving (Z,W)
        deriving stock Eq }
TySynInstD TySynEqn
{ type instance ... }
OpenTypeFamilyD

open type families (may also appear in [Dec] of ClassD and InstanceD)

Fields

ClosedTypeFamilyD TypeFamilyHead [TySynEqn]
{ type family F a b = (r :: *) | r -> a where ... }
RoleAnnotD Name [Role]
{ type role T nominal representational }
StandaloneDerivD (Maybe DerivStrategy) Cxt Type
{ deriving stock instance Ord a => Ord (Foo a) }
DefaultSigD Name Type
{ default size :: Data a => a -> Int }
PatSynD

Pattern Synonyms

Fields

  • Name
  • PatSynArgs
  • PatSynDir
  • Pat

    { pattern P v1 v2 .. vn <- p } unidirectional or { pattern P v1 v2 .. vn = p } implicit bidirectional or { pattern P v1 v2 .. vn <- p where P v1 v2 .. vn = e } explicit bidirectional

    also, besides prefix pattern synonyms, both infix and record pattern synonyms are supported. See PatSynArgs for details

PatSynSigD Name PatSynType

A pattern synonym's type signature.

ImplicitParamBindD String Exp
{ ?x = expr }

Implicit parameter binding declaration. Can only be used in let and where clauses which consist entirely of implicit bindings.

Instances
Instances details
Data Dec Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Dec -> c Dec Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Dec Source

toConstr :: Dec -> Constr Source

dataTypeOf :: Dec -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Dec) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Dec) Source

gmapT :: (forall b. Data b => b -> b) -> Dec -> Dec Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Dec -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Dec -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Dec -> m Dec Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Dec -> m Dec Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Dec -> m Dec Source

Generic Dec Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Dec :: Type -> Type Source

Methods

from :: Dec -> Rep Dec x Source

to :: Rep Dec x -> Dec Source

Show Dec Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Dec -> ShowS Source

show :: Dec -> String Source

showList :: [Dec] -> ShowS Source

Eq Dec Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Dec -> Dec -> Bool Source

(/=) :: Dec -> Dec -> Bool Source

Ord Dec Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Dec -> Dec -> Ordering Source

(<) :: Dec -> Dec -> Bool Source

(<=) :: Dec -> Dec -> Bool Source

(>) :: Dec -> Dec -> Bool Source

(>=) :: Dec -> Dec -> Bool Source

max :: Dec -> Dec -> Dec Source

min :: Dec -> Dec -> Dec Source

Ppr Dec Source
Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: Dec -> Doc Source

ppr_list :: [Dec] -> Doc Source

type Rep Dec Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep Dec = D1 ('MetaData "Dec" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((((C1 ('MetaCons "FunD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Clause])) :+: (C1 ('MetaCons "ValD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Body) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Dec]))) :+: C1 ('MetaCons "DataD" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Cxt) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TyVarBndr ()]))) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Kind)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Con]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DerivClause])))))) :+: (C1 ('MetaCons "NewtypeD" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Cxt) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TyVarBndr ()]))) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Kind)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Con) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DerivClause])))) :+: (C1 ('MetaCons "TySynD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TyVarBndr ()]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) :+: C1 ('MetaCons "ClassD" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Cxt) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TyVarBndr ()]) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [FunDep]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Dec]))))))) :+: ((C1 ('MetaCons "InstanceD" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Overlap)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Cxt)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Dec]))) :+: (C1 ('MetaCons "SigD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :+: C1 ('MetaCons "KiSigD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Kind)))) :+: (C1 ('MetaCons "ForeignD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Foreign)) :+: (C1 ('MetaCons "InfixD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Fixity) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)) :+: C1 ('MetaCons "DefaultD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Type])))))) :+: (((C1 ('MetaCons "PragmaD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pragma)) :+: (C1 ('MetaCons "DataFamilyD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TyVarBndr ()]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Kind)))) :+: C1 ('MetaCons "DataInstD" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Cxt) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe [TyVarBndr ()])) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Kind)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Con]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DerivClause])))))) :+: (C1 ('MetaCons "NewtypeInstD" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Cxt) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe [TyVarBndr ()])) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Kind)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Con) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DerivClause])))) :+: (C1 ('MetaCons "TySynInstD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 TySynEqn)) :+: C1 ('MetaCons "OpenTypeFamilyD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 TypeFamilyHead))))) :+: ((C1 ('MetaCons "ClosedTypeFamilyD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 TypeFamilyHead) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TySynEqn])) :+: (C1 ('MetaCons "RoleAnnotD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Role])) :+: C1 ('MetaCons "StandaloneDerivD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe DerivStrategy)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Cxt) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))))) :+: ((C1 ('MetaCons "DefaultSigD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :+: C1 ('MetaCons "PatSynD" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 PatSynArgs)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 PatSynDir) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat)))) :+: (C1 ('MetaCons "PatSynSigD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 PatSynType)) :+: C1 ('MetaCons "ImplicitParamBindD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp)))))))

data Clause Source

Constructors

Clause [Pat] Body [Dec]
f { p1 p2 = body where decs }
Instances
Instances details
Data Clause Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Clause -> c Clause Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Clause Source

toConstr :: Clause -> Constr Source

dataTypeOf :: Clause -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Clause) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Clause) Source

gmapT :: (forall b. Data b => b -> b) -> Clause -> Clause Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Clause -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Clause -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Clause -> m Clause Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Clause -> m Clause Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Clause -> m Clause Source

Generic Clause Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Clause :: Type -> Type Source

Methods

from :: Clause -> Rep Clause x Source

to :: Rep Clause x -> Clause Source

Show Clause Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq Clause Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Clause -> Clause -> Bool Source

(/=) :: Clause -> Clause -> Bool Source

Ord Clause Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ppr Clause Source
Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: Clause -> Doc Source

ppr_list :: [Clause] -> Doc Source

type Rep Clause Source
Instance details

Defined in Language.Haskell.TH.Syntax

data Bang Source

Constructors

Bang SourceUnpackedness SourceStrictness
C { {-# UNPACK #-} !}a
Instances
Instances details
Data Bang Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bang -> c Bang Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bang Source

toConstr :: Bang -> Constr Source

dataTypeOf :: Bang -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Bang) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bang) Source

gmapT :: (forall b. Data b => b -> b) -> Bang -> Bang Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Bang -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Bang -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bang -> m Bang Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bang -> m Bang Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bang -> m Bang Source

Generic Bang Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Bang :: Type -> Type Source

Methods

from :: Bang -> Rep Bang x Source

to :: Rep Bang x -> Bang Source

Show Bang Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq Bang Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Bang -> Bang -> Bool Source

(/=) :: Bang -> Bang -> Bool Source

Ord Bang Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Bang -> Bang -> Ordering Source

(<) :: Bang -> Bang -> Bool Source

(<=) :: Bang -> Bang -> Bool Source

(>) :: Bang -> Bang -> Bool Source

(>=) :: Bang -> Bang -> Bool Source

max :: Bang -> Bang -> Bang Source

min :: Bang -> Bang -> Bang Source

Ppr Bang Source
Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: Bang -> Doc Source

ppr_list :: [Bang] -> Doc Source

type Rep Bang Source
Instance details

Defined in Language.Haskell.TH.Syntax

data Callconv Source

Instances
Instances details
Data Callconv Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Callconv -> c Callconv Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Callconv Source

toConstr :: Callconv -> Constr Source

dataTypeOf :: Callconv -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Callconv) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Callconv) Source

gmapT :: (forall b. Data b => b -> b) -> Callconv -> Callconv Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Callconv -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Callconv -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Callconv -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Callconv -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Callconv -> m Callconv Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Callconv -> m Callconv Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Callconv -> m Callconv Source

Generic Callconv Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Callconv :: Type -> Type Source

Show Callconv Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq Callconv Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ord Callconv Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep Callconv Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep Callconv = D1 ('MetaData "Callconv" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((C1 ('MetaCons "CCall" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "StdCall" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "CApi" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Prim" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "JavaScript" 'PrefixI 'False) (U1 :: Type -> Type))))

data Safety Source

Constructors

Instances
Instances details
Data Safety Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Safety -> c Safety Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Safety Source

toConstr :: Safety -> Constr Source

dataTypeOf :: Safety -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Safety) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Safety) Source

gmapT :: (forall b. Data b => b -> b) -> Safety -> Safety Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Safety -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Safety -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Safety -> m Safety Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Safety -> m Safety Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Safety -> m Safety Source

Generic Safety Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Safety :: Type -> Type Source

Methods

from :: Safety -> Rep Safety x Source

to :: Rep Safety x -> Safety Source

Show Safety Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq Safety Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Safety -> Safety -> Bool Source

(/=) :: Safety -> Safety -> Bool Source

Ord Safety Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep Safety Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep Safety = D1 ('MetaData "Safety" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "Unsafe" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Safe" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Interruptible" 'PrefixI 'False) (U1 :: Type -> Type)))

data Pragma Source

Instances
Instances details
Data Pragma Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Pragma -> c Pragma Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Pragma Source

toConstr :: Pragma -> Constr Source

dataTypeOf :: Pragma -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Pragma) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pragma) Source

gmapT :: (forall b. Data b => b -> b) -> Pragma -> Pragma Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pragma -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pragma -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Pragma -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Pragma -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Pragma -> m Pragma Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Pragma -> m Pragma Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Pragma -> m Pragma Source

Generic Pragma Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Pragma :: Type -> Type Source

Methods

from :: Pragma -> Rep Pragma x Source

to :: Rep Pragma x -> Pragma Source

Show Pragma Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq Pragma Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Pragma -> Pragma -> Bool Source

(/=) :: Pragma -> Pragma -> Bool Source

Ord Pragma Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ppr Pragma Source
Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: Pragma -> Doc Source

ppr_list :: [Pragma] -> Doc Source

type Rep Pragma Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep Pragma = D1 ('MetaData "Pragma" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (((C1 ('MetaCons "InlineP" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Inline)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 RuleMatch) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Phases))) :+: C1 ('MetaCons "OpaqueP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name))) :+: (C1 ('MetaCons "SpecialiseP" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Inline)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Phases))) :+: C1 ('MetaCons "SpecialiseInstP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)))) :+: ((C1 ('MetaCons "RuleP" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe [TyVarBndr ()])) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [RuleBndr]))) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Phases)))) :+: C1 ('MetaCons "AnnP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 AnnTarget) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp))) :+: (C1 ('MetaCons "LineP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)) :+: C1 ('MetaCons "CompleteP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Name))))))

data Inline Source

Constructors

Instances
Instances details
Data Inline Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Inline -> c Inline Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Inline Source

toConstr :: Inline -> Constr Source

dataTypeOf :: Inline -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Inline) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inline) Source

gmapT :: (forall b. Data b => b -> b) -> Inline -> Inline Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Inline -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Inline -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Inline -> m Inline Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Inline -> m Inline Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Inline -> m Inline Source

Generic Inline Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Inline :: Type -> Type Source

Methods

from :: Inline -> Rep Inline x Source

to :: Rep Inline x -> Inline Source

Show Inline Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq Inline Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Inline -> Inline -> Bool Source

(/=) :: Inline -> Inline -> Bool Source

Ord Inline Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ppr Inline Source
Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: Inline -> Doc Source

ppr_list :: [Inline] -> Doc Source

type Rep Inline Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep Inline = D1 ('MetaData "Inline" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "NoInline" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Inline" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Inlinable" 'PrefixI 'False) (U1 :: Type -> Type)))

data RuleMatch Source

Constructors

Instances
Instances details
Data RuleMatch Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleMatch -> c RuleMatch Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RuleMatch Source

toConstr :: RuleMatch -> Constr Source

dataTypeOf :: RuleMatch -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RuleMatch) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleMatch) Source

gmapT :: (forall b. Data b => b -> b) -> RuleMatch -> RuleMatch Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleMatch -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleMatch -> r Source

gmapQ :: (forall d. Data d => d -> u) -> RuleMatch -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleMatch -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch Source

Generic RuleMatch Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep RuleMatch :: Type -> Type Source

Show RuleMatch Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq RuleMatch Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ord RuleMatch Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ppr RuleMatch Source
Instance details

Defined in Language.Haskell.TH.Ppr

type Rep RuleMatch Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep RuleMatch = D1 ('MetaData "RuleMatch" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "ConLike" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "FunLike" 'PrefixI 'False) (U1 :: Type -> Type))

data Phases Source

Instances
Instances details
Data Phases Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Phases -> c Phases Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Phases Source

toConstr :: Phases -> Constr Source

dataTypeOf :: Phases -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Phases) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Phases) Source

gmapT :: (forall b. Data b => b -> b) -> Phases -> Phases Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Phases -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Phases -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Phases -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Phases -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Phases -> m Phases Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Phases -> m Phases Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Phases -> m Phases Source

Generic Phases Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Phases :: Type -> Type Source

Methods

from :: Phases -> Rep Phases x Source

to :: Rep Phases x -> Phases Source

Show Phases Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq Phases Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Phases -> Phases -> Bool Source

(/=) :: Phases -> Phases -> Bool Source

Ord Phases Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ppr Phases Source
Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: Phases -> Doc Source

ppr_list :: [Phases] -> Doc Source

type Rep Phases Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep Phases = D1 ('MetaData "Phases" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "AllPhases" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "FromPhase" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int)) :+: C1 ('MetaCons "BeforePhase" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int))))

data RuleBndr Source

Instances
Instances details
Data RuleBndr Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleBndr -> c RuleBndr Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RuleBndr Source

toConstr :: RuleBndr -> Constr Source

dataTypeOf :: RuleBndr -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RuleBndr) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleBndr) Source

gmapT :: (forall b. Data b => b -> b) -> RuleBndr -> RuleBndr Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr -> r Source

gmapQ :: (forall d. Data d => d -> u) -> RuleBndr -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleBndr -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr Source

Generic RuleBndr Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep RuleBndr :: Type -> Type Source

Show RuleBndr Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq RuleBndr Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ord RuleBndr Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ppr RuleBndr Source
Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: RuleBndr -> Doc Source

ppr_list :: [RuleBndr] -> Doc Source

type Rep RuleBndr Source
Instance details

Defined in Language.Haskell.TH.Syntax

data AnnTarget Source

Instances
Instances details
Data AnnTarget Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnTarget -> c AnnTarget Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnTarget Source

toConstr :: AnnTarget -> Constr Source

dataTypeOf :: AnnTarget -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnTarget) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnTarget) Source

gmapT :: (forall b. Data b => b -> b) -> AnnTarget -> AnnTarget Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnTarget -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnTarget -> r Source

gmapQ :: (forall d. Data d => d -> u) -> AnnTarget -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnTarget -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget Source

Generic AnnTarget Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep AnnTarget :: Type -> Type Source

Show AnnTarget Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq AnnTarget Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ord AnnTarget Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep AnnTarget Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep AnnTarget = D1 ('MetaData "AnnTarget" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "ModuleAnnotation" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "TypeAnnotation" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)) :+: C1 ('MetaCons "ValueAnnotation" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name))))

data FunDep Source

Constructors

Instances
Instances details
Data FunDep Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunDep -> c FunDep Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FunDep Source

toConstr :: FunDep -> Constr Source

dataTypeOf :: FunDep -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FunDep) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunDep) Source

gmapT :: (forall b. Data b => b -> b) -> FunDep -> FunDep Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r Source

gmapQ :: (forall d. Data d => d -> u) -> FunDep -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> FunDep -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunDep -> m FunDep Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep -> m FunDep Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep -> m FunDep Source

Generic FunDep Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep FunDep :: Type -> Type Source

Methods

from :: FunDep -> Rep FunDep x Source

to :: Rep FunDep x -> FunDep Source

Show FunDep Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq FunDep Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: FunDep -> FunDep -> Bool Source

(/=) :: FunDep -> FunDep -> Bool Source

Ord FunDep Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ppr FunDep Source
Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: FunDep -> Doc Source

ppr_list :: [FunDep] -> Doc Source

type Rep FunDep Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep FunDep = D1 ('MetaData "FunDep" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "FunDep" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name])))

data TySynEqn Source

One equation of a type family instance or closed type family. The arguments are the left-hand-side type and the right-hand-side result.

For instance, if you had the following type family:

type family Foo (a :: k) :: k where
  forall k (a :: k). Foo @k a = a

The Foo @k a = a equation would be represented as follows:

TySynEqn (Just [PlainTV k, KindedTV a (VarT k)])
           (AppT (AppKindT (ConT ''Foo) (VarT k)) (VarT a))
           (VarT a)

Constructors

Instances
Instances details
Data TySynEqn Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TySynEqn -> c TySynEqn Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TySynEqn Source

toConstr :: TySynEqn -> Constr Source

dataTypeOf :: TySynEqn -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TySynEqn) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TySynEqn) Source

gmapT :: (forall b. Data b => b -> b) -> TySynEqn -> TySynEqn Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TySynEqn -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TySynEqn -> r Source

gmapQ :: (forall d. Data d => d -> u) -> TySynEqn -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> TySynEqn -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn Source

Generic TySynEqn Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep TySynEqn :: Type -> Type Source

Show TySynEqn Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq TySynEqn Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ord TySynEqn Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep TySynEqn Source
Instance details

Defined in Language.Haskell.TH.Syntax

data TypeFamilyHead Source

Common elements of OpenTypeFamilyD and ClosedTypeFamilyD. By analogy with "head" for type classes and type class instances as defined in Type classes: an exploration of the design space, the TypeFamilyHead is defined to be the elements of the declaration between type family and where.

Instances
Instances details
Data TypeFamilyHead Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypeFamilyHead -> c TypeFamilyHead Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TypeFamilyHead Source

toConstr :: TypeFamilyHead -> Constr Source

dataTypeOf :: TypeFamilyHead -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TypeFamilyHead) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeFamilyHead) Source

gmapT :: (forall b. Data b => b -> b) -> TypeFamilyHead -> TypeFamilyHead Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r Source

gmapQ :: (forall d. Data d => d -> u) -> TypeFamilyHead -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeFamilyHead -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeFamilyHead -> m TypeFamilyHead Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeFamilyHead -> m TypeFamilyHead Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeFamilyHead -> m TypeFamilyHead Source

Generic TypeFamilyHead Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep TypeFamilyHead :: Type -> Type Source

Show TypeFamilyHead Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq TypeFamilyHead Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ord TypeFamilyHead Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep TypeFamilyHead Source
Instance details

Defined in Language.Haskell.TH.Syntax

data FixityDirection Source

Constructors

Instances
Instances details
Data FixityDirection Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FixityDirection -> c FixityDirection Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FixityDirection Source

toConstr :: FixityDirection -> Constr Source

dataTypeOf :: FixityDirection -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FixityDirection) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FixityDirection) Source

gmapT :: (forall b. Data b => b -> b) -> FixityDirection -> FixityDirection Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r Source

gmapQ :: (forall d. Data d => d -> u) -> FixityDirection -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> FixityDirection -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection Source

Generic FixityDirection Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep FixityDirection :: Type -> Type Source

Show FixityDirection Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq FixityDirection Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ord FixityDirection Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep FixityDirection Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep FixityDirection = D1 ('MetaData "FixityDirection" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "InfixL" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "InfixR" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "InfixN" 'PrefixI 'False) (U1 :: Type -> Type)))

data PatSynDir Source

A pattern synonym's directionality.

Constructors

Unidir
pattern P x {<-} p
ImplBidir
pattern P x {=} p
ExplBidir [Clause]
pattern P x {<-} p where P x = e
Instances
Instances details
Data PatSynDir Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PatSynDir -> c PatSynDir Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PatSynDir Source

toConstr :: PatSynDir -> Constr Source

dataTypeOf :: PatSynDir -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PatSynDir) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatSynDir) Source

gmapT :: (forall b. Data b => b -> b) -> PatSynDir -> PatSynDir Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PatSynDir -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PatSynDir -> r Source

gmapQ :: (forall d. Data d => d -> u) -> PatSynDir -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> PatSynDir -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir Source

Generic PatSynDir Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep PatSynDir :: Type -> Type Source

Show PatSynDir Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq PatSynDir Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ord PatSynDir Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ppr PatSynDir Source
Instance details

Defined in Language.Haskell.TH.Ppr

type Rep PatSynDir Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep PatSynDir = D1 ('MetaData "PatSynDir" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "Unidir" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "ImplBidir" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ExplBidir" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Clause]))))

data PatSynArgs Source

A pattern synonym's argument type.

Constructors

PrefixPatSyn [Name]
pattern P {x y z} = p
InfixPatSyn Name Name
pattern {x P y} = p
RecordPatSyn [Name]
pattern P { {x,y,z} } = p
Instances
Instances details
Data PatSynArgs Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PatSynArgs -> c PatSynArgs Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PatSynArgs Source

toConstr :: PatSynArgs -> Constr Source

dataTypeOf :: PatSynArgs -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PatSynArgs) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatSynArgs) Source

gmapT :: (forall b. Data b => b -> b) -> PatSynArgs -> PatSynArgs Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PatSynArgs -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PatSynArgs -> r Source

gmapQ :: (forall d. Data d => d -> u) -> PatSynArgs -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> PatSynArgs -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs Source

Generic PatSynArgs Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep PatSynArgs :: Type -> Type Source

Show PatSynArgs Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq PatSynArgs Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ord PatSynArgs Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ppr PatSynArgs Source
Instance details

Defined in Language.Haskell.TH.Ppr

type Rep PatSynArgs Source
Instance details

Defined in Language.Haskell.TH.Syntax

data Exp Source

Constructors

VarE Name
{ x }
ConE Name
data T1 = C1 t1 t2; p = {C1} e1 e2
LitE Lit
{ 5 or 'c'}
AppE Exp Exp
{ f x }
AppTypeE Exp Type
{ f @Int }
InfixE (Maybe Exp) Exp (Maybe Exp)
{x + y} or {(x+)} or {(+ x)} or {(+)}
UInfixE Exp Exp Exp
{x + y}

See Language.Haskell.TH.Syntax

ParensE Exp
{ (e) }

See Language.Haskell.TH.Syntax

LamE [Pat] Exp
{ \ p1 p2 -> e }
LamCaseE [Match]
{ \case m1; m2 }
LamCasesE [Clause]
{ \cases m1; m2 }
TupE [Maybe Exp]
{ (e1,e2) }

The Maybe is necessary for handling tuple sections.

(1,)

translates to

TupE [Just (LitE (IntegerL 1)),Nothing]
UnboxedTupE [Maybe Exp]
{ (# e1,e2 #) }

The Maybe is necessary for handling tuple sections.

(# 'c', #)

translates to

UnboxedTupE [Just (LitE (CharL 'c')),Nothing]
UnboxedSumE Exp SumAlt SumArity
{ (#|e|#) }
CondE Exp Exp Exp
{ if e1 then e2 else e3 }
MultiIfE [(Guard, Exp)]
{ if | g1 -> e1 | g2 -> e2 }
LetE [Dec] Exp
{ let { x=e1; y=e2 } in e3 }
CaseE Exp [Match]
{ case e of m1; m2 }
DoE (Maybe ModName) [Stmt]

{ do { p <- e1; e2 } } or a qualified do if the module name is present

MDoE (Maybe ModName) [Stmt]

{ mdo { x <- e1 y; y <- e2 x; } } or a qualified mdo if the module name is present

CompE [Stmt]
{ [ (x,y) | x <- xs, y <- ys ] }

The result expression of the comprehension is the last of the Stmts, and should be a NoBindS.

E.g. translation:

[ f x | x <- xs ]
CompE [BindS (VarP x) (VarE xs), NoBindS (AppE (VarE f) (VarE x))]
ArithSeqE Range
{ [ 1 ,2 .. 10 ] }
ListE [Exp]
{ [1,2,3] }
SigE Exp Type
{ e :: t }
RecConE Name [FieldExp]
{ T { x = y, z = w } }
RecUpdE Exp [FieldExp]
{ (f x) { z = w } }
StaticE Exp
{ static e }
UnboundVarE Name
{ _x }

This is used for holes or unresolved identifiers in AST quotes. Note that it could either have a variable name or constructor name.

LabelE String

{ #x } ( Overloaded label )

ImplicitParamVarE String

{ ?x } ( Implicit parameter )

GetFieldE Exp String

{ exp.field } ( Overloaded Record Dot )

ProjectionE (NonEmpty String)

(.x) or (.x.y) (Record projections)

Instances
Instances details
Data Exp Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Exp -> c Exp Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Exp Source

toConstr :: Exp -> Constr Source

dataTypeOf :: Exp -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Exp) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp) Source

gmapT :: (forall b. Data b => b -> b) -> Exp -> Exp Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Exp -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Exp -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Exp -> m Exp Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp -> m Exp Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp -> m Exp Source

Generic Exp Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Exp :: Type -> Type Source

Methods

from :: Exp -> Rep Exp x Source

to :: Rep Exp x -> Exp Source

Show Exp Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Exp -> ShowS Source

show :: Exp -> String Source

showList :: [Exp] -> ShowS Source

Eq Exp Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Exp -> Exp -> Bool Source

(/=) :: Exp -> Exp -> Bool Source

Ord Exp Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Exp -> Exp -> Ordering Source

(<) :: Exp -> Exp -> Bool Source

(<=) :: Exp -> Exp -> Bool Source

(>) :: Exp -> Exp -> Bool Source

(>=) :: Exp -> Exp -> Bool Source

max :: Exp -> Exp -> Exp Source

min :: Exp -> Exp -> Exp Source

Ppr Exp Source
Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: Exp -> Doc Source

ppr_list :: [Exp] -> Doc Source

type Rep Exp Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep Exp = D1 ('MetaData "Exp" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (((((C1 ('MetaCons "VarE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)) :+: C1 ('MetaCons "ConE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name))) :+: (C1 ('MetaCons "LitE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Lit)) :+: C1 ('MetaCons "AppE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp)))) :+: ((C1 ('MetaCons "AppTypeE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :+: C1 ('MetaCons "InfixE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Exp)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Exp))))) :+: (C1 ('MetaCons "UInfixE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp))) :+: C1 ('MetaCons "ParensE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp))))) :+: (((C1 ('MetaCons "LamE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Pat]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp)) :+: C1 ('MetaCons "LamCaseE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Match]))) :+: (C1 ('MetaCons "LamCasesE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Clause])) :+: C1 ('MetaCons "TupE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Maybe Exp])))) :+: ((C1 ('MetaCons "UnboxedTupE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Maybe Exp])) :+: C1 ('MetaCons "UnboxedSumE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SumAlt) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SumArity)))) :+: (C1 ('MetaCons "CondE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp))) :+: C1 ('MetaCons "MultiIfE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(Guard, Exp)])))))) :+: ((((C1 ('MetaCons "LetE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Dec]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp)) :+: C1 ('MetaCons "CaseE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Match]))) :+: (C1 ('MetaCons "DoE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe ModName)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Stmt])) :+: C1 ('MetaCons "MDoE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe ModName)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Stmt])))) :+: ((C1 ('MetaCons "CompE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Stmt])) :+: C1 ('MetaCons "ArithSeqE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Range))) :+: (C1 ('MetaCons "ListE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Exp])) :+: C1 ('MetaCons "SigE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))))) :+: (((C1 ('MetaCons "RecConE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [FieldExp])) :+: C1 ('MetaCons "RecUpdE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [FieldExp]))) :+: (C1 ('MetaCons "StaticE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp)) :+: C1 ('MetaCons "UnboundVarE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)))) :+: ((C1 ('MetaCons "LabelE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)) :+: C1 ('MetaCons "ImplicitParamVarE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String))) :+: (C1 ('MetaCons "GetFieldE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)) :+: C1 ('MetaCons "ProjectionE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (NonEmpty String))))))))

data Match Source

Constructors

Match Pat Body [Dec]
case e of { pat -> body where decs }
Instances
Instances details
Data Match Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Match -> c Match Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Match Source

toConstr :: Match -> Constr Source

dataTypeOf :: Match -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Match) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match) Source

gmapT :: (forall b. Data b => b -> b) -> Match -> Match Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Match -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Match -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Match -> m Match Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Match -> m Match Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Match -> m Match Source

Generic Match Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Match :: Type -> Type Source

Methods

from :: Match -> Rep Match x Source

to :: Rep Match x -> Match Source

Show Match Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq Match Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Match -> Match -> Bool Source

(/=) :: Match -> Match -> Bool Source

Ord Match Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ppr Match Source
Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: Match -> Doc Source

ppr_list :: [Match] -> Doc Source

type Rep Match Source
Instance details

Defined in Language.Haskell.TH.Syntax

data Body Source

Constructors

GuardedB [(Guard, Exp)]
f p { | e1 = e2
      | e3 = e4 }
 where ds
NormalB Exp
f p { = e } where ds
Instances
Instances details
Data Body Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Body -> c Body Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Body Source

toConstr :: Body -> Constr Source

dataTypeOf :: Body -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Body) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Body) Source

gmapT :: (forall b. Data b => b -> b) -> Body -> Body Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Body -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Body -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Body -> m Body Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Body -> m Body Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Body -> m Body Source

Generic Body Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Body :: Type -> Type Source

Methods

from :: Body -> Rep Body x Source

to :: Rep Body x -> Body Source

Show Body Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq Body Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Body -> Body -> Bool Source

(/=) :: Body -> Body -> Bool Source

Ord Body Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Body -> Body -> Ordering Source

(<) :: Body -> Body -> Bool Source

(<=) :: Body -> Body -> Bool Source

(>) :: Body -> Body -> Bool Source

(>=) :: Body -> Body -> Bool Source

max :: Body -> Body -> Body Source

min :: Body -> Body -> Body Source

type Rep Body Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep Body = D1 ('MetaData "Body" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "GuardedB" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(Guard, Exp)])) :+: C1 ('MetaCons "NormalB" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp)))

data Guard Source

Constructors

NormalG Exp
f x { | odd x } = x
PatG [Stmt]
f x { | Just y <- x, Just z <- y } = z
Instances
Instances details
Data Guard Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Guard -> c Guard Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Guard Source

toConstr :: Guard -> Constr Source

dataTypeOf :: Guard -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Guard) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Guard) Source

gmapT :: (forall b. Data b => b -> b) -> Guard -> Guard Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Guard -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Guard -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Guard -> m Guard Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Guard -> m Guard Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Guard -> m Guard Source

Generic Guard Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Guard :: Type -> Type Source

Methods

from :: Guard -> Rep Guard x Source

to :: Rep Guard x -> Guard Source

Show Guard Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq Guard Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Guard -> Guard -> Bool Source

(/=) :: Guard -> Guard -> Bool Source

Ord Guard Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep Guard Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep Guard = D1 ('MetaData "Guard" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "NormalG" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp)) :+: C1 ('MetaCons "PatG" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Stmt])))

data Stmt Source

Constructors

BindS Pat Exp
p <- e
LetS [Dec]
{ let { x=e1; y=e2 } }
NoBindS Exp
e
ParS [[Stmt]]

x <- e1 | s2, s3 | s4 (in CompE)

RecS [Stmt]
rec { s1; s2 }
Instances
Instances details
Data Stmt Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Stmt -> c Stmt Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Stmt Source

toConstr :: Stmt -> Constr Source

dataTypeOf :: Stmt -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Stmt) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stmt) Source

gmapT :: (forall b. Data b => b -> b) -> Stmt -> Stmt Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Stmt -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Stmt -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Stmt -> m Stmt Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Stmt -> m Stmt Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Stmt -> m Stmt Source

Generic Stmt Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Stmt :: Type -> Type Source

Methods

from :: Stmt -> Rep Stmt x Source

to :: Rep Stmt x -> Stmt Source

Show Stmt Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq Stmt Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Stmt -> Stmt -> Bool Source

(/=) :: Stmt -> Stmt -> Bool Source

Ord Stmt Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Stmt -> Stmt -> Ordering Source

(<) :: Stmt -> Stmt -> Bool Source

(<=) :: Stmt -> Stmt -> Bool Source

(>) :: Stmt -> Stmt -> Bool Source

(>=) :: Stmt -> Stmt -> Bool Source

max :: Stmt -> Stmt -> Stmt Source

min :: Stmt -> Stmt -> Stmt Source

Ppr Stmt Source
Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: Stmt -> Doc Source

ppr_list :: [Stmt] -> Doc Source

type Rep Stmt Source
Instance details

Defined in Language.Haskell.TH.Syntax

data Range Source

Instances
Instances details
Data Range Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Range -> c Range Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Range Source

toConstr :: Range -> Constr Source

dataTypeOf :: Range -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Range) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Range) Source

gmapT :: (forall b. Data b => b -> b) -> Range -> Range Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Range -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Range -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Range -> m Range Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Range -> m Range Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Range -> m Range Source

Generic Range Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Range :: Type -> Type Source

Methods

from :: Range -> Rep Range x Source

to :: Rep Range x -> Range Source

Show Range Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq Range Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Range -> Range -> Bool Source

(/=) :: Range -> Range -> Bool Source

Ord Range Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ppr Range Source
Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: Range -> Doc Source

ppr_list :: [Range] -> Doc Source

type Rep Range Source
Instance details

Defined in Language.Haskell.TH.Syntax

data Lit Source

Constructors

CharL Char
StringL String
IntegerL Integer

Used for overloaded and non-overloaded literals. We don't have a good way to represent non-overloaded literals at the moment. Maybe that doesn't matter?

RationalL Rational
IntPrimL Integer
WordPrimL Integer
FloatPrimL Rational
DoublePrimL Rational
StringPrimL [Word8]

A primitive C-style string, type Addr#

BytesPrimL Bytes

Some raw bytes, type Addr#:

CharPrimL Char
Instances
Instances details
Data Lit Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Lit -> c Lit Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Lit Source

toConstr :: Lit -> Constr Source

dataTypeOf :: Lit -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Lit) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lit) Source

gmapT :: (forall b. Data b => b -> b) -> Lit -> Lit Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Lit -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Lit -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Lit -> m Lit Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Lit -> m Lit Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Lit -> m Lit Source

Generic Lit Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Lit :: Type -> Type Source

Methods

from :: Lit -> Rep Lit x Source

to :: Rep Lit x -> Lit Source

Show Lit Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Lit -> ShowS Source

show :: Lit -> String Source

showList :: [Lit] -> ShowS Source

Eq Lit Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Lit -> Lit -> Bool Source

(/=) :: Lit -> Lit -> Bool Source

Ord Lit Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Lit -> Lit -> Ordering Source

(<) :: Lit -> Lit -> Bool Source

(<=) :: Lit -> Lit -> Bool Source

(>) :: Lit -> Lit -> Bool Source

(>=) :: Lit -> Lit -> Bool Source

max :: Lit -> Lit -> Lit Source

min :: Lit -> Lit -> Lit Source

Ppr Lit Source
Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: Lit -> Doc Source

ppr_list :: [Lit] -> Doc Source

type Rep Lit Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep Lit = D1 ('MetaData "Lit" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (((C1 ('MetaCons "CharL" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Char)) :+: C1 ('MetaCons "StringL" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String))) :+: (C1 ('MetaCons "IntegerL" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Integer)) :+: (C1 ('MetaCons "RationalL" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Rational)) :+: C1 ('MetaCons "IntPrimL" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Integer))))) :+: ((C1 ('MetaCons "WordPrimL" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Integer)) :+: (C1 ('MetaCons "FloatPrimL" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Rational)) :+: C1 ('MetaCons "DoublePrimL" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Rational)))) :+: (C1 ('MetaCons "StringPrimL" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Word8])) :+: (C1 ('MetaCons "BytesPrimL" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bytes)) :+: C1 ('MetaCons "CharPrimL" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Char))))))

data Pat Source

Pattern in Haskell given in {}

Constructors

LitP Lit
{ 5 or 'c' }
VarP Name
{ x }
TupP [Pat]
{ (p1,p2) }
UnboxedTupP [Pat]
{ (# p1,p2 #) }
UnboxedSumP Pat SumAlt SumArity
{ (#|p|#) }
ConP Name [Type] [Pat]
data T1 = C1 t1 t2; {C1 @ty1 p1 p2} = e
InfixP Pat Name Pat
foo ({x :+ y}) = e
UInfixP Pat Name Pat
foo ({x :+ y}) = e

See Language.Haskell.TH.Syntax

ParensP Pat
{(p)}

See Language.Haskell.TH.Syntax

TildeP Pat
{ ~p }
BangP Pat
{ !p }
AsP Name Pat
{ x @ p }
WildP
{ _ }
RecP Name [FieldPat]
f (Pt { pointx = x }) = g x
ListP [Pat]
{ [1,2,3] }
SigP Pat Type
{ p :: t }
ViewP Exp Pat
{ e -> p }
Instances
Instances details
Data Pat Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Pat -> c Pat Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Pat Source

toConstr :: Pat -> Constr Source

dataTypeOf :: Pat -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Pat) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat) Source

gmapT :: (forall b. Data b => b -> b) -> Pat -> Pat Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Pat -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Pat -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Pat -> m Pat Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Pat -> m Pat Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Pat -> m Pat Source

Generic Pat Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Pat :: Type -> Type Source

Methods

from :: Pat -> Rep Pat x Source

to :: Rep Pat x -> Pat Source

Show Pat Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Pat -> ShowS Source

show :: Pat -> String Source

showList :: [Pat] -> ShowS Source

Eq Pat Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Pat -> Pat -> Bool Source

(/=) :: Pat -> Pat -> Bool Source

Ord Pat Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Pat -> Pat -> Ordering Source

(<) :: Pat -> Pat -> Bool Source

(<=) :: Pat -> Pat -> Bool Source

(>) :: Pat -> Pat -> Bool Source

(>=) :: Pat -> Pat -> Bool Source

max :: Pat -> Pat -> Pat Source

min :: Pat -> Pat -> Pat Source

Ppr Pat Source
Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: Pat -> Doc Source

ppr_list :: [Pat] -> Doc Source

type Rep Pat Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep Pat = D1 ('MetaData "Pat" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((((C1 ('MetaCons "LitP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Lit)) :+: C1 ('MetaCons "VarP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name))) :+: (C1 ('MetaCons "TupP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Pat])) :+: C1 ('MetaCons "UnboxedTupP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Pat])))) :+: ((C1 ('MetaCons "UnboxedSumP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SumAlt) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SumArity))) :+: C1 ('MetaCons "ConP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Type]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Pat])))) :+: (C1 ('MetaCons "InfixP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat))) :+: C1 ('MetaCons "UInfixP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat)))))) :+: (((C1 ('MetaCons "ParensP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat)) :+: C1 ('MetaCons "TildeP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat))) :+: (C1 ('MetaCons "BangP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat)) :+: C1 ('MetaCons "AsP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat)))) :+: ((C1 ('MetaCons "WildP" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "RecP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [FieldPat]))) :+: (C1 ('MetaCons "ListP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Pat])) :+: (C1 ('MetaCons "SigP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :+: C1 ('MetaCons "ViewP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat)))))))

type FieldExp = (Name, Exp) Source

type FieldPat = (Name, Pat) Source

data TyVarBndr flag Source

Constructors

PlainTV Name flag
a
KindedTV Name flag Kind
(a :: k)
Instances
Instances details
Functor TyVarBndr Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

fmap :: (a -> b) -> TyVarBndr a -> TyVarBndr b Source

(<$) :: a -> TyVarBndr b -> TyVarBndr a Source

Data flag => Data (TyVarBndr flag) Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyVarBndr flag -> c (TyVarBndr flag) Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyVarBndr flag) Source

toConstr :: TyVarBndr flag -> Constr Source

dataTypeOf :: TyVarBndr flag -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyVarBndr flag)) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TyVarBndr flag)) Source

gmapT :: (forall b. Data b => b -> b) -> TyVarBndr flag -> TyVarBndr flag Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyVarBndr flag -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyVarBndr flag -> r Source

gmapQ :: (forall d. Data d => d -> u) -> TyVarBndr flag -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyVarBndr flag -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyVarBndr flag -> m (TyVarBndr flag) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyVarBndr flag -> m (TyVarBndr flag) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyVarBndr flag -> m (TyVarBndr flag) Source

Generic (TyVarBndr flag) Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep (TyVarBndr flag) :: Type -> Type Source

Methods

from :: TyVarBndr flag -> Rep (TyVarBndr flag) x Source

to :: Rep (TyVarBndr flag) x -> TyVarBndr flag Source

Show flag => Show (TyVarBndr flag) Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> TyVarBndr flag -> ShowS Source

show :: TyVarBndr flag -> String Source

showList :: [TyVarBndr flag] -> ShowS Source

Eq flag => Eq (TyVarBndr flag) Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: TyVarBndr flag -> TyVarBndr flag -> Bool Source

(/=) :: TyVarBndr flag -> TyVarBndr flag -> Bool Source

Ord flag => Ord (TyVarBndr flag) Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

compare :: TyVarBndr flag -> TyVarBndr flag -> Ordering Source

(<) :: TyVarBndr flag -> TyVarBndr flag -> Bool Source

(<=) :: TyVarBndr flag -> TyVarBndr flag -> Bool Source

(>) :: TyVarBndr flag -> TyVarBndr flag -> Bool Source

(>=) :: TyVarBndr flag -> TyVarBndr flag -> Bool Source

max :: TyVarBndr flag -> TyVarBndr flag -> TyVarBndr flag Source

min :: TyVarBndr flag -> TyVarBndr flag -> TyVarBndr flag Source

PprFlag flag => Ppr (TyVarBndr flag) Source
Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: TyVarBndr flag -> Doc Source

ppr_list :: [TyVarBndr flag] -> Doc Source

type Rep (TyVarBndr flag) Source
Instance details

Defined in Language.Haskell.TH.Syntax

data TyLit Source

Constructors

NumTyLit Integer
2
StrTyLit String
"Hello"
CharTyLit Char

'C', @since 4.16.0.0

Instances
Instances details
Data TyLit Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyLit -> c TyLit Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TyLit Source

toConstr :: TyLit -> Constr Source

dataTypeOf :: TyLit -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TyLit) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyLit) Source

gmapT :: (forall b. Data b => b -> b) -> TyLit -> TyLit Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r Source

gmapQ :: (forall d. Data d => d -> u) -> TyLit -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyLit -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit Source

Generic TyLit Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep TyLit :: Type -> Type Source

Methods

from :: TyLit -> Rep TyLit x Source

to :: Rep TyLit x -> TyLit Source

Show TyLit Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq TyLit Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: TyLit -> TyLit -> Bool Source

(/=) :: TyLit -> TyLit -> Bool Source

Ord TyLit Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ppr TyLit Source
Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: TyLit -> Doc Source

ppr_list :: [TyLit] -> Doc Source

type Rep TyLit Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Kind = Type Source

To avoid duplication between kinds and types, they are defined to be the same. Naturally, you would never have a type be StarT and you would never have a kind be SigT, but many of the other constructors are shared. Note that the kind Bool is denoted with ConT, not PromotedT. Similarly, tuple kinds are made with TupleT, not PromotedTupleT.

type Cxt Source

Arguments

= [Pred]
(Eq a, Ord b)

type Pred = Type Source

Since the advent of ConstraintKinds, constraints are really just types. Equality constraints use the EqualityT constructor. Constraints may also be tuples of other constraints.

data Role Source

Role annotations

Constructors

NominalR
nominal
RepresentationalR
representational
PhantomR
phantom
InferR
_
Instances
Instances details
Data Role Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Role -> c Role Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Role Source

toConstr :: Role -> Constr Source

dataTypeOf :: Role -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Role) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Role) Source

gmapT :: (forall b. Data b => b -> b) -> Role -> Role Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Role -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Role -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Role -> m Role Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m Role Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m Role Source

Generic Role Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Role :: Type -> Type Source

Methods

from :: Role -> Rep Role x Source

to :: Rep Role x -> Role Source

Show Role Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq Role Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Role -> Role -> Bool Source

(/=) :: Role -> Role -> Bool Source

Ord Role Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Role -> Role -> Ordering Source

(<) :: Role -> Role -> Bool Source

(<=) :: Role -> Role -> Bool Source

(>) :: Role -> Role -> Bool Source

(>=) :: Role -> Role -> Bool Source

max :: Role -> Role -> Role Source

min :: Role -> Role -> Role Source

Ppr Role Source
Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: Role -> Doc Source

ppr_list :: [Role] -> Doc Source

type Rep Role Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep Role = D1 ('MetaData "Role" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((C1 ('MetaCons "NominalR" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "RepresentationalR" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "PhantomR" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "InferR" 'PrefixI 'False) (U1 :: Type -> Type)))

data Specificity Source

Constructors

Instances
Instances details
Data Specificity Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Specificity -> c Specificity Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Specificity Source

toConstr :: Specificity -> Constr Source

dataTypeOf :: Specificity -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Specificity) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Specificity) Source

gmapT :: (forall b. Data b => b -> b) -> Specificity -> Specificity Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Specificity -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Specificity -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Specificity -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Specificity -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Specificity -> m Specificity Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Specificity -> m Specificity Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Specificity -> m Specificity Source

Generic Specificity Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Specificity :: Type -> Type Source

Show Specificity Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq Specificity Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ord Specificity Source
Instance details

Defined in Language.Haskell.TH.Syntax

PprFlag Specificity Source
Instance details

Defined in Language.Haskell.TH.Ppr

type Rep Specificity Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep Specificity = D1 ('MetaData "Specificity" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "SpecifiedSpec" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "InferredSpec" 'PrefixI 'False) (U1 :: Type -> Type))

data FamilyResultSig Source

Type family result signature

Constructors

NoSig

no signature

KindSig Kind
k
TyVarSig (TyVarBndr ())
= r, = (r :: k)
Instances
Instances details
Data FamilyResultSig Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamilyResultSig -> c FamilyResultSig Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FamilyResultSig Source

toConstr :: FamilyResultSig -> Constr Source

dataTypeOf :: FamilyResultSig -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FamilyResultSig) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FamilyResultSig) Source

gmapT :: (forall b. Data b => b -> b) -> FamilyResultSig -> FamilyResultSig Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r Source

gmapQ :: (forall d. Data d => d -> u) -> FamilyResultSig -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> FamilyResultSig -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamilyResultSig -> m FamilyResultSig Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyResultSig -> m FamilyResultSig Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyResultSig -> m FamilyResultSig Source

Generic FamilyResultSig Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep FamilyResultSig :: Type -> Type Source

Show FamilyResultSig Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq FamilyResultSig Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ord FamilyResultSig Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ppr FamilyResultSig Source
Instance details

Defined in Language.Haskell.TH.Ppr

type Rep FamilyResultSig Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep FamilyResultSig = D1 ('MetaData "FamilyResultSig" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "NoSig" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "KindSig" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Kind)) :+: C1 ('MetaCons "TyVarSig" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (TyVarBndr ())))))

data InjectivityAnn Source

Injectivity annotation

Constructors

Instances
Instances details
Data InjectivityAnn Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InjectivityAnn -> c InjectivityAnn Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c InjectivityAnn Source

toConstr :: InjectivityAnn -> Constr Source

dataTypeOf :: InjectivityAnn -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c InjectivityAnn) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InjectivityAnn) Source

gmapT :: (forall b. Data b => b -> b) -> InjectivityAnn -> InjectivityAnn Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r Source

gmapQ :: (forall d. Data d => d -> u) -> InjectivityAnn -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> InjectivityAnn -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InjectivityAnn -> m InjectivityAnn Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityAnn -> m InjectivityAnn Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityAnn -> m InjectivityAnn Source

Generic InjectivityAnn Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep InjectivityAnn :: Type -> Type Source

Show InjectivityAnn Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq InjectivityAnn Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ord InjectivityAnn Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ppr InjectivityAnn Source
Instance details

Defined in Language.Haskell.TH.Ppr

type Rep InjectivityAnn Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep InjectivityAnn = D1 ('MetaData "InjectivityAnn" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "InjectivityAnn" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name])))

type PatSynType = Type Source

A pattern synonym's type. Note that a pattern synonym's fully specified type has a peculiar shape coming with two forall quantifiers and two constraint contexts. For example, consider the pattern synonym

pattern P x1 x2 ... xn = <some-pattern>

P's complete type is of the following form

pattern P :: forall universals.   required constraints
          => forall existentials. provided constraints
          => t1 -> t2 -> ... -> tn -> t

consisting of four parts:

  1. the (possibly empty lists of) universally quantified type variables and required constraints on them.
  2. the (possibly empty lists of) existentially quantified type variables and the provided constraints on them.
  3. the types t1, t2, .., tn of x1, x2, .., xn, respectively
  4. the type t of <some-pattern>, mentioning only universals.

Pattern synonym types interact with TH when (a) reifying a pattern synonym, (b) pretty printing, or (c) specifying a pattern synonym's type signature explicitly:

  • Reification always returns a pattern synonym's fully specified type in abstract syntax.
  • Pretty printing via pprPatSynType abbreviates a pattern synonym's type unambiguously in concrete syntax: The rule of thumb is to print initial empty universals and the required context as () =>, if existentials and a provided context follow. If only universals and their required context, but no existentials are specified, only the universals and their required context are printed. If both or none are specified, so both (or none) are printed.
  • When specifying a pattern synonym's type explicitly with PatSynSigD either one of the universals, the existentials, or their contexts may be left empty.

See the GHC user's guide for more information on pattern synonyms and their types: https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#pattern-synonyms.

type BangType = (Bang, Type) Source

type VarBangType = (Name, Bang, Type) Source

data DocLoc Source

A location at which to attach Haddock documentation. Note that adding documentation to a Name defined oustide of the current module will cause an error.

Constructors

ModuleDoc

At the current module's header.

DeclDoc Name

At a declaration, not necessarily top level.

ArgDoc Name Int

At a specific argument of a function, indexed by its position.

InstDoc Type

At a class or family instance.

Instances
Instances details
Data DocLoc Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DocLoc -> c DocLoc Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DocLoc Source

toConstr :: DocLoc -> Constr Source

dataTypeOf :: DocLoc -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DocLoc) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DocLoc) Source

gmapT :: (forall b. Data b => b -> b) -> DocLoc -> DocLoc Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DocLoc -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DocLoc -> r Source

gmapQ :: (forall d. Data d => d -> u) -> DocLoc -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> DocLoc -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DocLoc -> m DocLoc Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DocLoc -> m DocLoc Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DocLoc -> m DocLoc Source

Generic DocLoc Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep DocLoc :: Type -> Type Source

Methods

from :: DocLoc -> Rep DocLoc x Source

to :: Rep DocLoc x -> DocLoc Source

Show DocLoc Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq DocLoc Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: DocLoc -> DocLoc -> Bool Source

(/=) :: DocLoc -> DocLoc -> Bool Source

Ord DocLoc Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep DocLoc Source
Instance details

Defined in Language.Haskell.TH.Syntax

data DerivClause Source

A single deriving clause at the end of a datatype.

Constructors

DerivClause (Maybe DerivStrategy) Cxt
{ deriving stock (Eq, Ord) }
Instances
Instances details
Data DerivClause Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivClause -> c DerivClause Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DerivClause Source

toConstr :: DerivClause -> Constr Source

dataTypeOf :: DerivClause -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DerivClause) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DerivClause) Source

gmapT :: (forall b. Data b => b -> b) -> DerivClause -> DerivClause Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivClause -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivClause -> r Source

gmapQ :: (forall d. Data d => d -> u) -> DerivClause -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivClause -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause Source

Generic DerivClause Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep DerivClause :: Type -> Type Source

Show DerivClause Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq DerivClause Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ord DerivClause Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep DerivClause Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep DerivClause = D1 ('MetaData "DerivClause" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "DerivClause" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe DerivStrategy)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Cxt)))

data DerivStrategy Source

What the user explicitly requests when deriving an instance.

Constructors

StockStrategy

A "standard" derived instance

AnyclassStrategy
-XDeriveAnyClass
NewtypeStrategy
-XGeneralizedNewtypeDeriving
ViaStrategy Type
-XDerivingVia
Instances
Instances details
Data DerivStrategy Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivStrategy -> c DerivStrategy Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DerivStrategy Source

toConstr :: DerivStrategy -> Constr Source

dataTypeOf :: DerivStrategy -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DerivStrategy) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DerivStrategy) Source

gmapT :: (forall b. Data b => b -> b) -> DerivStrategy -> DerivStrategy Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r Source

gmapQ :: (forall d. Data d => d -> u) -> DerivStrategy -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivStrategy -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy Source

Generic DerivStrategy Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep DerivStrategy :: Type -> Type Source

Show DerivStrategy Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq DerivStrategy Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ord DerivStrategy Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep DerivStrategy Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep DerivStrategy = D1 ('MetaData "DerivStrategy" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((C1 ('MetaCons "StockStrategy" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "AnyclassStrategy" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "NewtypeStrategy" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ViaStrategy" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))))

data Overlap Source

Varieties of allowed instance overlap.

Constructors

Overlappable

May be overlapped by more specific instances

Overlapping

May overlap a more general instance

Overlaps

Both Overlapping and Overlappable

Incoherent

Both Overlapping and Overlappable, and pick an arbitrary one if multiple choices are available.

Instances
Instances details
Data Overlap Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Overlap -> c Overlap Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Overlap Source

toConstr :: Overlap -> Constr Source

dataTypeOf :: Overlap -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Overlap) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Overlap) Source

gmapT :: (forall b. Data b => b -> b) -> Overlap -> Overlap Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Overlap -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Overlap -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Overlap -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Overlap -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Overlap -> m Overlap Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Overlap -> m Overlap Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Overlap -> m Overlap Source

Generic Overlap Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Overlap :: Type -> Type Source

Methods

from :: Overlap -> Rep Overlap x Source

to :: Rep Overlap x -> Overlap Source

Show Overlap Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq Overlap Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ord Overlap Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep Overlap Source
Instance details

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)))

type Uniq = Integer Source

Uniq is used by GHC to distinguish names from each other.

data NameFlavour Source

Constructors

NameS

An unqualified name; dynamically bound

NameQ ModName

A qualified name; dynamically bound

NameU !Uniq

A unique local name

NameL !Uniq

Local name bound outside of the TH AST

NameG NameSpace PkgName ModName

Global name bound outside of the TH AST: An original name (occurrences only, not binders) Need the namespace too to be sure which thing we are naming

Instances
Instances details
Data NameFlavour Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NameFlavour -> c NameFlavour Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NameFlavour Source

toConstr :: NameFlavour -> Constr Source

dataTypeOf :: NameFlavour -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NameFlavour) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameFlavour) Source

gmapT :: (forall b. Data b => b -> b) -> NameFlavour -> NameFlavour Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NameFlavour -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NameFlavour -> r Source

gmapQ :: (forall d. Data d => d -> u) -> NameFlavour -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> NameFlavour -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour Source

Generic NameFlavour Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep NameFlavour :: Type -> Type Source

Show NameFlavour Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq NameFlavour Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ord NameFlavour Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep NameFlavour Source
Instance details

Defined in Language.Haskell.TH.Syntax

data NameIs Source

Constructors

data Bytes Source

Raw bytes embedded into the binary.

Avoid using Bytes constructor directly as it is likely to change in the future. Use helpers such as mkBytes in Language.Haskell.TH.Lib instead.

Constructors

Bytes

Fields

Instances
Instances details
Data Bytes Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bytes -> c Bytes Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bytes Source

toConstr :: Bytes -> Constr Source

dataTypeOf :: Bytes -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Bytes) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bytes) Source

gmapT :: (forall b. Data b => b -> b) -> Bytes -> Bytes Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Bytes -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Bytes -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bytes -> m Bytes Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bytes -> m Bytes Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bytes -> m Bytes Source

Generic Bytes Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Bytes :: Type -> Type Source

Methods

from :: Bytes -> Rep Bytes x Source

to :: Rep Bytes x -> Bytes Source

Show Bytes Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq Bytes Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Bytes -> Bytes -> Bool Source

(/=) :: Bytes -> Bytes -> Bool Source

Ord Bytes Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep Bytes Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep Bytes = D1 ('MetaData "Bytes" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "Bytes" 'PrefixI 'True) (S1 ('MetaSel ('Just "bytesPtr") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (ForeignPtr Word8)) :*: (S1 ('MetaSel ('Just "bytesOffset") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Word) :*: S1 ('MetaSel ('Just "bytesSize") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Word))))

class (MonadIO m, MonadFail m) => Quasi m where Source

Methods

qNewName Source

Arguments

:: String
-> m Name

Fresh names

qReport Source

Arguments

:: Bool
-> String
-> m ()

Report an error (True) or warning (False) ...but carry on; use fail to stop

qRecover Source

Arguments

:: m a

the error handler

-> m a

action which may fail

-> m a

Recover from the monadic fail

qLookupName :: Bool -> String -> m (Maybe Name) Source

qReify :: Name -> m Info Source

qReifyFixity :: Name -> m (Maybe Fixity) Source

qReifyType :: Name -> m Type Source

qReifyInstances :: Name -> [Type] -> m [Dec] Source

qReifyRoles :: Name -> m [Role] Source

qReifyAnnotations :: Data a => AnnLookup -> m [a] Source

qReifyModule :: Module -> m ModuleInfo Source

qReifyConStrictness :: Name -> m [DecidedStrictness] Source

qLocation :: m Loc Source

qRunIO :: IO a -> m a Source

qGetPackageRoot :: m FilePath Source

qAddDependentFile :: FilePath -> m () Source

qAddTempFile :: String -> m FilePath Source

qAddTopDecls :: [Dec] -> m () Source

qAddForeignFilePath :: ForeignSrcLang -> String -> m () Source

qAddModFinalizer :: Q () -> m () Source

qAddCorePlugin :: String -> m () Source

qGetQ :: Typeable a => m (Maybe a) Source

qPutQ :: Typeable a => a -> m () Source

qIsExtEnabled :: Extension -> m Bool Source

qExtsEnabled :: m [Extension] Source

qPutDoc :: DocLoc -> String -> m () Source

qGetDoc :: DocLoc -> m (Maybe String) Source

Instances
Instances details
Quasi IO Source
Instance details

Defined in Language.Haskell.TH.Syntax

Quasi Q Source
Instance details

Defined in Language.Haskell.TH.Syntax

class Lift (t :: TYPE r) where Source

A Lift instance can have any of its values turned into a Template Haskell expression. This is needed when a value used within a Template Haskell quotation is bound outside the Oxford brackets ([| ... |] or [|| ... ||]) but not at the top level. As an example:

add1 :: Int -> Q (TExp Int)
add1 x = [|| x + 1 ||]

Template Haskell has no way of knowing what value x will take on at splice-time, so it requires the type of x to be an instance of Lift.

A Lift instance must satisfy $(lift x) ≡ x and $$(liftTyped x) ≡ x for all x, where $(...) and $$(...) are Template Haskell splices. It is additionally expected that lift x ≡ unTypeQ (liftTyped x).

Lift instances can be derived automatically by use of the -XDeriveLift GHC language extension:

{-# LANGUAGE DeriveLift #-}
module Foo where

import Language.Haskell.TH.Syntax

data Bar a = Bar1 a (Bar a) | Bar2 String
  deriving Lift

Representation-polymorphic since template-haskell-2.16.0.0.

Minimal complete definition

liftTyped

Methods

lift :: Quote m => t -> m Exp Source

Turn a value into a Template Haskell expression, suitable for use in a splice.

default lift :: (r ~ 'BoxedRep 'Lifted, Quote m) => t -> m Exp Source

liftTyped :: Quote m => t -> Code m t Source

Turn a value into a Template Haskell typed expression, suitable for use in a typed splice.

Since: template-haskell-2.16.0.0

Instances
Instances details
Lift Addr# Source

Produces an Addr# literal from the NUL-terminated C-string starting at the given memory address.

Since: template-haskell-2.16.0.0

Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Addr# -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => Addr# -> Code m Addr# Source

Lift Double# Source

Since: template-haskell-2.16.0.0

Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Double# -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => Double# -> Code m Double# Source

Lift Float# Source

Since: template-haskell-2.16.0.0

Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Float# -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => Float# -> Code m Float# Source

Lift Int# Source

Since: template-haskell-2.16.0.0

Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Int# -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => Int# -> Code m Int# Source

Lift ByteArray Source

Since: template-haskell-2.19.0.0

Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => ByteArray -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => ByteArray -> Code m ByteArray Source

Lift Void Source

Since: template-haskell-2.15.0.0

Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Void -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => Void -> Code m Void Source

Lift Int16 Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Int16 -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => Int16 -> Code m Int16 Source

Lift Int32 Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Int32 -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => Int32 -> Code m Int32 Source

Lift Int64 Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Int64 -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => Int64 -> Code m Int64 Source

Lift Int8 Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Int8 -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => Int8 -> Code m Int8 Source

Lift Word16 Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Word16 -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => Word16 -> Code m Word16 Source

Lift Word32 Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Word32 -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => Word32 -> Code m Word32 Source

Lift Word64 Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Word64 -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => Word64 -> Code m Word64 Source

Lift Word8 Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Word8 -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => Word8 -> Code m Word8 Source

Lift Integer Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Integer -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => Integer -> Code m Integer Source

Lift Natural Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Natural -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => Natural -> Code m Natural Source

Lift () Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => () -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => () -> Code m () Source

Lift Bool Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Bool -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => Bool -> Code m Bool Source

Lift Char Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Char -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => Char -> Code m Char Source

Lift Double Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Double -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => Double -> Code m Double Source

Lift Float Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Float -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => Float -> Code m Float Source

Lift Int Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Int -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => Int -> Code m Int Source

Lift Word Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Word -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => Word -> Code m Word Source

Lift Char# Source

Since: template-haskell-2.16.0.0

Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Char# -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => Char# -> Code m Char# Source

Lift Word# Source

Since: template-haskell-2.16.0.0

Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Word# -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => Word# -> Code m Word# Source

Lift (# #) Source

Since: template-haskell-2.16.0.0

Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => (# #) -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => (# #) -> Code m (# #) Source

Integral a => Lift (Ratio a :: Type) Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Ratio a -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => Ratio a -> Code m (Ratio a) Source

Lift a => Lift (NonEmpty a :: Type) Source

Since: template-haskell-2.15.0.0

Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => NonEmpty a -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => NonEmpty a -> Code m (NonEmpty a) Source

Lift a => Lift (Maybe a :: Type) Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Maybe a -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => Maybe a -> Code m (Maybe a) Source

Lift a => Lift ([a] :: Type) Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => [a] -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => [a] -> Code m [a] Source

(Lift a, Lift b) => Lift (Either a b :: Type) Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Either a b -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => Either a b -> Code m (Either a b) Source

(Lift a, Lift b) => Lift ((a, b) :: Type) Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => (a, b) -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => (a, b) -> Code m (a, b) Source

(Lift a, Lift b, Lift c) => Lift ((a, b, c) :: Type) Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => (a, b, c) -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => (a, b, c) -> Code m (a, b, c) Source

(Lift a, Lift b, Lift c, Lift d) => Lift ((a, b, c, d) :: Type) Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => (a, b, c, d) -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => (a, b, c, d) -> Code m (a, b, c, d) Source

(Lift a, Lift b, Lift c, Lift d, Lift e) => Lift ((a, b, c, d, e) :: Type) Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => (a, b, c, d, e) -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => (a, b, c, d, e) -> Code m (a, b, c, d, e) Source

(Lift a, Lift b, Lift c, Lift d, Lift e, Lift f) => Lift ((a, b, c, d, e, f) :: Type) Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => (a, b, c, d, e, f) -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => (a, b, c, d, e, f) -> Code m (a, b, c, d, e, f) Source

(Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g) => Lift ((a, b, c, d, e, f, g) :: Type) Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => (a, b, c, d, e, f, g) -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => (a, b, c, d, e, f, g) -> Code m (a, b, c, d, e, f, g) Source

Lift a => Lift ((# a #) :: TYPE ('TupleRep '[LiftedRep])) Source

Since: template-haskell-2.16.0.0

Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => (# a #) -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => (# a #) -> Code m (# a #) Source

(Lift a, Lift b) => Lift ((# a | b #) :: TYPE ('SumRep '[LiftedRep, LiftedRep])) Source

Since: template-haskell-2.16.0.0

Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => (# a | b #) -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => (# a | b #) -> Code m (# a | b #) Source

(Lift a, Lift b) => Lift ((# a, b #) :: TYPE ('TupleRep '[LiftedRep, LiftedRep])) Source

Since: template-haskell-2.16.0.0

Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => (# a, b #) -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => (# a, b #) -> Code m (# a, b #) Source

(Lift a, Lift b, Lift c) => Lift ((# a | b | c #) :: TYPE ('SumRep '[LiftedRep, LiftedRep, LiftedRep])) Source

Since: template-haskell-2.16.0.0

Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => (# a | b | c #) -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => (# a | b | c #) -> Code m (# a | b | c #) Source

(Lift a, Lift b, Lift c) => Lift ((# a, b, c #) :: TYPE ('TupleRep '[LiftedRep, LiftedRep, LiftedRep])) Source

Since: template-haskell-2.16.0.0

Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => (# a, b, c #) -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => (# a, b, c #) -> Code m (# a, b, c #) Source

(Lift a, Lift b, Lift c, Lift d) => Lift ((# a | b | c | d #) :: TYPE ('SumRep '[LiftedRep, LiftedRep, LiftedRep, LiftedRep])) Source

Since: template-haskell-2.16.0.0

Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => (# a | b | c | d #) -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => (# a | b | c | d #) -> Code m (# a | b | c | d #) Source

(Lift a, Lift b, Lift c, Lift d) => Lift ((# a, b, c, d #) :: TYPE ('TupleRep '[LiftedRep, LiftedRep, LiftedRep, LiftedRep])) Source

Since: template-haskell-2.16.0.0

Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => (# a, b, c, d #) -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => (# a, b, c, d #) -> Code m (# a, b, c, d #) Source

(Lift a, Lift b, Lift c, Lift d, Lift e) => Lift ((# a | b | c | d | e #) :: TYPE ('SumRep '[LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep])) Source

Since: template-haskell-2.16.0.0

Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => (# a | b | c | d | e #) -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => (# a | b | c | d | e #) -> Code m (# a | b | c | d | e #) Source

(Lift a, Lift b, Lift c, Lift d, Lift e) => Lift ((# a, b, c, d, e #) :: TYPE ('TupleRep '[LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep])) Source

Since: template-haskell-2.16.0.0

Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => (# a, b, c, d, e #) -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => (# a, b, c, d, e #) -> Code m (# a, b, c, d, e #) Source

(Lift a, Lift b, Lift c, Lift d, Lift e, Lift f) => Lift ((# a | b | c | d | e | f #) :: TYPE ('SumRep '[LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep])) Source

Since: template-haskell-2.16.0.0

Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => (# a | b | c | d | e | f #) -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => (# a | b | c | d | e | f #) -> Code m (# a | b | c | d | e | f #) Source

(Lift a, Lift b, Lift c, Lift d, Lift e, Lift f) => Lift ((# a, b, c, d, e, f #) :: TYPE ('TupleRep '[LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep])) Source

Since: template-haskell-2.16.0.0

Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => (# a, b, c, d, e, f #) -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => (# a, b, c, d, e, f #) -> Code m (# a, b, c, d, e, f #) Source

(Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g) => Lift ((# a | b | c | d | e | f | g #) :: TYPE ('SumRep '[LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep])) Source

Since: template-haskell-2.16.0.0

Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => (# a | b | c | d | e | f | g #) -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => (# a | b | c | d | e | f | g #) -> Code m (# a | b | c | d | e | f | g #) Source

(Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g) => Lift ((# a, b, c, d, e, f, g #) :: TYPE ('TupleRep '[LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep])) Source

Since: template-haskell-2.16.0.0

Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => (# a, b, c, d, e, f, g #) -> m Exp Source

liftTyped :: forall (m :: Type -> Type). Quote m => (# a, b, c, d, e, f, g #) -> Code m (# a, b, c, d, e, f, g #) Source

newtype ModName Source

Constructors

Instances
Instances details
Data ModName Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModName -> c ModName Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ModName Source

toConstr :: ModName -> Constr Source

dataTypeOf :: ModName -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ModName) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModName) Source

gmapT :: (forall b. Data b => b -> b) -> ModName -> ModName Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModName -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModName -> r Source

gmapQ :: (forall d. Data d => d -> u) -> ModName -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> ModName -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModName -> m ModName Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModName -> m ModName Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModName -> m ModName Source

Generic ModName Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep ModName :: Type -> Type Source

Methods

from :: ModName -> Rep ModName x Source

to :: Rep ModName x -> ModName Source

Show ModName Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq ModName Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ord ModName Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep ModName Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep ModName = D1 ('MetaData "ModName" "Language.Haskell.TH.Syntax" "template-haskell" 'True) (C1 ('MetaCons "ModName" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)))

newtype PkgName Source

Constructors

Instances
Instances details
Data PkgName Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PkgName -> c PkgName Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PkgName Source

toConstr :: PkgName -> Constr Source

dataTypeOf :: PkgName -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PkgName) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PkgName) Source

gmapT :: (forall b. Data b => b -> b) -> PkgName -> PkgName Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PkgName -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PkgName -> r Source

gmapQ :: (forall d. Data d => d -> u) -> PkgName -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> PkgName -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PkgName -> m PkgName Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PkgName -> m PkgName Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PkgName -> m PkgName Source

Generic PkgName Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep PkgName :: Type -> Type Source

Methods

from :: PkgName -> Rep PkgName x Source

to :: Rep PkgName x -> PkgName Source

Show PkgName Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq PkgName Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ord PkgName Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep PkgName Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep PkgName = D1 ('MetaData "PkgName" "Language.Haskell.TH.Syntax" "template-haskell" 'True) (C1 ('MetaCons "PkgName" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)))

newtype OccName Source

Constructors

Instances
Instances details
Data OccName Source
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OccName -> c OccName Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OccName Source

toConstr :: OccName -> Constr Source

dataTypeOf :: OccName -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OccName) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OccName) Source

gmapT :: (forall b. Data b => b -> b) -> OccName -> OccName Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OccName -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OccName -> r Source

gmapQ :: (forall d. Data d => d -> u) -> OccName -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> OccName -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> OccName -> m OccName Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OccName -> m OccName Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OccName -> m OccName Source

Generic OccName Source
Instance details

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep OccName :: Type -> Type Source

Methods

from :: OccName -> Rep OccName x Source

to :: Rep OccName x -> OccName Source

Show OccName Source
Instance details

Defined in Language.Haskell.TH.Syntax

Eq OccName Source
Instance details

Defined in Language.Haskell.TH.Syntax

Ord OccName Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep OccName Source
Instance details

Defined in Language.Haskell.TH.Syntax

type Rep OccName = D1 ('MetaData "OccName" "Language.Haskell.TH.Syntax" "template-haskell" 'True) (C1 ('MetaCons "OccName" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)))

type CharPos Source

Arguments

= (Int, Int)

Line and character position

type StrictType = BangType Source

As of template-haskell-2.11.0.0, StrictType has been replaced by BangType.

type VarStrictType = VarBangType Source

As of template-haskell-2.11.0.0, VarStrictType has been replaced by VarBangType.

recover Source

Arguments

:: Q a

handler to invoke on failure

-> Q a

computation to run

-> Q a

Recover from errors raised by reportError or fail.

reportError :: String -> Q () Source

Report an error to the user, but allow the current splice's computation to carry on. To abort the computation, use fail.

runIO :: IO a -> Q a Source

The runIO function lets you run an I/O computation in the Q monad. Take care: you are guaranteed the ordering of calls to runIO within a single Q computation, but not about the order in which splices are run.

Note: for various murky reasons, stdout and stderr handles are not necessarily flushed when the compiler finishes running, so you should flush them yourself.

runQ :: Quasi m => Q a -> m a Source

reportWarning :: String -> Q () Source

Report a warning to the user, and carry on.

report :: Bool -> String -> Q () Source

Deprecated: Use reportError or reportWarning instead

Report an error (True) or warning (False), but carry on; use fail to stop.

location :: Q Loc Source

The location at which this computation is spliced.

reify :: Name -> Q Info Source

reify looks up information about the Name. It will fail with a compile error if the Name is not visible. A Name is visible if it is imported or defined in a prior top-level declaration group. See the documentation for newDeclarationGroup for more details.

It is sometimes useful to construct the argument name using lookupTypeName or lookupValueName to ensure that we are reifying from the right namespace. For instance, in this context:

data D = D

which D does reify (mkName "D") return information about? (Answer: D-the-type, but don't rely on it.) To ensure we get information about D-the-value, use lookupValueName:

do
  Just nm <- lookupValueName "D"
  reify nm

and to get information about D-the-type, use lookupTypeName.

reifyModule :: Module -> Q ModuleInfo Source

reifyModule mod looks up information about module mod. To look up the current module, call this function with the return value of thisModule.

newDeclarationGroup :: Q [Dec] Source

Template Haskell is capable of reifying information about types and terms defined in previous declaration groups. Top-level declaration splices break up declaration groups.

For an example, consider this code block. We define a datatype X and then try to call reify on the datatype.

module Check where

data X = X
    deriving Eq

$(do
    info <- reify ''X
    runIO $ print info
 )

This code fails to compile, noting that X is not available for reification at the site of reify. We can fix this by creating a new declaration group using an empty top-level splice:

data X = X
    deriving Eq

$(pure [])

$(do
    info <- reify ''X
    runIO $ print info
 )

We provide newDeclarationGroup as a means of documenting this behavior and providing a name for the pattern.

Since top level splices infer the presence of the $( ... ) brackets, we can also write:

data X = X
    deriving Eq

newDeclarationGroup

$(do
    info <- reify ''X
    runIO $ print info
 )

extsEnabled :: Q [Extension] Source

List all enabled language extensions.

isExtEnabled :: Extension -> Q Bool Source

Determine whether the given language extension is enabled in the Q monad.

lookupTypeName :: String -> Q (Maybe Name) Source

Look up the given name in the (type namespace of the) current splice's scope. See Language.Haskell.TH.Syntax for more details.

lookupValueName :: String -> Q (Maybe Name) Source

Look up the given name in the (value namespace of the) current splice's scope. See Language.Haskell.TH.Syntax for more details.

reifyFixity :: Name -> Q (Maybe Fixity) Source

reifyFixity nm attempts to find a fixity declaration for nm. For example, if the function foo has the fixity declaration infixr 7 foo, then reifyFixity 'foo would return Just (Fixity 7 InfixR). If the function bar does not have a fixity declaration, then reifyFixity 'bar returns Nothing, so you may assume bar has defaultFixity.

reifyType :: Name -> Q Type Source

reifyType nm attempts to find the type or kind of nm. For example, reifyType 'not returns Bool -> Bool, and reifyType ''Bool returns Type. This works even if there's no explicit signature and the type or kind is inferred.

reifyInstances :: Name -> [Type] -> Q [InstanceDec] Source

reifyInstances nm tys returns a list of visible instances of nm tys. That is, if nm is the name of a type class, then all instances of this class at the types tys are returned. Alternatively, if nm is the name of a data family or type family, all instances of this family at the types tys are returned.

Note that this is a "shallow" test; the declarations returned merely have instance heads which unify with nm tys, they need not actually be satisfiable.

  • reifyInstances ''Eq [ TupleT 2 `AppT` ConT ''A `AppT` ConT ''B ] contains the instance (Eq a, Eq b) => Eq (a, b) regardless of whether A and B themselves implement Eq
  • reifyInstances ''Show [ VarT (mkName "a") ] produces every available instance of Eq

There is one edge case: reifyInstances ''Typeable tys currently always produces an empty list (no matter what tys are given).

An instance is visible if it is imported or defined in a prior top-level declaration group. See the documentation for newDeclarationGroup for more details.

isInstance :: Name -> [Type] -> Q Bool Source

Is the list of instances returned by reifyInstances nonempty?

If you're confused by an instance not being visible despite being defined in the same module and above the splice in question, see the docs for newDeclarationGroup for a possible explanation.

reifyRoles :: Name -> Q [Role] Source

reifyRoles nm returns the list of roles associated with the parameters (both visible and invisible) of the tycon nm. Fails if nm cannot be found or is not a tycon. The returned list should never contain InferR.

An invisible parameter to a tycon is often a kind parameter. For example, if we have

type Proxy :: forall k. k -> Type
data Proxy a = MkProxy

and reifyRoles Proxy, we will get [NominalR, PhantomR]. The NominalR is the role of the invisible k parameter. Kind parameters are always nominal.

reifyAnnotations :: Data a => AnnLookup -> Q [a] Source

reifyAnnotations target returns the list of annotations associated with target. Only the annotations that are appropriately typed is returned. So if you have Int and String annotations for the same target, you have to call this function twice.

reifyConStrictness :: Name -> Q [DecidedStrictness] Source

reifyConStrictness nm looks up the strictness information for the fields of the constructor with the name nm. Note that the strictness information that reifyConStrictness returns may not correspond to what is written in the source code. For example, in the following data declaration:

data Pair a = Pair a a

reifyConStrictness would return [DecidedLazy, DecidedLazy] under most circumstances, but it would return [DecidedStrict, DecidedStrict] if the -XStrictData language extension was enabled.

unTypeCode :: forall (r :: RuntimeRep) (a :: TYPE r) m. Quote m => Code m a -> m Exp Source

Extract the untyped representation from the typed representation

unsafeCodeCoerce :: forall (r :: RuntimeRep) (a :: TYPE r) m. Quote m => m Exp -> Code m a Source

Unsafely convert an untyped code representation into a typed code representation.

hoistCode :: forall m n (r :: RuntimeRep) (a :: TYPE r). Monad m => (forall x. m x -> n x) -> Code m a -> Code n a Source

Modify the ambient monad used during code generation. For example, you can use hoistCode to handle a state effect: handleState :: Code (StateT Int Q) a -> Code Q a handleState = hoistCode (flip runState 0)

bindCode :: forall m a (r :: RuntimeRep) (b :: TYPE r). Monad m => m a -> (a -> Code m b) -> Code m b Source

Variant of (>>=) which allows effectful computations to be injected into code generation.

bindCode_ :: forall m a (r :: RuntimeRep) (b :: TYPE r). Monad m => m a -> Code m b -> Code m b Source

Variant of (>>) which allows effectful computations to be injected into code generation.

joinCode :: forall m (r :: RuntimeRep) (a :: TYPE r). Monad m => m (Code m a) -> Code m a Source

A useful combinator for embedding monadic actions into Code myCode :: ... => Code m a myCode = joinCode $ do x <- someSideEffect return (makeCodeWith x)

liftCode :: forall (r :: RuntimeRep) (a :: TYPE r) m. m (TExp a) -> Code m a Source

Lift a monadic action producing code into the typed Code representation

mkName :: String -> Name Source

Generate a capturable name. Occurrences of such names will be resolved according to the Haskell scoping rules at the occurrence site.

For example:

f = [| pi + $(varE (mkName "pi")) |]
...
g = let pi = 3 in $f

In this case, g is desugared to

g = Prelude.pi + 3

Note that mkName may be used with qualified names:

mkName "Prelude.pi"

See also dyn for a useful combinator. The above example could be rewritten using dyn as

f = [| pi + $(dyn "pi") |]

nameBase :: Name -> String Source

The name without its module prefix.

Examples
Expand
>>> nameBase ''Data.Either.Either
"Either"
>>> nameBase (mkName "foo")
"foo"
>>> nameBase (mkName "Module.foo")
"foo"

nameModule :: Name -> Maybe String Source

Module prefix of a name, if it exists.

Examples
Expand
>>> nameModule ''Data.Either.Either
Just "Data.Either"
>>> nameModule (mkName "foo")
Nothing
>>> nameModule (mkName "Module.foo")
Just "Module"

namePackage :: Name -> Maybe String Source

A name's package, if it exists.

Examples
Expand
>>> namePackage ''Data.Either.Either
Just "base"
>>> namePackage (mkName "foo")
Nothing
>>> namePackage (mkName "Module.foo")
Nothing

nameSpace :: Name -> Maybe NameSpace Source

Returns whether a name represents an occurrence of a top-level variable (VarName), data constructor (DataName), type constructor, or type class (TcClsName). If we can't be sure, it returns Nothing.

Examples
Expand
>>> nameSpace 'Prelude.id
Just VarName
>>> nameSpace (mkName "id")
Nothing -- only works for top-level variable names
>>> nameSpace 'Data.Maybe.Just
Just DataName
>>> nameSpace ''Data.Maybe.Maybe
Just TcClsName
>>> nameSpace ''Data.Ord.Ord
Just TcClsName

tupleTypeName :: Int -> Name Source

Tuple type constructor

tupleDataName :: Int -> Name Source

Tuple data constructor

unboxedTupleTypeName :: Int -> Name Source

Unboxed tuple type constructor

unboxedTupleDataName :: Int -> Name Source

Unboxed tuple data constructor

unboxedSumTypeName :: SumArity -> Name Source

Unboxed sum type constructor

unboxedSumDataName :: SumAlt -> SumArity -> Name Source

Unboxed sum data constructor

defaultFixity :: Fixity Source

Default fixity: infixl 9

maxPrecedence :: Int Source

Highest allowed operator precedence for Fixity constructor (answer: 9)

putDoc :: DocLoc -> String -> Q () Source

Add Haddock documentation to the specified location. This will overwrite any documentation at the location if it already exists. This will reify the specified name, so it must be in scope when you call it. If you want to add documentation to something that you are currently splicing, you can use addModFinalizer e.g.

do
  let nm = mkName "x"
  addModFinalizer $ putDoc (DeclDoc nm) "Hello"
  [d| $(varP nm) = 42 |]

The helper functions withDecDoc and withDecsDoc will do this for you, as will the funD_doc and other _doc combinators. You most likely want to have the -haddock flag turned on when using this. Adding documentation to anything outside of the current module will cause an error.

getDoc :: DocLoc -> Q (Maybe String) Source

Retreives the Haddock documentation at the specified location, if one exists. It can be used to read documentation on things defined outside of the current module, provided that those modules were compiled with the -haddock flag.

showName' :: NameIs -> Name -> String Source

dataToQa :: forall m a k q. (Quote m, Data a) => (Name -> k) -> (Lit -> m q) -> (k -> [m q] -> m q) -> (forall b. Data b => b -> Maybe (m q)) -> a -> m q Source

dataToQa is an internal utility function for constructing generic conversion functions from types with Data instances to various quasi-quoting representations. See the source of dataToExpQ and dataToPatQ for two example usages: mkCon, mkLit and appQ are overloadable to account for different syntax for expressions and patterns; antiQ allows you to override type-specific cases, a common usage is just const Nothing, which results in no overloading.

dataToExpQ :: (Quote m, Data a) => (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp Source

dataToExpQ converts a value to a Exp representation of the same value, in the SYB style. It is generalized to take a function override type-specific cases; see liftData for a more commonly used variant.

dataToPatQ :: (Quote m, Data a) => (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat Source

dataToPatQ converts a value to a Pat representation of the same value, in the SYB style. It takes a function to handle type-specific cases, alternatively, pass const Nothing to get default behavior.

newNameIO :: String -> IO Name Source

badIO :: String -> IO a Source

counter :: IORef Uniq Source

mkNameU :: String -> Uniq -> Name Source

Only used internally

unTypeQ :: forall (r :: RuntimeRep) (a :: TYPE r) m. Quote m => m (TExp a) -> m Exp Source

Discard the type annotation and produce a plain Template Haskell expression

Representation-polymorphic since template-haskell-2.16.0.0.

unsafeTExpCoerce :: forall (r :: RuntimeRep) (a :: TYPE r) m. Quote m => m Exp -> m (TExp a) Source

Annotate the Template Haskell expression with a type

This is unsafe because GHC cannot check for you that the expression really does have the type you claim it has.

Representation-polymorphic since template-haskell-2.16.0.0.

lookupName :: Bool -> String -> Q (Maybe Name) Source

getPackageRoot :: Q FilePath Source

Get the package root for the current package which is being compiled. This can be set explicitly with the -package-root flag but is normally just the current working directory.

The motivation for this flag is to provide a principled means to remove the assumption from splices that they will be executed in the directory where the cabal file resides. Projects such as haskell-language-server can't and don't change directory when compiling files but instead set the -package-root flag appropiately.

makeRelativeToProject :: FilePath -> Q FilePath Source

The input is a filepath, which if relative is offset by the package root.

addDependentFile :: FilePath -> Q () Source

Record external files that runIO is using (dependent upon). The compiler can then recognize that it should re-compile the Haskell file when an external file changes.

Expects an absolute file path.

Notes:

  • ghc -M does not know about these dependencies - it does not execute TH.
  • The dependency is based on file content, not a modification time

addTempFile :: String -> Q FilePath Source

Obtain a temporary file path with the given suffix. The compiler will delete this file after compilation.

addTopDecls :: [Dec] -> Q () Source

Add additional top-level declarations. The added declarations will be type checked along with the current declaration group.

addForeignFile :: ForeignSrcLang -> String -> Q () Source

Deprecated: Use addForeignSource instead

addForeignSource :: ForeignSrcLang -> String -> Q () Source

Emit a foreign file which will be compiled and linked to the object for the current module. Currently only languages that can be compiled with the C compiler are supported, and the flags passed as part of -optc will be also applied to the C compiler invocation that will compile them.

Note that for non-C languages (for example C++) extern C directives must be used to get symbols that we can access from Haskell.

To get better errors, it is recommended to use #line pragmas when emitting C files, e.g.

{-# LANGUAGE CPP #-}
...
addForeignSource LangC $ unlines
  [ "#line " ++ show (803 + 1) ++ " " ++ show "libraries/template-haskell/Language/Haskell/TH/Syntax.hs"
  , ...
  ]

addForeignFilePath :: ForeignSrcLang -> FilePath -> Q () Source

Same as addForeignSource, but expects to receive a path pointing to the foreign file instead of a String of its contents. Consider using this in conjunction with addTempFile.

This is a good alternative to addForeignSource when you are trying to directly link in an object file.

addModFinalizer :: Q () -> Q () Source

Add a finalizer that will run in the Q monad after the current module has been type checked. This only makes sense when run within a top-level splice.

The finalizer is given the local type environment at the splice point. Thus reify is able to find the local definitions when executed inside the finalizer.

addCorePlugin :: String -> Q () Source

Adds a core plugin to the compilation pipeline.

addCorePlugin m has almost the same effect as passing -fplugin=m to ghc in the command line. The major difference is that the plugin module m must not belong to the current package. When TH executes, it is too late to tell the compiler that we needed to compile first a plugin module in the current package.

getQ :: Typeable a => Q (Maybe a) Source

Get state from the Q monad. Note that the state is local to the Haskell module in which the Template Haskell expression is executed.

putQ :: Typeable a => a -> Q () Source

Replace the state in the Q monad. Note that the state is local to the Haskell module in which the Template Haskell expression is executed.

sequenceQ :: forall m. Monad m => forall a. [m a] -> m [a] Source

trueName :: Name Source

falseName :: Name Source

addrToByteArrayName :: Name Source

mkNameG_v :: String -> String -> String -> Name Source

addrToByteArray :: Int -> Addr# -> ByteArray Source

nothingName :: Name Source

justName :: Name Source

leftName :: Name Source

rightName :: Name Source

liftString :: Quote m => String -> m Exp Source

nonemptyName :: Name Source

mkNameG :: NameSpace -> String -> String -> String -> Name Source

Used for 'x etc, but not available to the programmer

oneName :: Name Source

manyName :: Name Source

mkOccName :: String -> OccName Source

mkPkgName :: String -> PkgName Source

mkModName :: String -> ModName Source

mkNameG_d :: String -> String -> String -> Name Source

showName :: Name -> String Source

liftData :: (Quote m, Data a) => a -> m Exp Source

liftData is a variant of lift in the Lift type class which works for any type with a Data instance.

modString :: ModName -> String Source

pkgString :: PkgName -> String Source

occString :: OccName -> String Source

thenCmp :: Ordering -> Ordering -> Ordering Source

mkNameL :: String -> Uniq -> Name Source

Only used internally

mkNameS :: String -> Name Source

mkNameG_tc :: String -> String -> String -> Name Source

mk_tup_name :: Int -> NameSpace -> Bool -> Name Source

eqBytes :: Bytes -> Bytes -> Bool Source

compareBytes :: Bytes -> Bytes -> Ordering Source

memcmp :: Ptr a -> Ptr b -> CSize -> IO CInt Source

cmpEq :: Ordering -> Bool Source

Language extensions

module Language.Haskell.TH.LanguageExtensions

data ForeignSrcLang Source

Foreign formats supported by GHC via TH

Constructors

LangC

C

LangCxx

C++

LangObjc

Objective C

LangObjcxx

Objective C++

LangAsm

Assembly language (.s)

RawObject

Object (.o)

Instances
Instances details
Generic ForeignSrcLang
Instance details

Defined in GHC.ForeignSrcLang.Type

Associated Types

type Rep ForeignSrcLang :: Type -> Type Source

Show ForeignSrcLang
Instance details

Defined in GHC.ForeignSrcLang.Type

Eq ForeignSrcLang
Instance details

Defined in GHC.ForeignSrcLang.Type

type Rep ForeignSrcLang
Instance details

Defined in GHC.ForeignSrcLang.Type

type Rep ForeignSrcLang = D1 ('MetaData "ForeignSrcLang" "GHC.ForeignSrcLang.Type" "ghc-boot-th-9.4.2" 'False) ((C1 ('MetaCons "LangC" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "LangCxx" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "LangObjc" 'PrefixI 'False) (U1 :: Type -> Type))) :+: (C1 ('MetaCons "LangObjcxx" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "LangAsm" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "RawObject" 'PrefixI 'False) (U1 :: Type -> Type))))

© The University of Glasgow and others
Licensed under a BSD-style license (see top of the page).
https://downloads.haskell.org/~ghc/9.4.2/docs/libraries/template-haskell-2.19.0.0/Language-Haskell-TH-Syntax.html