Language.Haskell.TH

template-haskell-2.12.0.0: Support library for Template Haskell

Safe Haskell | Safe
Language | Haskell2010

Language.Haskell.TH

Contents

- The monad and its operations
  - Administration: errors, locations and IO
  - Querying the compiler
    - Reify
    - Language extension lookup
    - Name lookup
    - Fixity lookup
    - Instance lookup
    - Roles lookup
    - Annotation lookup
    - Constructor strictness lookup
- Typed expressions
- Names
  - Constructing names
  - Deconstructing names
  - Built-in names
- The algebraic data types
  - Declarations
  - Expressions
  - Patterns
  - 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
  - | RebindableSyntax
  - | ConstraintKinds
  - | PolyKinds
  - | DataKinds
  - | InstanceSigs
  - | ApplicativeDo
  - | StandaloneDeriving
  - | DeriveDataTypeable
  - | AutoDeriveTypeable
  - | DeriveFunctor
  - | DeriveTraversable
  - | DeriveFoldable
  - | DeriveGeneric
  - | DefaultSignatures
  - | DeriveAnyClass
  - | DeriveLift
  - | DerivingStrategies
  - | TypeSynonymInstances
  - | FlexibleContexts
  - | FlexibleInstances
  - | ConstrainedClassMethods
  - | MultiParamTypeClasses
  - | NullaryTypeClasses
  - | FunctionalDependencies
  - | UnicodeSyntax
  - | ExistentialQuantification
  - | MagicHash
  - | EmptyDataDecls
  - | KindSignatures
  - | RoleAnnotations
  - | ParallelListComp
  - | TransformListComp
  - | MonadComprehensions
  - | GeneralizedNewtypeDeriving
  - | RecursiveDo
  - | PostfixOperators
  - | TupleSections
  - | PatternGuards
  - | LiberalTypeSynonyms
  - | RankNTypes
  - | ImpredicativeTypes
  - | TypeOperators
  - | ExplicitNamespaces
  - | PackageImports
  - | ExplicitForAll
  - | AlternativeLayoutRule
  - | AlternativeLayoutRuleTransitional
  - | DatatypeContexts
  - | NondecreasingIndentation
  - | RelaxedLayout
  - | TraditionalRecordSyntax
  - | LambdaCase
  - | MultiWayIf
  - | BinaryLiterals
  - | NegativeLiterals
  - | DuplicateRecordFields
  - | OverloadedLabels
  - | EmptyCase
  - | PatternSynonyms
  - | PartialTypeSignatures
  - | NamedWildCards
  - | StaticPointers
  - | TypeApplications
  - | Strict
  - | StrictData
  - | MonadFailDesugaring
- 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 Name [Type] (Maybe Kind) [Con] [DerivClause]
  - | NewtypeInstD Cxt Name [Type] (Maybe Kind) Con [DerivClause]
  - | TySynInstD Name 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
- 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 [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 FamFlavour
  - = TypeFam
  - | DataFam
- data TySynEqn = TySynEqn [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]
  - | CompE [Stmt]
  - | ArithSeqE Range
  - | ListE [Exp]
  - | SigE Exp Type
  - | RecConE Name [FieldExp]
  - | RecUpdE Exp [FieldExp]
  - | StaticE Exp
  - | UnboundVarE Name
- 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]]
- 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
  - | 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
- 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
- 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 # |
Methods (>>=) :: Q a -> (a -> Q b) -> Q b Source # (>>) :: Q a -> Q b -> Q b Source # return :: a -> Q a Source # fail :: String -> Q a Source #
Functor Q # |
Methods fmap :: (a -> b) -> Q a -> Q b Source # (<$) :: a -> Q b -> Q a Source #
MonadFail Q # |
Methods fail :: String -> Q a Source #
Applicative Q # |
Methods pure :: a -> Q a Source # (<*>) :: Q (a -> b) -> Q a -> Q b Source # liftA2 :: (a -> b -> c) -> Q a -> Q b -> Q c Source # (*>) :: Q a -> Q b -> Q b Source # (<*) :: Q a -> Q b -> Q a Source #
Quasi Q # |
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 # qAddTopDecls :: [Dec] -> Q () Source # qAddForeignFile :: ForeignSrcLang -> String -> Q () Source # qAddModFinalizer :: Q () -> 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 # |
Methods (==) :: Loc -> Loc -> Bool # (/=) :: Loc -> Loc -> Bool #
Data Loc # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Loc -> c Loc Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Loc Source # toConstr :: Loc -> Constr Source # dataTypeOf :: Loc -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Loc) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Loc) Source # gmapT :: (forall b. Data b => b -> b) -> Loc -> Loc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Loc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Loc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Loc -> m Loc Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Loc -> m Loc Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Loc -> m Loc Source #
Ord Loc # |
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 # |
Methods showsPrec :: Int -> Loc -> ShowS Source # show :: Loc -> String Source # showList :: [Loc] -> ShowS Source #
Generic Loc # |
Associated Types type Rep Loc :: * -> * Source # Methods from :: Loc -> Rep Loc x Source # to :: Rep Loc x -> Loc Source #
Ppr Loc # |
Methods ppr :: Loc -> Doc Source # ppr_list :: [Loc] -> Doc Source #
type Rep Loc # |
type Rep Loc = D1 * (MetaData "Loc" "Language.Haskell.TH.Syntax" "template-haskell" False) (C1 * (MetaCons "Loc" PrefixI True) ((:*:) * ((:*:) * (S1 * (MetaSel (Just Symbol "loc_filename") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) (S1 * (MetaSel (Just Symbol "loc_package") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String))) ((:*:) * (S1 * (MetaSel (Just Symbol "loc_module") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) ((:*:) * (S1 * (MetaSel (Just Symbol "loc_start") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * CharPos)) (S1 * (MetaSel (Just Symbol "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
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 # |
Methods (==) :: Info -> Info -> Bool # (/=) :: Info -> Info -> Bool #
Data Info # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Info -> c Info Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Info Source # toConstr :: Info -> Constr Source # dataTypeOf :: Info -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Info) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Info) Source # gmapT :: (forall b. Data b => b -> b) -> Info -> Info Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Info -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Info -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Info -> m Info Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Info -> m Info Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Info -> m Info Source #
Ord Info # |
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 # |
Methods showsPrec :: Int -> Info -> ShowS Source # show :: Info -> String Source # showList :: [Info] -> ShowS Source #
Generic Info # |
Associated Types type Rep Info :: * -> * Source # Methods from :: Info -> Rep Info x Source # to :: Rep Info x -> Info Source #
Ppr Info # |
Methods ppr :: Info -> Doc Source # ppr_list :: [Info] -> Doc Source #
type Rep Info # |
type Rep Info = D1 * (MetaData "Info" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "ClassI" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Dec)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [InstanceDec])))) (C1 * (MetaCons "ClassOpI" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Type)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * ParentName)))))) ((:+:) * (C1 * (MetaCons "TyConI" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Dec))) (C1 * (MetaCons "FamilyI" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Dec)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [InstanceDec])))))) ((:+:) * ((:+:) * (C1 * (MetaCons "PrimTyConI" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Arity)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Unlifted))))) (C1 * (MetaCons "DataConI" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Type)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * ParentName)))))) ((:+:) * (C1 * (MetaCons "PatSynI" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PatSynType)))) ((:+:) * (C1 * (MetaCons "VarI" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Type)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Dec)))))) (C1 * (MetaCons "TyVarI" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing 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 # |
Methods (==) :: ModuleInfo -> ModuleInfo -> Bool # (/=) :: ModuleInfo -> ModuleInfo -> Bool #
Data ModuleInfo # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModuleInfo -> c ModuleInfo Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ModuleInfo Source # toConstr :: ModuleInfo -> Constr Source # dataTypeOf :: ModuleInfo -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ModuleInfo) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleInfo) Source # gmapT :: (forall b. Data b => b -> b) -> ModuleInfo -> ModuleInfo Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r Source # gmapQ :: (forall d. Data d => d -> u) -> ModuleInfo -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> ModuleInfo -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo Source #
Ord ModuleInfo # |
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 # |
Methods showsPrec :: Int -> ModuleInfo -> ShowS Source # show :: ModuleInfo -> String Source # showList :: [ModuleInfo] -> ShowS Source #
Generic ModuleInfo # |
Associated Types type Rep ModuleInfo :: * -> * Source # Methods from :: ModuleInfo -> Rep ModuleInfo x Source # to :: Rep ModuleInfo x -> ModuleInfo Source #
Ppr ModuleInfo # |
Methods ppr :: ModuleInfo -> Doc Source # ppr_list :: [ModuleInfo] -> Doc Source #
type Rep ModuleInfo # |
type Rep ModuleInfo = D1 * (MetaData "ModuleInfo" "Language.Haskell.TH.Syntax" "template-haskell" False) (C1 * (MetaCons "ModuleInfo" PrefixI False) (S1 * (MetaSel (Nothing 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. `SumAlt`s 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 `SumAlt`s. For example, `(#|#)` has a `SumArity` of 2.

type Arity = Int Source #

In `PrimTyConI`, arity of the type constructor

type Unlifted = Bool Source #

In `PrimTyConI`, is the type constructor unlifted?

### Language extension lookup

data Extension :: * Source #

The language extensions known to GHC.

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

Constructors

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

Instances

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

extsEnabled :: Q [Extension] Source #

List all enabled language extensions.

isExtEnabled :: Extension -> Q Bool Source #

Determine whether the given language extension is enabled in the `Q` monad.

### Name lookup

lookupTypeName :: String -> Q (Maybe Name) Source #

Look up the given name in the (type namespace of the) current splice's scope. See Language.Haskell.TH.Syntax for more details.

lookupValueName :: String -> Q (Maybe Name) Source #

Look up the given name in the (value namespace of the) current splice's scope. See Language.Haskell.TH.Syntax for more details.

### Fixity lookup

reifyFixity :: Name -> Q (Maybe Fixity) Source #

`reifyFixity nm` attempts to find a fixity declaration for `nm`. For example, if the function `foo` has the fixity declaration `infixr 7 foo`, then `reifyFixity 'foo` would return ``Just` (`Fixity` 7 `InfixR`)`. If the function `bar` does not have a fixity declaration, then `reifyFixity 'bar` returns `Nothing`, so you may assume `bar` has `defaultFixity`.

### Instance lookup

reifyInstances :: Name -> [Type] -> Q [InstanceDec] Source #

`reifyInstances nm tys` returns a list of visible instances of `nm tys`. That is, if `nm` is the name of a type class, then all instances of this class at the types `tys` are returned. Alternatively, if `nm` is the name of a data family or type family, all instances of this family at the types `tys` are returned.

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

Is the list of instances returned by `reifyInstances` nonempty?

### Roles lookup

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

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

### Annotation lookup

reifyAnnotations :: Data a => AnnLookup -> Q [a] Source #

`reifyAnnotations target` returns the list of annotations associated with `target`. Only the annotations that are appropriately typed is returned. So if you have `Int` and `String` annotations for the same target, you have to call this function twice.

data AnnLookup Source #

Annotation target for reifyAnnotations

Constructors

AnnLookupModule Module |
AnnLookupName Name |

Instances

Eq AnnLookup # |
Methods (==) :: AnnLookup -> AnnLookup -> Bool # (/=) :: AnnLookup -> AnnLookup -> Bool #
Data AnnLookup # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnLookup -> c AnnLookup Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnLookup Source # toConstr :: AnnLookup -> Constr Source # dataTypeOf :: AnnLookup -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c AnnLookup) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnLookup) Source # gmapT :: (forall b. Data b => b -> b) -> AnnLookup -> AnnLookup Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnLookup -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnLookup -> r Source # gmapQ :: (forall d. Data d => d -> u) -> AnnLookup -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnLookup -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup Source #
Ord AnnLookup # |
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 # |
Methods showsPrec :: Int -> AnnLookup -> ShowS Source # show :: AnnLookup -> String Source # showList :: [AnnLookup] -> ShowS Source #
Generic AnnLookup # |
Associated Types type Rep AnnLookup :: * -> * Source # Methods from :: AnnLookup -> Rep AnnLookup x Source # to :: Rep AnnLookup x -> AnnLookup Source #
type Rep AnnLookup # |
type Rep AnnLookup = D1 * (MetaData "AnnLookup" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * (C1 * (MetaCons "AnnLookupModule" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Module))) (C1 * (MetaCons "AnnLookupName" PrefixI False) (S1 * (MetaSel (Nothing 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.

`Name`s 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 `Name`s 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 # |
Methods (==) :: Name -> Name -> Bool # (/=) :: Name -> Name -> Bool #
Data Name # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Name -> c Name Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Name Source # toConstr :: Name -> Constr Source # dataTypeOf :: Name -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Name) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name) Source # gmapT :: (forall b. Data b => b -> b) -> Name -> Name Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Name -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Name -> m Name Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name Source #
Ord Name # |
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 # |
Methods showsPrec :: Int -> Name -> ShowS Source # show :: Name -> String Source # showList :: [Name] -> ShowS Source #
Generic Name # |
Associated Types type Rep Name :: * -> * Source # Methods from :: Name -> Rep Name x Source # to :: Rep Name x -> Name Source #
Ppr Name # |
Methods ppr :: Name -> Doc Source # ppr_list :: [Name] -> Doc Source #
type Rep Name # |
type Rep Name = D1 * (MetaData "Name" "Language.Haskell.TH.Syntax" "template-haskell" False) (C1 * (MetaCons "Name" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * OccName)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * NameFlavour))))

data NameSpace Source #

Instances

Eq NameSpace # |
Methods (==) :: NameSpace -> NameSpace -> Bool # (/=) :: NameSpace -> NameSpace -> Bool #
Data NameSpace # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NameSpace -> c NameSpace Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NameSpace Source # toConstr :: NameSpace -> Constr Source # dataTypeOf :: NameSpace -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c NameSpace) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameSpace) Source # gmapT :: (forall b. Data b => b -> b) -> NameSpace -> NameSpace Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NameSpace -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NameSpace -> r Source # gmapQ :: (forall d. Data d => d -> u) -> NameSpace -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> NameSpace -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace Source #
Ord NameSpace # |
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 # |
Methods showsPrec :: Int -> NameSpace -> ShowS Source # show :: NameSpace -> String Source # showList :: [NameSpace] -> ShowS Source #
Generic NameSpace # |
Associated Types type Rep NameSpace :: * -> * Source # Methods from :: NameSpace -> Rep NameSpace x Source # to :: Rep NameSpace x -> NameSpace Source #
type Rep NameSpace # |
type Rep NameSpace = D1 * (MetaData "NameSpace" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * (C1 * (MetaCons "VarName" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "DataName" PrefixI False) (U1 *)) (C1 * (MetaCons "TcClsName" PrefixI False) (U1 *))))

## Constructing names

mkName :: String -> Name Source #

Generate a capturable name. Occurrences of such names will be resolved according to the Haskell scoping rules at the occurrence site.

For example:

    f = [| pi + $(varE (mkName "pi")) |]
    ...
    g = let pi = 3 in $f

In this case, `g` is desugared to

    g = Prelude.pi + 3

Note that `mkName` may be used with qualified names:

    mkName "Prelude.pi"

See also `dyn` for a useful combinator. The above example could be rewritten using `dyn` as

    f = [| pi + $(dyn "pi") |]

newName :: String -> Q Name Source #

Generate a fresh name, which cannot be captured.

For example, this:

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

will produce the splice

    f = \x0 -> \x -> x0

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

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

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

will produce the splice

    g = \x -> \x0 -> x0

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

## Deconstructing names

nameBase :: Name -> String Source #

The name without its module prefix.

#### Examples

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

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

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

    >>> nameSpace 'Prelude.id
    Just VarName
    >>> nameSpace (mkName "id")
    Nothing -- only works for top-level variable names
    >>> nameSpace 'Data.Maybe.Just
    Just DataName
    >>> nameSpace ''Data.Maybe.Maybe
    Just TcClsName
    >>> nameSpace ''Data.Ord.Ord
    Just TcClsName

## Built-in names

tupleTypeName :: Int -> Name Source #

Tuple type constructor

tupleDataName :: Int -> Name Source #

Tuple data constructor

unboxedTupleTypeName :: Int -> Name Source #

Unboxed tuple type constructor

unboxedTupleDataName :: Int -> Name Source #

Unboxed tuple data constructor

unboxedSumTypeName :: SumArity -> Name Source #

Unboxed sum type constructor

unboxedSumDataName :: SumAlt -> SumArity -> Name Source #

Unboxed sum data constructor

# The algebraic data types

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

## Declarations

data Dec Source #

Constructors

FunD Name [Clause] |
    { f p1 p2 = b where decs }
ValD Pat Body [Dec] |
    { p = b where decs }
DataD Cxt Name [TyVarBndr] (Maybe Kind) [Con] [DerivClause] |
    { data Cxt x => T x = A x | B (T x)
           deriving (Z,W)
           deriving stock Eq }
NewtypeD Cxt Name [TyVarBndr] (Maybe Kind) Con [DerivClause] |
    { newtype Cxt x => T x = A (B x)
           deriving (Z,W Q)
           deriving stock Eq }
TySynD Name [TyVarBndr] Type |
    { type T x = (x,x) }
ClassD Cxt Name [TyVarBndr] [FunDep] [Dec] |
    { class Eq a => Ord a where ds }
InstanceD (Maybe Overlap) Cxt Type [Dec] |
    { instance {-# OVERLAPS #-}
            Show w => Show [w] where ds }
SigD Name Type |
    { length :: [a] -> Int }
ForeignD Foreign |
    { foreign import ... }
    { foreign export ... }
InfixD Fixity Name |
    { infix 3 foo }
PragmaD Pragma |
    { {-# INLINE [1] foo #-} }
DataFamilyD Name [TyVarBndr] (Maybe Kind) |
    { data family T a b c :: * }
DataInstD Cxt Name [Type] (Maybe Kind) [Con] [DerivClause] |
    { data instance Cxt x => T [x]
           = A x | B (T x)
           deriving (Z,W)
           deriving stock Eq }
NewtypeInstD Cxt Name [Type] (Maybe Kind) Con [DerivClause] |
    { newtype instance Cxt x => T [x]
            = A (B x)
            deriving (Z,W)
            deriving stock Eq }
TySynInstD Name TySynEqn |
    { type instance ... }
OpenTypeFamilyD TypeFamilyHead |
    { type family T a b c = (r :: *) | r -> a b }
ClosedTypeFamilyD TypeFamilyHead [TySynEqn] |
    { type family F a b = (r :: *) | r -> a where ... }
RoleAnnotD Name [Role] |
    { type role T nominal representational }
StandaloneDerivD (Maybe DerivStrategy) Cxt Type |
    { deriving stock instance Ord a => Ord (Foo a) }
DefaultSigD Name Type |
    { default size :: Data a => a -> Int }
PatSynD Name PatSynArgs PatSynDir Pat | `{ pattern P v1 v2 .. vn <- p }` unidirectional or `{ pattern P v1 v2 .. vn = p }` implicit bidirectional or `{ pattern P v1 v2 .. vn <- p where P v1 v2 .. vn = e }` explicit bidirectional also, besides prefix pattern synonyms, both infix and record pattern synonyms are supported. See `PatSynArgs` for details
PatSynSigD Name PatSynType | A pattern synonym's type signature.

Instances

Eq Dec # |
Methods (==) :: Dec -> Dec -> Bool # (/=) :: Dec -> Dec -> Bool #
Data Dec # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Dec -> c Dec Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Dec Source # toConstr :: Dec -> Constr Source # dataTypeOf :: Dec -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Dec) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Dec) Source # gmapT :: (forall b. Data b => b -> b) -> Dec -> Dec Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Dec -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Dec -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Dec -> m Dec Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Dec -> m Dec Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Dec -> m Dec Source #
Ord Dec # |
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 # |
Methods showsPrec :: Int -> Dec -> ShowS Source # show :: Dec -> String Source # showList :: [Dec] -> ShowS Source #
Generic Dec # |
Associated Types type Rep Dec :: * -> * Source # Methods from :: Dec -> Rep Dec x Source # to :: Rep Dec x -> Dec Source #
Ppr Dec # |
Methods ppr :: Dec -> Doc Source # ppr_list :: [Dec] -> Doc Source #
type Rep Dec # |
type Rep Dec = D1 * (MetaData "Dec" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "FunD" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Clause])))) (C1 * (MetaCons "ValD" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Pat)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Body)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Dec])))))) ((:+:) * (C1 * (MetaCons "DataD" PrefixI False) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Cxt)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [TyVarBndr])))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Kind))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Con])) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [DerivClause])))))) ((:+:) * (C1 * (MetaCons "NewtypeD" PrefixI False) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Cxt)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [TyVarBndr])))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Kind))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Con)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [DerivClause])))))) (C1 * (MetaCons "TySynD" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [TyVarBndr])) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Type)))))))) ((:+:) * ((:+:) * (C1 * (MetaCons "ClassD" PrefixI False) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Cxt)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [TyVarBndr])) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [FunDep])) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Dec])))))) ((:+:) * (C1 * (MetaCons "InstanceD" PrefixI False) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Overlap))) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Cxt))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Type)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Dec]))))) (C1 * (MetaCons "SigD" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Type)))))) ((:+:) * (C1 * (MetaCons "ForeignD" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Foreign))) ((:+:) * (C1 * (MetaCons "InfixD" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Fixity)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)))) (C1 * (MetaCons "PragmaD" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Pragma))))))) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "DataFamilyD" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [TyVarBndr])) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Kind)))))) (C1 * (MetaCons "DataInstD" PrefixI False) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Cxt)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Type])))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Kind))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Con])) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [DerivClause]))))))) ((:+:) * (C1 * (MetaCons "NewtypeInstD" PrefixI False) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Cxt)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Type])))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Kind))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Con)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [DerivClause])))))) ((:+:) * (C1 * (MetaCons "TySynInstD" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * TySynEqn)))) (C1 * (MetaCons "OpenTypeFamilyD" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * TypeFamilyHead)))))) ((:+:) * ((:+:) * (C1 * (MetaCons "ClosedTypeFamilyD" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * TypeFamilyHead)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [TySynEqn])))) ((:+:) * (C1 * (MetaCons "RoleAnnotD" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Role])))) (C1 * (MetaCons "StandaloneDerivD" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe DerivStrategy))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Cxt)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Type))))))) ((:+:) * (C1 * (MetaCons "DefaultSigD" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Type)))) ((:+:) * (C1 * (MetaCons "PatSynD" PrefixI False) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PatSynArgs))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PatSynDir)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Pat))))) (C1 * (MetaCons "PatSynSigD" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PatSynType)))))))))

data Con Source #

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 # |
Methods (==) :: Con -> Con -> Bool # (/=) :: Con -> Con -> Bool #
Data Con # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Con -> c Con Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Con Source # toConstr :: Con -> Constr Source # dataTypeOf :: Con -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Con) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Con) Source # gmapT :: (forall b. Data b => b -> b) -> Con -> Con Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Con -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Con -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Con -> m Con Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Con -> m Con Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Con -> m Con Source #
Ord Con # |
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 # |
Methods showsPrec :: Int -> Con -> ShowS Source # show :: Con -> String Source # showList :: [Con] -> ShowS Source #
Generic Con # |
Associated Types type Rep Con :: * -> * Source # Methods from :: Con -> Rep Con x Source # to :: Rep Con x -> Con Source #
Ppr Con # |
Methods ppr :: Con -> Doc Source # ppr_list :: [Con] -> Doc Source #
type Rep Con # |
type Rep Con = D1 * (MetaData "Con" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * ((:+:) * (C1 * (MetaCons "NormalC" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [BangType])))) ((:+:) * (C1 * (MetaCons "RecC" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [VarBangType])))) (C1 * (MetaCons "InfixC" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * BangType)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * BangType))))))) ((:+:) * (C1 * (MetaCons "ForallC" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [TyVarBndr])) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Cxt)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Con))))) ((:+:) * (C1 * (MetaCons "GadtC" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Name])) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [BangType])) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Type))))) (C1 * (MetaCons "RecGadtC" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Name])) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [VarBangType])) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Type))))))))

data Clause Source #

Constructors

Clause [Pat] Body [Dec] |
    f { p1 p2 = body where decs }

Instances

Eq Clause # |
Methods (==) :: Clause -> Clause -> Bool # (/=) :: Clause -> Clause -> Bool #
Data Clause # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Clause -> c Clause Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Clause Source # toConstr :: Clause -> Constr Source # dataTypeOf :: Clause -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Clause) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Clause) Source # gmapT :: (forall b. Data b => b -> b) -> Clause -> Clause Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Clause -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Clause -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Clause -> m Clause Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Clause -> m Clause Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Clause -> m Clause Source #
Ord Clause # |
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 # |
Methods showsPrec :: Int -> Clause -> ShowS Source # show :: Clause -> String Source # showList :: [Clause] -> ShowS Source #
Generic Clause # |
Associated Types type Rep Clause :: * -> * Source # Methods from :: Clause -> Rep Clause x Source # to :: Rep Clause x -> Clause Source #
Ppr Clause # |
Methods ppr :: Clause -> Doc Source # ppr_list :: [Clause] -> Doc Source #
type Rep Clause # |
type Rep Clause = D1 * (MetaData "Clause" "Language.Haskell.TH.Syntax" "template-haskell" False) (C1 * (MetaCons "Clause" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Pat])) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Body)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Dec])))))

data SourceUnpackedness Source #

Constructors

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

Instances

Eq SourceUnpackedness # |
Methods (==) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool #
Data SourceUnpackedness # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceUnpackedness -> c SourceUnpackedness Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceUnpackedness Source # toConstr :: SourceUnpackedness -> Constr Source # dataTypeOf :: SourceUnpackedness -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SourceUnpackedness) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceUnpackedness) Source # gmapT :: (forall b. Data b => b -> b) -> SourceUnpackedness -> SourceUnpackedness Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r Source # gmapQ :: (forall d. Data d => d -> u) -> SourceUnpackedness -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceUnpackedness -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness Source #
Ord SourceUnpackedness # |
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 # |
Methods showsPrec :: Int -> SourceUnpackedness -> ShowS Source # show :: SourceUnpackedness -> String Source # showList :: [SourceUnpackedness] -> ShowS Source #
Generic SourceUnpackedness # |
Associated Types type Rep SourceUnpackedness :: * -> * Source # Methods from :: SourceUnpackedness -> Rep SourceUnpackedness x Source # to :: Rep SourceUnpackedness x -> SourceUnpackedness Source #
Ppr SourceUnpackedness # |
Methods ppr :: SourceUnpackedness -> Doc Source # ppr_list :: [SourceUnpackedness] -> Doc Source #
type Rep SourceUnpackedness # |
type Rep SourceUnpackedness = D1 * (MetaData "SourceUnpackedness" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * (C1 * (MetaCons "NoSourceUnpackedness" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "SourceNoUnpack" PrefixI False) (U1 *)) (C1 * (MetaCons "SourceUnpack" PrefixI False) (U1 *))))

data SourceStrictness Source #

Constructors

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

Instances

Eq SourceStrictness # |
Methods (==) :: SourceStrictness -> SourceStrictness -> Bool # (/=) :: SourceStrictness -> SourceStrictness -> Bool #
Data SourceStrictness # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceStrictness -> c SourceStrictness Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceStrictness Source # toConstr :: SourceStrictness -> Constr Source # dataTypeOf :: SourceStrictness -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SourceStrictness) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceStrictness) Source # gmapT :: (forall b. Data b => b -> b) -> SourceStrictness -> SourceStrictness Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r Source # gmapQ :: (forall d. Data d => d -> u) -> SourceStrictness -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceStrictness -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness Source #
Ord SourceStrictness # |
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 # |
Methods showsPrec :: Int -> SourceStrictness -> ShowS Source # show :: SourceStrictness -> String Source # showList :: [SourceStrictness] -> ShowS Source #
Generic SourceStrictness # |
Associated Types type Rep SourceStrictness :: * -> * Source # Methods from :: SourceStrictness -> Rep SourceStrictness x Source # to :: Rep SourceStrictness x -> SourceStrictness Source #
Ppr SourceStrictness # |
Methods ppr :: SourceStrictness -> Doc Source # ppr_list :: [SourceStrictness] -> Doc Source #
type Rep SourceStrictness # |
type Rep SourceStrictness = D1 * (MetaData "SourceStrictness" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * (C1 * (MetaCons "NoSourceStrictness" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "SourceLazy" PrefixI False) (U1 *)) (C1 * (MetaCons "SourceStrict" PrefixI False) (U1 *))))

data DecidedStrictness Source #

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

Constructors

DecidedLazy |
DecidedStrict |
DecidedUnpack |

Instances

Eq DecidedStrictness # |
Methods (==) :: DecidedStrictness -> DecidedStrictness -> Bool # (/=) :: DecidedStrictness -> DecidedStrictness -> Bool #
Data DecidedStrictness # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DecidedStrictness -> c DecidedStrictness Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DecidedStrictness Source # toConstr :: DecidedStrictness -> Constr Source # dataTypeOf :: DecidedStrictness -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c DecidedStrictness) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DecidedStrictness) Source # gmapT :: (forall b. Data b => b -> b) -> DecidedStrictness -> DecidedStrictness Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r Source # gmapQ :: (forall d. Data d => d -> u) -> DecidedStrictness -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> DecidedStrictness -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness Source #
Ord DecidedStrictness # |
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 # |
Methods showsPrec :: Int -> DecidedStrictness -> ShowS Source # show :: DecidedStrictness -> String Source # showList :: [DecidedStrictness] -> ShowS Source #
Generic DecidedStrictness # |
Associated Types type Rep DecidedStrictness :: * -> * Source # Methods from :: DecidedStrictness -> Rep DecidedStrictness x Source # to :: Rep DecidedStrictness x -> DecidedStrictness Source #
Ppr DecidedStrictness # |
Methods ppr :: DecidedStrictness -> Doc Source # ppr_list :: [DecidedStrictness] -> Doc Source #
type Rep DecidedStrictness # |
type Rep DecidedStrictness = D1 * (MetaData "DecidedStrictness" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * (C1 * (MetaCons "DecidedLazy" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "DecidedStrict" PrefixI False) (U1 *)) (C1 * (MetaCons "DecidedUnpack" PrefixI False) (U1 *))))

data Bang Source #

Constructors

Bang SourceUnpackedness SourceStrictness |
    C { {-# UNPACK #-} !}a

Instances

Eq Bang # |
Methods (==) :: Bang -> Bang -> Bool # (/=) :: Bang -> Bang -> Bool #
Data Bang # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bang -> c Bang Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bang Source # toConstr :: Bang -> Constr Source # dataTypeOf :: Bang -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Bang) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bang) Source # gmapT :: (forall b. Data b => b -> b) -> Bang -> Bang Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Bang -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Bang -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bang -> m Bang Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bang -> m Bang Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bang -> m Bang Source #
Ord Bang # |
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 # |
Methods showsPrec :: Int -> Bang -> ShowS Source # show :: Bang -> String Source # showList :: [Bang] -> ShowS Source #
Generic Bang # |
Associated Types type Rep Bang :: * -> * Source # Methods from :: Bang -> Rep Bang x Source # to :: Rep Bang x -> Bang Source #
Ppr Bang # |
Methods ppr :: Bang -> Doc Source # ppr_list :: [Bang] -> Doc Source #
type Rep Bang # |
type Rep Bang = D1 * (MetaData "Bang" "Language.Haskell.TH.Syntax" "template-haskell" False) (C1 * (MetaCons "Bang" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * SourceUnpackedness)) (S1 * (MetaSel (Nothing 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 # |
Methods (==) :: Foreign -> Foreign -> Bool # (/=) :: Foreign -> Foreign -> Bool #
Data Foreign # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Foreign -> c Foreign Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Foreign Source # toConstr :: Foreign -> Constr Source # dataTypeOf :: Foreign -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Foreign) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Foreign) Source # gmapT :: (forall b. Data b => b -> b) -> Foreign -> Foreign Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Foreign -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Foreign -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Foreign -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Foreign -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Foreign -> m Foreign Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Foreign -> m Foreign Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Foreign -> m Foreign Source #
Ord Foreign # |
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 # |
Methods showsPrec :: Int -> Foreign -> ShowS Source # show :: Foreign -> String Source # showList :: [Foreign] -> ShowS Source #
Generic Foreign # |
Associated Types type Rep Foreign :: * -> * Source # Methods from :: Foreign -> Rep Foreign x Source # to :: Rep Foreign x -> Foreign Source #
Ppr Foreign # |
Methods ppr :: Foreign -> Doc Source # ppr_list :: [Foreign] -> Doc Source #
type Rep Foreign # |
type Rep Foreign = D1 * (MetaData "Foreign" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * (C1 * (MetaCons "ImportF" PrefixI False) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Callconv)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Safety))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Type)))))) (C1 * (MetaCons "ExportF" PrefixI False) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Callconv)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Type))))))

data Callconv Source #

Constructors

CCall |
StdCall |
CApi |
Prim |
JavaScript |

Instances

Eq Callconv # |
Methods (==) :: Callconv -> Callconv -> Bool # (/=) :: Callconv -> Callconv -> Bool #
Data Callconv # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Callconv -> c Callconv Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Callconv Source # toConstr :: Callconv -> Constr Source # dataTypeOf :: Callconv -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Callconv) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Callconv) Source # gmapT :: (forall b. Data b => b -> b) -> Callconv -> Callconv Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Callconv -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Callconv -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Callconv -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Callconv -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Callconv -> m Callconv Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Callconv -> m Callconv Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Callconv -> m Callconv Source #
Ord Callconv # |
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 # |
Methods showsPrec :: Int -> Callconv -> ShowS Source # show :: Callconv -> String Source # showList :: [Callconv] -> ShowS Source #
Generic Callconv # |
Associated Types type Rep Callconv :: * -> * Source # Methods from :: Callconv -> Rep Callconv x Source # to :: Rep Callconv x -> Callconv Source #
type Rep Callconv # |
type Rep Callconv = D1 * (MetaData "Callconv" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * ((:+:) * (C1 * (MetaCons "CCall" PrefixI False) (U1 *)) (C1 * (MetaCons "StdCall" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "CApi" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "Prim" PrefixI False) (U1 *)) (C1 * (MetaCons "JavaScript" PrefixI False) (U1 *)))))

data Safety Source #

Constructors

Unsafe |
Safe |
Interruptible |

Instances

Eq Safety # |
Methods (==) :: Safety -> Safety -> Bool # (/=) :: Safety -> Safety -> Bool #
Data Safety # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Safety -> c Safety Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Safety Source # toConstr :: Safety -> Constr Source # dataTypeOf :: Safety -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Safety) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Safety) Source # gmapT :: (forall b. Data b => b -> b) -> Safety -> Safety Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Safety -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Safety -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Safety -> m Safety Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Safety -> m Safety Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Safety -> m Safety Source #
Ord Safety # |
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 # |
Methods showsPrec :: Int -> Safety -> ShowS Source # show :: Safety -> String Source # showList :: [Safety] -> ShowS Source #
Generic Safety # |
Associated Types type Rep Safety :: * -> * Source # Methods from :: Safety -> Rep Safety x Source # to :: Rep Safety x -> Safety Source #
type Rep Safety # |
type Rep Safety = D1 * (MetaData "Safety" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * (C1 * (MetaCons "Unsafe" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "Safe" PrefixI False) (U1 *)) (C1 * (MetaCons "Interruptible" PrefixI False) (U1 *))))

data Pragma Source #

Constructors

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

Instances

Eq Pragma # |
Methods (==) :: Pragma -> Pragma -> Bool # (/=) :: Pragma -> Pragma -> Bool #
Data Pragma # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Pragma -> c Pragma Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Pragma Source # toConstr :: Pragma -> Constr Source # dataTypeOf :: Pragma -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Pragma) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pragma) Source # gmapT :: (forall b. Data b => b -> b) -> Pragma -> Pragma Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pragma -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pragma -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Pragma -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Pragma -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Pragma -> m Pragma Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Pragma -> m Pragma Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Pragma -> m Pragma Source #
Ord Pragma # |
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 # |
Methods showsPrec :: Int -> Pragma -> ShowS Source # show :: Pragma -> String Source # showList :: [Pragma] -> ShowS Source #
Generic Pragma # |
Associated Types type Rep Pragma :: * -> * Source # Methods from :: Pragma -> Rep Pragma x Source # to :: Rep Pragma x -> Pragma Source #
Ppr Pragma # |
Methods ppr :: Pragma -> Doc Source # ppr_list :: [Pragma] -> Doc Source #
type Rep Pragma # |
type Rep Pragma = D1 * (MetaData "Pragma" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * ((:+:) * (C1 * (MetaCons "InlineP" PrefixI False) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Inline))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * RuleMatch)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Phases))))) ((:+:) * (C1 * (MetaCons "SpecialiseP" PrefixI False) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Type))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Inline))) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Phases))))) (C1 * (MetaCons "SpecialiseInstP" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Type))))) ((:+:) * ((:+:) * (C1 * (MetaCons "RuleP" PrefixI False) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [RuleBndr]))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Phases)))))) (C1 * (MetaCons "AnnP" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * AnnTarget)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp))))) ((:+:) * (C1 * (MetaCons "LineP" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Int)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)))) (C1 * (MetaCons "CompleteP" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Name])) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Name))))))))

data Inline Source #

Constructors

NoInline |
Inline |
Inlinable |

Instances

Eq Inline # |
Methods (==) :: Inline -> Inline -> Bool # (/=) :: Inline -> Inline -> Bool #
Data Inline # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Inline -> c Inline Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Inline Source # toConstr :: Inline -> Constr Source # dataTypeOf :: Inline -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Inline) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inline) Source # gmapT :: (forall b. Data b => b -> b) -> Inline -> Inline Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Inline -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Inline -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Inline -> m Inline Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Inline -> m Inline Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Inline -> m Inline Source #
Ord Inline # |
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 # |
Methods showsPrec :: Int -> Inline -> ShowS Source # show :: Inline -> String Source # showList :: [Inline] -> ShowS Source #
Generic Inline # |
Associated Types type Rep Inline :: * -> * Source # Methods from :: Inline -> Rep Inline x Source # to :: Rep Inline x -> Inline Source #
Ppr Inline # |
Methods ppr :: Inline -> Doc Source # ppr_list :: [Inline] -> Doc Source #
type Rep Inline # |
type Rep Inline = D1 * (MetaData "Inline" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * (C1 * (MetaCons "NoInline" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "Inline" PrefixI False) (U1 *)) (C1 * (MetaCons "Inlinable" PrefixI False) (U1 *))))

data RuleMatch Source #

Constructors

ConLike |
FunLike |

Instances

Eq RuleMatch # |
Methods (==) :: RuleMatch -> RuleMatch -> Bool # (/=) :: RuleMatch -> RuleMatch -> Bool #
Data RuleMatch # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleMatch -> c RuleMatch Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RuleMatch Source # toConstr :: RuleMatch -> Constr Source # dataTypeOf :: RuleMatch -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c RuleMatch) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleMatch) Source # gmapT :: (forall b. Data b => b -> b) -> RuleMatch -> RuleMatch Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleMatch -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleMatch -> r Source # gmapQ :: (forall d. Data d => d -> u) -> RuleMatch -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleMatch -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch Source #
Ord RuleMatch # |
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 # |
Methods showsPrec :: Int -> RuleMatch -> ShowS Source # show :: RuleMatch -> String Source # showList :: [RuleMatch] -> ShowS Source #
Generic RuleMatch # |
Associated Types type Rep RuleMatch :: * -> * Source # Methods from :: RuleMatch -> Rep RuleMatch x Source # to :: Rep RuleMatch x -> RuleMatch Source #
Ppr RuleMatch # |
Methods ppr :: RuleMatch -> Doc Source # ppr_list :: [RuleMatch] -> Doc Source #
type Rep RuleMatch # |
type Rep RuleMatch = D1 * (MetaData "RuleMatch" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * (C1 * (MetaCons "ConLike" PrefixI False) (U1 *)) (C1 * (MetaCons "FunLike" PrefixI False) (U1 *)))

data Phases Source #

Constructors

AllPhases |
FromPhase Int |
BeforePhase Int |

Instances

Eq Phases # |
Methods (==) :: Phases -> Phases -> Bool # (/=) :: Phases -> Phases -> Bool #
Data Phases # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Phases -> c Phases Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Phases Source # toConstr :: Phases -> Constr Source # dataTypeOf :: Phases -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Phases) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Phases) Source # gmapT :: (forall b. Data b => b -> b) -> Phases -> Phases Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Phases -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Phases -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Phases -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Phases -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Phases -> m Phases Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Phases -> m Phases Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Phases -> m Phases Source #
Ord Phases # |
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 # |
Methods showsPrec :: Int -> Phases -> ShowS Source # show :: Phases -> String Source # showList :: [Phases] -> ShowS Source #
Generic Phases # |
Associated Types type Rep Phases :: * -> * Source # Methods from :: Phases -> Rep Phases x Source # to :: Rep Phases x -> Phases Source #
Ppr Phases # |
Methods ppr :: Phases -> Doc Source # ppr_list :: [Phases] -> Doc Source #
type Rep Phases # |
type Rep Phases = D1 * (MetaData "Phases" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * (C1 * (MetaCons "AllPhases" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "FromPhase" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Int))) (C1 * (MetaCons "BeforePhase" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Int)))))

data RuleBndr Source #

Constructors

RuleVar Name |
TypedRuleVar Name Type |

Instances

Eq RuleBndr # |
Methods (==) :: RuleBndr -> RuleBndr -> Bool # (/=) :: RuleBndr -> RuleBndr -> Bool #
Data RuleBndr # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleBndr -> c RuleBndr Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RuleBndr Source # toConstr :: RuleBndr -> Constr Source # dataTypeOf :: RuleBndr -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c RuleBndr) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleBndr) Source # gmapT :: (forall b. Data b => b -> b) -> RuleBndr -> RuleBndr Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr -> r Source # gmapQ :: (forall d. Data d => d -> u) -> RuleBndr -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleBndr -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr Source #
Ord RuleBndr # |
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 # |
Methods showsPrec :: Int -> RuleBndr -> ShowS Source # show :: RuleBndr -> String Source # showList :: [RuleBndr] -> ShowS Source #
Generic RuleBndr # |
Associated Types type Rep RuleBndr :: * -> * Source # Methods from :: RuleBndr -> Rep RuleBndr x Source # to :: Rep RuleBndr x -> RuleBndr Source #
Ppr RuleBndr # |
Methods ppr :: RuleBndr -> Doc Source # ppr_list :: [RuleBndr] -> Doc Source #
type Rep RuleBndr # |
type Rep RuleBndr = D1 * (MetaData "RuleBndr" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * (C1 * (MetaCons "RuleVar" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name))) (C1 * (MetaCons "TypedRuleVar" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Type)))))

data AnnTarget Source #

Constructors

ModuleAnnotation |
TypeAnnotation Name |
ValueAnnotation Name |

Instances

Eq AnnTarget # |
Methods (==) :: AnnTarget -> AnnTarget -> Bool # (/=) :: AnnTarget -> AnnTarget -> Bool #
Data AnnTarget # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnTarget -> c AnnTarget Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnTarget Source # toConstr :: AnnTarget -> Constr Source # dataTypeOf :: AnnTarget -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c AnnTarget) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnTarget) Source # gmapT :: (forall b. Data b => b -> b) -> AnnTarget -> AnnTarget Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnTarget -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnTarget -> r Source # gmapQ :: (forall d. Data d => d -> u) -> AnnTarget -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnTarget -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget Source #
Ord AnnTarget # |
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 # |
Methods showsPrec :: Int -> AnnTarget -> ShowS Source # show :: AnnTarget -> String Source # showList :: [AnnTarget] -> ShowS Source #
Generic AnnTarget # |
Associated Types type Rep AnnTarget :: * -> * Source # Methods from :: AnnTarget -> Rep AnnTarget x Source # to :: Rep AnnTarget x -> AnnTarget Source #
type Rep AnnTarget # |
type Rep AnnTarget = D1 * (MetaData "AnnTarget" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * (C1 * (MetaCons "ModuleAnnotation" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "TypeAnnotation" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name))) (C1 * (MetaCons "ValueAnnotation" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)))))

data FunDep Source #

Constructors

FunDep [Name] [Name] |

Instances

Eq FunDep # |
Methods (==) :: FunDep -> FunDep -> Bool # (/=) :: FunDep -> FunDep -> Bool #
Data FunDep # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunDep -> c FunDep Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FunDep Source # toConstr :: FunDep -> Constr Source # dataTypeOf :: FunDep -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c FunDep) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunDep) Source # gmapT :: (forall b. Data b => b -> b) -> FunDep -> FunDep Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r Source # gmapQ :: (forall d. Data d => d -> u) -> FunDep -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> FunDep -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunDep -> m FunDep Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep -> m FunDep Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep -> m FunDep Source #
Ord FunDep # |
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 # |
Methods showsPrec :: Int -> FunDep -> ShowS Source # show :: FunDep -> String Source # showList :: [FunDep] -> ShowS Source #
Generic FunDep # |
Associated Types type Rep FunDep :: * -> * Source # Methods from :: FunDep -> Rep FunDep x Source # to :: Rep FunDep x -> FunDep Source #
Ppr FunDep # |
Methods ppr :: FunDep -> Doc Source # ppr_list :: [FunDep] -> Doc Source #
type Rep FunDep # |
type Rep FunDep = D1 * (MetaData "FunDep" "Language.Haskell.TH.Syntax" "template-haskell" False) (C1 * (MetaCons "FunDep" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Name])) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Name]))))

data FamFlavour Source #

Constructors

TypeFam |
DataFam |

Instances

Eq FamFlavour # |
Methods (==) :: FamFlavour -> FamFlavour -> Bool # (/=) :: FamFlavour -> FamFlavour -> Bool #
Data FamFlavour # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamFlavour -> c FamFlavour Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FamFlavour Source # toConstr :: FamFlavour -> Constr Source # dataTypeOf :: FamFlavour -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c FamFlavour) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FamFlavour) Source # gmapT :: (forall b. Data b => b -> b) -> FamFlavour -> FamFlavour Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamFlavour -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamFlavour -> r Source # gmapQ :: (forall d. Data d => d -> u) -> FamFlavour -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> FamFlavour -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamFlavour -> m FamFlavour Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamFlavour -> m FamFlavour Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamFlavour -> m FamFlavour Source #
Ord FamFlavour # |
Methods compare :: FamFlavour -> FamFlavour -> Ordering # (<) :: FamFlavour -> FamFlavour -> Bool # (<=) :: FamFlavour -> FamFlavour -> Bool # (>) :: FamFlavour -> FamFlavour -> Bool # (>=) :: FamFlavour -> FamFlavour -> Bool # max :: FamFlavour -> FamFlavour -> FamFlavour # min :: FamFlavour -> FamFlavour -> FamFlavour #
Show FamFlavour # |
Methods showsPrec :: Int -> FamFlavour -> ShowS Source # show :: FamFlavour -> String Source # showList :: [FamFlavour] -> ShowS Source #
Generic FamFlavour # |
Associated Types type Rep FamFlavour :: * -> * Source # Methods from :: FamFlavour -> Rep FamFlavour x Source # to :: Rep FamFlavour x -> FamFlavour Source #
Ppr FamFlavour # |
Methods ppr :: FamFlavour -> Doc Source # ppr_list :: [FamFlavour] -> Doc Source #
type Rep FamFlavour # |
type Rep FamFlavour = D1 * (MetaData "FamFlavour" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * (C1 * (MetaCons "TypeFam" PrefixI False) (U1 *)) (C1 * (MetaCons "DataFam" PrefixI False) (U1 *)))

data TySynEqn Source #

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

Constructors

TySynEqn [Type] Type |

Instances

Eq TySynEqn # |
Methods (==) :: TySynEqn -> TySynEqn -> Bool # (/=) :: TySynEqn -> TySynEqn -> Bool #
Data TySynEqn # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TySynEqn -> c TySynEqn Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TySynEqn Source # toConstr :: TySynEqn -> Constr Source # dataTypeOf :: TySynEqn -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c TySynEqn) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TySynEqn) Source # gmapT :: (forall b. Data b => b -> b) -> TySynEqn -> TySynEqn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TySynEqn -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TySynEqn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> TySynEqn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> TySynEqn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn Source #
Ord TySynEqn # |
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 # |
Methods showsPrec :: Int -> TySynEqn -> ShowS Source # show :: TySynEqn -> String Source # showList :: [TySynEqn] -> ShowS Source #
Generic TySynEqn # |
Associated Types type Rep TySynEqn :: * -> * Source # Methods from :: TySynEqn -> Rep TySynEqn x Source # to :: Rep TySynEqn x -> TySynEqn Source #
type Rep TySynEqn # |
type Rep TySynEqn = D1 * (MetaData "TySynEqn" "Language.Haskell.TH.Syntax" "template-haskell" False) (C1 * (MetaCons "TySynEqn" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Type])) (S1 * (MetaSel (Nothing 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 # |
Methods (==) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (/=) :: TypeFamilyHead -> TypeFamilyHead -> Bool #
Data TypeFamilyHead # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypeFamilyHead -> c TypeFamilyHead Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TypeFamilyHead Source # toConstr :: TypeFamilyHead -> Constr Source # dataTypeOf :: TypeFamilyHead -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c TypeFamilyHead) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeFamilyHead) Source # gmapT :: (forall b. Data b => b -> b) -> TypeFamilyHead -> TypeFamilyHead Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r Source # gmapQ :: (forall d. Data d => d -> u) -> TypeFamilyHead -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeFamilyHead -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeFamilyHead -> m TypeFamilyHead Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeFamilyHead -> m TypeFamilyHead Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeFamilyHead -> m TypeFamilyHead Source #
Ord TypeFamilyHead # |
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 # |
Methods showsPrec :: Int -> TypeFamilyHead -> ShowS Source # show :: TypeFamilyHead -> String Source # showList :: [TypeFamilyHead] -> ShowS Source #
Generic TypeFamilyHead # |
Associated Types type Rep TypeFamilyHead :: * -> * Source # Methods from :: TypeFamilyHead -> Rep TypeFamilyHead x Source # to :: Rep TypeFamilyHead x -> TypeFamilyHead Source #
type Rep TypeFamilyHead # |
type Rep TypeFamilyHead = D1 * (MetaData "TypeFamilyHead" "Language.Haskell.TH.Syntax" "template-haskell" False) (C1 * (MetaCons "TypeFamilyHead" PrefixI False) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [TyVarBndr]))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * FamilyResultSig)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe InjectivityAnn))))))

data Fixity Source #

Constructors

Fixity Int FixityDirection |

Instances

Eq Fixity # |
Methods (==) :: Fixity -> Fixity -> Bool # (/=) :: Fixity -> Fixity -> Bool #
Data Fixity # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Fixity -> c Fixity Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Fixity Source # toConstr :: Fixity -> Constr Source # dataTypeOf :: Fixity -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Fixity) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity) Source # gmapT :: (forall b. Data b => b -> b) -> Fixity -> Fixity Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Fixity -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Fixity -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity Source #
Ord Fixity # |
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 # |
Methods showsPrec :: Int -> Fixity -> ShowS Source # show :: Fixity -> String Source # showList :: [Fixity] -> ShowS Source #
Generic Fixity # |
Associated Types type Rep Fixity :: * -> * Source # Methods from :: Fixity -> Rep Fixity x Source # to :: Rep Fixity x -> Fixity Source #
type Rep Fixity # |
type Rep Fixity = D1 * (MetaData "Fixity" "Language.Haskell.TH.Syntax" "template-haskell" False) (C1 * (MetaCons "Fixity" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Int)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * FixityDirection))))

data FixityDirection Source #

Constructors

InfixL |
InfixR |
InfixN |

Instances

Eq FixityDirection # |
Methods (==) :: FixityDirection -> FixityDirection -> Bool # (/=) :: FixityDirection -> FixityDirection -> Bool #
Data FixityDirection # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FixityDirection -> c FixityDirection Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FixityDirection Source # toConstr :: FixityDirection -> Constr Source # dataTypeOf :: FixityDirection -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c FixityDirection) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FixityDirection) Source # gmapT :: (forall b. Data b => b -> b) -> FixityDirection -> FixityDirection Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r Source # gmapQ :: (forall d. Data d => d -> u) -> FixityDirection -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> FixityDirection -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection Source #
Ord FixityDirection # |
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 # |
Methods showsPrec :: Int -> FixityDirection -> ShowS Source # show :: FixityDirection -> String Source # showList :: [FixityDirection] -> ShowS Source #
Generic FixityDirection # |
Associated Types type Rep FixityDirection :: * -> * Source # Methods from :: FixityDirection -> Rep FixityDirection x Source # to :: Rep FixityDirection x -> FixityDirection Source #
type Rep FixityDirection # |
type Rep FixityDirection = D1 * (MetaData "FixityDirection" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * (C1 * (MetaCons "InfixL" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "InfixR" PrefixI False) (U1 *)) (C1 * (MetaCons "InfixN" PrefixI False) (U1 *))))

defaultFixity :: Fixity Source #

Default fixity: `infixl 9`

maxPrecedence :: Int Source #

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

data PatSynDir Source #

A pattern synonym's directionality.

Constructors

Unidir |
    pattern P x {<-} p
ImplBidir |
    pattern P x {=} p
ExplBidir [Clause] |
    pattern P x {<-} p where P x = e

Instances

Eq PatSynDir # |
Methods (==) :: PatSynDir -> PatSynDir -> Bool # (/=) :: PatSynDir -> PatSynDir -> Bool #
Data PatSynDir # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PatSynDir -> c PatSynDir Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PatSynDir Source # toConstr :: PatSynDir -> Constr Source # dataTypeOf :: PatSynDir -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c PatSynDir) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatSynDir) Source # gmapT :: (forall b. Data b => b -> b) -> PatSynDir -> PatSynDir Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PatSynDir -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PatSynDir -> r Source # gmapQ :: (forall d. Data d => d -> u) -> PatSynDir -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> PatSynDir -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir Source #
Ord PatSynDir # |
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 # |
Methods showsPrec :: Int -> PatSynDir -> ShowS Source # show :: PatSynDir -> String Source # showList :: [PatSynDir] -> ShowS Source #
Generic PatSynDir # |
Associated Types type Rep PatSynDir :: * -> * Source # Methods from :: PatSynDir -> Rep PatSynDir x Source # to :: Rep PatSynDir x -> PatSynDir Source #
Ppr PatSynDir # |
Methods ppr :: PatSynDir -> Doc Source # ppr_list :: [PatSynDir] -> Doc Source #
type Rep PatSynDir # |
type Rep PatSynDir = D1 * (MetaData "PatSynDir" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * (C1 * (MetaCons "Unidir" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "ImplBidir" PrefixI False) (U1 *)) (C1 * (MetaCons "ExplBidir" PrefixI False) (S1 * (MetaSel (Nothing 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 # |
Methods (==) :: PatSynArgs -> PatSynArgs -> Bool # (/=) :: PatSynArgs -> PatSynArgs -> Bool #
Data PatSynArgs # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PatSynArgs -> c PatSynArgs Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PatSynArgs Source # toConstr :: PatSynArgs -> Constr Source # dataTypeOf :: PatSynArgs -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c PatSynArgs) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatSynArgs) Source # gmapT :: (forall b. Data b => b -> b) -> PatSynArgs -> PatSynArgs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PatSynArgs -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PatSynArgs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> PatSynArgs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> PatSynArgs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs Source #
Ord PatSynArgs # |
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 # |
Methods showsPrec :: Int -> PatSynArgs -> ShowS Source # show :: PatSynArgs -> String Source # showList :: [PatSynArgs] -> ShowS Source #
Generic PatSynArgs # |
Associated Types type Rep PatSynArgs :: * -> * Source # Methods from :: PatSynArgs -> Rep PatSynArgs x Source # to :: Rep PatSynArgs x -> PatSynArgs Source #
Ppr PatSynArgs # |
Methods ppr :: PatSynArgs -> Doc Source # ppr_list :: [PatSynArgs] -> Doc Source #
type Rep PatSynArgs # |
type Rep PatSynArgs = D1 * (MetaData "PatSynArgs" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * (C1 * (MetaCons "PrefixPatSyn" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Name]))) ((:+:) * (C1 * (MetaCons "InfixPatSyn" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)))) (C1 * (MetaCons "RecordPatSyn" PrefixI False) (S1 * (MetaSel (Nothing 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 }  }
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 }` (hole)

Instances

Eq Exp # |
Methods (==) :: Exp -> Exp -> Bool # (/=) :: Exp -> Exp -> Bool #
Data Exp # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Exp -> c Exp Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Exp Source # toConstr :: Exp -> Constr Source # dataTypeOf :: Exp -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Exp) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp) Source # gmapT :: (forall b. Data b => b -> b) -> Exp -> Exp Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Exp -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Exp -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Exp -> m Exp Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp -> m Exp Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp -> m Exp Source #
Ord Exp # |
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 # |
Methods showsPrec :: Int -> Exp -> ShowS Source # show :: Exp -> String Source # showList :: [Exp] -> ShowS Source #
Generic Exp # |
Associated Types type Rep Exp :: * -> * Source # Methods from :: Exp -> Rep Exp x Source # to :: Rep Exp x -> Exp Source #
Ppr Exp # |
Methods ppr :: Exp -> Doc Source # ppr_list :: [Exp] -> Doc Source #
type Rep Exp # |
type Rep Exp = D1 * (MetaData "Exp" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "VarE" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name))) ((:+:) * (C1 * (MetaCons "ConE" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name))) (C1 * (MetaCons "LitE" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Lit))))) ((:+:) * (C1 * (MetaCons "AppE" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp)))) ((:+:) * (C1 * (MetaCons "AppTypeE" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Type)))) (C1 * (MetaCons "InfixE" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Exp))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Exp))))))))) ((:+:) * ((:+:) * (C1 * (MetaCons "UInfixE" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp))))) ((:+:) * (C1 * (MetaCons "ParensE" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp))) (C1 * (MetaCons "LamE" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Pat])) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp)))))) ((:+:) * ((:+:) * (C1 * (MetaCons "LamCaseE" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Match]))) (C1 * (MetaCons "TupE" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Exp])))) ((:+:) * (C1 * (MetaCons "UnboxedTupE" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Exp]))) (C1 * (MetaCons "UnboxedSumE" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * SumAlt)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * SumArity))))))))) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "CondE" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp))))) ((:+:) * (C1 * (MetaCons "MultiIfE" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [(Guard, Exp)]))) (C1 * (MetaCons "LetE" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Dec])) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp)))))) ((:+:) * (C1 * (MetaCons "CaseE" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Match])))) ((:+:) * (C1 * (MetaCons "DoE" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Stmt]))) (C1 * (MetaCons "CompE" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Stmt])))))) ((:+:) * ((:+:) * (C1 * (MetaCons "ArithSeqE" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Range))) ((:+:) * (C1 * (MetaCons "ListE" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Exp]))) (C1 * (MetaCons "SigE" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Type)))))) ((:+:) * ((:+:) * (C1 * (MetaCons "RecConE" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [FieldExp])))) (C1 * (MetaCons "RecUpdE" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [FieldExp]))))) ((:+:) * (C1 * (MetaCons "StaticE" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp))) (C1 * (MetaCons "UnboundVarE" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name))))))))

data Match Source #

Constructors

Match Pat Body [Dec] |
    case e of { pat -> body where decs }

Instances

Eq Match # |
Methods (==) :: Match -> Match -> Bool # (/=) :: Match -> Match -> Bool #
Data Match # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Match -> c Match Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Match Source # toConstr :: Match -> Constr Source # dataTypeOf :: Match -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Match) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match) Source # gmapT :: (forall b. Data b => b -> b) -> Match -> Match Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Match -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Match -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Match -> m Match Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Match -> m Match Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Match -> m Match Source #
Ord Match # |
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 # |
Methods showsPrec :: Int -> Match -> ShowS Source # show :: Match -> String Source # showList :: [Match] -> ShowS Source #
Generic Match # |
Associated Types type Rep Match :: * -> * Source # Methods from :: Match -> Rep Match x Source # to :: Rep Match x -> Match Source #
Ppr Match # |
Methods ppr :: Match -> Doc Source # ppr_list :: [Match] -> Doc Source #
type Rep Match # |
type Rep Match = D1 * (MetaData "Match" "Language.Haskell.TH.Syntax" "template-haskell" False) (C1 * (MetaCons "Match" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Pat)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Body)) (S1 * (MetaSel (Nothing 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 # |
Methods (==) :: Body -> Body -> Bool # (/=) :: Body -> Body -> Bool #
Data Body # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Body -> c Body Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Body Source # toConstr :: Body -> Constr Source # dataTypeOf :: Body -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Body) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Body) Source # gmapT :: (forall b. Data b => b -> b) -> Body -> Body Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Body -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Body -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Body -> m Body Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Body -> m Body Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Body -> m Body Source #
Ord Body # |
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 # |
Methods showsPrec :: Int -> Body -> ShowS Source # show :: Body -> String Source # showList :: [Body] -> ShowS Source #
Generic Body # |
Associated Types type Rep Body :: * -> * Source # Methods from :: Body -> Rep Body x Source # to :: Rep Body x -> Body Source #
type Rep Body # |
type Rep Body = D1 * (MetaData "Body" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * (C1 * (MetaCons "GuardedB" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [(Guard, Exp)]))) (C1 * (MetaCons "NormalB" PrefixI False) (S1 * (MetaSel (Nothing 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 # |
Methods (==) :: Guard -> Guard -> Bool # (/=) :: Guard -> Guard -> Bool #
Data Guard # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Guard -> c Guard Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Guard Source # toConstr :: Guard -> Constr Source # dataTypeOf :: Guard -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Guard) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Guard) Source # gmapT :: (forall b. Data b => b -> b) -> Guard -> Guard Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Guard -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Guard -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Guard -> m Guard Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Guard -> m Guard Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Guard -> m Guard Source #
Ord Guard # |
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 # |
Methods showsPrec :: Int -> Guard -> ShowS Source # show :: Guard -> String Source # showList :: [Guard] -> ShowS Source #
Generic Guard # |
Associated Types type Rep Guard :: * -> * Source # Methods from :: Guard -> Rep Guard x Source # to :: Rep Guard x -> Guard Source #
type Rep Guard # |
type Rep Guard = D1 * (MetaData "Guard" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * (C1 * (MetaCons "NormalG" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp))) (C1 * (MetaCons "PatG" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Stmt]))))

data Stmt Source #

Constructors

BindS Pat Exp |
LetS [Dec] |
NoBindS Exp |
ParS [[Stmt]] |

Instances

Eq Stmt # |
Methods (==) :: Stmt -> Stmt -> Bool # (/=) :: Stmt -> Stmt -> Bool #
Data Stmt # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Stmt -> c Stmt Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Stmt Source # toConstr :: Stmt -> Constr Source # dataTypeOf :: Stmt -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Stmt) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stmt) Source # gmapT :: (forall b. Data b => b -> b) -> Stmt -> Stmt Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Stmt -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Stmt -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Stmt -> m Stmt Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Stmt -> m Stmt Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Stmt -> m Stmt Source #
Ord Stmt # |
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 # |
Methods showsPrec :: Int -> Stmt -> ShowS Source # show :: Stmt -> String Source # showList :: [Stmt] -> ShowS Source #
Generic Stmt # |
Associated Types type Rep Stmt :: * -> * Source # Methods from :: Stmt -> Rep Stmt x Source # to :: Rep Stmt x -> Stmt Source #
Ppr Stmt # |
Methods ppr :: Stmt -> Doc Source # ppr_list :: [Stmt] -> Doc Source #
type Rep Stmt # |
type Rep Stmt = D1 * (MetaData "Stmt" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * ((:+:) * (C1 * (MetaCons "BindS" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Pat)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp)))) (C1 * (MetaCons "LetS" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Dec])))) ((:+:) * (C1 * (MetaCons "NoBindS" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp))) (C1 * (MetaCons "ParS" PrefixI False) (S1 * (MetaSel (Nothing 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 # |
Methods (==) :: Range -> Range -> Bool # (/=) :: Range -> Range -> Bool #
Data Range # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Range -> c Range Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Range Source # toConstr :: Range -> Constr Source # dataTypeOf :: Range -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Range) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Range) Source # gmapT :: (forall b. Data b => b -> b) -> Range -> Range Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Range -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Range -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Range -> m Range Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Range -> m Range Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Range -> m Range Source #
Ord Range # |
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 # |
Methods showsPrec :: Int -> Range -> ShowS Source # show :: Range -> String Source # showList :: [Range] -> ShowS Source #
Generic Range # |
Associated Types type Rep Range :: * -> * Source # Methods from :: Range -> Rep Range x Source # to :: Rep Range x -> Range Source #
Ppr Range # |
Methods ppr :: Range -> Doc Source # ppr_list :: [Range] -> Doc Source #
type Rep Range # |
type Rep Range = D1 * (MetaData "Range" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * ((:+:) * (C1 * (MetaCons "FromR" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp))) (C1 * (MetaCons "FromThenR" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp))))) ((:+:) * (C1 * (MetaCons "FromToR" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp)))) (C1 * (MetaCons "FromThenToR" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp)) (S1 * (MetaSel (Nothing 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 # |
Methods (==) :: Lit -> Lit -> Bool # (/=) :: Lit -> Lit -> Bool #
Data Lit # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Lit -> c Lit Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Lit Source # toConstr :: Lit -> Constr Source # dataTypeOf :: Lit -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Lit) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lit) Source # gmapT :: (forall b. Data b => b -> b) -> Lit -> Lit Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Lit -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Lit -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Lit -> m Lit Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Lit -> m Lit Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Lit -> m Lit Source #
Ord Lit # |
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 # |
Methods showsPrec :: Int -> Lit -> ShowS Source # show :: Lit -> String Source # showList :: [Lit] -> ShowS Source #
Generic Lit # |
Associated Types type Rep Lit :: * -> * Source # Methods from :: Lit -> Rep Lit x Source # to :: Rep Lit x -> Lit Source #
Ppr Lit # |
Methods ppr :: Lit -> Doc Source # ppr_list :: [Lit] -> Doc Source #
type Rep Lit # |
type Rep Lit = D1 * (MetaData "Lit" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "CharL" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Char))) (C1 * (MetaCons "StringL" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)))) ((:+:) * (C1 * (MetaCons "IntegerL" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Integer))) ((:+:) * (C1 * (MetaCons "RationalL" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Rational))) (C1 * (MetaCons "IntPrimL" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Integer)))))) ((:+:) * ((:+:) * (C1 * (MetaCons "WordPrimL" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Integer))) (C1 * (MetaCons "FloatPrimL" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Rational)))) ((:+:) * (C1 * (MetaCons "DoublePrimL" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Rational))) ((:+:) * (C1 * (MetaCons "StringPrimL" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Word8]))) (C1 * (MetaCons "CharPrimL" PrefixI False) (S1 * (MetaSel (Nothing 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 # |
Methods (==) :: Pat -> Pat -> Bool # (/=) :: Pat -> Pat -> Bool #
Data Pat # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Pat -> c Pat Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Pat Source # toConstr :: Pat -> Constr Source # dataTypeOf :: Pat -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Pat) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat) Source # gmapT :: (forall b. Data b => b -> b) -> Pat -> Pat Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Pat -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Pat -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Pat -> m Pat Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Pat -> m Pat Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Pat -> m Pat Source #
Ord Pat # |
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 # |
Methods showsPrec :: Int -> Pat -> ShowS Source # show :: Pat -> String Source # showList :: [Pat] -> ShowS Source #
Generic Pat # |
Associated Types type Rep Pat :: * -> * Source # Methods from :: Pat -> Rep Pat x Source # to :: Rep Pat x -> Pat Source #
Ppr Pat # |
Methods ppr :: Pat -> Doc Source # ppr_list :: [Pat] -> Doc Source #
type Rep Pat # |
type Rep Pat = D1 * (MetaData "Pat" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "LitP" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Lit))) (C1 * (MetaCons "VarP" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)))) ((:+:) * (C1 * (MetaCons "TupP" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Pat]))) (C1 * (MetaCons "UnboxedTupP" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Pat]))))) ((:+:) * ((:+:) * (C1 * (MetaCons "UnboxedSumP" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Pat)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * SumAlt)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * SumArity))))) (C1 * (MetaCons "ConP" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Pat]))))) ((:+:) * (C1 * (MetaCons "InfixP" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Pat)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Pat))))) (C1 * (MetaCons "UInfixP" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Pat)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Pat)))))))) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "ParensP" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Pat))) (C1 * (MetaCons "TildeP" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Pat)))) ((:+:) * (C1 * (MetaCons "BangP" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Pat))) (C1 * (MetaCons "AsP" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Pat)))))) ((:+:) * ((:+:) * (C1 * (MetaCons "WildP" PrefixI False) (U1 *)) (C1 * (MetaCons "RecP" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [FieldPat]))))) ((:+:) * (C1 * (MetaCons "ListP" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Pat]))) ((:+:) * (C1 * (MetaCons "SigP" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Pat)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Type)))) (C1 * (MetaCons "ViewP" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Exp)) (S1 * (MetaSel (Nothing 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
SigT Type Kind |
    t :: k
VarT Name |
    a
ConT Name |
    T
PromotedT Name |
    'T
InfixT Type Name Type |
    T + T
UInfixT Type Name Type |
    T + T
See Language.Haskell.TH.Syntax
ParensT Type |
    (T)
TupleT Int |
    (,), (,,), etc.
UnboxedTupleT Int |
    (#,#), (#,,#), etc.
UnboxedSumT SumArity |
    (#|#), (#||#), etc.
ArrowT |
    ->
EqualityT |
    ~
ListT |
    []
PromotedTupleT Int |
    '(), '(,), '(,,), etc.
PromotedNilT |
    '[]
PromotedConsT |
    (':)
StarT |
    *
ConstraintT |
    Constraint
LitT TyLit |
    0,1,2, etc.
WildCardT | @_,

Instances

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

data TyVarBndr Source #

Constructors

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

Instances

Eq TyVarBndr # |
Methods (==) :: TyVarBndr -> TyVarBndr -> Bool # (/=) :: TyVarBndr -> TyVarBndr -> Bool #
Data TyVarBndr # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyVarBndr -> c TyVarBndr Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TyVarBndr Source # toConstr :: TyVarBndr -> Constr Source # dataTypeOf :: TyVarBndr -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c TyVarBndr) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyVarBndr) Source # gmapT :: (forall b. Data b => b -> b) -> TyVarBndr -> TyVarBndr Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyVarBndr -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyVarBndr -> r Source # gmapQ :: (forall d. Data d => d -> u) -> TyVarBndr -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> TyVarBndr -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyVarBndr -> m TyVarBndr Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyVarBndr -> m TyVarBndr Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyVarBndr -> m TyVarBndr Source #
Ord TyVarBndr # |
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 # |
Methods showsPrec :: Int -> TyVarBndr -> ShowS Source # show :: TyVarBndr -> String Source # showList :: [TyVarBndr] -> ShowS Source #
Generic TyVarBndr # |
Associated Types type Rep TyVarBndr :: * -> * Source # Methods from :: TyVarBndr -> Rep TyVarBndr x Source # to :: Rep TyVarBndr x -> TyVarBndr Source #
Ppr TyVarBndr # |
Methods ppr :: TyVarBndr -> Doc Source # ppr_list :: [TyVarBndr] -> Doc Source #
type Rep TyVarBndr # |
type Rep TyVarBndr = D1 * (MetaData "TyVarBndr" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * (C1 * (MetaCons "PlainTV" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name))) (C1 * (MetaCons "KindedTV" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Kind)))))

data TyLit Source #

Constructors

NumTyLit Integer |
    2
StrTyLit String |
    Hello

Instances

Eq TyLit # |
Methods (==) :: TyLit -> TyLit -> Bool # (/=) :: TyLit -> TyLit -> Bool #
Data TyLit # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyLit -> c TyLit Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TyLit Source # toConstr :: TyLit -> Constr Source # dataTypeOf :: TyLit -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c TyLit) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyLit) Source # gmapT :: (forall b. Data b => b -> b) -> TyLit -> TyLit Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r Source # gmapQ :: (forall d. Data d => d -> u) -> TyLit -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> TyLit -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit Source #
Ord TyLit # |
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 # |
Methods showsPrec :: Int -> TyLit -> ShowS Source # show :: TyLit -> String Source # showList :: [TyLit] -> ShowS Source #
Generic TyLit # |
Associated Types type Rep TyLit :: * -> * Source # Methods from :: TyLit -> Rep TyLit x Source # to :: Rep TyLit x -> TyLit Source #
Ppr TyLit # |
Methods ppr :: TyLit -> Doc Source # ppr_list :: [TyLit] -> Doc Source #
type Rep TyLit # |
type Rep TyLit = D1 * (MetaData "TyLit" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * (C1 * (MetaCons "NumTyLit" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Integer))) (C1 * (MetaCons "StrTyLit" PrefixI False) (S1 * (MetaSel (Nothing 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 # |
Methods (==) :: Role -> Role -> Bool # (/=) :: Role -> Role -> Bool #
Data Role # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Role -> c Role Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Role Source # toConstr :: Role -> Constr Source # dataTypeOf :: Role -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Role) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Role) Source # gmapT :: (forall b. Data b => b -> b) -> Role -> Role Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Role -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Role -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Role -> m Role Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m Role Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m Role Source #
Ord Role # |
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 # |
Methods showsPrec :: Int -> Role -> ShowS Source # show :: Role -> String Source # showList :: [Role] -> ShowS Source #
Generic Role # |
Associated Types type Rep Role :: * -> * Source # Methods from :: Role -> Rep Role x Source # to :: Rep Role x -> Role Source #
Ppr Role # |
Methods ppr :: Role -> Doc Source # ppr_list :: [Role] -> Doc Source #
type Rep Role # |
type Rep Role = D1 * (MetaData "Role" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * ((:+:) * (C1 * (MetaCons "NominalR" PrefixI False) (U1 *)) (C1 * (MetaCons "RepresentationalR" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "PhantomR" PrefixI False) (U1 *)) (C1 * (MetaCons "InferR" PrefixI False) (U1 *))))

data FamilyResultSig Source #

Type family result signature

Constructors

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

Instances

Eq FamilyResultSig # |
Methods (==) :: FamilyResultSig -> FamilyResultSig -> Bool # (/=) :: FamilyResultSig -> FamilyResultSig -> Bool #
Data FamilyResultSig # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamilyResultSig -> c FamilyResultSig Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FamilyResultSig Source # toConstr :: FamilyResultSig -> Constr Source # dataTypeOf :: FamilyResultSig -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c FamilyResultSig) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FamilyResultSig) Source # gmapT :: (forall b. Data b => b -> b) -> FamilyResultSig -> FamilyResultSig Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r Source # gmapQ :: (forall d. Data d => d -> u) -> FamilyResultSig -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> FamilyResultSig -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamilyResultSig -> m FamilyResultSig Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyResultSig -> m FamilyResultSig Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyResultSig -> m FamilyResultSig Source #
Ord FamilyResultSig # |
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 # |
Methods showsPrec :: Int -> FamilyResultSig -> ShowS Source # show :: FamilyResultSig -> String Source # showList :: [FamilyResultSig] -> ShowS Source #
Generic FamilyResultSig # |
Associated Types type Rep FamilyResultSig :: * -> * Source # Methods from :: FamilyResultSig -> Rep FamilyResultSig x Source # to :: Rep FamilyResultSig x -> FamilyResultSig Source #
Ppr FamilyResultSig # |
Methods ppr :: FamilyResultSig -> Doc Source # ppr_list :: [FamilyResultSig] -> Doc Source #
type Rep FamilyResultSig # |
type Rep FamilyResultSig = D1 * (MetaData "FamilyResultSig" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) * (C1 * (MetaCons "NoSig" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "KindSig" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Kind))) (C1 * (MetaCons "TyVarSig" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * TyVarBndr)))))

data InjectivityAnn Source #

Injectivity annotation

Constructors

InjectivityAnn Name [Name] |

Instances

Eq InjectivityAnn # |
Methods (==) :: InjectivityAnn -> InjectivityAnn -> Bool # (/=) :: InjectivityAnn -> InjectivityAnn -> Bool #
Data InjectivityAnn # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InjectivityAnn -> c InjectivityAnn Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c InjectivityAnn Source # toConstr :: InjectivityAnn -> Constr Source # dataTypeOf :: InjectivityAnn -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c InjectivityAnn) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InjectivityAnn) Source # gmapT :: (forall b. Data b => b -> b) -> InjectivityAnn -> InjectivityAnn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> InjectivityAnn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> InjectivityAnn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> InjectivityAnn -> m InjectivityAnn Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityAnn -> m InjectivityAnn Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityAnn -> m InjectivityAnn Source #
Ord InjectivityAnn # |
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 # |
Methods showsPrec :: Int -> InjectivityAnn -> ShowS Source # show :: InjectivityAnn -> String Source # showList :: [InjectivityAnn] -> ShowS Source #
Generic InjectivityAnn # |
Associated Types type Rep InjectivityAnn :: * -> * Source # Methods from :: InjectivityAnn -> Rep InjectivityAnn x Source # to :: Rep InjectivityAnn x -> InjectivityAnn Source #
Ppr InjectivityAnn # |
Methods ppr :: InjectivityAnn -> Doc Source # ppr_list :: [InjectivityAnn] -> Doc Source #
type Rep InjectivityAnn # |
type Rep InjectivityAnn = D1 * (MetaData "InjectivityAnn" "Language.Haskell.TH.Syntax" "template-haskell" False) (C1 * (MetaCons "InjectivityAnn" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)) (S1 * (MetaSel (Nothing 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

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

consisting of four parts:

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

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

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

(b) Pretty printing via `pprPatSynType` abbreviates a pattern synonym's type unambiguously in concrete syntax: The rule of thumb is to print initial empty universals and the required context as `() =>`, if existentials and a provided context follow. If only universals and their required context, but no existentials are specified, only the universals and their required context are printed. If both or none are specified, so both (or none) are printed.

(c) When specifying a pattern synonym's type explicitly with `PatSynSigD` either one of the universals, the existentials, or their contexts may be left empty.

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

# Library functions

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 Exp # |
Methods ppr :: Exp -> Doc Source # ppr_list :: [Exp] -> Doc Source #
Ppr Match # |
Methods ppr :: Match -> Doc Source # ppr_list :: [Match] -> Doc Source #
Ppr Clause # |
Methods ppr :: Clause -> Doc Source # ppr_list :: [Clause] -> Doc Source #
Ppr Pat # |
Methods ppr :: Pat -> Doc Source # ppr_list :: [Pat] -> Doc Source #
Ppr Type # |
Methods ppr :: Type -> Doc Source # ppr_list :: [Type] -> Doc Source #
Ppr Dec # |
Methods ppr :: Dec -> Doc Source # ppr_list :: [Dec] -> Doc Source #
Ppr Name # |
Methods ppr :: Name -> Doc Source # ppr_list :: [Name] -> Doc Source #
Ppr FunDep # |
Methods ppr :: FunDep -> Doc Source # ppr_list :: [FunDep] -> Doc Source #
Ppr TyVarBndr # |
Methods ppr :: TyVarBndr -> Doc Source # ppr_list :: [TyVarBndr] -> Doc Source #
Ppr InjectivityAnn # |
Methods ppr :: InjectivityAnn -> Doc Source # ppr_list :: [InjectivityAnn] -> Doc Source #
Ppr Role # |
Methods ppr :: Role -> Doc Source # ppr_list :: [Role] -> Doc Source #
Ppr TyLit # |
Methods ppr :: TyLit -> Doc Source # ppr_list :: [TyLit] -> Doc Source #
Ppr FamilyResultSig # |
Methods ppr :: FamilyResultSig -> Doc Source # ppr_list :: [FamilyResultSig] -> Doc Source #
Ppr PatSynArgs # |
Methods ppr :: PatSynArgs -> Doc Source # ppr_list :: [PatSynArgs] -> Doc Source #
Ppr PatSynDir # |
Methods ppr :: PatSynDir -> Doc Source # ppr_list :: [PatSynDir] -> Doc Source #
Ppr Bang # |
Methods ppr :: Bang -> Doc Source # ppr_list :: [Bang] -> Doc Source #
Ppr Con # |
Methods ppr :: Con -> Doc Source # ppr_list :: [Con] -> Doc Source #
Ppr DecidedStrictness # |
Methods ppr :: DecidedStrictness -> Doc Source # ppr_list :: [DecidedStrictness] -> Doc Source #
Ppr SourceStrictness # |
Methods ppr :: SourceStrictness -> Doc Source # ppr_list :: [SourceStrictness] -> Doc Source #
Ppr SourceUnpackedness # |
Methods ppr :: SourceUnpackedness -> Doc Source # ppr_list :: [SourceUnpackedness] -> Doc Source #
Ppr RuleBndr # |
Methods ppr :: RuleBndr -> Doc Source # ppr_list :: [RuleBndr] -> Doc Source #
Ppr Phases # |
Methods ppr :: Phases -> Doc Source # ppr_list :: [Phases] -> Doc Source #
Ppr RuleMatch # |
Methods ppr :: RuleMatch -> Doc Source # ppr_list :: [RuleMatch] -> Doc Source #
Ppr Inline # |
Methods ppr :: Inline -> Doc Source # ppr_list :: [Inline] -> Doc Source #
Ppr Pragma # |
Methods ppr :: Pragma -> Doc Source # ppr_list :: [Pragma] -> Doc Source #
Ppr Foreign # |
Methods ppr :: Foreign -> Doc Source # ppr_list :: [Foreign] -> Doc Source #
Ppr FamFlavour # |
Methods ppr :: FamFlavour -> Doc Source # ppr_list :: [FamFlavour] -> Doc Source #
Ppr Range # |
Methods ppr :: Range -> Doc Source # ppr_list :: [Range] -> Doc Source #
Ppr Stmt # |
Methods ppr :: Stmt -> Doc Source # ppr_list :: [Stmt] -> Doc Source #
Ppr Lit # |
Methods ppr :: Lit -> Doc Source # ppr_list :: [Lit] -> Doc Source #
Ppr ModuleInfo # |
Methods ppr :: ModuleInfo -> Doc Source # ppr_list :: [ModuleInfo] -> Doc Source #
Ppr Info # |
Methods ppr :: Info -> Doc Source # ppr_list :: [Info] -> Doc Source #
Ppr Loc # |
Methods ppr :: Loc -> Doc Source # ppr_list :: [Loc] -> Doc Source #
Ppr Module # |
Methods ppr :: Module -> Doc Source # ppr_list :: [Module] -> Doc Source #
Ppr a => Ppr [a] # |
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 #