Safe Haskell	Safe
Language	Haskell2010

Language.Haskell.TH

Contents

The monad and its operations
- Administration: errors, locations and IO
- Querying the compiler
Typed expressions
Names
The algebraic data types
Library functions
Pretty-printer

Description

The public face of Template Haskell

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

Synopsis

data Q a
runQ :: Quasi m => Q a -> m a
reportError :: String -> Q ()
reportWarning :: String -> Q ()
report :: Bool -> String -> Q ()
recover :: Q a -> Q a -> Q a
location :: Q Loc
data Loc = Loc {
- loc_filename :: String
- loc_package :: String
- loc_module :: String
- loc_start :: CharPos
- loc_end :: CharPos
}
runIO :: IO a -> Q a
reify :: Name -> Q Info
reifyModule :: Module -> Q ModuleInfo
data Info
- = ClassI Dec [InstanceDec]
- | ClassOpI Name Type ParentName
- | TyConI Dec
- | FamilyI Dec [InstanceDec]
- | PrimTyConI Name Arity Unlifted
- | DataConI Name Type ParentName
- | PatSynI Name PatSynType
- | VarI Name Type (Maybe Dec)
- | TyVarI Name Type
data ModuleInfo = ModuleInfo [Module]
type InstanceDec = Dec
type ParentName = Name
type SumAlt = Int
type SumArity = Int
type Arity = Int
type Unlifted = Bool
data Extension
- = 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
- | BlockArguments
- | RebindableSyntax
- | ConstraintKinds
- | PolyKinds
- | DataKinds
- | InstanceSigs
- | ApplicativeDo
- | StandaloneDeriving
- | DeriveDataTypeable
- | AutoDeriveTypeable
- | DeriveFunctor
- | DeriveTraversable
- | DeriveFoldable
- | DeriveGeneric
- | DefaultSignatures
- | DeriveAnyClass
- | DeriveLift
- | DerivingStrategies
- | DerivingVia
- | 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
- | NumericUnderscores
- | QuantifiedConstraints
- | StarIsType
extsEnabled :: Q [Extension]
isExtEnabled :: Extension -> Q Bool
lookupTypeName :: String -> Q (Maybe Name)
lookupValueName :: String -> Q (Maybe Name)
reifyFixity :: Name -> Q (Maybe Fixity)
reifyInstances :: Name -> [Type] -> Q [InstanceDec]
isInstance :: Name -> [Type] -> Q Bool
reifyRoles :: Name -> Q [Role]
reifyAnnotations :: Data a => AnnLookup -> Q [a]
data AnnLookup
- = AnnLookupModule Module
- | AnnLookupName Name
reifyConStrictness :: Name -> Q [DecidedStrictness]
data TExp a
unType :: TExp a -> Exp
data Name
data NameSpace
mkName :: String -> Name
newName :: String -> Q Name
nameBase :: Name -> String
nameModule :: Name -> Maybe String
namePackage :: Name -> Maybe String
nameSpace :: Name -> Maybe NameSpace
tupleTypeName :: Int -> Name
tupleDataName :: Int -> Name
unboxedTupleTypeName :: Int -> Name
unboxedTupleDataName :: Int -> Name
unboxedSumTypeName :: SumArity -> Name
unboxedSumDataName :: SumAlt -> SumArity -> Name
data Dec
- = FunD Name [Clause]
- | ValD Pat Body [Dec]
- | DataD Cxt Name [TyVarBndr] (Maybe Kind) [Con] [DerivClause]
- | NewtypeD Cxt Name [TyVarBndr] (Maybe Kind) Con [DerivClause]
- | TySynD Name [TyVarBndr] Type
- | ClassD Cxt Name [TyVarBndr] [FunDep] [Dec]
- | InstanceD (Maybe Overlap) Cxt Type [Dec]
- | SigD Name Type
- | ForeignD Foreign
- | InfixD Fixity Name
- | PragmaD Pragma
- | DataFamilyD Name [TyVarBndr] (Maybe Kind)
- | DataInstD Cxt (Maybe [TyVarBndr]) Type (Maybe Kind) [Con] [DerivClause]
- | NewtypeInstD Cxt (Maybe [TyVarBndr]) Type (Maybe Kind) Con [DerivClause]
- | TySynInstD TySynEqn
- | OpenTypeFamilyD TypeFamilyHead
- | ClosedTypeFamilyD TypeFamilyHead [TySynEqn]
- | RoleAnnotD Name [Role]
- | StandaloneDerivD (Maybe DerivStrategy) Cxt Type
- | DefaultSigD Name Type
- | PatSynD Name PatSynArgs PatSynDir Pat
- | PatSynSigD Name PatSynType
- | ImplicitParamBindD String Exp
data Con
- = NormalC Name [BangType]
- | RecC Name [VarBangType]
- | InfixC BangType Name BangType
- | ForallC [TyVarBndr] Cxt Con
- | GadtC [Name] [BangType] Type
- | RecGadtC [Name] [VarBangType] Type
data Clause = Clause [Pat] Body [Dec]
data SourceUnpackedness
- = NoSourceUnpackedness
- | SourceNoUnpack
- | SourceUnpack
data SourceStrictness
- = NoSourceStrictness
- | SourceLazy
- | SourceStrict
data DecidedStrictness
- = DecidedLazy
- | DecidedStrict
- | DecidedUnpack
data Bang = Bang SourceUnpackedness SourceStrictness
type Strict = Bang
data Foreign
- = ImportF Callconv Safety String Name Type
- | ExportF Callconv String Name Type
data Callconv
- = CCall
- | StdCall
- | CApi
- | Prim
- | JavaScript
data Safety
- = Unsafe
- | Safe
- | Interruptible
data Pragma
- = InlineP Name Inline RuleMatch Phases
- | SpecialiseP Name Type (Maybe Inline) Phases
- | SpecialiseInstP Type
- | RuleP String (Maybe [TyVarBndr]) [RuleBndr] Exp Exp Phases
- | AnnP AnnTarget Exp
- | LineP Int String
- | CompleteP [Name] (Maybe Name)
data Inline
- = NoInline
- | Inline
- | Inlinable
data RuleMatch
- = ConLike
- | FunLike
data Phases
- = AllPhases
- | FromPhase Int
- | BeforePhase Int
data RuleBndr
- = RuleVar Name
- | TypedRuleVar Name Type
data AnnTarget
- = ModuleAnnotation
- | TypeAnnotation Name
- | ValueAnnotation Name
data FunDep = FunDep [Name] [Name]
data TySynEqn = TySynEqn (Maybe [TyVarBndr]) Type Type
data TypeFamilyHead = TypeFamilyHead Name [TyVarBndr] FamilyResultSig (Maybe InjectivityAnn)
data Fixity = Fixity Int FixityDirection
data FixityDirection
- = InfixL
- | InfixR
- | InfixN
defaultFixity :: Fixity
maxPrecedence :: Int
data PatSynDir
- = Unidir
- | ImplBidir
- | ExplBidir [Clause]
data PatSynArgs
- = PrefixPatSyn [Name]
- | InfixPatSyn Name Name
- | RecordPatSyn [Name]
data Exp
- = VarE Name
- | ConE Name
- | LitE Lit
- | AppE Exp Exp
- | AppTypeE Exp Type
- | InfixE (Maybe Exp) Exp (Maybe Exp)
- | UInfixE Exp Exp Exp
- | ParensE Exp
- | LamE [Pat] Exp
- | LamCaseE [Match]
- | TupE [Exp]
- | UnboxedTupE [Exp]
- | UnboxedSumE Exp SumAlt SumArity
- | CondE Exp Exp Exp
- | MultiIfE [(Guard, Exp)]
- | LetE [Dec] Exp
- | CaseE Exp [Match]
- | DoE [Stmt]
- | MDoE [Stmt]
- | CompE [Stmt]
- | ArithSeqE Range
- | ListE [Exp]
- | SigE Exp Type
- | RecConE Name [FieldExp]
- | RecUpdE Exp [FieldExp]
- | StaticE Exp
- | UnboundVarE Name
- | LabelE String
- | ImplicitParamVarE String
data Match = Match Pat Body [Dec]
data Body
- = GuardedB [(Guard, Exp)]
- | NormalB Exp
data Guard
- = NormalG Exp
- | PatG [Stmt]
data Stmt
- = BindS Pat Exp
- | LetS [Dec]
- | NoBindS Exp
- | ParS [[Stmt]]
- | RecS [Stmt]
data Range
- = FromR Exp
- | FromThenR Exp Exp
- | FromToR Exp Exp
- | FromThenToR Exp Exp Exp
data Lit
- = CharL Char
- | StringL String
- | IntegerL Integer
- | RationalL Rational
- | IntPrimL Integer
- | WordPrimL Integer
- | FloatPrimL Rational
- | DoublePrimL Rational
- | StringPrimL [Word8]
- | CharPrimL Char
data Pat
- = LitP Lit
- | VarP Name
- | TupP [Pat]
- | UnboxedTupP [Pat]
- | UnboxedSumP Pat SumAlt SumArity
- | ConP Name [Pat]
- | InfixP Pat Name Pat
- | UInfixP Pat Name Pat
- | ParensP Pat
- | TildeP Pat
- | BangP Pat
- | AsP Name Pat
- | WildP
- | RecP Name [FieldPat]
- | ListP [Pat]
- | SigP Pat Type
- | ViewP Exp Pat
type FieldExp = (Name, Exp)
type FieldPat = (Name, Pat)
data Type
- = ForallT [TyVarBndr] Cxt Type
- | AppT Type Type
- | AppKindT Type Kind
- | SigT Type Kind
- | VarT Name
- | ConT Name
- | PromotedT Name
- | InfixT Type Name Type
- | UInfixT Type Name Type
- | ParensT Type
- | TupleT Int
- | UnboxedTupleT Int
- | UnboxedSumT SumArity
- | ArrowT
- | EqualityT
- | ListT
- | PromotedTupleT Int
- | PromotedNilT
- | PromotedConsT
- | StarT
- | ConstraintT
- | LitT TyLit
- | WildCardT
- | ImplicitParamT String Type
data TyVarBndr
- = PlainTV Name
- | KindedTV Name Kind
data TyLit
- = NumTyLit Integer
- | StrTyLit String
type Kind = Type
type Cxt = [Pred]
type Pred = Type
data Role
- = NominalR
- | RepresentationalR
- | PhantomR
- | InferR
data FamilyResultSig
- = NoSig
- | KindSig Kind
- | TyVarSig TyVarBndr
data InjectivityAnn = InjectivityAnn Name [Name]
type PatSynType = Type
module Language.Haskell.TH.Lib
class Ppr a where
- ppr :: a -> Doc
- ppr_list :: [a] -> Doc
pprint :: Ppr a => a -> String
pprExp :: Precedence -> Exp -> Doc
pprLit :: Precedence -> Lit -> Doc
pprPat :: Precedence -> Pat -> Doc
pprParendType :: Type -> Doc

The monad and its operations

data Q a Source #

Instances

Monad Q Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (>>=) :: Q a -> (a -> Q b) -> Q b # (>>) :: Q a -> Q b -> Q b # return :: a -> Q a # fail :: String -> Q a #
Functor Q Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods fmap :: (a -> b) -> Q a -> Q b # (<$) :: a -> Q b -> Q a #
MonadFail Q Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods fail :: String -> Q a #
Applicative Q Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods pure :: a -> Q a # (<>) :: Q (a -> b) -> Q a -> Q b # liftA2 :: (a -> b -> c) -> Q a -> Q b -> Q c # (>) :: Q a -> Q b -> Q b # (<*) :: Q a -> Q b -> Q a #
MonadIO Q Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods liftIO :: IO a -> Q a #
Quasi Q Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods qNewName :: String -> Q Name Source # qReport :: Bool -> String -> Q () Source # qRecover :: Q a -> Q a -> Q a Source # qLookupName :: Bool -> String -> Q (Maybe Name) Source # qReify :: Name -> Q Info Source # qReifyFixity :: Name -> Q (Maybe Fixity) Source # qReifyInstances :: Name -> [Type] -> Q [Dec] Source # qReifyRoles :: Name -> Q [Role] Source # qReifyAnnotations :: Data a => AnnLookup -> Q [a] Source # qReifyModule :: Module -> Q ModuleInfo Source # qReifyConStrictness :: Name -> Q [DecidedStrictness] Source # qLocation :: Q Loc Source # qRunIO :: IO a -> Q a Source # qAddDependentFile :: FilePath -> Q () Source # qAddTempFile :: String -> Q FilePath Source # qAddTopDecls :: [Dec] -> Q () Source # qAddForeignFilePath :: ForeignSrcLang -> String -> Q () Source # qAddModFinalizer :: Q () -> Q () Source # qAddCorePlugin :: String -> Q () Source # qGetQ :: Typeable a => Q (Maybe a) Source # qPutQ :: Typeable a => a -> Q () Source # qIsExtEnabled :: Extension -> Q Bool Source # qExtsEnabled :: Q [Extension] Source #

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 #

Constructors

Loc
Fields loc_filename :: String loc_package :: String loc_module :: String loc_start :: CharPos loc_end :: CharPos

Instances

Eq Loc Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Loc -> Loc -> Bool # (/=) :: Loc -> Loc -> Bool #
Data Loc Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Loc -> c Loc # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Loc # toConstr :: Loc -> Constr # dataTypeOf :: Loc -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Loc) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Loc) # gmapT :: (forall b. Data b => b -> b) -> Loc -> Loc # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r # gmapQ :: (forall d. Data d => d -> u) -> Loc -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Loc -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Loc -> m Loc # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Loc -> m Loc # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Loc -> m Loc #
Ord Loc Source #
Instance details Defined in Language.Haskell.TH.Syntax 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 Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Loc -> ShowS # show :: Loc -> String # showList :: [Loc] -> ShowS #
Generic Loc Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Loc :: Type -> Type # Methods from :: Loc -> Rep Loc x # to :: Rep Loc x -> Loc #
Binary Loc Source #
Instance details Defined in GHCi.TH.Binary Methods put :: Loc -> Put # get :: Get Loc # putList :: [Loc] -> Put #
Ppr Loc Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Loc -> Doc Source # ppr_list :: [Loc] -> Doc Source #
type Rep Loc Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep Loc = D1 (MetaData "Loc" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "Loc" PrefixI True) ((S1 (MetaSel (Just "loc_filename") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :: S1 (MetaSel (Just "loc_package") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)) :: (S1 (MetaSel (Just "loc_module") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :: (S1 (MetaSel (Just "loc_start") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 CharPos) :: S1 (MetaSel (Just "loc_end") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 CharPos)))))

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. At present, this reified declaration will never have derived instances attached to it (if you wish to check for an instance, see `reifyInstances`).
FamilyI Dec [InstanceDec]	A type or data family, with a list of its visible instances. A closed type family is returned with 0 instances.
PrimTyConI Name Arity Unlifted	A "primitive" type constructor, which can't be expressed with a `Dec`. Examples: `(->)`, `Int#`.
DataConI Name Type ParentName	A data constructor
PatSynI Name PatSynType	A pattern synonym
VarI Name Type (Maybe Dec)	A "value" variable (as opposed to a type variable, see `TyVarI`). The `Maybe Dec` field contains `Just` the declaration which defined the variable - including the RHS of the declaration - or else `Nothing`, in the case where the RHS is unavailable to the compiler. At present, this value is always `Nothing`: returning the RHS has not yet been implemented because of lack of interest.
TyVarI Name Type	A type variable. The `Type` field contains the type which underlies the variable. At present, this is always `VarT theName`, but future changes may permit refinement of this.

Instances

Eq Info Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Info -> Info -> Bool # (/=) :: Info -> Info -> Bool #
Data Info Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Info -> c Info # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Info # toConstr :: Info -> Constr # dataTypeOf :: Info -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Info) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Info) # gmapT :: (forall b. Data b => b -> b) -> Info -> Info # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r # gmapQ :: (forall d. Data d => d -> u) -> Info -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Info -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Info -> m Info # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Info -> m Info # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Info -> m Info #
Ord Info Source #
Instance details Defined in Language.Haskell.TH.Syntax 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 Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Info -> ShowS # show :: Info -> String # showList :: [Info] -> ShowS #
Generic Info Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Info :: Type -> Type # Methods from :: Info -> Rep Info x # to :: Rep Info x -> Info #
Binary Info Source #
Instance details Defined in GHCi.TH.Binary Methods put :: Info -> Put # get :: Get Info # putList :: [Info] -> Put #
Ppr Info Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Info -> Doc Source # ppr_list :: [Info] -> Doc Source #
type Rep Info Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep Info = D1 (MetaData "Info" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" 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 Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: ModuleInfo -> ModuleInfo -> Bool # (/=) :: ModuleInfo -> ModuleInfo -> Bool #
Data ModuleInfo Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModuleInfo -> c ModuleInfo # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ModuleInfo # toConstr :: ModuleInfo -> Constr # dataTypeOf :: ModuleInfo -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ModuleInfo) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleInfo) # gmapT :: (forall b. Data b => b -> b) -> ModuleInfo -> ModuleInfo # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r # gmapQ :: (forall d. Data d => d -> u) -> ModuleInfo -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ModuleInfo -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo #
Ord ModuleInfo Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: ModuleInfo -> ModuleInfo -> Ordering # (<) :: ModuleInfo -> ModuleInfo -> Bool # (<=) :: ModuleInfo -> ModuleInfo -> Bool # (>) :: ModuleInfo -> ModuleInfo -> Bool # (>=) :: ModuleInfo -> ModuleInfo -> Bool # max :: ModuleInfo -> ModuleInfo -> ModuleInfo # min :: ModuleInfo -> ModuleInfo -> ModuleInfo #
Show ModuleInfo Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> ModuleInfo -> ShowS # show :: ModuleInfo -> String # showList :: [ModuleInfo] -> ShowS #
Generic ModuleInfo Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep ModuleInfo :: Type -> Type # Methods from :: ModuleInfo -> Rep ModuleInfo x # to :: Rep ModuleInfo x -> ModuleInfo #
Binary ModuleInfo Source #
Instance details Defined in GHCi.TH.Binary Methods put :: ModuleInfo -> Put # get :: Get ModuleInfo # putList :: [ModuleInfo] -> Put #
Ppr ModuleInfo Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: ModuleInfo -> Doc Source # ppr_list :: [ModuleInfo] -> Doc Source #
type Rep ModuleInfo Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep ModuleInfo = D1 (MetaData "ModuleInfo" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" 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:

InstanceD (with empty [Dec])
DataInstD or NewtypeInstD (with empty derived [Name])
TySynInstD

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:

(#_|#) has SumAlt 1 (out of a total SumArity of 2)
(#|_#) has SumAlt 2 (out of a total SumArity of 2)

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
BlockArguments
RebindableSyntax
ConstraintKinds
PolyKinds
DataKinds
InstanceSigs
ApplicativeDo
StandaloneDeriving
DeriveDataTypeable
AutoDeriveTypeable
DeriveFunctor
DeriveTraversable
DeriveFoldable
DeriveGeneric
DefaultSignatures
DeriveAnyClass
DeriveLift
DerivingStrategies
DerivingVia
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
NumericUnderscores
QuantifiedConstraints
StarIsType

Instances

Bounded Extension Source #
Instance details Defined in GHC.LanguageExtensions.Type Methods minBound :: Extension # maxBound :: Extension #
Enum Extension Source #
Instance details Defined in GHC.LanguageExtensions.Type Methods succ :: Extension -> Extension # pred :: Extension -> Extension # toEnum :: Int -> Extension # fromEnum :: Extension -> Int # enumFrom :: Extension -> [Extension] # enumFromThen :: Extension -> Extension -> [Extension] # enumFromTo :: Extension -> Extension -> [Extension] # enumFromThenTo :: Extension -> Extension -> Extension -> [Extension] #
Eq Extension Source #
Instance details Defined in GHC.LanguageExtensions.Type Methods (==) :: Extension -> Extension -> Bool # (/=) :: Extension -> Extension -> Bool #
Show Extension Source #
Instance details Defined in GHC.LanguageExtensions.Type Methods showsPrec :: Int -> Extension -> ShowS # show :: Extension -> String # showList :: [Extension] -> ShowS #
Generic Extension Source #
Instance details Defined in GHC.LanguageExtensions.Type Associated Types type Rep Extension :: Type -> Type # Methods from :: Extension -> Rep Extension x # to :: Rep Extension x -> Extension #
Binary Extension Source #
Instance details Defined in GHC.LanguageExtensions Methods put :: Extension -> Put # get :: Get Extension # putList :: [Extension] -> Put #
Outputable Extension Source #
Instance details Defined in Outputable Methods ppr :: Extension -> SDoc Source # pprPrec :: Rational -> Extension -> SDoc Source #
type Rep Extension Source #
Instance details Defined in GHC.LanguageExtensions.Type type Rep Extension = D1 (MetaData "Extension" "GHC.LanguageExtensions.Type" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) ((((((C1 (MetaCons "Cpp" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "OverlappingInstances" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "UndecidableInstances" PrefixI False) (U1 :: Type -> Type))) :+: ((C1 (MetaCons "IncoherentInstances" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "UndecidableSuperClasses" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "MonomorphismRestriction" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "MonoPatBinds" PrefixI False) (U1 :: Type -> Type)))) :+: ((C1 (MetaCons "MonoLocalBinds" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "RelaxedPolyRec" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "ExtendedDefaultRules" PrefixI False) (U1 :: Type -> Type))) :+: ((C1 (MetaCons "ForeignFunctionInterface" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "UnliftedFFITypes" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "InterruptibleFFI" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "CApiFFI" PrefixI False) (U1 :: Type -> Type))))) :+: (((C1 (MetaCons "GHCForeignImportPrim" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "JavaScriptFFI" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "ParallelArrays" PrefixI False) (U1 :: Type -> Type))) :+: ((C1 (MetaCons "Arrows" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "TemplateHaskell" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "TemplateHaskellQuotes" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "QuasiQuotes" PrefixI False) (U1 :: Type -> Type)))) :+: ((C1 (MetaCons "ImplicitParams" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "ImplicitPrelude" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "ScopedTypeVariables" PrefixI False) (U1 :: Type -> Type))) :+: ((C1 (MetaCons "AllowAmbiguousTypes" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "UnboxedTuples" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "UnboxedSums" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "BangPatterns" PrefixI False) (U1 :: Type -> Type)))))) :+: ((((C1 (MetaCons "TypeFamilies" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "TypeFamilyDependencies" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "TypeInType" PrefixI False) (U1 :: Type -> Type))) :+: ((C1 (MetaCons "OverloadedStrings" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "OverloadedLists" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "NumDecimals" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "DisambiguateRecordFields" PrefixI False) (U1 :: Type -> Type)))) :+: ((C1 (MetaCons "RecordWildCards" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "RecordPuns" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "ViewPatterns" PrefixI False) (U1 :: Type -> Type))) :+: ((C1 (MetaCons "GADTs" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "GADTSyntax" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "NPlusKPatterns" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "DoAndIfThenElse" PrefixI False) (U1 :: Type -> Type))))) :+: (((C1 (MetaCons "BlockArguments" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "RebindableSyntax" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "ConstraintKinds" PrefixI False) (U1 :: Type -> Type))) :+: ((C1 (MetaCons "PolyKinds" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "DataKinds" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "InstanceSigs" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "ApplicativeDo" PrefixI False) (U1 :: Type -> Type)))) :+: (((C1 (MetaCons "StandaloneDeriving" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "DeriveDataTypeable" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "AutoDeriveTypeable" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "DeriveFunctor" PrefixI False) (U1 :: Type -> Type))) :+: ((C1 (MetaCons "DeriveTraversable" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "DeriveFoldable" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "DeriveGeneric" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "DefaultSignatures" PrefixI False) (U1 :: Type -> Type))))))) :+: (((((C1 (MetaCons "DeriveAnyClass" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "DeriveLift" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "DerivingStrategies" PrefixI False) (U1 :: Type -> Type))) :+: ((C1 (MetaCons "DerivingVia" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "TypeSynonymInstances" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "FlexibleContexts" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "FlexibleInstances" PrefixI False) (U1 :: Type -> Type)))) :+: ((C1 (MetaCons "ConstrainedClassMethods" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "MultiParamTypeClasses" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "NullaryTypeClasses" PrefixI False) (U1 :: Type -> Type))) :+: ((C1 (MetaCons "FunctionalDependencies" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "UnicodeSyntax" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "ExistentialQuantification" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "MagicHash" PrefixI False) (U1 :: Type -> Type))))) :+: (((C1 (MetaCons "EmptyDataDecls" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "KindSignatures" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "RoleAnnotations" PrefixI False) (U1 :: Type -> Type))) :+: ((C1 (MetaCons "ParallelListComp" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "TransformListComp" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "MonadComprehensions" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "GeneralizedNewtypeDeriving" PrefixI False) (U1 :: Type -> Type)))) :+: (((C1 (MetaCons "RecursiveDo" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "PostfixOperators" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "TupleSections" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "PatternGuards" PrefixI False) (U1 :: Type -> Type))) :+: ((C1 (MetaCons "LiberalTypeSynonyms" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "RankNTypes" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "ImpredicativeTypes" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "TypeOperators" PrefixI False) (U1 :: Type -> Type)))))) :+: ((((C1 (MetaCons "ExplicitNamespaces" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "PackageImports" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "ExplicitForAll" PrefixI False) (U1 :: Type -> Type))) :+: ((C1 (MetaCons "AlternativeLayoutRule" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "AlternativeLayoutRuleTransitional" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "DatatypeContexts" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "NondecreasingIndentation" PrefixI False) (U1 :: Type -> Type)))) :+: ((C1 (MetaCons "RelaxedLayout" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "TraditionalRecordSyntax" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "LambdaCase" PrefixI False) (U1 :: Type -> Type))) :+: ((C1 (MetaCons "MultiWayIf" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "BinaryLiterals" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "NegativeLiterals" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "HexFloatLiterals" PrefixI False) (U1 :: Type -> Type))))) :+: (((C1 (MetaCons "DuplicateRecordFields" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "OverloadedLabels" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "EmptyCase" PrefixI False) (U1 :: Type -> Type))) :+: ((C1 (MetaCons "PatternSynonyms" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "PartialTypeSignatures" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "NamedWildCards" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "StaticPointers" PrefixI False) (U1 :: Type -> Type)))) :+: (((C1 (MetaCons "TypeApplications" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "Strict" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "StrictData" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "MonadFailDesugaring" PrefixI False) (U1 :: Type -> Type))) :+: ((C1 (MetaCons "EmptyDataDeriving" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "NumericUnderscores" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "QuantifiedConstraints" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "StarIsType" PrefixI False) (U1 :: Type -> Type))))))))

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.

Note that this is a "shallow" test; the declarations returned merely have instance heads which unify with nm tys, they need not actually be satisfiable.

reifyInstances ''Eq [ TupleT 2 `AppT` ConT ''A `AppT` ConT ''B ] contains the instance (Eq a, Eq b) => Eq (a, b) regardless of whether A and B themselves implement Eq
reifyInstances ''Show [ VarT (mkName "a") ] produces every available instance of Eq

There is one edge case: reifyInstances ''Typeable tys currently always produces an empty list (no matter what tys are given).

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

Constructors

AnnLookupModule Module
AnnLookupName Name

Instances

Eq AnnLookup Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: AnnLookup -> AnnLookup -> Bool # (/=) :: AnnLookup -> AnnLookup -> Bool #
Data AnnLookup Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnLookup -> c AnnLookup # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnLookup # toConstr :: AnnLookup -> Constr # dataTypeOf :: AnnLookup -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnLookup) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnLookup) # gmapT :: (forall b. Data b => b -> b) -> AnnLookup -> AnnLookup # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnLookup -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnLookup -> r # gmapQ :: (forall d. Data d => d -> u) -> AnnLookup -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnLookup -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup #
Ord AnnLookup Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: AnnLookup -> AnnLookup -> Ordering # (<) :: AnnLookup -> AnnLookup -> Bool # (<=) :: AnnLookup -> AnnLookup -> Bool # (>) :: AnnLookup -> AnnLookup -> Bool # (>=) :: AnnLookup -> AnnLookup -> Bool # max :: AnnLookup -> AnnLookup -> AnnLookup # min :: AnnLookup -> AnnLookup -> AnnLookup #
Show AnnLookup Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> AnnLookup -> ShowS # show :: AnnLookup -> String # showList :: [AnnLookup] -> ShowS #
Generic AnnLookup Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep AnnLookup :: Type -> Type # Methods from :: AnnLookup -> Rep AnnLookup x # to :: Rep AnnLookup x -> AnnLookup #
Binary AnnLookup Source #
Instance details Defined in GHCi.TH.Binary Methods put :: AnnLookup -> Put # get :: Get AnnLookup # putList :: [AnnLookup] -> Put #
type Rep AnnLookup Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep AnnLookup = D1 (MetaData "AnnLookup" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" 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 #

unType :: TExp a -> Exp 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 Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Name -> Name -> Bool # (/=) :: Name -> Name -> Bool #
Data Name Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Name -> c Name # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Name # toConstr :: Name -> Constr # dataTypeOf :: Name -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Name) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name) # gmapT :: (forall b. Data b => b -> b) -> Name -> Name # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r # gmapQ :: (forall d. Data d => d -> u) -> Name -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Name -> m Name # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name #
Ord Name Source #
Instance details Defined in Language.Haskell.TH.Syntax 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 Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Name -> ShowS # show :: Name -> String # showList :: [Name] -> ShowS #
Generic Name Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Name :: Type -> Type # Methods from :: Name -> Rep Name x # to :: Rep Name x -> Name #
Binary Name Source #
Instance details Defined in GHCi.TH.Binary Methods put :: Name -> Put # get :: Get Name # putList :: [Name] -> Put #
Ppr Name Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Name -> Doc Source # ppr_list :: [Name] -> Doc Source #
type Rep Name Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep Name = D1 (MetaData "Name" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "Name" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 OccName) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 NameFlavour)))

data NameSpace Source #

Instances

Eq NameSpace Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: NameSpace -> NameSpace -> Bool # (/=) :: NameSpace -> NameSpace -> Bool #
Data NameSpace Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NameSpace -> c NameSpace # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NameSpace # toConstr :: NameSpace -> Constr # dataTypeOf :: NameSpace -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NameSpace) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameSpace) # gmapT :: (forall b. Data b => b -> b) -> NameSpace -> NameSpace # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NameSpace -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NameSpace -> r # gmapQ :: (forall d. Data d => d -> u) -> NameSpace -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NameSpace -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace #
Ord NameSpace Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: NameSpace -> NameSpace -> Ordering # (<) :: NameSpace -> NameSpace -> Bool # (<=) :: NameSpace -> NameSpace -> Bool # (>) :: NameSpace -> NameSpace -> Bool # (>=) :: NameSpace -> NameSpace -> Bool # max :: NameSpace -> NameSpace -> NameSpace # min :: NameSpace -> NameSpace -> NameSpace #
Show NameSpace Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> NameSpace -> ShowS # show :: NameSpace -> String # showList :: [NameSpace] -> ShowS #
Generic NameSpace Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep NameSpace :: Type -> Type # Methods from :: NameSpace -> Rep NameSpace x # to :: Rep NameSpace x -> NameSpace #
Binary NameSpace Source #
Instance details Defined in GHCi.TH.Binary Methods put :: NameSpace -> Put # get :: Get NameSpace # putList :: [NameSpace] -> Put #
type Rep NameSpace Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep NameSpace = D1 (MetaData "NameSpace" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "VarName" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "DataName" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "TcClsName" PrefixI False) (U1 :: Type -> Type)))

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 (Maybe [TyVarBndr]) Type (Maybe Kind) [Con] [DerivClause]	{ data instance Cxt x => T [x] = A x \| B (T x) deriving (Z,W) deriving stock Eq }
NewtypeInstD Cxt (Maybe [TyVarBndr]) Type (Maybe Kind) Con [DerivClause]	{ newtype instance Cxt x => T [x] = A (B x) deriving (Z,W) deriving stock Eq }
TySynInstD TySynEqn	{ type instance ... }
OpenTypeFamilyD 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.
ImplicitParamBindD String Exp	{ ?x = expr } Implicit parameter binding declaration. Can only be used in let and where clauses which consist entirely of implicit bindings.

Instances

Eq Dec Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Dec -> Dec -> Bool # (/=) :: Dec -> Dec -> Bool #
Data Dec Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Dec -> c Dec # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Dec # toConstr :: Dec -> Constr # dataTypeOf :: Dec -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Dec) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Dec) # gmapT :: (forall b. Data b => b -> b) -> Dec -> Dec # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r # gmapQ :: (forall d. Data d => d -> u) -> Dec -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Dec -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Dec -> m Dec # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Dec -> m Dec # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Dec -> m Dec #
Ord Dec Source #
Instance details Defined in Language.Haskell.TH.Syntax 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 Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Dec -> ShowS # show :: Dec -> String # showList :: [Dec] -> ShowS #
Generic Dec Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Dec :: Type -> Type # Methods from :: Dec -> Rep Dec x # to :: Rep Dec x -> Dec #
Binary Dec Source #
Instance details Defined in GHCi.TH.Binary Methods put :: Dec -> Put # get :: Get Dec # putList :: [Dec] -> Put #
Ppr Dec Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Dec -> Doc Source # ppr_list :: [Dec] -> Doc Source #
type Rep Dec Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep Dec = D1 (MetaData "Dec" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" 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 (Maybe [TyVarBndr])) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type))) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Kind)) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Con]) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [DerivClause])))) :+: C1 (MetaCons "NewtypeInstD" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Cxt) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe [TyVarBndr])) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type))) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Kind)) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Con) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [DerivClause])))))) :+: (C1 (MetaCons "TySynInstD" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 TySynEqn)) :+: (C1 (MetaCons "OpenTypeFamilyD" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 TypeFamilyHead)) :+: C1 (MetaCons "ClosedTypeFamilyD" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 TypeFamilyHead) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [TySynEqn]))))) :+: ((C1 (MetaCons "RoleAnnotD" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Role])) :+: (C1 (MetaCons "StandaloneDerivD" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe DerivStrategy)) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Cxt) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type))) :+: C1 (MetaCons "DefaultSigD" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)))) :+: (C1 (MetaCons "PatSynD" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PatSynArgs)) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PatSynDir) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Pat))) :+: (C1 (MetaCons "PatSynSigD" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PatSynType)) :+: C1 (MetaCons "ImplicitParamBindD" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)))))))

data 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 Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Con -> Con -> Bool # (/=) :: Con -> Con -> Bool #
Data Con Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Con -> c Con # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Con # toConstr :: Con -> Constr # dataTypeOf :: Con -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Con) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Con) # gmapT :: (forall b. Data b => b -> b) -> Con -> Con # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r # gmapQ :: (forall d. Data d => d -> u) -> Con -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Con -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Con -> m Con # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Con -> m Con # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Con -> m Con #
Ord Con Source #
Instance details Defined in Language.Haskell.TH.Syntax 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 Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Con -> ShowS # show :: Con -> String # showList :: [Con] -> ShowS #
Generic Con Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Con :: Type -> Type # Methods from :: Con -> Rep Con x # to :: Rep Con x -> Con #
Binary Con Source #
Instance details Defined in GHCi.TH.Binary Methods put :: Con -> Put # get :: Get Con # putList :: [Con] -> Put #
Ppr Con Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Con -> Doc Source # ppr_list :: [Con] -> Doc Source #
type Rep Con Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep Con = D1 (MetaData "Con" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" 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 Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Clause -> Clause -> Bool # (/=) :: Clause -> Clause -> Bool #
Data Clause Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Clause -> c Clause # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Clause # toConstr :: Clause -> Constr # dataTypeOf :: Clause -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Clause) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Clause) # gmapT :: (forall b. Data b => b -> b) -> Clause -> Clause # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r # gmapQ :: (forall d. Data d => d -> u) -> Clause -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Clause -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Clause -> m Clause # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Clause -> m Clause # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Clause -> m Clause #
Ord Clause Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Clause -> Clause -> Ordering # (<) :: Clause -> Clause -> Bool # (<=) :: Clause -> Clause -> Bool # (>) :: Clause -> Clause -> Bool # (>=) :: Clause -> Clause -> Bool # max :: Clause -> Clause -> Clause # min :: Clause -> Clause -> Clause #
Show Clause Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Clause -> ShowS # show :: Clause -> String # showList :: [Clause] -> ShowS #
Generic Clause Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Clause :: Type -> Type # Methods from :: Clause -> Rep Clause x # to :: Rep Clause x -> Clause #
Binary Clause Source #
Instance details Defined in GHCi.TH.Binary Methods put :: Clause -> Put # get :: Get Clause # putList :: [Clause] -> Put #
Ppr Clause Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Clause -> Doc Source # ppr_list :: [Clause] -> Doc Source #
type Rep Clause Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep Clause = D1 (MetaData "Clause" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "Clause" 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]))))

data SourceUnpackedness Source #

Constructors

NoSourceUnpackedness	C a
SourceNoUnpack	C { {-# NOUNPACK #-} } a
SourceUnpack	C { {-# UNPACK #-} } a

Instances

Eq SourceUnpackedness Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool #
Data SourceUnpackedness Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceUnpackedness -> c SourceUnpackedness # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceUnpackedness # toConstr :: SourceUnpackedness -> Constr # dataTypeOf :: SourceUnpackedness -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SourceUnpackedness) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceUnpackedness) # gmapT :: (forall b. Data b => b -> b) -> SourceUnpackedness -> SourceUnpackedness # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r # gmapQ :: (forall d. Data d => d -> u) -> SourceUnpackedness -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceUnpackedness -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness #
Ord SourceUnpackedness Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering # (<) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (<=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (>) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (>=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness # min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness #
Show SourceUnpackedness Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> SourceUnpackedness -> ShowS # show :: SourceUnpackedness -> String # showList :: [SourceUnpackedness] -> ShowS #
Generic SourceUnpackedness Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep SourceUnpackedness :: Type -> Type # Methods from :: SourceUnpackedness -> Rep SourceUnpackedness x # to :: Rep SourceUnpackedness x -> SourceUnpackedness #
Binary SourceUnpackedness Source #
Instance details Defined in GHCi.TH.Binary Methods put :: SourceUnpackedness -> Put # get :: Get SourceUnpackedness # putList :: [SourceUnpackedness] -> Put #
Ppr SourceUnpackedness Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: SourceUnpackedness -> Doc Source # ppr_list :: [SourceUnpackedness] -> Doc Source #
type Rep SourceUnpackedness Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep SourceUnpackedness = D1 (MetaData "SourceUnpackedness" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "NoSourceUnpackedness" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "SourceNoUnpack" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "SourceUnpack" PrefixI False) (U1 :: Type -> Type)))

data SourceStrictness Source #

Constructors

NoSourceStrictness	C a
SourceLazy	C {~}a
SourceStrict	C {!}a

Instances

Eq SourceStrictness Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: SourceStrictness -> SourceStrictness -> Bool # (/=) :: SourceStrictness -> SourceStrictness -> Bool #
Data SourceStrictness Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceStrictness -> c SourceStrictness # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceStrictness # toConstr :: SourceStrictness -> Constr # dataTypeOf :: SourceStrictness -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SourceStrictness) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceStrictness) # gmapT :: (forall b. Data b => b -> b) -> SourceStrictness -> SourceStrictness # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r # gmapQ :: (forall d. Data d => d -> u) -> SourceStrictness -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceStrictness -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness #
Ord SourceStrictness Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: SourceStrictness -> SourceStrictness -> Ordering # (<) :: SourceStrictness -> SourceStrictness -> Bool # (<=) :: SourceStrictness -> SourceStrictness -> Bool # (>) :: SourceStrictness -> SourceStrictness -> Bool # (>=) :: SourceStrictness -> SourceStrictness -> Bool # max :: SourceStrictness -> SourceStrictness -> SourceStrictness # min :: SourceStrictness -> SourceStrictness -> SourceStrictness #
Show SourceStrictness Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> SourceStrictness -> ShowS # show :: SourceStrictness -> String # showList :: [SourceStrictness] -> ShowS #
Generic SourceStrictness Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep SourceStrictness :: Type -> Type # Methods from :: SourceStrictness -> Rep SourceStrictness x # to :: Rep SourceStrictness x -> SourceStrictness #
Binary SourceStrictness Source #
Instance details Defined in GHCi.TH.Binary Methods put :: SourceStrictness -> Put # get :: Get SourceStrictness # putList :: [SourceStrictness] -> Put #
Ppr SourceStrictness Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: SourceStrictness -> Doc Source # ppr_list :: [SourceStrictness] -> Doc Source #
type Rep SourceStrictness Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep SourceStrictness = D1 (MetaData "SourceStrictness" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "NoSourceStrictness" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "SourceLazy" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "SourceStrict" PrefixI False) (U1 :: Type -> Type)))

data 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.

Constructors

DecidedLazy
DecidedStrict
DecidedUnpack

Instances

Eq DecidedStrictness Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: DecidedStrictness -> DecidedStrictness -> Bool # (/=) :: DecidedStrictness -> DecidedStrictness -> Bool #
Data DecidedStrictness Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DecidedStrictness -> c DecidedStrictness # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DecidedStrictness # toConstr :: DecidedStrictness -> Constr # dataTypeOf :: DecidedStrictness -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DecidedStrictness) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DecidedStrictness) # gmapT :: (forall b. Data b => b -> b) -> DecidedStrictness -> DecidedStrictness # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r # gmapQ :: (forall d. Data d => d -> u) -> DecidedStrictness -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DecidedStrictness -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness #
Ord DecidedStrictness Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: DecidedStrictness -> DecidedStrictness -> Ordering # (<) :: DecidedStrictness -> DecidedStrictness -> Bool # (<=) :: DecidedStrictness -> DecidedStrictness -> Bool # (>) :: DecidedStrictness -> DecidedStrictness -> Bool # (>=) :: DecidedStrictness -> DecidedStrictness -> Bool # max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness # min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness #
Show DecidedStrictness Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> DecidedStrictness -> ShowS # show :: DecidedStrictness -> String # showList :: [DecidedStrictness] -> ShowS #
Generic DecidedStrictness Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep DecidedStrictness :: Type -> Type # Methods from :: DecidedStrictness -> Rep DecidedStrictness x # to :: Rep DecidedStrictness x -> DecidedStrictness #
Binary DecidedStrictness Source #
Instance details Defined in GHCi.TH.Binary Methods put :: DecidedStrictness -> Put # get :: Get DecidedStrictness # putList :: [DecidedStrictness] -> Put #
Ppr DecidedStrictness Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: DecidedStrictness -> Doc Source # ppr_list :: [DecidedStrictness] -> Doc Source #
type Rep DecidedStrictness Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep DecidedStrictness = D1 (MetaData "DecidedStrictness" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "DecidedLazy" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "DecidedStrict" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "DecidedUnpack" PrefixI False) (U1 :: Type -> Type)))

data Bang Source #

Constructors

Bang SourceUnpackedness SourceStrictness

C { {-# UNPACK #-} !}a

Instances

Eq Bang Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Bang -> Bang -> Bool # (/=) :: Bang -> Bang -> Bool #
Data Bang Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bang -> c Bang # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bang # toConstr :: Bang -> Constr # dataTypeOf :: Bang -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Bang) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bang) # gmapT :: (forall b. Data b => b -> b) -> Bang -> Bang # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r # gmapQ :: (forall d. Data d => d -> u) -> Bang -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Bang -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bang -> m Bang # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bang -> m Bang # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bang -> m Bang #
Ord Bang Source #
Instance details Defined in Language.Haskell.TH.Syntax 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 Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Bang -> ShowS # show :: Bang -> String # showList :: [Bang] -> ShowS #
Generic Bang Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Bang :: Type -> Type # Methods from :: Bang -> Rep Bang x # to :: Rep Bang x -> Bang #
Binary Bang Source #
Instance details Defined in GHCi.TH.Binary Methods put :: Bang -> Put # get :: Get Bang # putList :: [Bang] -> Put #
Ppr Bang Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Bang -> Doc Source # ppr_list :: [Bang] -> Doc Source #
type Rep Bang Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep Bang = D1 (MetaData "Bang" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "Bang" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SourceUnpackedness) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SourceStrictness)))

type Strict = Bang Source #

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

data Foreign Source #

Constructors

ImportF Callconv Safety String Name Type
ExportF Callconv String Name Type

Instances

Eq Foreign Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Foreign -> Foreign -> Bool # (/=) :: Foreign -> Foreign -> Bool #
Data Foreign Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Foreign -> c Foreign # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Foreign # toConstr :: Foreign -> Constr # dataTypeOf :: Foreign -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Foreign) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Foreign) # gmapT :: (forall b. Data b => b -> b) -> Foreign -> Foreign # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Foreign -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Foreign -> r # gmapQ :: (forall d. Data d => d -> u) -> Foreign -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Foreign -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Foreign -> m Foreign # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Foreign -> m Foreign # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Foreign -> m Foreign #
Ord Foreign Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Foreign -> Foreign -> Ordering # (<) :: Foreign -> Foreign -> Bool # (<=) :: Foreign -> Foreign -> Bool # (>) :: Foreign -> Foreign -> Bool # (>=) :: Foreign -> Foreign -> Bool # max :: Foreign -> Foreign -> Foreign # min :: Foreign -> Foreign -> Foreign #
Show Foreign Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Foreign -> ShowS # show :: Foreign -> String # showList :: [Foreign] -> ShowS #
Generic Foreign Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Foreign :: Type -> Type # Methods from :: Foreign -> Rep Foreign x # to :: Rep Foreign x -> Foreign #
Binary Foreign Source #
Instance details Defined in GHCi.TH.Binary Methods put :: Foreign -> Put # get :: Get Foreign # putList :: [Foreign] -> Put #
Ppr Foreign Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Foreign -> Doc Source # ppr_list :: [Foreign] -> Doc Source #
type Rep Foreign Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep Foreign = D1 (MetaData "Foreign" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "ImportF" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Callconv) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Safety)) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)))) :+: C1 (MetaCons "ExportF" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Callconv) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type))))

data Callconv Source #

Constructors

CCall
StdCall
CApi
Prim
JavaScript

Instances

Eq Callconv Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Callconv -> Callconv -> Bool # (/=) :: Callconv -> Callconv -> Bool #
Data Callconv Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Callconv -> c Callconv # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Callconv # toConstr :: Callconv -> Constr # dataTypeOf :: Callconv -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Callconv) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Callconv) # gmapT :: (forall b. Data b => b -> b) -> Callconv -> Callconv # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Callconv -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Callconv -> r # gmapQ :: (forall d. Data d => d -> u) -> Callconv -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Callconv -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Callconv -> m Callconv # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Callconv -> m Callconv # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Callconv -> m Callconv #
Ord Callconv Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Callconv -> Callconv -> Ordering # (<) :: Callconv -> Callconv -> Bool # (<=) :: Callconv -> Callconv -> Bool # (>) :: Callconv -> Callconv -> Bool # (>=) :: Callconv -> Callconv -> Bool # max :: Callconv -> Callconv -> Callconv # min :: Callconv -> Callconv -> Callconv #
Show Callconv Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Callconv -> ShowS # show :: Callconv -> String # showList :: [Callconv] -> ShowS #
Generic Callconv Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Callconv :: Type -> Type # Methods from :: Callconv -> Rep Callconv x # to :: Rep Callconv x -> Callconv #
Binary Callconv Source #
Instance details Defined in GHCi.TH.Binary Methods put :: Callconv -> Put # get :: Get Callconv # putList :: [Callconv] -> Put #
type Rep Callconv Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep Callconv = D1 (MetaData "Callconv" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) ((C1 (MetaCons "CCall" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "StdCall" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "CApi" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "Prim" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "JavaScript" PrefixI False) (U1 :: Type -> Type))))

data Safety Source #

Constructors

Unsafe
Safe
Interruptible

Instances

Eq Safety Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Safety -> Safety -> Bool # (/=) :: Safety -> Safety -> Bool #
Data Safety Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Safety -> c Safety # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Safety # toConstr :: Safety -> Constr # dataTypeOf :: Safety -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Safety) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Safety) # gmapT :: (forall b. Data b => b -> b) -> Safety -> Safety # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r # gmapQ :: (forall d. Data d => d -> u) -> Safety -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Safety -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Safety -> m Safety # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Safety -> m Safety # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Safety -> m Safety #
Ord Safety Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Safety -> Safety -> Ordering # (<) :: Safety -> Safety -> Bool # (<=) :: Safety -> Safety -> Bool # (>) :: Safety -> Safety -> Bool # (>=) :: Safety -> Safety -> Bool # max :: Safety -> Safety -> Safety # min :: Safety -> Safety -> Safety #
Show Safety Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Safety -> ShowS # show :: Safety -> String # showList :: [Safety] -> ShowS #
Generic Safety Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Safety :: Type -> Type # Methods from :: Safety -> Rep Safety x # to :: Rep Safety x -> Safety #
Binary Safety Source #
Instance details Defined in GHCi.TH.Binary Methods put :: Safety -> Put # get :: Get Safety # putList :: [Safety] -> Put #
type Rep Safety Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep Safety = D1 (MetaData "Safety" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "Unsafe" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "Safe" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "Interruptible" PrefixI False) (U1 :: Type -> Type)))

data Pragma Source #

Constructors

InlineP Name Inline RuleMatch Phases
SpecialiseP Name Type (Maybe Inline) Phases
SpecialiseInstP Type
RuleP String (Maybe [TyVarBndr]) [RuleBndr] Exp Exp Phases
AnnP AnnTarget Exp
LineP Int String
CompleteP [Name] (Maybe Name)	{ {-# COMPLETE C_1, ..., C_i [ :: T ] #-} }

Instances

Eq Pragma Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Pragma -> Pragma -> Bool # (/=) :: Pragma -> Pragma -> Bool #
Data Pragma Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Pragma -> c Pragma # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Pragma # toConstr :: Pragma -> Constr # dataTypeOf :: Pragma -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Pragma) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pragma) # gmapT :: (forall b. Data b => b -> b) -> Pragma -> Pragma # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pragma -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pragma -> r # gmapQ :: (forall d. Data d => d -> u) -> Pragma -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Pragma -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Pragma -> m Pragma # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Pragma -> m Pragma # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Pragma -> m Pragma #
Ord Pragma Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Pragma -> Pragma -> Ordering # (<) :: Pragma -> Pragma -> Bool # (<=) :: Pragma -> Pragma -> Bool # (>) :: Pragma -> Pragma -> Bool # (>=) :: Pragma -> Pragma -> Bool # max :: Pragma -> Pragma -> Pragma # min :: Pragma -> Pragma -> Pragma #
Show Pragma Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Pragma -> ShowS # show :: Pragma -> String # showList :: [Pragma] -> ShowS #
Generic Pragma Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Pragma :: Type -> Type # Methods from :: Pragma -> Rep Pragma x # to :: Rep Pragma x -> Pragma #
Binary Pragma Source #
Instance details Defined in GHCi.TH.Binary Methods put :: Pragma -> Put # get :: Get Pragma # putList :: [Pragma] -> Put #
Ppr Pragma Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Pragma -> Doc Source # ppr_list :: [Pragma] -> Doc Source #
type Rep Pragma Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep Pragma = D1 (MetaData "Pragma" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" 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 (Maybe [TyVarBndr])) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [RuleBndr]))) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Phases)))) :+: C1 (MetaCons "AnnP" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 AnnTarget) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp))) :+: (C1 (MetaCons "LineP" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)) :+: C1 (MetaCons "CompleteP" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Name]) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Name))))))

data Inline Source #

Constructors

NoInline
Inline
Inlinable

Instances

Eq Inline Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Inline -> Inline -> Bool # (/=) :: Inline -> Inline -> Bool #
Data Inline Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Inline -> c Inline # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Inline # toConstr :: Inline -> Constr # dataTypeOf :: Inline -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Inline) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inline) # gmapT :: (forall b. Data b => b -> b) -> Inline -> Inline # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r # gmapQ :: (forall d. Data d => d -> u) -> Inline -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Inline -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Inline -> m Inline # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Inline -> m Inline # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Inline -> m Inline #
Ord Inline Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Inline -> Inline -> Ordering # (<) :: Inline -> Inline -> Bool # (<=) :: Inline -> Inline -> Bool # (>) :: Inline -> Inline -> Bool # (>=) :: Inline -> Inline -> Bool # max :: Inline -> Inline -> Inline # min :: Inline -> Inline -> Inline #
Show Inline Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Inline -> ShowS # show :: Inline -> String # showList :: [Inline] -> ShowS #
Generic Inline Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Inline :: Type -> Type # Methods from :: Inline -> Rep Inline x # to :: Rep Inline x -> Inline #
Binary Inline Source #
Instance details Defined in GHCi.TH.Binary Methods put :: Inline -> Put # get :: Get Inline # putList :: [Inline] -> Put #
Ppr Inline Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Inline -> Doc Source # ppr_list :: [Inline] -> Doc Source #
type Rep Inline Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep Inline = D1 (MetaData "Inline" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "NoInline" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "Inline" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "Inlinable" PrefixI False) (U1 :: Type -> Type)))

data RuleMatch Source #

Constructors

ConLike
FunLike

Instances

Eq RuleMatch Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: RuleMatch -> RuleMatch -> Bool # (/=) :: RuleMatch -> RuleMatch -> Bool #
Data RuleMatch Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleMatch -> c RuleMatch # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RuleMatch # toConstr :: RuleMatch -> Constr # dataTypeOf :: RuleMatch -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RuleMatch) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleMatch) # gmapT :: (forall b. Data b => b -> b) -> RuleMatch -> RuleMatch # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleMatch -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleMatch -> r # gmapQ :: (forall d. Data d => d -> u) -> RuleMatch -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleMatch -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch #
Ord RuleMatch Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: RuleMatch -> RuleMatch -> Ordering # (<) :: RuleMatch -> RuleMatch -> Bool # (<=) :: RuleMatch -> RuleMatch -> Bool # (>) :: RuleMatch -> RuleMatch -> Bool # (>=) :: RuleMatch -> RuleMatch -> Bool # max :: RuleMatch -> RuleMatch -> RuleMatch # min :: RuleMatch -> RuleMatch -> RuleMatch #
Show RuleMatch Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> RuleMatch -> ShowS # show :: RuleMatch -> String # showList :: [RuleMatch] -> ShowS #
Generic RuleMatch Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep RuleMatch :: Type -> Type # Methods from :: RuleMatch -> Rep RuleMatch x # to :: Rep RuleMatch x -> RuleMatch #
Binary RuleMatch Source #
Instance details Defined in GHCi.TH.Binary Methods put :: RuleMatch -> Put # get :: Get RuleMatch # putList :: [RuleMatch] -> Put #
Ppr RuleMatch Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: RuleMatch -> Doc Source # ppr_list :: [RuleMatch] -> Doc Source #
type Rep RuleMatch Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep RuleMatch = D1 (MetaData "RuleMatch" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "ConLike" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "FunLike" PrefixI False) (U1 :: Type -> Type))

data Phases Source #

Constructors

AllPhases
FromPhase Int
BeforePhase Int

Instances

Eq Phases Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Phases -> Phases -> Bool # (/=) :: Phases -> Phases -> Bool #
Data Phases Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Phases -> c Phases # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Phases # toConstr :: Phases -> Constr # dataTypeOf :: Phases -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Phases) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Phases) # gmapT :: (forall b. Data b => b -> b) -> Phases -> Phases # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Phases -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Phases -> r # gmapQ :: (forall d. Data d => d -> u) -> Phases -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Phases -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Phases -> m Phases # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Phases -> m Phases # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Phases -> m Phases #
Ord Phases Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Phases -> Phases -> Ordering # (<) :: Phases -> Phases -> Bool # (<=) :: Phases -> Phases -> Bool # (>) :: Phases -> Phases -> Bool # (>=) :: Phases -> Phases -> Bool # max :: Phases -> Phases -> Phases # min :: Phases -> Phases -> Phases #
Show Phases Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Phases -> ShowS # show :: Phases -> String # showList :: [Phases] -> ShowS #
Generic Phases Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Phases :: Type -> Type # Methods from :: Phases -> Rep Phases x # to :: Rep Phases x -> Phases #
Binary Phases Source #
Instance details Defined in GHCi.TH.Binary Methods put :: Phases -> Put # get :: Get Phases # putList :: [Phases] -> Put #
Ppr Phases Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Phases -> Doc Source # ppr_list :: [Phases] -> Doc Source #
type Rep Phases Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep Phases = D1 (MetaData "Phases" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "AllPhases" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "FromPhase" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)) :+: C1 (MetaCons "BeforePhase" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int))))

data RuleBndr Source #

Constructors

RuleVar Name
TypedRuleVar Name Type

Instances

Eq RuleBndr Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: RuleBndr -> RuleBndr -> Bool # (/=) :: RuleBndr -> RuleBndr -> Bool #
Data RuleBndr Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleBndr -> c RuleBndr # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RuleBndr # toConstr :: RuleBndr -> Constr # dataTypeOf :: RuleBndr -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RuleBndr) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleBndr) # gmapT :: (forall b. Data b => b -> b) -> RuleBndr -> RuleBndr # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr -> r # gmapQ :: (forall d. Data d => d -> u) -> RuleBndr -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleBndr -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr #
Ord RuleBndr Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: RuleBndr -> RuleBndr -> Ordering # (<) :: RuleBndr -> RuleBndr -> Bool # (<=) :: RuleBndr -> RuleBndr -> Bool # (>) :: RuleBndr -> RuleBndr -> Bool # (>=) :: RuleBndr -> RuleBndr -> Bool # max :: RuleBndr -> RuleBndr -> RuleBndr # min :: RuleBndr -> RuleBndr -> RuleBndr #
Show RuleBndr Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> RuleBndr -> ShowS # show :: RuleBndr -> String # showList :: [RuleBndr] -> ShowS #
Generic RuleBndr Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep RuleBndr :: Type -> Type # Methods from :: RuleBndr -> Rep RuleBndr x # to :: Rep RuleBndr x -> RuleBndr #
Binary RuleBndr Source #
Instance details Defined in GHCi.TH.Binary Methods put :: RuleBndr -> Put # get :: Get RuleBndr # putList :: [RuleBndr] -> Put #
Ppr RuleBndr Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: RuleBndr -> Doc Source # ppr_list :: [RuleBndr] -> Doc Source #
type Rep RuleBndr Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep RuleBndr = D1 (MetaData "RuleBndr" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "RuleVar" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) :+: C1 (MetaCons "TypedRuleVar" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)))

data AnnTarget Source #

Constructors

ModuleAnnotation
TypeAnnotation Name
ValueAnnotation Name

Instances

Eq AnnTarget Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: AnnTarget -> AnnTarget -> Bool # (/=) :: AnnTarget -> AnnTarget -> Bool #
Data AnnTarget Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnTarget -> c AnnTarget # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnTarget # toConstr :: AnnTarget -> Constr # dataTypeOf :: AnnTarget -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnTarget) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnTarget) # gmapT :: (forall b. Data b => b -> b) -> AnnTarget -> AnnTarget # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnTarget -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnTarget -> r # gmapQ :: (forall d. Data d => d -> u) -> AnnTarget -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnTarget -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget #
Ord AnnTarget Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: AnnTarget -> AnnTarget -> Ordering # (<) :: AnnTarget -> AnnTarget -> Bool # (<=) :: AnnTarget -> AnnTarget -> Bool # (>) :: AnnTarget -> AnnTarget -> Bool # (>=) :: AnnTarget -> AnnTarget -> Bool # max :: AnnTarget -> AnnTarget -> AnnTarget # min :: AnnTarget -> AnnTarget -> AnnTarget #
Show AnnTarget Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> AnnTarget -> ShowS # show :: AnnTarget -> String # showList :: [AnnTarget] -> ShowS #
Generic AnnTarget Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep AnnTarget :: Type -> Type # Methods from :: AnnTarget -> Rep AnnTarget x # to :: Rep AnnTarget x -> AnnTarget #
Binary AnnTarget Source #
Instance details Defined in GHCi.TH.Binary Methods put :: AnnTarget -> Put # get :: Get AnnTarget # putList :: [AnnTarget] -> Put #
type Rep AnnTarget Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep AnnTarget = D1 (MetaData "AnnTarget" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "ModuleAnnotation" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "TypeAnnotation" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) :+: C1 (MetaCons "ValueAnnotation" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name))))

data FunDep Source #

Constructors

FunDep [Name] [Name]

Instances

Eq FunDep Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: FunDep -> FunDep -> Bool # (/=) :: FunDep -> FunDep -> Bool #
Data FunDep Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunDep -> c FunDep # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FunDep # toConstr :: FunDep -> Constr # dataTypeOf :: FunDep -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FunDep) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunDep) # gmapT :: (forall b. Data b => b -> b) -> FunDep -> FunDep # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r # gmapQ :: (forall d. Data d => d -> u) -> FunDep -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FunDep -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunDep -> m FunDep # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep -> m FunDep # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep -> m FunDep #
Ord FunDep Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: FunDep -> FunDep -> Ordering # (<) :: FunDep -> FunDep -> Bool # (<=) :: FunDep -> FunDep -> Bool # (>) :: FunDep -> FunDep -> Bool # (>=) :: FunDep -> FunDep -> Bool # max :: FunDep -> FunDep -> FunDep # min :: FunDep -> FunDep -> FunDep #
Show FunDep Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> FunDep -> ShowS # show :: FunDep -> String # showList :: [FunDep] -> ShowS #
Generic FunDep Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep FunDep :: Type -> Type # Methods from :: FunDep -> Rep FunDep x # to :: Rep FunDep x -> FunDep #
Binary FunDep Source #
Instance details Defined in GHCi.TH.Binary Methods put :: FunDep -> Put # get :: Get FunDep # putList :: [FunDep] -> Put #
Ppr FunDep Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: FunDep -> Doc Source # ppr_list :: [FunDep] -> Doc Source #
type Rep FunDep Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep FunDep = D1 (MetaData "FunDep" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "FunDep" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Name]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Name])))

data TySynEqn Source #

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

For instance, if you had the following type family:

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

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

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

Constructors

TySynEqn (Maybe [TyVarBndr]) Type Type

Instances

Eq TySynEqn Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: TySynEqn -> TySynEqn -> Bool # (/=) :: TySynEqn -> TySynEqn -> Bool #
Data TySynEqn Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TySynEqn -> c TySynEqn # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TySynEqn # toConstr :: TySynEqn -> Constr # dataTypeOf :: TySynEqn -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TySynEqn) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TySynEqn) # gmapT :: (forall b. Data b => b -> b) -> TySynEqn -> TySynEqn # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TySynEqn -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TySynEqn -> r # gmapQ :: (forall d. Data d => d -> u) -> TySynEqn -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TySynEqn -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn #
Ord TySynEqn Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: TySynEqn -> TySynEqn -> Ordering # (<) :: TySynEqn -> TySynEqn -> Bool # (<=) :: TySynEqn -> TySynEqn -> Bool # (>) :: TySynEqn -> TySynEqn -> Bool # (>=) :: TySynEqn -> TySynEqn -> Bool # max :: TySynEqn -> TySynEqn -> TySynEqn # min :: TySynEqn -> TySynEqn -> TySynEqn #
Show TySynEqn Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> TySynEqn -> ShowS # show :: TySynEqn -> String # showList :: [TySynEqn] -> ShowS #
Generic TySynEqn Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TySynEqn :: Type -> Type # Methods from :: TySynEqn -> Rep TySynEqn x # to :: Rep TySynEqn x -> TySynEqn #
Binary TySynEqn Source #
Instance details Defined in GHCi.TH.Binary Methods put :: TySynEqn -> Put # get :: Get TySynEqn # putList :: [TySynEqn] -> Put #
type Rep TySynEqn Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep TySynEqn = D1 (MetaData "TySynEqn" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "TySynEqn" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe [TyVarBndr])) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type))))

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.

Constructors

TypeFamilyHead Name [TyVarBndr] FamilyResultSig (Maybe InjectivityAnn)

Instances

Eq TypeFamilyHead Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (/=) :: TypeFamilyHead -> TypeFamilyHead -> Bool #
Data TypeFamilyHead Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypeFamilyHead -> c TypeFamilyHead # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TypeFamilyHead # toConstr :: TypeFamilyHead -> Constr # dataTypeOf :: TypeFamilyHead -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TypeFamilyHead) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeFamilyHead) # gmapT :: (forall b. Data b => b -> b) -> TypeFamilyHead -> TypeFamilyHead # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r # gmapQ :: (forall d. Data d => d -> u) -> TypeFamilyHead -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeFamilyHead -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeFamilyHead -> m TypeFamilyHead # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeFamilyHead -> m TypeFamilyHead # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeFamilyHead -> m TypeFamilyHead #
Ord TypeFamilyHead Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: TypeFamilyHead -> TypeFamilyHead -> Ordering # (<) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (<=) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (>) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (>=) :: TypeFamilyHead -> TypeFamilyHead -> Bool # max :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead # min :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead #
Show TypeFamilyHead Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> TypeFamilyHead -> ShowS # show :: TypeFamilyHead -> String # showList :: [TypeFamilyHead] -> ShowS #
Generic TypeFamilyHead Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TypeFamilyHead :: Type -> Type # Methods from :: TypeFamilyHead -> Rep TypeFamilyHead x # to :: Rep TypeFamilyHead x -> TypeFamilyHead #
Binary TypeFamilyHead Source #
Instance details Defined in GHCi.TH.Binary Methods put :: TypeFamilyHead -> Put # get :: Get TypeFamilyHead # putList :: [TypeFamilyHead] -> Put #
type Rep TypeFamilyHead Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep TypeFamilyHead = D1 (MetaData "TypeFamilyHead" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "TypeFamilyHead" 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 FamilyResultSig) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe InjectivityAnn)))))

data Fixity Source #

Constructors

Fixity Int FixityDirection

Instances

Eq Fixity Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Fixity -> Fixity -> Bool # (/=) :: Fixity -> Fixity -> Bool #
Data Fixity Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Fixity -> c Fixity # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Fixity # toConstr :: Fixity -> Constr # dataTypeOf :: Fixity -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Fixity) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity) # gmapT :: (forall b. Data b => b -> b) -> Fixity -> Fixity # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r # gmapQ :: (forall d. Data d => d -> u) -> Fixity -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Fixity -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity #
Ord Fixity Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Fixity -> Fixity -> Ordering # (<) :: Fixity -> Fixity -> Bool # (<=) :: Fixity -> Fixity -> Bool # (>) :: Fixity -> Fixity -> Bool # (>=) :: Fixity -> Fixity -> Bool # max :: Fixity -> Fixity -> Fixity # min :: Fixity -> Fixity -> Fixity #
Show Fixity Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Fixity -> ShowS # show :: Fixity -> String # showList :: [Fixity] -> ShowS #
Generic Fixity Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Fixity :: Type -> Type # Methods from :: Fixity -> Rep Fixity x # to :: Rep Fixity x -> Fixity #
Binary Fixity Source #
Instance details Defined in GHCi.TH.Binary Methods put :: Fixity -> Put # get :: Get Fixity # putList :: [Fixity] -> Put #
type Rep Fixity Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep Fixity = D1 (MetaData "Fixity" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "Fixity" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 FixityDirection)))

data FixityDirection Source #

Constructors

InfixL
InfixR
InfixN

Instances

Eq FixityDirection Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: FixityDirection -> FixityDirection -> Bool # (/=) :: FixityDirection -> FixityDirection -> Bool #
Data FixityDirection Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FixityDirection -> c FixityDirection # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FixityDirection # toConstr :: FixityDirection -> Constr # dataTypeOf :: FixityDirection -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FixityDirection) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FixityDirection) # gmapT :: (forall b. Data b => b -> b) -> FixityDirection -> FixityDirection # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r # gmapQ :: (forall d. Data d => d -> u) -> FixityDirection -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FixityDirection -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection #
Ord FixityDirection Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: FixityDirection -> FixityDirection -> Ordering # (<) :: FixityDirection -> FixityDirection -> Bool # (<=) :: FixityDirection -> FixityDirection -> Bool # (>) :: FixityDirection -> FixityDirection -> Bool # (>=) :: FixityDirection -> FixityDirection -> Bool # max :: FixityDirection -> FixityDirection -> FixityDirection # min :: FixityDirection -> FixityDirection -> FixityDirection #
Show FixityDirection Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> FixityDirection -> ShowS # show :: FixityDirection -> String # showList :: [FixityDirection] -> ShowS #
Generic FixityDirection Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep FixityDirection :: Type -> Type # Methods from :: FixityDirection -> Rep FixityDirection x # to :: Rep FixityDirection x -> FixityDirection #
Binary FixityDirection Source #
Instance details Defined in GHCi.TH.Binary Methods put :: FixityDirection -> Put # get :: Get FixityDirection # putList :: [FixityDirection] -> Put #
type Rep FixityDirection Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep FixityDirection = D1 (MetaData "FixityDirection" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "InfixL" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "InfixR" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "InfixN" PrefixI False) (U1 :: Type -> Type)))

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 Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: PatSynDir -> PatSynDir -> Bool # (/=) :: PatSynDir -> PatSynDir -> Bool #
Data PatSynDir Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PatSynDir -> c PatSynDir # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PatSynDir # toConstr :: PatSynDir -> Constr # dataTypeOf :: PatSynDir -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PatSynDir) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatSynDir) # gmapT :: (forall b. Data b => b -> b) -> PatSynDir -> PatSynDir # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PatSynDir -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PatSynDir -> r # gmapQ :: (forall d. Data d => d -> u) -> PatSynDir -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PatSynDir -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir #
Ord PatSynDir Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: PatSynDir -> PatSynDir -> Ordering # (<) :: PatSynDir -> PatSynDir -> Bool # (<=) :: PatSynDir -> PatSynDir -> Bool # (>) :: PatSynDir -> PatSynDir -> Bool # (>=) :: PatSynDir -> PatSynDir -> Bool # max :: PatSynDir -> PatSynDir -> PatSynDir # min :: PatSynDir -> PatSynDir -> PatSynDir #
Show PatSynDir Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> PatSynDir -> ShowS # show :: PatSynDir -> String # showList :: [PatSynDir] -> ShowS #
Generic PatSynDir Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep PatSynDir :: Type -> Type # Methods from :: PatSynDir -> Rep PatSynDir x # to :: Rep PatSynDir x -> PatSynDir #
Binary PatSynDir Source #
Instance details Defined in GHCi.TH.Binary Methods put :: PatSynDir -> Put # get :: Get PatSynDir # putList :: [PatSynDir] -> Put #
Ppr PatSynDir Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: PatSynDir -> Doc Source # ppr_list :: [PatSynDir] -> Doc Source #
type Rep PatSynDir Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep PatSynDir = D1 (MetaData "PatSynDir" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "Unidir" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "ImplBidir" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "ExplBidir" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Clause]))))

data PatSynArgs Source #

A pattern synonym's argument type.

Constructors

PrefixPatSyn [Name]	pattern P {x y z} = p
InfixPatSyn Name Name	pattern {x P y} = p
RecordPatSyn [Name]	pattern P { {x,y,z} } = p

Instances

Eq PatSynArgs Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: PatSynArgs -> PatSynArgs -> Bool # (/=) :: PatSynArgs -> PatSynArgs -> Bool #
Data PatSynArgs Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PatSynArgs -> c PatSynArgs # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PatSynArgs # toConstr :: PatSynArgs -> Constr # dataTypeOf :: PatSynArgs -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PatSynArgs) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatSynArgs) # gmapT :: (forall b. Data b => b -> b) -> PatSynArgs -> PatSynArgs # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PatSynArgs -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PatSynArgs -> r # gmapQ :: (forall d. Data d => d -> u) -> PatSynArgs -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PatSynArgs -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs #
Ord PatSynArgs Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: PatSynArgs -> PatSynArgs -> Ordering # (<) :: PatSynArgs -> PatSynArgs -> Bool # (<=) :: PatSynArgs -> PatSynArgs -> Bool # (>) :: PatSynArgs -> PatSynArgs -> Bool # (>=) :: PatSynArgs -> PatSynArgs -> Bool # max :: PatSynArgs -> PatSynArgs -> PatSynArgs # min :: PatSynArgs -> PatSynArgs -> PatSynArgs #
Show PatSynArgs Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> PatSynArgs -> ShowS # show :: PatSynArgs -> String # showList :: [PatSynArgs] -> ShowS #
Generic PatSynArgs Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep PatSynArgs :: Type -> Type # Methods from :: PatSynArgs -> Rep PatSynArgs x # to :: Rep PatSynArgs x -> PatSynArgs #
Binary PatSynArgs Source #
Instance details Defined in GHCi.TH.Binary Methods put :: PatSynArgs -> Put # get :: Get PatSynArgs # putList :: [PatSynArgs] -> Put #
Ppr PatSynArgs Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: PatSynArgs -> Doc Source # ppr_list :: [PatSynArgs] -> Doc Source #
type Rep PatSynArgs Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep PatSynArgs = D1 (MetaData "PatSynArgs" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "PrefixPatSyn" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Name])) :+: (C1 (MetaCons "InfixPatSyn" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) :+: C1 (MetaCons "RecordPatSyn" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Name]))))

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 } }
MDoE [Stmt]	{ mdo { x <- e1 y; y <- e2 x; } }
CompE [Stmt]	{ [ (x,y) \| x <- xs, y <- ys ] } The result expression of the comprehension is the last of the `Stmt`s, and should be a `NoBindS`. E.g. translation: [ f x \| x <- xs ] CompE [BindS (VarP x) (VarE xs), NoBindS (AppE (VarE f) (VarE x))]
ArithSeqE Range	{ [ 1 ,2 .. 10 ] }
ListE [Exp]	{ [1,2,3] }
SigE Exp Type	{ e :: t }
RecConE Name [FieldExp]	{ T { x = y, z = w } }
RecUpdE Exp [FieldExp]	{ (f x) { z = w } }
StaticE Exp	{ static e }
UnboundVarE Name	{ _x } This is used for holes or unresolved identifiers in AST quotes. Note that it could either have a variable name or constructor name.
LabelE String	`{ #x }` ( Overloaded label )
ImplicitParamVarE String	`{ ?x }` ( Implicit parameter )

Instances

Eq Exp Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Exp -> Exp -> Bool # (/=) :: Exp -> Exp -> Bool #
Data Exp Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Exp -> c Exp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Exp # toConstr :: Exp -> Constr # dataTypeOf :: Exp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Exp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp) # gmapT :: (forall b. Data b => b -> b) -> Exp -> Exp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r # gmapQ :: (forall d. Data d => d -> u) -> Exp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Exp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Exp -> m Exp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp -> m Exp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp -> m Exp #
Ord Exp Source #
Instance details Defined in Language.Haskell.TH.Syntax 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 Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Exp -> ShowS # show :: Exp -> String # showList :: [Exp] -> ShowS #
Generic Exp Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Exp :: Type -> Type # Methods from :: Exp -> Rep Exp x # to :: Rep Exp x -> Exp #
Binary Exp Source #
Instance details Defined in GHCi.TH.Binary Methods put :: Exp -> Put # get :: Get Exp # putList :: [Exp] -> Put #
Ppr Exp Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Exp -> Doc Source # ppr_list :: [Exp] -> Doc Source #
type Rep Exp Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep Exp = D1 (MetaData "Exp" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" 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 "MDoE" 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)) :+: C1 (MetaCons "ImplicitParamVarE" 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 Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Match -> Match -> Bool # (/=) :: Match -> Match -> Bool #
Data Match Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Match -> c Match # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Match # toConstr :: Match -> Constr # dataTypeOf :: Match -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Match) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match) # gmapT :: (forall b. Data b => b -> b) -> Match -> Match # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r # gmapQ :: (forall d. Data d => d -> u) -> Match -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Match -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Match -> m Match # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Match -> m Match # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Match -> m Match #
Ord Match Source #
Instance details Defined in Language.Haskell.TH.Syntax 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 Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Match -> ShowS # show :: Match -> String # showList :: [Match] -> ShowS #
Generic Match Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Match :: Type -> Type # Methods from :: Match -> Rep Match x # to :: Rep Match x -> Match #
Binary Match Source #
Instance details Defined in GHCi.TH.Binary Methods put :: Match -> Put # get :: Get Match # putList :: [Match] -> Put #
Ppr Match Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Match -> Doc Source # ppr_list :: [Match] -> Doc Source #
type Rep Match Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep Match = D1 (MetaData "Match" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "Match" 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]))))

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 Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Body -> Body -> Bool # (/=) :: Body -> Body -> Bool #
Data Body Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Body -> c Body # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Body # toConstr :: Body -> Constr # dataTypeOf :: Body -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Body) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Body) # gmapT :: (forall b. Data b => b -> b) -> Body -> Body # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r # gmapQ :: (forall d. Data d => d -> u) -> Body -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Body -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Body -> m Body # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Body -> m Body # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Body -> m Body #
Ord Body Source #
Instance details Defined in Language.Haskell.TH.Syntax 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 Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Body -> ShowS # show :: Body -> String # showList :: [Body] -> ShowS #
Generic Body Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Body :: Type -> Type # Methods from :: Body -> Rep Body x # to :: Rep Body x -> Body #
Binary Body Source #
Instance details Defined in GHCi.TH.Binary Methods put :: Body -> Put # get :: Get Body # putList :: [Body] -> Put #
type Rep Body Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep Body = D1 (MetaData "Body" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "GuardedB" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [(Guard, Exp)])) :+: C1 (MetaCons "NormalB" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)))

data Guard Source #

Constructors

NormalG Exp	f x { \| odd x } = x
PatG [Stmt]	f x { \| Just y <- x, Just z <- y } = z

Instances

Eq Guard Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Guard -> Guard -> Bool # (/=) :: Guard -> Guard -> Bool #
Data Guard Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Guard -> c Guard # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Guard # toConstr :: Guard -> Constr # dataTypeOf :: Guard -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Guard) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Guard) # gmapT :: (forall b. Data b => b -> b) -> Guard -> Guard # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r # gmapQ :: (forall d. Data d => d -> u) -> Guard -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Guard -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Guard -> m Guard # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Guard -> m Guard # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Guard -> m Guard #
Ord Guard Source #
Instance details Defined in Language.Haskell.TH.Syntax 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 Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Guard -> ShowS # show :: Guard -> String # showList :: [Guard] -> ShowS #
Generic Guard Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Guard :: Type -> Type # Methods from :: Guard -> Rep Guard x # to :: Rep Guard x -> Guard #
Binary Guard Source #
Instance details Defined in GHCi.TH.Binary Methods put :: Guard -> Put # get :: Get Guard # putList :: [Guard] -> Put #
type Rep Guard Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep Guard = D1 (MetaData "Guard" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "NormalG" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) :+: C1 (MetaCons "PatG" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Stmt])))

data Stmt Source #

Constructors

BindS Pat Exp	p <- e
LetS [Dec]	{ let { x=e1; y=e2 } }
NoBindS Exp	e
ParS [[Stmt]]	`x <- e1 \| s2, s3 \| s4` (in `CompE`)
RecS [Stmt]	rec { s1; s2 }

Instances

Eq Stmt Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Stmt -> Stmt -> Bool # (/=) :: Stmt -> Stmt -> Bool #
Data Stmt Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Stmt -> c Stmt # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Stmt # toConstr :: Stmt -> Constr # dataTypeOf :: Stmt -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Stmt) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stmt) # gmapT :: (forall b. Data b => b -> b) -> Stmt -> Stmt # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r # gmapQ :: (forall d. Data d => d -> u) -> Stmt -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Stmt -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Stmt -> m Stmt # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Stmt -> m Stmt # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Stmt -> m Stmt #
Ord Stmt Source #
Instance details Defined in Language.Haskell.TH.Syntax 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 Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Stmt -> ShowS # show :: Stmt -> String # showList :: [Stmt] -> ShowS #
Generic Stmt Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Stmt :: Type -> Type # Methods from :: Stmt -> Rep Stmt x # to :: Rep Stmt x -> Stmt #
Binary Stmt Source #
Instance details Defined in GHCi.TH.Binary Methods put :: Stmt -> Put # get :: Get Stmt # putList :: [Stmt] -> Put #
Ppr Stmt Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Stmt -> Doc Source # ppr_list :: [Stmt] -> Doc Source #
type Rep Stmt Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep Stmt = D1 (MetaData "Stmt" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) ((C1 (MetaCons "BindS" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Pat) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) :+: C1 (MetaCons "LetS" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Dec]))) :+: (C1 (MetaCons "NoBindS" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) :+: (C1 (MetaCons "ParS" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [[Stmt]])) :+: C1 (MetaCons "RecS" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Stmt])))))

data Range Source #

Constructors

FromR Exp
FromThenR Exp Exp
FromToR Exp Exp
FromThenToR Exp Exp Exp

Instances

Eq Range Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Range -> Range -> Bool # (/=) :: Range -> Range -> Bool #
Data Range Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Range -> c Range # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Range # toConstr :: Range -> Constr # dataTypeOf :: Range -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Range) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Range) # gmapT :: (forall b. Data b => b -> b) -> Range -> Range # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r # gmapQ :: (forall d. Data d => d -> u) -> Range -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Range -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Range -> m Range # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Range -> m Range # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Range -> m Range #
Ord Range Source #
Instance details Defined in Language.Haskell.TH.Syntax 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 Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Range -> ShowS # show :: Range -> String # showList :: [Range] -> ShowS #
Generic Range Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Range :: Type -> Type # Methods from :: Range -> Rep Range x # to :: Rep Range x -> Range #
Binary Range Source #
Instance details Defined in GHCi.TH.Binary Methods put :: Range -> Put # get :: Get Range # putList :: [Range] -> Put #
Ppr Range Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Range -> Doc Source # ppr_list :: [Range] -> Doc Source #
type Rep Range Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep Range = D1 (MetaData "Range" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) ((C1 (MetaCons "FromR" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) :+: C1 (MetaCons "FromThenR" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp))) :+: (C1 (MetaCons "FromToR" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) :+: C1 (MetaCons "FromThenToR" 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)))))

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 Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Lit -> Lit -> Bool # (/=) :: Lit -> Lit -> Bool #
Data Lit Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Lit -> c Lit # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Lit # toConstr :: Lit -> Constr # dataTypeOf :: Lit -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Lit) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lit) # gmapT :: (forall b. Data b => b -> b) -> Lit -> Lit # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r # gmapQ :: (forall d. Data d => d -> u) -> Lit -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Lit -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Lit -> m Lit # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Lit -> m Lit # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Lit -> m Lit #
Ord Lit Source #
Instance details Defined in Language.Haskell.TH.Syntax 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 Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Lit -> ShowS # show :: Lit -> String # showList :: [Lit] -> ShowS #
Generic Lit Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Lit :: Type -> Type # Methods from :: Lit -> Rep Lit x # to :: Rep Lit x -> Lit #
Binary Lit Source #
Instance details Defined in GHCi.TH.Binary Methods put :: Lit -> Put # get :: Get Lit # putList :: [Lit] -> Put #
Ppr Lit Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Lit -> Doc Source # ppr_list :: [Lit] -> Doc Source #
type Rep Lit Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep Lit = D1 (MetaData "Lit" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" 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 Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Pat -> Pat -> Bool # (/=) :: Pat -> Pat -> Bool #
Data Pat Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Pat -> c Pat # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Pat # toConstr :: Pat -> Constr # dataTypeOf :: Pat -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Pat) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat) # gmapT :: (forall b. Data b => b -> b) -> Pat -> Pat # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r # gmapQ :: (forall d. Data d => d -> u) -> Pat -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Pat -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Pat -> m Pat # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Pat -> m Pat # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Pat -> m Pat #
Ord Pat Source #
Instance details Defined in Language.Haskell.TH.Syntax 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 Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Pat -> ShowS # show :: Pat -> String # showList :: [Pat] -> ShowS #
Generic Pat Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Pat :: Type -> Type # Methods from :: Pat -> Rep Pat x # to :: Rep Pat x -> Pat #
Binary Pat Source #
Instance details Defined in GHCi.TH.Binary Methods put :: Pat -> Put # get :: Get Pat # putList :: [Pat] -> Put #
Ppr Pat Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Pat -> Doc Source # ppr_list :: [Pat] -> Doc Source #
type Rep Pat Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep Pat = D1 (MetaData "Pat" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" 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 :: Type -> Type) :+: C1 (MetaCons "RecP" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [FieldPat]))) :+: (C1 (MetaCons "ListP" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Pat])) :+: (C1 (MetaCons "SigP" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Pat) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)) :+: C1 (MetaCons "ViewP" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Pat)))))))

type FieldExp = (Name, Exp) Source #

type FieldPat = (Name, Pat) Source #

Types

data Type Source #

Constructors

ForallT [TyVarBndr] Cxt Type	forall <vars>. <ctxt> => <type>
AppT Type Type	T a b
AppKindT Type Kind	T @k t
SigT Type Kind	t :: k
VarT Name	a
ConT Name	T
PromotedT Name	'T
InfixT Type Name Type	T + T
UInfixT Type Name Type	T + T See Language.Haskell.TH.Syntax
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	_
ImplicitParamT String Type	?x :: t

Instances

Eq Type Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Type -> Type -> Bool # (/=) :: Type -> Type -> Bool #
Data Type Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Type -> c Type # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Type # toConstr :: Type -> Constr # dataTypeOf :: Type -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Type) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type) # gmapT :: (forall b. Data b => b -> b) -> Type -> Type # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r # gmapQ :: (forall d. Data d => d -> u) -> Type -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Type -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Type -> m Type # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type #
Ord Type Source #
Instance details Defined in Language.Haskell.TH.Syntax 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 Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Type -> ShowS # show :: Type -> String # showList :: [Type] -> ShowS #
Generic Type Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Type :: Type -> Type # Methods from :: Type -> Rep Type x # to :: Rep Type x -> Type #
Binary Type Source #
Instance details Defined in GHCi.TH.Binary Methods put :: Type -> Put # get :: Get Type # putList :: [Type] -> Put #
Ppr Type Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Type -> Doc Source # ppr_list :: [Type] -> Doc Source #
type Rep Type Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep Type = D1 (MetaData "Type" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" 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 "AppKindT" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Kind)))) :+: (C1 (MetaCons "SigT" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Kind)) :+: (C1 (MetaCons "VarT" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) :+: C1 (MetaCons "ConT" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name))))) :+: ((C1 (MetaCons "PromotedT" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) :+: (C1 (MetaCons "InfixT" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type))) :+: C1 (MetaCons "UInfixT" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type))))) :+: (C1 (MetaCons "ParensT" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)) :+: (C1 (MetaCons "TupleT" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)) :+: C1 (MetaCons "UnboxedTupleT" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)))))) :+: (((C1 (MetaCons "UnboxedSumT" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SumArity)) :+: (C1 (MetaCons "ArrowT" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "EqualityT" PrefixI False) (U1 :: Type -> Type))) :+: (C1 (MetaCons "ListT" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "PromotedTupleT" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)) :+: C1 (MetaCons "PromotedNilT" PrefixI False) (U1 :: Type -> Type)))) :+: ((C1 (MetaCons "PromotedConsT" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "StarT" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "ConstraintT" PrefixI False) (U1 :: Type -> Type))) :+: (C1 (MetaCons "LitT" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 TyLit)) :+: (C1 (MetaCons "WildCardT" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "ImplicitParamT" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)))))))

data TyVarBndr Source #

Constructors

PlainTV Name	a
KindedTV Name Kind	(a :: k)

Instances

Eq TyVarBndr Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: TyVarBndr -> TyVarBndr -> Bool # (/=) :: TyVarBndr -> TyVarBndr -> Bool #
Data TyVarBndr Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyVarBndr -> c TyVarBndr # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TyVarBndr # toConstr :: TyVarBndr -> Constr # dataTypeOf :: TyVarBndr -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TyVarBndr) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyVarBndr) # gmapT :: (forall b. Data b => b -> b) -> TyVarBndr -> TyVarBndr # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyVarBndr -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyVarBndr -> r # gmapQ :: (forall d. Data d => d -> u) -> TyVarBndr -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TyVarBndr -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyVarBndr -> m TyVarBndr # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyVarBndr -> m TyVarBndr # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyVarBndr -> m TyVarBndr #
Ord TyVarBndr Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: TyVarBndr -> TyVarBndr -> Ordering # (<) :: TyVarBndr -> TyVarBndr -> Bool # (<=) :: TyVarBndr -> TyVarBndr -> Bool # (>) :: TyVarBndr -> TyVarBndr -> Bool # (>=) :: TyVarBndr -> TyVarBndr -> Bool # max :: TyVarBndr -> TyVarBndr -> TyVarBndr # min :: TyVarBndr -> TyVarBndr -> TyVarBndr #
Show TyVarBndr Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> TyVarBndr -> ShowS # show :: TyVarBndr -> String # showList :: [TyVarBndr] -> ShowS #
Generic TyVarBndr Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TyVarBndr :: Type -> Type # Methods from :: TyVarBndr -> Rep TyVarBndr x # to :: Rep TyVarBndr x -> TyVarBndr #
Binary TyVarBndr Source #
Instance details Defined in GHCi.TH.Binary Methods put :: TyVarBndr -> Put # get :: Get TyVarBndr # putList :: [TyVarBndr] -> Put #
Ppr TyVarBndr Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: TyVarBndr -> Doc Source # ppr_list :: [TyVarBndr] -> Doc Source #
type Rep TyVarBndr Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep TyVarBndr = D1 (MetaData "TyVarBndr" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "PlainTV" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) :+: C1 (MetaCons "KindedTV" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Kind)))

data TyLit Source #

Constructors

NumTyLit Integer	2
StrTyLit String	"Hello"

Instances

Eq TyLit Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: TyLit -> TyLit -> Bool # (/=) :: TyLit -> TyLit -> Bool #
Data TyLit Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyLit -> c TyLit # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TyLit # toConstr :: TyLit -> Constr # dataTypeOf :: TyLit -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TyLit) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyLit) # gmapT :: (forall b. Data b => b -> b) -> TyLit -> TyLit # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r # gmapQ :: (forall d. Data d => d -> u) -> TyLit -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TyLit -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit #
Ord TyLit Source #
Instance details Defined in Language.Haskell.TH.Syntax 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 Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> TyLit -> ShowS # show :: TyLit -> String # showList :: [TyLit] -> ShowS #
Generic TyLit Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TyLit :: Type -> Type # Methods from :: TyLit -> Rep TyLit x # to :: Rep TyLit x -> TyLit #
Binary TyLit Source #
Instance details Defined in GHCi.TH.Binary Methods put :: TyLit -> Put # get :: Get TyLit # putList :: [TyLit] -> Put #
Ppr TyLit Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: TyLit -> Doc Source # ppr_list :: [TyLit] -> Doc Source #
type Rep TyLit Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep TyLit = D1 (MetaData "TyLit" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "NumTyLit" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer)) :+: C1 (MetaCons "StrTyLit" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))

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 Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Role -> Role -> Bool # (/=) :: Role -> Role -> Bool #
Data Role Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Role -> c Role # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Role # toConstr :: Role -> Constr # dataTypeOf :: Role -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Role) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Role) # gmapT :: (forall b. Data b => b -> b) -> Role -> Role # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r # gmapQ :: (forall d. Data d => d -> u) -> Role -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Role -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Role -> m Role # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m Role # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m Role #
Ord Role Source #
Instance details Defined in Language.Haskell.TH.Syntax 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 Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Role -> ShowS # show :: Role -> String # showList :: [Role] -> ShowS #
Generic Role Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Role :: Type -> Type # Methods from :: Role -> Rep Role x # to :: Rep Role x -> Role #
Binary Role Source #
Instance details Defined in GHCi.TH.Binary Methods put :: Role -> Put # get :: Get Role # putList :: [Role] -> Put #
Ppr Role Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Role -> Doc Source # ppr_list :: [Role] -> Doc Source #
type Rep Role Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep Role = D1 (MetaData "Role" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) ((C1 (MetaCons "NominalR" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "RepresentationalR" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "PhantomR" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "InferR" PrefixI False) (U1 :: Type -> Type)))

data FamilyResultSig Source #

Type family result signature

Constructors

NoSig	no signature
KindSig Kind	k
TyVarSig TyVarBndr	= r, = (r :: k)

Instances

Eq FamilyResultSig Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: FamilyResultSig -> FamilyResultSig -> Bool # (/=) :: FamilyResultSig -> FamilyResultSig -> Bool #
Data FamilyResultSig Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamilyResultSig -> c FamilyResultSig # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FamilyResultSig # toConstr :: FamilyResultSig -> Constr # dataTypeOf :: FamilyResultSig -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FamilyResultSig) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FamilyResultSig) # gmapT :: (forall b. Data b => b -> b) -> FamilyResultSig -> FamilyResultSig # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r # gmapQ :: (forall d. Data d => d -> u) -> FamilyResultSig -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FamilyResultSig -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamilyResultSig -> m FamilyResultSig # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyResultSig -> m FamilyResultSig # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyResultSig -> m FamilyResultSig #
Ord FamilyResultSig Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: FamilyResultSig -> FamilyResultSig -> Ordering # (<) :: FamilyResultSig -> FamilyResultSig -> Bool # (<=) :: FamilyResultSig -> FamilyResultSig -> Bool # (>) :: FamilyResultSig -> FamilyResultSig -> Bool # (>=) :: FamilyResultSig -> FamilyResultSig -> Bool # max :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig # min :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig #
Show FamilyResultSig Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> FamilyResultSig -> ShowS # show :: FamilyResultSig -> String # showList :: [FamilyResultSig] -> ShowS #
Generic FamilyResultSig Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep FamilyResultSig :: Type -> Type # Methods from :: FamilyResultSig -> Rep FamilyResultSig x # to :: Rep FamilyResultSig x -> FamilyResultSig #
Binary FamilyResultSig Source #
Instance details Defined in GHCi.TH.Binary Methods put :: FamilyResultSig -> Put # get :: Get FamilyResultSig # putList :: [FamilyResultSig] -> Put #
Ppr FamilyResultSig Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: FamilyResultSig -> Doc Source # ppr_list :: [FamilyResultSig] -> Doc Source #
type Rep FamilyResultSig Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep FamilyResultSig = D1 (MetaData "FamilyResultSig" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "NoSig" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "KindSig" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Kind)) :+: C1 (MetaCons "TyVarSig" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 TyVarBndr))))

data InjectivityAnn Source #

Injectivity annotation

Constructors

InjectivityAnn Name [Name]

Instances

Eq InjectivityAnn Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: InjectivityAnn -> InjectivityAnn -> Bool # (/=) :: InjectivityAnn -> InjectivityAnn -> Bool #
Data InjectivityAnn Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InjectivityAnn -> c InjectivityAnn # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c InjectivityAnn # toConstr :: InjectivityAnn -> Constr # dataTypeOf :: InjectivityAnn -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c InjectivityAnn) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InjectivityAnn) # gmapT :: (forall b. Data b => b -> b) -> InjectivityAnn -> InjectivityAnn # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r # gmapQ :: (forall d. Data d => d -> u) -> InjectivityAnn -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> InjectivityAnn -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> InjectivityAnn -> m InjectivityAnn # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityAnn -> m InjectivityAnn # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityAnn -> m InjectivityAnn #
Ord InjectivityAnn Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: InjectivityAnn -> InjectivityAnn -> Ordering # (<) :: InjectivityAnn -> InjectivityAnn -> Bool # (<=) :: InjectivityAnn -> InjectivityAnn -> Bool # (>) :: InjectivityAnn -> InjectivityAnn -> Bool # (>=) :: InjectivityAnn -> InjectivityAnn -> Bool # max :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn # min :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn #
Show InjectivityAnn Source #
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> InjectivityAnn -> ShowS # show :: InjectivityAnn -> String # showList :: [InjectivityAnn] -> ShowS #
Generic InjectivityAnn Source #
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep InjectivityAnn :: Type -> Type # Methods from :: InjectivityAnn -> Rep InjectivityAnn x # to :: Rep InjectivityAnn x -> InjectivityAnn #
Binary InjectivityAnn Source #
Instance details Defined in GHCi.TH.Binary Methods put :: InjectivityAnn -> Put # get :: Get InjectivityAnn # putList :: [InjectivityAnn] -> Put #
Ppr InjectivityAnn Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: InjectivityAnn -> Doc Source # ppr_list :: [InjectivityAnn] -> Doc Source #
type Rep InjectivityAnn Source #
Instance details Defined in Language.Haskell.TH.Syntax type Rep InjectivityAnn = D1 (MetaData "InjectivityAnn" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.8.1.20191204-KZSqkS4MwGRH5wjhlvvtXj" False) (C1 (MetaCons "InjectivityAnn" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Name])))

type PatSynType = Type Source #

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

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

P's complete type is of the following form

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

consisting of four parts:

the (possibly empty lists of) universally quantified type variables and required constraints on them.
the (possibly empty lists of) existentially quantified type variables and the provided constraints on them.
the types t1, t2, .., tn of x1, x2, .., xn, respectively
the type t of <some-pattern>, mentioning only universals.

Pattern synonym types interact with TH when (a) reifying a pattern synonym, (b) pretty printing, or (c) specifying a pattern synonym's type signature explicitly:

Reification always returns a pattern synonym's fully specified type in abstract syntax.
Pretty printing via pprPatSynType abbreviates a pattern synonym's type unambiguously in concrete syntax: The rule of thumb is to print initial empty universals and the required context as () =>, if existentials and a provided context follow. If only universals and their required context, but no existentials are specified, only the universals and their required context are printed. If both or none are specified, so both (or none) are printed.
When specifying a pattern synonym's type explicitly with PatSynSigD either one of the universals, the existentials, or their contexts may be left empty.

See the GHC user's guide for more information on pattern synonyms and their types: https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#pattern-synonyms.

Library functions

module Language.Haskell.TH.Lib

Pretty-printer

class Ppr a where Source #

Minimal complete definition

ppr

Methods

ppr :: a -> Doc Source #

ppr_list :: [a] -> Doc Source #

Instances

Ppr Role Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Role -> Doc Source # ppr_list :: [Role] -> Doc Source #
Ppr TyLit Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: TyLit -> Doc Source # ppr_list :: [TyLit] -> Doc Source #
Ppr InjectivityAnn Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: InjectivityAnn -> Doc Source # ppr_list :: [InjectivityAnn] -> Doc Source #
Ppr FamilyResultSig Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: FamilyResultSig -> Doc Source # ppr_list :: [FamilyResultSig] -> Doc Source #
Ppr TyVarBndr Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: TyVarBndr -> Doc Source # ppr_list :: [TyVarBndr] -> Doc Source #
Ppr Type Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Type -> Doc Source # ppr_list :: [Type] -> Doc Source #
Ppr PatSynArgs Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: PatSynArgs -> Doc Source # ppr_list :: [PatSynArgs] -> Doc Source #
Ppr PatSynDir Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: PatSynDir -> Doc Source # ppr_list :: [PatSynDir] -> Doc Source #
Ppr Bang Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Bang -> Doc Source # ppr_list :: [Bang] -> Doc Source #
Ppr Con Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Con -> Doc Source # ppr_list :: [Con] -> Doc Source #
Ppr DecidedStrictness Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: DecidedStrictness -> Doc Source # ppr_list :: [DecidedStrictness] -> Doc Source #
Ppr SourceStrictness Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: SourceStrictness -> Doc Source # ppr_list :: [SourceStrictness] -> Doc Source #
Ppr SourceUnpackedness Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: SourceUnpackedness -> Doc Source # ppr_list :: [SourceUnpackedness] -> Doc Source #
Ppr RuleBndr Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: RuleBndr -> Doc Source # ppr_list :: [RuleBndr] -> Doc Source #
Ppr Phases Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Phases -> Doc Source # ppr_list :: [Phases] -> Doc Source #
Ppr RuleMatch Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: RuleMatch -> Doc Source # ppr_list :: [RuleMatch] -> Doc Source #
Ppr Inline Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Inline -> Doc Source # ppr_list :: [Inline] -> Doc Source #
Ppr Pragma Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Pragma -> Doc Source # ppr_list :: [Pragma] -> Doc Source #
Ppr Foreign Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Foreign -> Doc Source # ppr_list :: [Foreign] -> Doc Source #
Ppr FunDep Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: FunDep -> Doc Source # ppr_list :: [FunDep] -> Doc Source #
Ppr Dec Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Dec -> Doc Source # ppr_list :: [Dec] -> Doc Source #
Ppr Range Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Range -> Doc Source # ppr_list :: [Range] -> Doc Source #
Ppr Stmt Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Stmt -> Doc Source # ppr_list :: [Stmt] -> Doc Source #
Ppr Exp Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Exp -> Doc Source # ppr_list :: [Exp] -> Doc Source #
Ppr Clause Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Clause -> Doc Source # ppr_list :: [Clause] -> Doc Source #
Ppr Match Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Match -> Doc Source # ppr_list :: [Match] -> Doc Source #
Ppr Pat Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Pat -> Doc Source # ppr_list :: [Pat] -> Doc Source #
Ppr Lit Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Lit -> Doc Source # ppr_list :: [Lit] -> Doc Source #
Ppr ModuleInfo Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: ModuleInfo -> Doc Source # ppr_list :: [ModuleInfo] -> Doc Source #
Ppr Info Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Info -> Doc Source # ppr_list :: [Info] -> Doc Source #
Ppr Loc Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Loc -> Doc Source # ppr_list :: [Loc] -> Doc Source #
Ppr Name Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Name -> Doc Source # ppr_list :: [Name] -> Doc Source #
Ppr Module Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: Module -> Doc Source # ppr_list :: [Module] -> Doc Source #
Ppr TypeArg Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: TypeArg -> Doc Source # ppr_list :: [TypeArg] -> Doc Source #
Ppr a => Ppr [a] Source #
Instance details Defined in Language.Haskell.TH.Ppr Methods ppr :: [a] -> Doc Source # ppr_list :: [[a]] -> Doc Source #

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

pprExp :: Precedence -> Exp -> Doc Source #

pprLit :: Precedence -> Lit -> Doc Source #

pprPat :: Precedence -> Pat -> Doc Source #

pprParendType :: Type -> Doc Source #