template-haskell-2.13.0.0: Support library for Template Haskell

Safe HaskellSafe
LanguageHaskell2010

Language.Haskell.TH

Contents

Description

The public face of Template Haskell

For other documentation, refer to: http://www.haskell.org/haskellwiki/Template_Haskell

Synopsis

The monad and its operations

data Q a Source #

Instances
Monad Q # 
Instance details

Methods

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

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

return :: a -> Q a Source #

fail :: String -> Q a Source #

Functor Q # 
Instance details

Methods

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

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

MonadFail Q # 
Instance details

Methods

fail :: String -> Q a Source #

Applicative Q # 
Instance details

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 #

MonadIO Q # 
Instance details

Methods

liftIO :: IO a -> Q a Source #

Quasi Q # 
Instance details

runQ :: Quasi m => Q a -> m a Source #

Administration: errors, locations and IO

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.

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.

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.

location :: Q Loc Source #

The location at which this computation is spliced.

data Loc Source #

Instances
Eq Loc # 
Instance details

Methods

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

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

Data Loc # 
Instance details

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 :: (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 #

Ord Loc # 
Instance details

Methods

compare :: Loc -> Loc -> Ordering #

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

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

(>) :: Loc -> Loc -> Bool #

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

max :: Loc -> Loc -> Loc #

min :: Loc -> Loc -> Loc #

Show Loc # 
Instance details
Generic Loc # 
Instance details

Associated Types

type Rep Loc :: * -> * Source #

Methods

from :: Loc -> Rep Loc x Source #

to :: Rep Loc x -> Loc Source #

Ppr Loc # 
Instance details

Methods

ppr :: Loc -> Doc Source #

ppr_list :: [Loc] -> Doc Source #

type Rep Loc # 
Instance details

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.

Querying the compiler

Reify

reify :: Name -> Q Info Source #

reify looks up information about the Name.

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.

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

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
Eq Info # 
Instance details

Methods

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

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

Data Info # 
Instance details

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 :: (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 #

Ord Info # 
Instance details

Methods

compare :: Info -> Info -> Ordering #

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

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

(>) :: Info -> Info -> Bool #

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

max :: Info -> Info -> Info #

min :: Info -> Info -> Info #

Show Info # 
Instance details
Generic Info # 
Instance details

Associated Types

type Rep Info :: * -> * Source #

Methods

from :: Info -> Rep Info x Source #

to :: Rep Info x -> Info Source #

Ppr Info # 
Instance details

Methods

ppr :: Info -> Doc Source #

ppr_list :: [Info] -> Doc Source #

type Rep Info # 
Instance details
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
Eq ModuleInfo # 
Instance details
Data ModuleInfo # 
Instance details

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 :: (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 #

Ord ModuleInfo # 
Instance details
Show ModuleInfo # 
Instance details
Generic ModuleInfo # 
Instance details

Associated Types

type Rep ModuleInfo :: * -> * Source #

Ppr ModuleInfo # 
Instance details
type Rep ModuleInfo # 
Instance details
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 desribes 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

type Unlifted = Bool Source #

In PrimTyConI, is the type constructor unlifted?

Language extension lookup

data Extension :: * Source #

The language extensions known to GHC.

Note that there is an orphan Binary instance for this type supplied by the GHC.LanguageExtensions module provided by ghc-boot. We can't provide here as this would require adding transitive dependencies to the template-haskell package, which must have a minimal dependency set.

Constructors

Cpp 
OverlappingInstances 
UndecidableInstances 
IncoherentInstances 
UndecidableSuperClasses 
MonomorphismRestriction 
MonoPatBinds 
MonoLocalBinds 
RelaxedPolyRec 
ExtendedDefaultRules 
ForeignFunctionInterface 
UnliftedFFITypes 
InterruptibleFFI 
CApiFFI 
GHCForeignImportPrim 
JavaScriptFFI 
ParallelArrays 
Arrows 
TemplateHaskell 
TemplateHaskellQuotes 
QuasiQuotes 
ImplicitParams 
ImplicitPrelude 
ScopedTypeVariables 
AllowAmbiguousTypes 
UnboxedTuples 
UnboxedSums 
BangPatterns 
TypeFamilies 
TypeFamilyDependencies 
TypeInType 
OverloadedStrings 
OverloadedLists 
NumDecimals 
DisambiguateRecordFields 
RecordWildCards 
RecordPuns 
ViewPatterns 
GADTs 
GADTSyntax 
NPlusKPatterns 
DoAndIfThenElse 
RebindableSyntax 
ConstraintKinds 
PolyKinds 
DataKinds 
InstanceSigs 
ApplicativeDo 
StandaloneDeriving 
DeriveDataTypeable 
AutoDeriveTypeable 
DeriveFunctor 
DeriveTraversable 
DeriveFoldable 
DeriveGeneric 
DefaultSignatures 
DeriveAnyClass 
DeriveLift 
DerivingStrategies 
TypeSynonymInstances 
FlexibleContexts 
FlexibleInstances 
ConstrainedClassMethods 
MultiParamTypeClasses 
NullaryTypeClasses 
FunctionalDependencies 
UnicodeSyntax 
ExistentialQuantification 
MagicHash 
EmptyDataDecls 
KindSignatures 
RoleAnnotations 
ParallelListComp 
TransformListComp 
MonadComprehensions 
GeneralizedNewtypeDeriving 
RecursiveDo 
PostfixOperators 
TupleSections 
PatternGuards 
LiberalTypeSynonyms 
RankNTypes 
ImpredicativeTypes 
TypeOperators 
ExplicitNamespaces 
PackageImports 
ExplicitForAll 
AlternativeLayoutRule 
AlternativeLayoutRuleTransitional 
DatatypeContexts 
NondecreasingIndentation 
RelaxedLayout 
TraditionalRecordSyntax 
LambdaCase 
MultiWayIf 
BinaryLiterals 
NegativeLiterals 
HexFloatLiterals 
DuplicateRecordFields 
OverloadedLabels 
EmptyCase 
PatternSynonyms 
PartialTypeSignatures 
NamedWildCards 
StaticPointers 
TypeApplications 
Strict 
StrictData 
MonadFailDesugaring 
EmptyDataDeriving 
Instances
Enum Extension 
Instance details
Eq Extension 
Instance details
Show Extension 
Instance details
Generic Extension 
Instance details

Associated Types

type Rep Extension :: * -> * Source #

type Rep Extension 
Instance details
type Rep Extension = D1 (MetaData "Extension" "GHC.LanguageExtensions.Type" "ghc-boot-th-8.4.0.20171214" False) ((((((C1 (MetaCons "Cpp" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "OverlappingInstances" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "UndecidableInstances" PrefixI False) (U1 :: * -> *))) :+: (C1 (MetaCons "IncoherentInstances" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "UndecidableSuperClasses" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "MonomorphismRestriction" PrefixI False) (U1 :: * -> *)))) :+: ((C1 (MetaCons "MonoPatBinds" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "MonoLocalBinds" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "RelaxedPolyRec" PrefixI False) (U1 :: * -> *))) :+: ((C1 (MetaCons "ExtendedDefaultRules" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "ForeignFunctionInterface" PrefixI False) (U1 :: * -> *)) :+: (C1 (MetaCons "UnliftedFFITypes" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "InterruptibleFFI" PrefixI False) (U1 :: * -> *))))) :+: (((C1 (MetaCons "CApiFFI" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "GHCForeignImportPrim" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "JavaScriptFFI" PrefixI False) (U1 :: * -> *))) :+: ((C1 (MetaCons "ParallelArrays" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "Arrows" PrefixI False) (U1 :: * -> *)) :+: (C1 (MetaCons "TemplateHaskell" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "TemplateHaskellQuotes" PrefixI False) (U1 :: * -> *)))) :+: ((C1 (MetaCons "QuasiQuotes" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "ImplicitParams" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "ImplicitPrelude" PrefixI False) (U1 :: * -> *))) :+: ((C1 (MetaCons "ScopedTypeVariables" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "AllowAmbiguousTypes" PrefixI False) (U1 :: * -> *)) :+: (C1 (MetaCons "UnboxedTuples" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "UnboxedSums" PrefixI False) (U1 :: * -> *)))))) :+: ((((C1 (MetaCons "BangPatterns" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "TypeFamilies" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "TypeFamilyDependencies" PrefixI False) (U1 :: * -> *))) :+: ((C1 (MetaCons "TypeInType" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "OverloadedStrings" PrefixI False) (U1 :: * -> *)) :+: (C1 (MetaCons "OverloadedLists" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "NumDecimals" PrefixI False) (U1 :: * -> *)))) :+: ((C1 (MetaCons "DisambiguateRecordFields" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "RecordWildCards" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "RecordPuns" PrefixI False) (U1 :: * -> *))) :+: ((C1 (MetaCons "ViewPatterns" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "GADTs" PrefixI False) (U1 :: * -> *)) :+: (C1 (MetaCons "GADTSyntax" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "NPlusKPatterns" PrefixI False) (U1 :: * -> *))))) :+: (((C1 (MetaCons "DoAndIfThenElse" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "RebindableSyntax" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "ConstraintKinds" PrefixI False) (U1 :: * -> *))) :+: ((C1 (MetaCons "PolyKinds" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "DataKinds" PrefixI False) (U1 :: * -> *)) :+: (C1 (MetaCons "InstanceSigs" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "ApplicativeDo" PrefixI False) (U1 :: * -> *)))) :+: ((C1 (MetaCons "StandaloneDeriving" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "DeriveDataTypeable" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "AutoDeriveTypeable" PrefixI False) (U1 :: * -> *))) :+: ((C1 (MetaCons "DeriveFunctor" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "DeriveTraversable" PrefixI False) (U1 :: * -> *)) :+: (C1 (MetaCons "DeriveFoldable" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "DeriveGeneric" PrefixI False) (U1 :: * -> *))))))) :+: (((((C1 (MetaCons "DefaultSignatures" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "DeriveAnyClass" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "DeriveLift" PrefixI False) (U1 :: * -> *))) :+: (C1 (MetaCons "DerivingStrategies" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "TypeSynonymInstances" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "FlexibleContexts" PrefixI False) (U1 :: * -> *)))) :+: ((C1 (MetaCons "FlexibleInstances" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "ConstrainedClassMethods" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "MultiParamTypeClasses" PrefixI False) (U1 :: * -> *))) :+: ((C1 (MetaCons "NullaryTypeClasses" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "FunctionalDependencies" PrefixI False) (U1 :: * -> *)) :+: (C1 (MetaCons "UnicodeSyntax" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "ExistentialQuantification" PrefixI False) (U1 :: * -> *))))) :+: (((C1 (MetaCons "MagicHash" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "EmptyDataDecls" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "KindSignatures" PrefixI False) (U1 :: * -> *))) :+: ((C1 (MetaCons "RoleAnnotations" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "ParallelListComp" PrefixI False) (U1 :: * -> *)) :+: (C1 (MetaCons "TransformListComp" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "MonadComprehensions" PrefixI False) (U1 :: * -> *)))) :+: ((C1 (MetaCons "GeneralizedNewtypeDeriving" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "RecursiveDo" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "PostfixOperators" PrefixI False) (U1 :: * -> *))) :+: ((C1 (MetaCons "TupleSections" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "PatternGuards" PrefixI False) (U1 :: * -> *)) :+: (C1 (MetaCons "LiberalTypeSynonyms" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "RankNTypes" PrefixI False) (U1 :: * -> *)))))) :+: ((((C1 (MetaCons "ImpredicativeTypes" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "TypeOperators" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "ExplicitNamespaces" PrefixI False) (U1 :: * -> *))) :+: ((C1 (MetaCons "PackageImports" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "ExplicitForAll" PrefixI False) (U1 :: * -> *)) :+: (C1 (MetaCons "AlternativeLayoutRule" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "AlternativeLayoutRuleTransitional" PrefixI False) (U1 :: * -> *)))) :+: ((C1 (MetaCons "DatatypeContexts" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "NondecreasingIndentation" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "RelaxedLayout" PrefixI False) (U1 :: * -> *))) :+: ((C1 (MetaCons "TraditionalRecordSyntax" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "LambdaCase" PrefixI False) (U1 :: * -> *)) :+: (C1 (MetaCons "MultiWayIf" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "BinaryLiterals" PrefixI False) (U1 :: * -> *))))) :+: (((C1 (MetaCons "NegativeLiterals" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "HexFloatLiterals" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "DuplicateRecordFields" PrefixI False) (U1 :: * -> *))) :+: ((C1 (MetaCons "OverloadedLabels" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "EmptyCase" PrefixI False) (U1 :: * -> *)) :+: (C1 (MetaCons "PatternSynonyms" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "PartialTypeSignatures" PrefixI False) (U1 :: * -> *)))) :+: ((C1 (MetaCons "NamedWildCards" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "StaticPointers" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "TypeApplications" PrefixI False) (U1 :: * -> *))) :+: ((C1 (MetaCons "Strict" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "StrictData" PrefixI False) (U1 :: * -> *)) :+: (C1 (MetaCons "MonadFailDesugaring" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "EmptyDataDeriving" PrefixI False) (U1 :: * -> *))))))))

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.

Name lookup

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.

Fixity lookup

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.

Instance lookup

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.

isInstance :: Name -> [Type] -> Q Bool Source #

Is the list of instances returned by reifyInstances nonempty?

Roles lookup

reifyRoles :: Name -> Q [Role] Source #

reifyRoles nm returns the list of roles associated with the parameters of the tycon nm. Fails if nm cannot be found or is not a tycon. The returned list should never contain InferR.

Annotation lookup

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.

data AnnLookup Source #

Annotation target for reifyAnnotations

Instances
Eq AnnLookup # 
Instance details
Data AnnLookup # 
Instance details

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 :: (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 #

Ord AnnLookup # 
Instance details
Show AnnLookup # 
Instance details
Generic AnnLookup # 
Instance details

Associated Types

type Rep AnnLookup :: * -> * Source #

type Rep AnnLookup # 
Instance details
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)))

Constructor strictness lookup

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.

Typed expressions

data TExp a Source #

Names

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.

Instances
Eq Name # 
Instance details

Methods

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

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

Data Name # 
Instance details

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 :: (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 #

Ord Name # 
Instance details

Methods

compare :: Name -> Name -> Ordering #

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

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

(>) :: Name -> Name -> Bool #

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

max :: Name -> Name -> Name #

min :: Name -> Name -> Name #

Show Name # 
Instance details
Generic Name # 
Instance details

Associated Types

type Rep Name :: * -> * Source #

Methods

from :: Name -> Rep Name x Source #

to :: Rep Name x -> Name Source #

Ppr Name # 
Instance details

Methods

ppr :: Name -> Doc Source #

ppr_list :: [Name] -> Doc Source #

type Rep Name # 
Instance details

data NameSpace Source #

Instances
Eq NameSpace # 
Instance details
Data NameSpace # 
Instance details

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 :: (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 #

Ord NameSpace # 
Instance details
Show NameSpace # 
Instance details
Generic NameSpace # 
Instance details

Associated Types

type Rep NameSpace :: * -> * Source #

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

Constructing names

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") |]

newName :: String -> Q 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.

Deconstructing names

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

Built-in names

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

The algebraic data types

The lowercase versions (syntax operators) of these constructors are preferred to these constructors, since they compose better with quotations ([| |]) and splices ($( ... ))

Declarations

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 }
ForeignD Foreign
{ foreign import ... }
{ foreign export ... }
InfixD Fixity Name
{ infix 3 foo }
PragmaD Pragma
{ {-# INLINE [1] foo #-} }
DataFamilyD Name [TyVarBndr] (Maybe Kind)
{ data family T a b c :: * }
DataInstD Cxt Name [Type] (Maybe Kind) [Con] [DerivClause]
{ data instance Cxt x => T [x]
       = A x | B (T x)
       deriving (Z,W)
       deriving stock Eq }
NewtypeInstD Cxt Name [Type] (Maybe Kind) Con [DerivClause]
{ newtype instance Cxt x => T [x]
        = A (B x)
        deriving (Z,W)
        deriving stock Eq }
TySynInstD Name TySynEqn
{ type instance ... }
OpenTypeFamilyD TypeFamilyHead
{ type family T a b c = (r :: *) | r -> a b }
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 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.

Instances
Eq Dec # 
Instance details

Methods

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

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

Data Dec # 
Instance details

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 :: (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 #

Ord Dec # 
Instance details

Methods

compare :: Dec -> Dec -> Ordering #

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

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

(>) :: Dec -> Dec -> Bool #

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

max :: Dec -> Dec -> Dec #

min :: Dec -> Dec -> Dec #

Show Dec # 
Instance details
Generic Dec # 
Instance details

Associated Types

type Rep Dec :: * -> * Source #

Methods

from :: Dec -> Rep Dec x Source #

to :: Rep Dec x -> Dec Source #

Ppr Dec # 
Instance details

Methods

ppr :: Dec -> Doc Source #

ppr_list :: [Dec] -> Doc Source #

type Rep Dec # 
Instance details
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 "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 "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 Name) :*: 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 Name) :*: 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 Name) :*: 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)))))))

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.

Constructors

NormalC Name [BangType]
C Int a
RecC Name [VarBangType]
C { v :: Int, w :: a }
InfixC BangType Name BangType
Int :+ a
ForallC [TyVarBndr] 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
Eq Con # 
Instance details

Methods

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

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

Data Con # 
Instance details

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 :: (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 #

Ord Con # 
Instance details

Methods

compare :: Con -> Con -> Ordering #

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

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

(>) :: Con -> Con -> Bool #

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

max :: Con -> Con -> Con #

min :: Con -> Con -> Con #

Show Con # 
Instance details
Generic Con # 
Instance details

Associated Types

type Rep Con :: * -> * Source #

Methods

from :: Con -> Rep Con x Source #

to :: Rep Con x -> Con Source #

Ppr Con # 
Instance details

Methods

ppr :: Con -> Doc Source #

ppr_list :: [Con] -> Doc Source #

type Rep Con # 
Instance details
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]) :*: (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))))))

data Clause Source #

Constructors

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

Methods

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

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

Data Clause # 
Instance details

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 :: (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 #

Ord Clause # 
Instance details
Show Clause # 
Instance details
Generic Clause # 
Instance details

Associated Types

type Rep Clause :: * -> * Source #

Ppr Clause # 
Instance details

Methods

ppr :: Clause -> Doc Source #

ppr_list :: [Clause] -> Doc Source #

type Rep Clause # 
Instance details

data SourceUnpackedness Source #

Constructors

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

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 :: (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 #

Ord SourceUnpackedness # 
Instance details
Show SourceUnpackedness # 
Instance details
Generic SourceUnpackedness # 
Instance details

Associated Types

type Rep SourceUnpackedness :: * -> * Source #

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

data SourceStrictness Source #

Constructors

NoSourceStrictness
C a
SourceLazy
C {~}a
SourceStrict
C {!}a
Instances
Eq SourceStrictness # 
Instance details
Data SourceStrictness # 
Instance details

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 :: (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 #

Ord SourceStrictness # 
Instance details
Show SourceStrictness # 
Instance details
Generic SourceStrictness # 
Instance details

Associated Types

type Rep SourceStrictness :: * -> * Source #

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

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
Eq DecidedStrictness # 
Instance details
Data DecidedStrictness # 
Instance details

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 :: (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 #

Ord DecidedStrictness # 
Instance details
Show DecidedStrictness # 
Instance details
Generic DecidedStrictness # 
Instance details

Associated Types

type Rep DecidedStrictness :: * -> * Source #

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

data Bang Source #

Constructors

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

Methods

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

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

Data Bang # 
Instance details

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 :: (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 #

Ord Bang # 
Instance details

Methods

compare :: Bang -> Bang -> Ordering #

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

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

(>) :: Bang -> Bang -> Bool #

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

max :: Bang -> Bang -> Bang #

min :: Bang -> Bang -> Bang #

Show Bang # 
Instance details
Generic Bang # 
Instance details

Associated Types

type Rep Bang :: * -> * Source #

Methods

from :: Bang -> Rep Bang x Source #

to :: Rep Bang x -> Bang Source #

Ppr Bang # 
Instance details

Methods

ppr :: Bang -> Doc Source #

ppr_list :: [Bang] -> Doc Source #

type Rep Bang # 
Instance details

type Strict = Bang Source #

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

data Foreign Source #

Instances
Eq Foreign # 
Instance details

Methods

(==) :: Foreign -> Foreign -> Bool #

(/=) :: Foreign -> Foreign -> Bool #

Data Foreign # 
Instance details

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 :: (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 #

Ord Foreign # 
Instance details
Show Foreign # 
Instance details
Generic Foreign # 
Instance details

Associated Types

type Rep Foreign :: * -> * Source #

Ppr Foreign # 
Instance details
type Rep Foreign # 
Instance details

data Callconv Source #

Constructors

CCall 
StdCall 
CApi 
Prim 
JavaScript 
Instances
Eq Callconv # 
Instance details
Data Callconv # 
Instance details

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 :: (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 #

Ord Callconv # 
Instance details
Show Callconv # 
Instance details
Generic Callconv # 
Instance details

Associated Types

type Rep Callconv :: * -> * Source #

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

data Safety Source #

Constructors

Unsafe 
Safe 
Interruptible 
Instances
Eq Safety # 
Instance details

Methods

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

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

Data Safety # 
Instance details

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 :: (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 #

Ord Safety # 
Instance details
Show Safety # 
Instance details
Generic Safety # 
Instance details

Associated Types

type Rep Safety :: * -> * Source #

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

data Pragma Source #

Instances
Eq Pragma # 
Instance details

Methods

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

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

Data Pragma # 
Instance details

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 :: (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 #

Ord Pragma # 
Instance details
Show Pragma # 
Instance details
Generic Pragma # 
Instance details

Associated Types

type Rep Pragma :: * -> * Source #

Ppr Pragma # 
Instance details

Methods

ppr :: Pragma -> Doc Source #

ppr_list :: [Pragma] -> Doc Source #

type Rep Pragma # 
Instance details
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 "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 [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

NoInline 
Inline 
Inlinable 
Instances
Eq Inline # 
Instance details

Methods

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

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

Data Inline # 
Instance details

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 :: (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 #

Ord Inline # 
Instance details
Show Inline # 
Instance details
Generic Inline # 
Instance details

Associated Types

type Rep Inline :: * -> * Source #

Ppr Inline # 
Instance details

Methods

ppr :: Inline -> Doc Source #

ppr_list :: [Inline] -> Doc Source #

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

data RuleMatch Source #

Constructors

ConLike 
FunLike 
Instances
Eq RuleMatch # 
Instance details
Data RuleMatch # 
Instance details

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 :: (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 #

Ord RuleMatch # 
Instance details
Show RuleMatch # 
Instance details
Generic RuleMatch # 
Instance details

Associated Types

type Rep RuleMatch :: * -> * Source #

Ppr RuleMatch # 
Instance details
type Rep RuleMatch # 
Instance details
type Rep RuleMatch = D1 (MetaData "RuleMatch" "Language.Haskell.TH.Syntax" "template-haskell" False) (C1 (MetaCons "ConLike" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "FunLike" PrefixI False) (U1 :: * -> *))

data Phases Source #

Instances
Eq Phases # 
Instance details

Methods

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

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

Data Phases # 
Instance details

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 :: (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 #

Ord Phases # 
Instance details
Show Phases # 
Instance details
Generic Phases # 
Instance details

Associated Types

type Rep Phases :: * -> * Source #

Ppr Phases # 
Instance details

Methods

ppr :: Phases -> Doc Source #

ppr_list :: [Phases] -> Doc Source #

type Rep Phases # 
Instance details
type Rep Phases = D1 (MetaData "Phases" "Language.Haskell.TH.Syntax" "template-haskell" False) (C1 (MetaCons "AllPhases" PrefixI False) (U1 :: * -> *) :+: (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
Eq RuleBndr # 
Instance details
Data RuleBndr # 
Instance details

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 :: (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 #

Ord RuleBndr # 
Instance details
Show RuleBndr # 
Instance details
Generic RuleBndr # 
Instance details

Associated Types

type Rep RuleBndr :: * -> * Source #

Ppr RuleBndr # 
Instance details
type Rep RuleBndr # 
Instance details

data AnnTarget Source #

Instances
Eq AnnTarget # 
Instance details
Data AnnTarget # 
Instance details

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 :: (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 #

Ord AnnTarget # 
Instance details
Show AnnTarget # 
Instance details
Generic AnnTarget # 
Instance details

Associated Types

type Rep AnnTarget :: * -> * Source #

type Rep AnnTarget # 
Instance details
type Rep AnnTarget = D1 (MetaData "AnnTarget" "Language.Haskell.TH.Syntax" "template-haskell" False) (C1 (MetaCons "ModuleAnnotation" PrefixI False) (U1 :: * -> *) :+: (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

FunDep [Name] [Name] 
Instances
Eq FunDep # 
Instance details

Methods

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

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

Data FunDep # 
Instance details

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 :: (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 #

Ord FunDep # 
Instance details
Show FunDep # 
Instance details
Generic FunDep # 
Instance details

Associated Types

type Rep FunDep :: * -> * Source #

Ppr FunDep # 
Instance details

Methods

ppr :: FunDep -> Doc Source #

ppr_list :: [FunDep] -> Doc Source #

type Rep FunDep # 
Instance details

data TySynEqn Source #

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

Constructors

TySynEqn [Type] Type 
Instances
Eq TySynEqn # 
Instance details
Data TySynEqn # 
Instance details

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 :: (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 #

Ord TySynEqn # 
Instance details
Show TySynEqn # 
Instance details
Generic TySynEqn # 
Instance details

Associated Types

type Rep TySynEqn :: * -> * Source #

type Rep TySynEqn # 
Instance details

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
Eq TypeFamilyHead # 
Instance details
Data TypeFamilyHead # 
Instance details

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 :: (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 #

Ord TypeFamilyHead # 
Instance details
Show TypeFamilyHead # 
Instance details
Generic TypeFamilyHead # 
Instance details

Associated Types

type Rep TypeFamilyHead :: * -> * Source #

type Rep TypeFamilyHead # 
Instance details

data Fixity Source #

Constructors

Fixity Int FixityDirection 
Instances
Eq Fixity # 
Instance details

Methods

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

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

Data Fixity # 
Instance details

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 :: (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 #

Ord Fixity # 
Instance details
Show Fixity # 
Instance details
Generic Fixity # 
Instance details

Associated Types

type Rep Fixity :: * -> * Source #

type Rep Fixity # 
Instance details

data FixityDirection Source #

Constructors

InfixL 
InfixR 
InfixN 
Instances
Eq FixityDirection # 
Instance details
Data FixityDirection # 
Instance details

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 :: (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 #

Ord FixityDirection # 
Instance details
Show FixityDirection # 
Instance details
Generic FixityDirection # 
Instance details

Associated Types

type Rep FixityDirection :: * -> * Source #

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

defaultFixity :: Fixity Source #

Default fixity: infixl 9

maxPrecedence :: Int Source #

Highest allowed operator precedence for Fixity constructor (answer: 9)

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
Eq PatSynDir # 
Instance details
Data PatSynDir # 
Instance details

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 :: (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 #

Ord PatSynDir # 
Instance details
Show PatSynDir # 
Instance details
Generic PatSynDir # 
Instance details

Associated Types

type Rep PatSynDir :: * -> * Source #

Ppr PatSynDir # 
Instance details
type Rep PatSynDir # 
Instance details
type Rep PatSynDir = D1 (MetaData "PatSynDir" "Language.Haskell.TH.Syntax" "template-haskell" False) (C1 (MetaCons "Unidir" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "ImplBidir" PrefixI False) (U1 :: * -> *) :+: 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
Eq PatSynArgs # 
Instance details
Data PatSynArgs # 
Instance details

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 :: (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 #

Ord PatSynArgs # 
Instance details
Show PatSynArgs # 
Instance details
Generic PatSynArgs # 
Instance details

Associated Types

type Rep PatSynArgs :: * -> * Source #

Ppr PatSynArgs # 
Instance details
type Rep PatSynArgs # 
Instance details

Expressions

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 }
TupE [Exp]
{ (e1,e2) }
UnboxedTupE [Exp]
{ (# e1,e2 #) }
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 [Stmt]
{ do { p <- e1; e2 }  }
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 } (hole)

LabelE String

{ #x } ( Overloaded label )

Instances
Eq Exp # 
Instance details

Methods

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

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

Data Exp # 
Instance details

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 :: (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 #

Ord Exp # 
Instance details

Methods

compare :: Exp -> Exp -> Ordering #

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

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

(>) :: Exp -> Exp -> Bool #

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

max :: Exp -> Exp -> Exp #

min :: Exp -> Exp -> Exp #

Show Exp # 
Instance details
Generic Exp # 
Instance details

Associated Types

type Rep Exp :: * -> * Source #

Methods

from :: Exp -> Rep Exp x Source #

to :: Rep Exp x -> Exp Source #

Ppr Exp # 
Instance details

Methods

ppr :: Exp -> Doc Source #

ppr_list :: [Exp] -> Doc Source #

type Rep Exp # 
Instance details
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 "TupE" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Exp]))) :+: (C1 (MetaCons "UnboxedTupE" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [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 [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)))))))

data Match Source #

Constructors

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

Methods

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

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

Data Match # 
Instance details

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 :: (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 #

Ord Match # 
Instance details

Methods

compare :: Match -> Match -> Ordering #

(<) :: Match -> Match -> Bool #

(<=) :: Match -> Match -> Bool #

(>) :: Match -> Match -> Bool #

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

max :: Match -> Match -> Match #

min :: Match -> Match -> Match #

Show Match # 
Instance details
Generic Match # 
Instance details

Associated Types

type Rep Match :: * -> * Source #

Methods

from :: Match -> Rep Match x Source #

to :: Rep Match x -> Match Source #

Ppr Match # 
Instance details

Methods

ppr :: Match -> Doc Source #

ppr_list :: [Match] -> Doc Source #

type Rep Match # 
Instance details

data Body Source #

Constructors

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

Methods

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

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

Data Body # 
Instance details

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 :: (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 #

Ord Body # 
Instance details

Methods

compare :: Body -> Body -> Ordering #

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

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

(>) :: Body -> Body -> Bool #

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

max :: Body -> Body -> Body #

min :: Body -> Body -> Body #

Show Body # 
Instance details
Generic Body # 
Instance details

Associated Types

type Rep Body :: * -> * Source #

Methods

from :: Body -> Rep Body x Source #

to :: Rep Body x -> Body Source #

type Rep Body # 
Instance details

data Guard Source #

Constructors

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

Methods

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

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

Data Guard # 
Instance details

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 :: (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 #

Ord Guard # 
Instance details

Methods

compare :: Guard -> Guard -> Ordering #

(<) :: Guard -> Guard -> Bool #

(<=) :: Guard -> Guard -> Bool #

(>) :: Guard -> Guard -> Bool #

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

max :: Guard -> Guard -> Guard #

min :: Guard -> Guard -> Guard #

Show Guard # 
Instance details
Generic Guard # 
Instance details

Associated Types

type Rep Guard :: * -> * Source #

Methods

from :: Guard -> Rep Guard x Source #

to :: Rep Guard x -> Guard Source #

type Rep Guard # 
Instance details

data Stmt Source #

Constructors

BindS Pat Exp 
LetS [Dec] 
NoBindS Exp 
ParS [[Stmt]] 
Instances
Eq Stmt # 
Instance details

Methods

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

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

Data Stmt # 
Instance details

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 :: (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 #

Ord Stmt # 
Instance details

Methods

compare :: Stmt -> Stmt -> Ordering #

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

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

(>) :: Stmt -> Stmt -> Bool #

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

max :: Stmt -> Stmt -> Stmt #

min :: Stmt -> Stmt -> Stmt #

Show Stmt # 
Instance details
Generic Stmt # 
Instance details

Associated Types

type Rep Stmt :: * -> * Source #

Methods

from :: Stmt -> Rep Stmt x Source #

to :: Rep Stmt x -> Stmt Source #

Ppr Stmt # 
Instance details

Methods

ppr :: Stmt -> Doc Source #

ppr_list :: [Stmt] -> Doc Source #

type Rep Stmt # 
Instance details

data Range Source #

Instances
Eq Range # 
Instance details

Methods

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

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

Data Range # 
Instance details

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 :: (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 #

Ord Range # 
Instance details

Methods

compare :: Range -> Range -> Ordering #

(<) :: Range -> Range -> Bool #

(<=) :: Range -> Range -> Bool #

(>) :: Range -> Range -> Bool #

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

max :: Range -> Range -> Range #

min :: Range -> Range -> Range #

Show Range # 
Instance details
Generic Range # 
Instance details

Associated Types

type Rep Range :: * -> * Source #

Methods

from :: Range -> Rep Range x Source #

to :: Rep Range x -> Range Source #

Ppr Range # 
Instance details

Methods

ppr :: Range -> Doc Source #

ppr_list :: [Range] -> Doc Source #

type Rep Range # 
Instance details

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#

CharPrimL Char 
Instances
Eq Lit # 
Instance details

Methods

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

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

Data Lit # 
Instance details

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 :: (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 #

Ord Lit # 
Instance details

Methods

compare :: Lit -> Lit -> Ordering #

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

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

(>) :: Lit -> Lit -> Bool #

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

max :: Lit -> Lit -> Lit #

min :: Lit -> Lit -> Lit #

Show Lit # 
Instance details
Generic Lit # 
Instance details

Associated Types

type Rep Lit :: * -> * Source #

Methods

from :: Lit -> Rep Lit x Source #

to :: Rep Lit x -> Lit Source #

Ppr Lit # 
Instance details

Methods

ppr :: Lit -> Doc Source #

ppr_list :: [Lit] -> Doc Source #

type Rep Lit # 
Instance details
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 "CharPrimL" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Char))))))

Patterns

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 [Pat]
data T1 = C1 t1 t2; {C1 p1 p1} = 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
Eq Pat # 
Instance details

Methods

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

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

Data Pat # 
Instance details

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 :: (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 #

Ord Pat # 
Instance details

Methods

compare :: Pat -> Pat -> Ordering #

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

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

(>) :: Pat -> Pat -> Bool #

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

max :: Pat -> Pat -> Pat #

min :: Pat -> Pat -> Pat #

Show Pat # 
Instance details
Generic Pat # 
Instance details

Associated Types

type Rep Pat :: * -> * Source #

Methods

from :: Pat -> Rep Pat x Source #

to :: Rep Pat x -> Pat Source #

Ppr Pat # 
Instance details

Methods

ppr :: Pat -> Doc Source #

ppr_list :: [Pat] -> Doc Source #

type Rep Pat # 
Instance details
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 [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 :: * -> *) :+: 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)))))))

Types

data Type Source #

Constructors

ForallT [TyVarBndr] Cxt Type
forall <vars>. <ctxt> => <type>
AppT Type Type
T a b
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

ParensT Type
(T)
TupleT Int
(,), (,,), etc.
UnboxedTupleT Int
(#,#), (#,,#), etc.
UnboxedSumT SumArity
(#|#), (#||#), etc.
ArrowT
->
EqualityT
~
ListT
[]
PromotedTupleT Int
'(), '(,), '(,,), etc.
PromotedNilT
'[]
PromotedConsT
(':)
StarT
*
ConstraintT
Constraint
LitT TyLit
0,1,2, etc.
WildCardT
_
Instances
Eq Type # 
Instance details

Methods

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

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

Data Type # 
Instance details

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 :: (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 #

Ord Type # 
Instance details

Methods

compare :: Type -> Type -> Ordering #

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

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

(>) :: Type -> Type -> Bool #

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

max :: Type -> Type -> Type #

min :: Type -> Type -> Type #

Show Type # 
Instance details
Generic Type # 
Instance details

Associated Types

type Rep Type :: * -> * Source #

Methods

from :: Type -> Rep Type x Source #

to :: Rep Type x -> Type Source #

Ppr Type # 
Instance details

Methods

ppr :: Type -> Doc Source #

ppr_list :: [Type] -> Doc Source #

type Rep Type # 
Instance details
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]) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Cxt) :*: 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 "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 "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 :: * -> *)) :+: (C1 (MetaCons "EqualityT" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "ListT" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "PromotedTupleT" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int))))) :+: ((C1 (MetaCons "PromotedNilT" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "PromotedConsT" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "StarT" PrefixI False) (U1 :: * -> *))) :+: (C1 (MetaCons "ConstraintT" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "LitT" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 TyLit)) :+: C1 (MetaCons "WildCardT" PrefixI False) (U1 :: * -> *))))))

data TyVarBndr Source #

Constructors

PlainTV Name
a
KindedTV Name Kind
(a :: k)
Instances
Eq TyVarBndr # 
Instance details
Data TyVarBndr # 
Instance details

Methods

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

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

toConstr :: TyVarBndr -> Constr Source #

dataTypeOf :: TyVarBndr -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord TyVarBndr # 
Instance details
Show TyVarBndr # 
Instance details
Generic TyVarBndr # 
Instance details

Associated Types

type Rep TyVarBndr :: * -> * Source #

Ppr TyVarBndr # 
Instance details
type Rep TyVarBndr # 
Instance details

data TyLit Source #

Constructors

NumTyLit Integer
2
StrTyLit String
"Hello"
Instances
Eq TyLit # 
Instance details

Methods

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

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

Data TyLit # 
Instance details

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 :: (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 #

Ord TyLit # 
Instance details

Methods

compare :: TyLit -> TyLit -> Ordering #

(<) :: TyLit -> TyLit -> Bool #

(<=) :: TyLit -> TyLit -> Bool #

(>) :: TyLit -> TyLit -> Bool #

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

max :: TyLit -> TyLit -> TyLit #

min :: TyLit -> TyLit -> TyLit #

Show TyLit # 
Instance details
Generic TyLit # 
Instance details

Associated Types

type Rep TyLit :: * -> * Source #

Methods

from :: TyLit -> Rep TyLit x Source #

to :: Rep TyLit x -> TyLit Source #

Ppr TyLit # 
Instance details

Methods

ppr :: TyLit -> Doc Source #

ppr_list :: [TyLit] -> Doc Source #

type Rep TyLit # 
Instance details

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
Eq Role # 
Instance details

Methods

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

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

Data Role # 
Instance details

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 :: (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 #

Ord Role # 
Instance details

Methods

compare :: Role -> Role -> Ordering #

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

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

(>) :: Role -> Role -> Bool #

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

max :: Role -> Role -> Role #

min :: Role -> Role -> Role #

Show Role # 
Instance details
Generic Role # 
Instance details

Associated Types

type Rep Role :: * -> * Source #

Methods

from :: Role -> Rep Role x Source #

to :: Rep Role x -> Role Source #

Ppr Role # 
Instance details

Methods

ppr :: Role -> Doc Source #

ppr_list :: [Role] -> Doc Source #

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

data FamilyResultSig Source #

Type family result signature

Constructors

NoSig

no signature

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

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 :: (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 #

Ord FamilyResultSig # 
Instance details
Show FamilyResultSig # 
Instance details
Generic FamilyResultSig # 
Instance details

Associated Types

type Rep FamilyResultSig :: * -> * Source #

Ppr FamilyResultSig # 
Instance details
type Rep FamilyResultSig # 
Instance details

data InjectivityAnn Source #

Injectivity annotation

Constructors

InjectivityAnn Name [Name] 
Instances
Eq InjectivityAnn # 
Instance details
Data InjectivityAnn # 
Instance details

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 :: (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 #

Ord InjectivityAnn # 
Instance details
Show InjectivityAnn # 
Instance details
Generic InjectivityAnn # 
Instance details

Associated Types

type Rep InjectivityAnn :: * -> * Source #

Ppr InjectivityAnn # 
Instance details
type Rep InjectivityAnn # 
Instance details

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

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:

(a) Reification always returns a pattern synonym's *fully* specified type in abstract syntax.

(b) 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.

(c) 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/syntax-extns.html#pattern-synonyms.

Library functions

Pretty-printer

class Ppr a where Source #

Minimal complete definition

ppr

Methods

ppr :: a -> Doc Source #

ppr_list :: [a] -> Doc Source #

Instances
Ppr Exp # 
Instance details

Methods

ppr :: Exp -> Doc Source #

ppr_list :: [Exp] -> Doc Source #

Ppr Match # 
Instance details

Methods

ppr :: Match -> Doc Source #

ppr_list :: [Match] -> Doc Source #

Ppr Clause # 
Instance details

Methods

ppr :: Clause -> Doc Source #

ppr_list :: [Clause] -> Doc Source #

Ppr Pat # 
Instance details

Methods

ppr :: Pat -> Doc Source #

ppr_list :: [Pat] -> Doc Source #

Ppr Type # 
Instance details

Methods

ppr :: Type -> Doc Source #

ppr_list :: [Type] -> Doc Source #

Ppr Dec # 
Instance details

Methods

ppr :: Dec -> Doc Source #

ppr_list :: [Dec] -> Doc Source #

Ppr Name # 
Instance details

Methods

ppr :: Name -> Doc Source #

ppr_list :: [Name] -> Doc Source #

Ppr FunDep # 
Instance details

Methods

ppr :: FunDep -> Doc Source #

ppr_list :: [FunDep] -> Doc Source #

Ppr InjectivityAnn # 
Instance details
Ppr Role # 
Instance details

Methods

ppr :: Role -> Doc Source #

ppr_list :: [Role] -> Doc Source #

Ppr TyLit # 
Instance details

Methods

ppr :: TyLit -> Doc Source #

ppr_list :: [TyLit] -> Doc Source #

Ppr FamilyResultSig # 
Instance details
Ppr TyVarBndr # 
Instance details
Ppr PatSynArgs # 
Instance details
Ppr PatSynDir # 
Instance details
Ppr Bang # 
Instance details

Methods

ppr :: Bang -> Doc Source #

ppr_list :: [Bang] -> Doc Source #

Ppr Con # 
Instance details

Methods

ppr :: Con -> Doc Source #

ppr_list :: [Con] -> Doc Source #

Ppr DecidedStrictness # 
Instance details
Ppr SourceStrictness # 
Instance details
Ppr SourceUnpackedness # 
Instance details
Ppr RuleBndr # 
Instance details
Ppr Phases # 
Instance details

Methods

ppr :: Phases -> Doc Source #

ppr_list :: [Phases] -> Doc Source #

Ppr RuleMatch # 
Instance details
Ppr Inline # 
Instance details

Methods

ppr :: Inline -> Doc Source #

ppr_list :: [Inline] -> Doc Source #

Ppr Pragma # 
Instance details

Methods

ppr :: Pragma -> Doc Source #

ppr_list :: [Pragma] -> Doc Source #

Ppr Foreign # 
Instance details
Ppr Range # 
Instance details

Methods

ppr :: Range -> Doc Source #

ppr_list :: [Range] -> Doc Source #

Ppr Stmt # 
Instance details

Methods

ppr :: Stmt -> Doc Source #

ppr_list :: [Stmt] -> Doc Source #

Ppr Lit # 
Instance details

Methods

ppr :: Lit -> Doc Source #

ppr_list :: [Lit] -> Doc Source #

Ppr ModuleInfo # 
Instance details
Ppr Info # 
Instance details

Methods

ppr :: Info -> Doc Source #

ppr_list :: [Info] -> Doc Source #

Ppr Loc # 
Instance details

Methods

ppr :: Loc -> Doc Source #

ppr_list :: [Loc] -> Doc Source #

Ppr Module # 
Instance details

Methods

ppr :: Module -> Doc Source #

ppr_list :: [Module] -> Doc Source #

Ppr a => Ppr [a] # 
Instance details

Methods

ppr :: [a] -> Doc Source #

ppr_list :: [[a]] -> Doc Source #

pprint :: Ppr a => a -> String Source #