| Copyright | (c) The University of Glasgow 2003 |
|---|---|
| License | BSD-style (see the file libraries/base/LICENSE) |
| Maintainer | libraries@haskell.org |
| Stability | experimental |
| Portability | portable |
| Safe Haskell | Trustworthy |
| Language | Haskell2010 |
Language.Haskell.TH.Syntax
Contents
Description
Abstract syntax definitions for Template Haskell.
Synopsis
- type Kind = Type
- data AnnLookup
- data Role
- data TyLit
- data InjectivityAnn = InjectivityAnn Name [Name]
- data FamilyResultSig
- data TyVarBndr
- data Type
- = ForallT [TyVarBndr] Cxt Type
- | ForallVisT [TyVarBndr] Type
- | AppT Type Type
- | AppKindT Type Kind
- | SigT Type Kind
- | VarT Name
- | ConT Name
- | PromotedT Name
- | InfixT Type Name Type
- | UInfixT Type Name Type
- | ParensT Type
- | TupleT Int
- | UnboxedTupleT Int
- | UnboxedSumT SumArity
- | ArrowT
- | EqualityT
- | ListT
- | PromotedTupleT Int
- | PromotedNilT
- | PromotedConsT
- | StarT
- | ConstraintT
- | LitT TyLit
- | WildCardT
- | ImplicitParamT String Type
- data PatSynArgs
- = PrefixPatSyn [Name]
- | InfixPatSyn Name Name
- | RecordPatSyn [Name]
- data PatSynDir
- type VarStrictType = VarBangType
- type StrictType = BangType
- type Strict = Bang
- type VarBangType = (Name, Bang, Type)
- type BangType = (Bang, Type)
- data Bang = Bang SourceUnpackedness SourceStrictness
- data Con
- data DecidedStrictness
- data SourceStrictness
- data SourceUnpackedness
- type Pred = Type
- type Cxt = [Pred]
- data AnnTarget
- data RuleBndr
- data Phases
- data RuleMatch
- data Inline
- data Pragma
- data Safety
- = Unsafe
- | Safe
- | Interruptible
- data Callconv
- = CCall
- | StdCall
- | CApi
- | Prim
- | JavaScript
- data Foreign
- data FunDep = FunDep [Name] [Name]
- data TySynEqn = TySynEqn (Maybe [TyVarBndr]) Type Type
- data TypeFamilyHead = TypeFamilyHead Name [TyVarBndr] FamilyResultSig (Maybe InjectivityAnn)
- type PatSynType = Type
- data DerivStrategy
- data DerivClause = DerivClause (Maybe DerivStrategy) Cxt
- data Overlap
- 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
- | KiSigD Name Kind
- | ForeignD Foreign
- | InfixD Fixity Name
- | PragmaD Pragma
- | DataFamilyD Name [TyVarBndr] (Maybe Kind)
- | DataInstD Cxt (Maybe [TyVarBndr]) Type (Maybe Kind) [Con] [DerivClause]
- | NewtypeInstD Cxt (Maybe [TyVarBndr]) Type (Maybe Kind) Con [DerivClause]
- | TySynInstD TySynEqn
- | OpenTypeFamilyD TypeFamilyHead
- | ClosedTypeFamilyD TypeFamilyHead [TySynEqn]
- | RoleAnnotD Name [Role]
- | StandaloneDerivD (Maybe DerivStrategy) Cxt Type
- | DefaultSigD Name Type
- | PatSynD Name PatSynArgs PatSynDir Pat
- | PatSynSigD Name PatSynType
- | ImplicitParamBindD String Exp
- data Range
- data Stmt
- data Guard
- data Body
- type FieldExp = (Name, Exp)
- 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 [Maybe Exp]
- | UnboxedTupE [Maybe Exp]
- | UnboxedSumE Exp SumAlt SumArity
- | CondE Exp Exp Exp
- | MultiIfE [(Guard, Exp)]
- | LetE [Dec] Exp
- | CaseE Exp [Match]
- | DoE [Stmt]
- | MDoE [Stmt]
- | CompE [Stmt]
- | ArithSeqE Range
- | ListE [Exp]
- | SigE Exp Type
- | RecConE Name [FieldExp]
- | RecUpdE Exp [FieldExp]
- | StaticE Exp
- | UnboundVarE Name
- | LabelE String
- | ImplicitParamVarE String
- data Clause = Clause [Pat] Body [Dec]
- data Match = Match Pat Body [Dec]
- type FieldPat = (Name, Pat)
- data Pat
- data Bytes = Bytes {
- bytesPtr :: ForeignPtr Word8
- bytesOffset :: Word
- bytesSize :: Word
- data Lit
- data FixityDirection
- data Fixity = Fixity Int FixityDirection
- type InstanceDec = Dec
- type Unlifted = Bool
- type Arity = Int
- type SumArity = Int
- type SumAlt = Int
- type ParentName = Name
- data ModuleInfo = ModuleInfo [Module]
- data Info
- type CharPos = (Int, Int)
- data Loc = Loc {}
- data NameIs
- type Uniq = Integer
- data NameSpace
- data NameFlavour
- data Name = Name OccName NameFlavour
- newtype OccName = OccName String
- data Module = Module PkgName ModName
- newtype PkgName = PkgName String
- newtype ModName = ModName String
- class Lift (t :: TYPE r) where
- newtype TExp (a :: TYPE (r :: RuntimeRep)) = TExp {}
- newtype Q a = Q {}
- class (MonadIO m, MonadFail m) => Quasi m where
- qNewName :: String -> m Name
- qReport :: Bool -> String -> m ()
- qRecover :: m a -> m a -> m a
- qLookupName :: Bool -> String -> m (Maybe Name)
- qReify :: Name -> m Info
- qReifyFixity :: Name -> m (Maybe Fixity)
- qReifyType :: Name -> m Type
- qReifyInstances :: Name -> [Type] -> m [Dec]
- qReifyRoles :: Name -> m [Role]
- qReifyAnnotations :: Data a => AnnLookup -> m [a]
- qReifyModule :: Module -> m ModuleInfo
- qReifyConStrictness :: Name -> m [DecidedStrictness]
- qLocation :: m Loc
- qRunIO :: IO a -> m a
- qAddDependentFile :: FilePath -> m ()
- qAddTempFile :: String -> m FilePath
- qAddTopDecls :: [Dec] -> m ()
- qAddForeignFilePath :: ForeignSrcLang -> String -> m ()
- qAddModFinalizer :: Q () -> m ()
- qAddCorePlugin :: String -> m ()
- qGetQ :: Typeable a => m (Maybe a)
- qPutQ :: Typeable a => a -> m ()
- qIsExtEnabled :: Extension -> m Bool
- qExtsEnabled :: m [Extension]
- badIO :: String -> IO a
- counter :: IORef Uniq
- runQ :: Quasi m => Q a -> m a
- unTypeQ :: forall (r :: RuntimeRep) (a :: TYPE r). Q (TExp a) -> Q Exp
- unsafeTExpCoerce :: forall (r :: RuntimeRep) (a :: TYPE r). Q Exp -> Q (TExp a)
- newName :: String -> Q Name
- report :: Bool -> String -> Q ()
- reportError :: String -> Q ()
- reportWarning :: String -> Q ()
- recover :: Q a -> Q a -> Q a
- lookupName :: Bool -> String -> Q (Maybe Name)
- lookupTypeName :: String -> Q (Maybe Name)
- lookupValueName :: String -> Q (Maybe Name)
- reify :: Name -> Q Info
- reifyFixity :: Name -> Q (Maybe Fixity)
- reifyType :: Name -> Q Type
- reifyInstances :: Name -> [Type] -> Q [InstanceDec]
- reifyRoles :: Name -> Q [Role]
- reifyAnnotations :: Data a => AnnLookup -> Q [a]
- reifyModule :: Module -> Q ModuleInfo
- reifyConStrictness :: Name -> Q [DecidedStrictness]
- isInstance :: Name -> [Type] -> Q Bool
- location :: Q Loc
- runIO :: IO a -> Q a
- addDependentFile :: FilePath -> Q ()
- addTempFile :: String -> Q FilePath
- addTopDecls :: [Dec] -> Q ()
- addForeignFile :: ForeignSrcLang -> String -> Q ()
- addForeignSource :: ForeignSrcLang -> String -> Q ()
- addForeignFilePath :: ForeignSrcLang -> FilePath -> Q ()
- addModFinalizer :: Q () -> Q ()
- addCorePlugin :: String -> Q ()
- getQ :: Typeable a => Q (Maybe a)
- putQ :: Typeable a => a -> Q ()
- isExtEnabled :: Extension -> Q Bool
- extsEnabled :: Q [Extension]
- returnQ :: a -> Q a
- bindQ :: Q a -> (a -> Q b) -> Q b
- sequenceQ :: [Q a] -> Q [a]
- liftString :: String -> Q Exp
- trueName :: Name
- falseName :: Name
- nothingName :: Name
- justName :: Name
- leftName :: Name
- rightName :: Name
- nonemptyName :: Name
- dataToQa :: forall a k q. Data a => (Name -> k) -> (Lit -> Q q) -> (k -> [Q q] -> Q q) -> (forall b. Data b => b -> Maybe (Q q)) -> a -> Q q
- dataToExpQ :: Data a => (forall b. Data b => b -> Maybe (Q Exp)) -> a -> Q Exp
- liftData :: Data a => a -> Q Exp
- dataToPatQ :: Data a => (forall b. Data b => b -> Maybe (Q Pat)) -> a -> Q Pat
- mkModName :: String -> ModName
- modString :: ModName -> String
- mkPkgName :: String -> PkgName
- pkgString :: PkgName -> String
- mkOccName :: String -> OccName
- occString :: OccName -> String
- nameBase :: Name -> String
- nameModule :: Name -> Maybe String
- namePackage :: Name -> Maybe String
- nameSpace :: Name -> Maybe NameSpace
- mkName :: String -> Name
- mkNameU :: String -> Uniq -> Name
- mkNameL :: String -> Uniq -> Name
- mkNameG :: NameSpace -> String -> String -> String -> Name
- mkNameS :: String -> Name
- mkNameG_v :: String -> String -> String -> Name
- mkNameG_tc :: String -> String -> String -> Name
- mkNameG_d :: String -> String -> String -> Name
- showName :: Name -> String
- showName' :: NameIs -> Name -> String
- tupleDataName :: Int -> Name
- tupleTypeName :: Int -> Name
- unboxedTupleDataName :: Int -> Name
- unboxedTupleTypeName :: Int -> Name
- mk_tup_name :: Int -> NameSpace -> Bool -> Name
- unboxedSumDataName :: SumAlt -> SumArity -> Name
- unboxedSumTypeName :: SumArity -> Name
- maxPrecedence :: Int
- defaultFixity :: Fixity
- cmpEq :: Ordering -> Bool
- thenCmp :: Ordering -> Ordering -> Ordering
- module Language.Haskell.TH.LanguageExtensions
- data ForeignSrcLang
Documentation
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.
Annotation target for reifyAnnotations
Constructors
| AnnLookupModule Module | |
| AnnLookupName Name |
Instances
| Eq AnnLookup Source # | |
| Data AnnLookup Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnLookup -> c AnnLookup # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnLookup # toConstr :: AnnLookup -> Constr # dataTypeOf :: AnnLookup -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnLookup) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnLookup) # gmapT :: (forall b. Data b => b -> b) -> AnnLookup -> AnnLookup # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnLookup -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnLookup -> r # gmapQ :: (forall d. Data d => d -> u) -> AnnLookup -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnLookup -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup # | |
| Ord AnnLookup Source # | |
| Show AnnLookup Source # | |
| Generic AnnLookup Source # | |
| Binary AnnLookup Source # | |
| type Rep AnnLookup Source # | |
Defined in Language.Haskell.TH.Syntax type Rep AnnLookup = D1 (MetaData "AnnLookup" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.10.2.20200808-1yGh9NazOlH8xYNIwuirq3" False) (C1 (MetaCons "AnnLookupModule" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Module)) :+: C1 (MetaCons "AnnLookupName" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name))) | |
Role annotations
Constructors
| NominalR | nominal |
| RepresentationalR | representational |
| PhantomR | phantom |
| InferR | _ |
Instances
| Eq Role Source # | |
| Data Role Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Role -> c Role # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Role # dataTypeOf :: Role -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Role) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Role) # gmapT :: (forall b. Data b => b -> b) -> Role -> Role # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r # gmapQ :: (forall d. Data d => d -> u) -> Role -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Role -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Role -> m Role # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m Role # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m Role # | |
| Ord Role Source # | |
| Show Role Source # | |
| Generic Role Source # | |
| Binary Role Source # | |
| Ppr Role Source # | |
| type Rep Role Source # | |
Defined in Language.Haskell.TH.Syntax type Rep Role = D1 (MetaData "Role" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.10.2.20200808-1yGh9NazOlH8xYNIwuirq3" False) ((C1 (MetaCons "NominalR" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "RepresentationalR" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "PhantomR" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "InferR" PrefixI False) (U1 :: Type -> Type))) | |
Instances
| Eq TyLit Source # | |
| Data TyLit Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyLit -> c TyLit # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TyLit # dataTypeOf :: TyLit -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TyLit) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyLit) # gmapT :: (forall b. Data b => b -> b) -> TyLit -> TyLit # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r # gmapQ :: (forall d. Data d => d -> u) -> TyLit -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TyLit -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit # | |
| Ord TyLit Source # | |
| Show TyLit Source # | |
| Generic TyLit Source # | |
| Binary TyLit Source # | |
| Ppr TyLit Source # | |
| type Rep TyLit Source # | |
Defined in Language.Haskell.TH.Syntax type Rep TyLit = D1 (MetaData "TyLit" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.10.2.20200808-1yGh9NazOlH8xYNIwuirq3" False) (C1 (MetaCons "NumTyLit" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer)) :+: C1 (MetaCons "StrTyLit" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))) | |
data InjectivityAnn Source #
Injectivity annotation
Constructors
| InjectivityAnn Name [Name] |
Instances
data FamilyResultSig Source #
Type family result signature
Instances
Instances
Constructors
| ForallT [TyVarBndr] Cxt Type | forall <vars>. <ctxt> => <type> |
| ForallVisT [TyVarBndr] Type | forall <vars> -> <type> |
| AppT Type Type | T a b |
| AppKindT Type Kind | T @k t |
| SigT Type Kind | t :: k |
| VarT Name | a |
| ConT Name | T |
| PromotedT Name | 'T |
| InfixT Type Name Type | T + T |
| UInfixT Type Name Type | T + T |
| ParensT Type | (T) |
| TupleT Int | (,), (,,), etc. |
| UnboxedTupleT Int | (#,#), (#,,#), etc. |
| UnboxedSumT SumArity | (#|#), (#||#), etc. |
| ArrowT | -> |
| EqualityT | ~ |
| ListT | [] |
| PromotedTupleT Int | '(), '(,), '(,,), etc. |
| PromotedNilT | '[] |
| PromotedConsT | (':) |
| StarT | * |
| ConstraintT | Constraint |
| LitT TyLit | 0,1,2, etc. |
| WildCardT | _ |
| ImplicitParamT String Type | ?x :: t |
Instances
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
A pattern synonym's directionality.
Constructors
| Unidir | pattern P x {<-} p |
| ImplBidir | pattern P x {=} p |
| ExplBidir [Clause] | pattern P x {<-} p where P x = e |
Instances
| Eq PatSynDir Source # | |
| Data PatSynDir Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PatSynDir -> c PatSynDir # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PatSynDir # toConstr :: PatSynDir -> Constr # dataTypeOf :: PatSynDir -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PatSynDir) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatSynDir) # gmapT :: (forall b. Data b => b -> b) -> PatSynDir -> PatSynDir # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PatSynDir -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PatSynDir -> r # gmapQ :: (forall d. Data d => d -> u) -> PatSynDir -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PatSynDir -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir # | |
| Ord PatSynDir Source # | |
| Show PatSynDir Source # | |
| Generic PatSynDir Source # | |
| Binary PatSynDir Source # | |
| Ppr PatSynDir Source # | |
| type Rep PatSynDir Source # | |
Defined in Language.Haskell.TH.Syntax type Rep PatSynDir = D1 (MetaData "PatSynDir" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.10.2.20200808-1yGh9NazOlH8xYNIwuirq3" False) (C1 (MetaCons "Unidir" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "ImplBidir" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "ExplBidir" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Clause])))) | |
type VarStrictType = VarBangType Source #
As of template-haskell-2.11.0.0, VarStrictType has been replaced by
VarBangType.
type StrictType = BangType Source #
As of template-haskell-2.11.0.0, StrictType has been replaced by
BangType.
Constructors
| Bang SourceUnpackedness SourceStrictness | C { {-# UNPACK #-} !}a |
Instances
| Eq Bang Source # | |
| Data Bang Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bang -> c Bang # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bang # dataTypeOf :: Bang -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Bang) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bang) # gmapT :: (forall b. Data b => b -> b) -> Bang -> Bang # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r # gmapQ :: (forall d. Data d => d -> u) -> Bang -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Bang -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bang -> m Bang # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bang -> m Bang # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bang -> m Bang # | |
| Ord Bang Source # | |
| Show Bang Source # | |
| Generic Bang Source # | |
| Binary Bang Source # | |
| Ppr Bang Source # | |
| type Rep Bang Source # | |
Defined in Language.Haskell.TH.Syntax type Rep Bang = D1 (MetaData "Bang" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.10.2.20200808-1yGh9NazOlH8xYNIwuirq3" False) (C1 (MetaCons "Bang" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SourceUnpackedness) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SourceStrictness))) | |
A single data constructor.
The constructors for Con can roughly be divided up into two categories:
those for constructors with "vanilla" syntax (NormalC, RecC, and
InfixC), and those for constructors with GADT syntax (GadtC and
RecGadtC). The ForallC constructor, which quantifies additional type
variables and class contexts, can surround either variety of constructor.
However, the type variables that it quantifies are different depending
on what constructor syntax is used:
- If a
ForallCsurrounds a constructor with vanilla syntax, then theForallCwill only quantify existential type variables. For example:
data Foo a = forall b. MkFoo a b
In MkFoo, ForallC will quantify b, but not a.
- If a
ForallCsurrounds a constructor with GADT syntax, then theForallCwill quantify all type variables used in the constructor. For example:
data Bar a b where
MkBar :: (a ~ b) => c -> MkBar a b
In MkBar, ForallC will quantify a, b, and c.
Constructors
| NormalC Name [BangType] | C Int a |
| RecC Name [VarBangType] | C { v :: Int, w :: a } |
| InfixC BangType Name BangType | Int :+ a |
| ForallC [TyVarBndr] Cxt Con | forall a. Eq a => C [a] |
| GadtC [Name] [BangType] Type | C :: a -> b -> T b Int |
| RecGadtC [Name] [VarBangType] Type | C :: { v :: Int } -> T b Int |
Instances
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
data SourceStrictness Source #
Constructors
| NoSourceStrictness | C a |
| SourceLazy | C {~}a |
| SourceStrict | C {!}a |
Instances
data SourceUnpackedness Source #
Constructors
| NoSourceUnpackedness | C a |
| SourceNoUnpack | C { {-# NOUNPACK #-} } a |
| SourceUnpack | C { {-# UNPACK #-} } a |
Instances
Since the advent of ConstraintKinds, constraints are really just types.
Equality constraints use the EqualityT constructor. Constraints may also
be tuples of other constraints.
Constructors
| ModuleAnnotation | |
| TypeAnnotation Name | |
| ValueAnnotation Name |
Instances
| Eq AnnTarget Source # | |
| Data AnnTarget Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnTarget -> c AnnTarget # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnTarget # toConstr :: AnnTarget -> Constr # dataTypeOf :: AnnTarget -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnTarget) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnTarget) # gmapT :: (forall b. Data b => b -> b) -> AnnTarget -> AnnTarget # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnTarget -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnTarget -> r # gmapQ :: (forall d. Data d => d -> u) -> AnnTarget -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnTarget -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget # | |
| Ord AnnTarget Source # | |
| Show AnnTarget Source # | |
| Generic AnnTarget Source # | |
| Binary AnnTarget Source # | |
| type Rep AnnTarget Source # | |
Defined in Language.Haskell.TH.Syntax type Rep AnnTarget = D1 (MetaData "AnnTarget" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.10.2.20200808-1yGh9NazOlH8xYNIwuirq3" False) (C1 (MetaCons "ModuleAnnotation" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "TypeAnnotation" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) :+: C1 (MetaCons "ValueAnnotation" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)))) | |
Constructors
| RuleVar Name | |
| TypedRuleVar Name Type |
Instances
| Eq RuleBndr Source # | |
| Data RuleBndr Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleBndr -> c RuleBndr # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RuleBndr # toConstr :: RuleBndr -> Constr # dataTypeOf :: RuleBndr -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RuleBndr) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleBndr) # gmapT :: (forall b. Data b => b -> b) -> RuleBndr -> RuleBndr # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr -> r # gmapQ :: (forall d. Data d => d -> u) -> RuleBndr -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleBndr -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr # | |
| Ord RuleBndr Source # | |
Defined in Language.Haskell.TH.Syntax | |
| Show RuleBndr Source # | |
| Generic RuleBndr Source # | |
| Binary RuleBndr Source # | |
| Ppr RuleBndr Source # | |
| type Rep RuleBndr Source # | |
Defined in Language.Haskell.TH.Syntax type Rep RuleBndr = D1 (MetaData "RuleBndr" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.10.2.20200808-1yGh9NazOlH8xYNIwuirq3" False) (C1 (MetaCons "RuleVar" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) :+: C1 (MetaCons "TypedRuleVar" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type))) | |
Constructors
| AllPhases | |
| FromPhase Int | |
| BeforePhase Int |
Instances
| Eq Phases Source # | |
| Data Phases Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Phases -> c Phases # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Phases # toConstr :: Phases -> Constr # dataTypeOf :: Phases -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Phases) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Phases) # gmapT :: (forall b. Data b => b -> b) -> Phases -> Phases # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Phases -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Phases -> r # gmapQ :: (forall d. Data d => d -> u) -> Phases -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Phases -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Phases -> m Phases # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Phases -> m Phases # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Phases -> m Phases # | |
| Ord Phases Source # | |
| Show Phases Source # | |
| Generic Phases Source # | |
| Binary Phases Source # | |
| Ppr Phases Source # | |
| type Rep Phases Source # | |
Defined in Language.Haskell.TH.Syntax type Rep Phases = D1 (MetaData "Phases" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.10.2.20200808-1yGh9NazOlH8xYNIwuirq3" False) (C1 (MetaCons "AllPhases" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "FromPhase" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)) :+: C1 (MetaCons "BeforePhase" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)))) | |
Instances
| Eq RuleMatch Source # | |
| Data RuleMatch Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleMatch -> c RuleMatch # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RuleMatch # toConstr :: RuleMatch -> Constr # dataTypeOf :: RuleMatch -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RuleMatch) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleMatch) # gmapT :: (forall b. Data b => b -> b) -> RuleMatch -> RuleMatch # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleMatch -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleMatch -> r # gmapQ :: (forall d. Data d => d -> u) -> RuleMatch -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleMatch -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch # | |
| Ord RuleMatch Source # | |
| Show RuleMatch Source # | |
| Generic RuleMatch Source # | |
| Binary RuleMatch Source # | |
| Ppr RuleMatch Source # | |
| type Rep RuleMatch Source # | |
Instances
| Eq Inline Source # | |
| Data Inline Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Inline -> c Inline # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Inline # toConstr :: Inline -> Constr # dataTypeOf :: Inline -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Inline) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inline) # gmapT :: (forall b. Data b => b -> b) -> Inline -> Inline # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r # gmapQ :: (forall d. Data d => d -> u) -> Inline -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Inline -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Inline -> m Inline # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Inline -> m Inline # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Inline -> m Inline # | |
| Ord Inline Source # | |
| Show Inline Source # | |
| Generic Inline Source # | |
| Binary Inline Source # | |
| Ppr Inline Source # | |
| type Rep Inline Source # | |
Defined in Language.Haskell.TH.Syntax type Rep Inline = D1 (MetaData "Inline" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.10.2.20200808-1yGh9NazOlH8xYNIwuirq3" False) (C1 (MetaCons "NoInline" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "Inline" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "Inlinable" PrefixI False) (U1 :: Type -> Type))) | |
Constructors
| InlineP Name Inline RuleMatch Phases | |
| SpecialiseP Name Type (Maybe Inline) Phases | |
| SpecialiseInstP Type | |
| RuleP String (Maybe [TyVarBndr]) [RuleBndr] Exp Exp Phases | |
| AnnP AnnTarget Exp | |
| LineP Int String | |
| CompleteP [Name] (Maybe Name) | { {-# COMPLETE C_1, ..., C_i [ :: T ] #-} } |
Instances
Constructors
| Unsafe | |
| Safe | |
| Interruptible |
Instances
| Eq Safety Source # | |
| Data Safety Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Safety -> c Safety # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Safety # toConstr :: Safety -> Constr # dataTypeOf :: Safety -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Safety) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Safety) # gmapT :: (forall b. Data b => b -> b) -> Safety -> Safety # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r # gmapQ :: (forall d. Data d => d -> u) -> Safety -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Safety -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Safety -> m Safety # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Safety -> m Safety # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Safety -> m Safety # | |
| Ord Safety Source # | |
| Show Safety Source # | |
| Generic Safety Source # | |
| Binary Safety Source # | |
| type Rep Safety Source # | |
Defined in Language.Haskell.TH.Syntax type Rep Safety = D1 (MetaData "Safety" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.10.2.20200808-1yGh9NazOlH8xYNIwuirq3" False) (C1 (MetaCons "Unsafe" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "Safe" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "Interruptible" PrefixI False) (U1 :: Type -> Type))) | |
Constructors
| CCall | |
| StdCall | |
| CApi | |
| Prim | |
| JavaScript |
Instances
| Eq Callconv Source # | |
| Data Callconv Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Callconv -> c Callconv # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Callconv # toConstr :: Callconv -> Constr # dataTypeOf :: Callconv -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Callconv) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Callconv) # gmapT :: (forall b. Data b => b -> b) -> Callconv -> Callconv # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Callconv -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Callconv -> r # gmapQ :: (forall d. Data d => d -> u) -> Callconv -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Callconv -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Callconv -> m Callconv # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Callconv -> m Callconv # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Callconv -> m Callconv # | |
| Ord Callconv Source # | |
Defined in Language.Haskell.TH.Syntax | |
| Show Callconv Source # | |
| Generic Callconv Source # | |
| Binary Callconv Source # | |
| type Rep Callconv Source # | |
Defined in Language.Haskell.TH.Syntax type Rep Callconv = D1 (MetaData "Callconv" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.10.2.20200808-1yGh9NazOlH8xYNIwuirq3" False) ((C1 (MetaCons "CCall" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "StdCall" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "CApi" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "Prim" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "JavaScript" PrefixI False) (U1 :: Type -> Type)))) | |
Instances
Instances
| Eq FunDep Source # | |
| Data FunDep Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunDep -> c FunDep # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FunDep # toConstr :: FunDep -> Constr # dataTypeOf :: FunDep -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FunDep) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunDep) # gmapT :: (forall b. Data b => b -> b) -> FunDep -> FunDep # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r # gmapQ :: (forall d. Data d => d -> u) -> FunDep -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FunDep -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunDep -> m FunDep # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep -> m FunDep # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep -> m FunDep # | |
| Ord FunDep Source # | |
| Show FunDep Source # | |
| Generic FunDep Source # | |
| Binary FunDep Source # | |
| Ppr FunDep Source # | |
| type Rep FunDep Source # | |
Defined in Language.Haskell.TH.Syntax type Rep FunDep = D1 (MetaData "FunDep" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.10.2.20200808-1yGh9NazOlH8xYNIwuirq3" False) (C1 (MetaCons "FunDep" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Name]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Name]))) | |
One equation of a type family instance or closed type family. The arguments are the left-hand-side type and the right-hand-side result.
For instance, if you had the following type family:
type family Foo (a :: k) :: k where forall k (a :: k). Foo @k a = a
The Foo @k a = a equation would be represented as follows:
TySynEqn(Just[PlainTVk,KindedTVa (VarTk)]) (AppT(AppKindT(ConT''Foo) (VarTk)) (VarTa)) (VarTa)
Instances
| Eq TySynEqn Source # | |
| Data TySynEqn Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TySynEqn -> c TySynEqn # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TySynEqn # toConstr :: TySynEqn -> Constr # dataTypeOf :: TySynEqn -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TySynEqn) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TySynEqn) # gmapT :: (forall b. Data b => b -> b) -> TySynEqn -> TySynEqn # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TySynEqn -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TySynEqn -> r # gmapQ :: (forall d. Data d => d -> u) -> TySynEqn -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TySynEqn -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn # | |
| Ord TySynEqn Source # | |
Defined in Language.Haskell.TH.Syntax | |
| Show TySynEqn Source # | |
| Generic TySynEqn Source # | |
| Binary TySynEqn Source # | |
| type Rep TySynEqn Source # | |
Defined in Language.Haskell.TH.Syntax type Rep TySynEqn = D1 (MetaData "TySynEqn" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.10.2.20200808-1yGh9NazOlH8xYNIwuirq3" False) (C1 (MetaCons "TySynEqn" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe [TyVarBndr])) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)))) | |
data TypeFamilyHead Source #
Common elements of OpenTypeFamilyD and ClosedTypeFamilyD. By
analogy with "head" for type classes and type class instances as
defined in Type classes: an exploration of the design space, the
TypeFamilyHead is defined to be the elements of the declaration
between type family and where.
Constructors
| TypeFamilyHead Name [TyVarBndr] FamilyResultSig (Maybe InjectivityAnn) |
Instances
type PatSynType = Type Source #
A pattern synonym's type. Note that a pattern synonym's fully specified type has a peculiar shape coming with two forall quantifiers and two constraint contexts. For example, consider the pattern synonym
pattern P x1 x2 ... xn = <some-pattern>
P's complete type is of the following form
pattern P :: forall universals. required constraints
=> forall existentials. provided constraints
=> t1 -> t2 -> ... -> tn -> tconsisting of four parts:
- the (possibly empty lists of) universally quantified type variables and required constraints on them.
- the (possibly empty lists of) existentially quantified type variables and the provided constraints on them.
- the types
t1,t2, ..,tnofx1,x2, ..,xn, respectively - the type
tof<some-pattern>, mentioning only universals.
Pattern synonym types interact with TH when (a) reifying a pattern synonym, (b) pretty printing, or (c) specifying a pattern synonym's type signature explicitly:
- Reification always returns a pattern synonym's fully specified type in abstract syntax.
- Pretty printing via
pprPatSynTypeabbreviates a pattern synonym's type unambiguously in concrete syntax: The rule of thumb is to print initial empty universals and the required context as() =>, if existentials and a provided context follow. If only universals and their required context, but no existentials are specified, only the universals and their required context are printed. If both or none are specified, so both (or none) are printed. - When specifying a pattern synonym's type explicitly with
PatSynSigDeither one of the universals, the existentials, or their contexts may be left empty.
See the GHC user's guide for more information on pattern synonyms and their types: https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#pattern-synonyms.
data DerivStrategy Source #
What the user explicitly requests when deriving an instance.
Constructors
| StockStrategy | A "standard" derived instance |
| AnyclassStrategy | -XDeriveAnyClass |
| NewtypeStrategy | -XGeneralizedNewtypeDeriving |
| ViaStrategy Type | -XDerivingVia |
Instances
data DerivClause Source #
A single deriving clause at the end of a datatype.
Constructors
| DerivClause (Maybe DerivStrategy) Cxt | { deriving stock (Eq, Ord) } |
Instances
Varieties of allowed instance overlap.
Constructors
| Overlappable | May be overlapped by more specific instances |
| Overlapping | May overlap a more general instance |
| Overlaps | Both |
| Incoherent | Both |
Instances
| Eq Overlap Source # | |
| Data Overlap Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Overlap -> c Overlap # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Overlap # toConstr :: Overlap -> Constr # dataTypeOf :: Overlap -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Overlap) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Overlap) # gmapT :: (forall b. Data b => b -> b) -> Overlap -> Overlap # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Overlap -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Overlap -> r # gmapQ :: (forall d. Data d => d -> u) -> Overlap -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Overlap -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Overlap -> m Overlap # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Overlap -> m Overlap # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Overlap -> m Overlap # | |
| Ord Overlap Source # | |
Defined in Language.Haskell.TH.Syntax | |
| Show Overlap Source # | |
| Generic Overlap Source # | |
| Binary Overlap Source # | |
| type Rep Overlap Source # | |
Defined in Language.Haskell.TH.Syntax type Rep Overlap = D1 (MetaData "Overlap" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.10.2.20200808-1yGh9NazOlH8xYNIwuirq3" False) ((C1 (MetaCons "Overlappable" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "Overlapping" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "Overlaps" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "Incoherent" PrefixI False) (U1 :: Type -> Type))) | |
Constructors
| FunD Name [Clause] | { f p1 p2 = b where decs } |
| ValD Pat Body [Dec] | { p = b where decs } |
| DataD Cxt Name [TyVarBndr] (Maybe Kind) [Con] [DerivClause] | { data Cxt x => T x = A x | B (T x)
deriving (Z,W)
deriving stock Eq } |
| NewtypeD Cxt Name [TyVarBndr] (Maybe Kind) Con [DerivClause] | { newtype Cxt x => T x = A (B x)
deriving (Z,W Q)
deriving stock Eq } |
| TySynD Name [TyVarBndr] Type | { type T x = (x,x) } |
| ClassD Cxt Name [TyVarBndr] [FunDep] [Dec] | { class Eq a => Ord a where ds } |
| InstanceD (Maybe Overlap) Cxt Type [Dec] | { instance {-# OVERLAPS #-}
Show w => Show [w] where ds } |
| SigD Name Type | { length :: [a] -> Int } |
| KiSigD Name Kind | { type TypeRep :: k -> Type } |
| ForeignD Foreign | { foreign import ... }
{ foreign export ... } |
| InfixD Fixity Name | { infix 3 foo } |
| PragmaD Pragma | { {-# INLINE [1] foo #-} } |
| DataFamilyD Name [TyVarBndr] (Maybe Kind) | { data family T a b c :: * } |
| DataInstD Cxt (Maybe [TyVarBndr]) Type (Maybe Kind) [Con] [DerivClause] | { data instance Cxt x => T [x]
= A x | B (T x)
deriving (Z,W)
deriving stock Eq } |
| NewtypeInstD Cxt (Maybe [TyVarBndr]) Type (Maybe Kind) Con [DerivClause] | { newtype instance Cxt x => T [x]
= A (B x)
deriving (Z,W)
deriving stock Eq } |
| TySynInstD TySynEqn | { type instance ... } |
| OpenTypeFamilyD TypeFamilyHead | { type family T a b c = (r :: *) | r -> a b } |
| ClosedTypeFamilyD TypeFamilyHead [TySynEqn] | { type family F a b = (r :: *) | r -> a where ... } |
| RoleAnnotD Name [Role] | { type role T nominal representational } |
| StandaloneDerivD (Maybe DerivStrategy) Cxt Type | { deriving stock instance Ord a => Ord (Foo a) } |
| DefaultSigD Name Type | { default size :: Data a => a -> Int } |
| PatSynD Name PatSynArgs PatSynDir Pat |
also, besides prefix pattern synonyms, both infix and record
pattern synonyms are supported. See |
| PatSynSigD Name PatSynType | A pattern synonym's type signature. |
| ImplicitParamBindD String Exp | { ?x = expr }Implicit parameter binding declaration. Can only be used in let and where clauses which consist entirely of implicit bindings. |
Instances
Instances
Constructors
| BindS Pat Exp | p <- e |
| LetS [Dec] | { let { x=e1; y=e2 } } |
| NoBindS Exp | e |
| ParS [[Stmt]] |
|
| RecS [Stmt] | rec { s1; s2 } |
Instances
Instances
| Eq Guard Source # | |
| Data Guard Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Guard -> c Guard # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Guard # dataTypeOf :: Guard -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Guard) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Guard) # gmapT :: (forall b. Data b => b -> b) -> Guard -> Guard # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r # gmapQ :: (forall d. Data d => d -> u) -> Guard -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Guard -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Guard -> m Guard # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Guard -> m Guard # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Guard -> m Guard # | |
| Ord Guard Source # | |
| Show Guard Source # | |
| Generic Guard Source # | |
| Binary Guard Source # | |
| type Rep Guard Source # | |
Defined in Language.Haskell.TH.Syntax type Rep Guard = D1 (MetaData "Guard" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.10.2.20200808-1yGh9NazOlH8xYNIwuirq3" False) (C1 (MetaCons "NormalG" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) :+: C1 (MetaCons "PatG" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Stmt]))) | |
Constructors
| GuardedB [(Guard, Exp)] | f p { | e1 = e2
| e3 = e4 }
where ds |
| NormalB Exp | f p { = e } where ds |
Instances
| Eq Body Source # | |
| Data Body Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Body -> c Body # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Body # dataTypeOf :: Body -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Body) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Body) # gmapT :: (forall b. Data b => b -> b) -> Body -> Body # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r # gmapQ :: (forall d. Data d => d -> u) -> Body -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Body -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Body -> m Body # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Body -> m Body # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Body -> m Body # | |
| Ord Body Source # | |
| Show Body Source # | |
| Generic Body Source # | |
| Binary Body Source # | |
| type Rep Body Source # | |
Defined in Language.Haskell.TH.Syntax type Rep Body = D1 (MetaData "Body" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.10.2.20200808-1yGh9NazOlH8xYNIwuirq3" False) (C1 (MetaCons "GuardedB" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [(Guard, Exp)])) :+: C1 (MetaCons "NormalB" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp))) | |
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} |
| ParensE Exp | { (e) } |
| LamE [Pat] Exp | { \ p1 p2 -> e } |
| LamCaseE [Match] | { \case m1; m2 } |
| TupE [Maybe Exp] | { (e1,e2) }The (1,) translates to TupE [Just (LitE (IntegerL 1)),Nothing] |
| UnboxedTupE [Maybe Exp] | { (# e1,e2 #) }The (# 'c', #) translates to UnboxedTupE [Just (LitE (CharL 'c')),Nothing] |
| UnboxedSumE Exp SumAlt SumArity | { (#|e|#) } |
| CondE Exp Exp Exp | { if e1 then e2 else e3 } |
| MultiIfE [(Guard, Exp)] | { if | g1 -> e1 | g2 -> e2 } |
| LetE [Dec] Exp | { let { x=e1; y=e2 } in e3 } |
| CaseE Exp [Match] | { case e of m1; m2 } |
| DoE [Stmt] | { do { p <- e1; e2 } } |
| MDoE [Stmt] | { mdo { x <- e1 y; y <- e2 x; } } |
| CompE [Stmt] | { [ (x,y) | x <- xs, y <- ys ] }The result expression of the comprehension is
the last of the E.g. translation: [ f x | x <- xs ] CompE [BindS (VarP x) (VarE xs), NoBindS (AppE (VarE f) (VarE x))] |
| ArithSeqE Range | { [ 1 ,2 .. 10 ] } |
| ListE [Exp] | { [1,2,3] } |
| SigE Exp Type | { e :: t } |
| RecConE Name [FieldExp] | { T { x = y, z = w } } |
| RecUpdE Exp [FieldExp] | { (f x) { z = w } } |
| StaticE Exp | { static e } |
| UnboundVarE Name | { _x }This is used for holes or unresolved identifiers in AST quotes. Note that it could either have a variable name or constructor name. |
| LabelE String |
|
| ImplicitParamVarE String |
|
Instances
Instances
| Eq Clause Source # | |
| Data Clause Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Clause -> c Clause # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Clause # toConstr :: Clause -> Constr # dataTypeOf :: Clause -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Clause) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Clause) # gmapT :: (forall b. Data b => b -> b) -> Clause -> Clause # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r # gmapQ :: (forall d. Data d => d -> u) -> Clause -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Clause -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Clause -> m Clause # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Clause -> m Clause # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Clause -> m Clause # | |
| Ord Clause Source # | |
| Show Clause Source # | |
| Generic Clause Source # | |
| Binary Clause Source # | |
| Ppr Clause Source # | |
| type Rep Clause Source # | |
Defined in Language.Haskell.TH.Syntax type Rep Clause = D1 (MetaData "Clause" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.10.2.20200808-1yGh9NazOlH8xYNIwuirq3" False) (C1 (MetaCons "Clause" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Pat]) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Body) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Dec])))) | |
Instances
| Eq Match Source # | |
| Data Match Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Match -> c Match # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Match # dataTypeOf :: Match -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Match) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match) # gmapT :: (forall b. Data b => b -> b) -> Match -> Match # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r # gmapQ :: (forall d. Data d => d -> u) -> Match -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Match -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Match -> m Match # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Match -> m Match # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Match -> m Match # | |
| Ord Match Source # | |
| Show Match Source # | |
| Generic Match Source # | |
| Binary Match Source # | |
| Ppr Match Source # | |
| type Rep Match Source # | |
Defined in Language.Haskell.TH.Syntax type Rep Match = D1 (MetaData "Match" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.10.2.20200808-1yGh9NazOlH8xYNIwuirq3" False) (C1 (MetaCons "Match" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Pat) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Body) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Dec])))) | |
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 |
| ParensP Pat | {(p)} |
| 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
Raw bytes embedded into the binary.
Avoid using Bytes constructor directly as it is likely to change in the
future. Use helpers such as mkBytes in Language.Haskell.TH.Lib instead.
Constructors
| Bytes | |
Fields
| |
Instances
| Eq Bytes Source # | |
| Data Bytes Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bytes -> c Bytes # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bytes # dataTypeOf :: Bytes -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Bytes) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bytes) # gmapT :: (forall b. Data b => b -> b) -> Bytes -> Bytes # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r # gmapQ :: (forall d. Data d => d -> u) -> Bytes -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Bytes -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bytes -> m Bytes # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bytes -> m Bytes # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bytes -> m Bytes # | |
| Ord Bytes Source # | |
| Show Bytes Source # | |
| Generic Bytes Source # | |
| Binary Bytes Source # | |
| type Rep Bytes Source # | |
Defined in Language.Haskell.TH.Syntax type Rep Bytes = D1 (MetaData "Bytes" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.10.2.20200808-1yGh9NazOlH8xYNIwuirq3" False) (C1 (MetaCons "Bytes" PrefixI True) (S1 (MetaSel (Just "bytesPtr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ForeignPtr Word8)) :*: (S1 (MetaSel (Just "bytesOffset") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word) :*: S1 (MetaSel (Just "bytesSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word)))) | |
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 |
| BytesPrimL Bytes | Some raw bytes, type |
| CharPrimL Char |
Instances
data FixityDirection Source #
Instances
Constructors
| Fixity Int FixityDirection |
Instances
| Eq Fixity Source # | |
| Data Fixity Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Fixity -> c Fixity # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Fixity # toConstr :: Fixity -> Constr # dataTypeOf :: Fixity -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Fixity) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity) # gmapT :: (forall b. Data b => b -> b) -> Fixity -> Fixity # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r # gmapQ :: (forall d. Data d => d -> u) -> Fixity -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Fixity -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity # | |
| Ord Fixity Source # | |
| Show Fixity Source # | |
| Generic Fixity Source # | |
| Binary Fixity Source # | |
| type Rep Fixity Source # | |
Defined in Language.Haskell.TH.Syntax type Rep Fixity = D1 (MetaData "Fixity" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.10.2.20200808-1yGh9NazOlH8xYNIwuirq3" False) (C1 (MetaCons "Fixity" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 FixityDirection))) | |
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]DataInstDorNewtypeInstD(with empty derived[)Name]TySynInstD
In PrimTyConI, is the type constructor unlifted?
In PrimTyConI, arity of the type constructor
In UnboxedSumE, UnboxedSumT, and UnboxedSumP, the total number of
SumAlts. For example, (#|#) has a SumArity of 2.
In UnboxedSumE and UnboxedSumP, the number associated with a
particular data constructor. SumAlts are one-indexed and should never
exceed the value of its corresponding SumArity. For example:
data ModuleInfo Source #
Obtained from reifyModule in the Q Monad.
Constructors
| ModuleInfo [Module] | Contains the import list of the module. |
Instances
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 |
| 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 |
| 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 The |
| TyVarI Name Type | A type variable. The |
Instances
Constructors
| Loc | |
Fields
| |
Instances
| Eq Loc Source # | |
| Data Loc Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Loc -> c Loc # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Loc # dataTypeOf :: Loc -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Loc) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Loc) # gmapT :: (forall b. Data b => b -> b) -> Loc -> Loc # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r # gmapQ :: (forall d. Data d => d -> u) -> Loc -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Loc -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Loc -> m Loc # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Loc -> m Loc # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Loc -> m Loc # | |
| Ord Loc Source # | |
| Show Loc Source # | |
| Generic Loc Source # | |
| Binary Loc Source # | |
| Ppr Loc Source # | |
| type Rep Loc Source # | |
Defined in Language.Haskell.TH.Syntax type Rep Loc = D1 (MetaData "Loc" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.10.2.20200808-1yGh9NazOlH8xYNIwuirq3" False) (C1 (MetaCons "Loc" PrefixI True) ((S1 (MetaSel (Just "loc_filename") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :*: S1 (MetaSel (Just "loc_package") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)) :*: (S1 (MetaSel (Just "loc_module") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :*: (S1 (MetaSel (Just "loc_start") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 CharPos) :*: S1 (MetaSel (Just "loc_end") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 CharPos))))) | |
Constructors
| VarName | Variables |
| DataName | Data constructors |
| TcClsName | Type constructors and classes; Haskell has them in the same name space for now. |
Instances
| Eq NameSpace Source # | |
| Data NameSpace Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NameSpace -> c NameSpace # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NameSpace # toConstr :: NameSpace -> Constr # dataTypeOf :: NameSpace -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NameSpace) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameSpace) # gmapT :: (forall b. Data b => b -> b) -> NameSpace -> NameSpace # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NameSpace -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NameSpace -> r # gmapQ :: (forall d. Data d => d -> u) -> NameSpace -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NameSpace -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace # | |
| Ord NameSpace Source # | |
| Show NameSpace Source # | |
| Generic NameSpace Source # | |
| Binary NameSpace Source # | |
| type Rep NameSpace Source # | |
Defined in Language.Haskell.TH.Syntax type Rep NameSpace = D1 (MetaData "NameSpace" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.10.2.20200808-1yGh9NazOlH8xYNIwuirq3" False) (C1 (MetaCons "VarName" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "DataName" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "TcClsName" PrefixI False) (U1 :: Type -> Type))) | |
data NameFlavour Source #
Constructors
| NameS | An unqualified name; dynamically bound |
| NameQ ModName | A qualified name; dynamically bound |
| NameU !Uniq | A unique local name |
| NameL !Uniq | Local name bound outside of the TH AST |
| NameG NameSpace PkgName ModName | Global name bound outside of the TH AST: An original name (occurrences only, not binders) Need the namespace too to be sure which thing we are naming |
Instances
An abstract type representing names in the syntax tree.
Names can be constructed in several ways, which come with different
name-capture guarantees (see Language.Haskell.TH.Syntax for
an explanation of name capture):
- the built-in syntax
'fand''Tcan be used to construct names, The expression'fgives aNamewhich refers to the valuefcurrently in scope, and''Tgives aNamewhich refers to the typeTcurrently in scope. These names can never be captured. lookupValueNameandlookupTypeNameare similar to'fand''Trespectively, but theNames are looked up at the point where the current splice is being run. These names can never be captured.newNamemonadically generates a new name, which can never be captured.mkNamegenerates a capturable name.
Names constructed using newName and mkName may be used in bindings
(such as let x = ... or x -> ...), but names constructed using
lookupValueName, lookupTypeName, 'f, ''T may not.
Constructors
| Name OccName NameFlavour |
Instances
| Eq Name Source # | |
| Data Name Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Name -> c Name # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Name # dataTypeOf :: Name -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Name) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name) # gmapT :: (forall b. Data b => b -> b) -> Name -> Name # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r # gmapQ :: (forall d. Data d => d -> u) -> Name -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Name -> m Name # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name # | |
| Ord Name Source # | |
| Show Name Source # | |
| Generic Name Source # | |
| Binary Name Source # | |
| Ppr Name Source # | |
| type Rep Name Source # | |
Defined in Language.Haskell.TH.Syntax type Rep Name = D1 (MetaData "Name" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.10.2.20200808-1yGh9NazOlH8xYNIwuirq3" False) (C1 (MetaCons "Name" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 OccName) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 NameFlavour))) | |
Instances
| Eq OccName Source # | |
| Data OccName Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OccName -> c OccName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OccName # toConstr :: OccName -> Constr # dataTypeOf :: OccName -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OccName) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OccName) # gmapT :: (forall b. Data b => b -> b) -> OccName -> OccName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OccName -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OccName -> r # gmapQ :: (forall d. Data d => d -> u) -> OccName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> OccName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OccName -> m OccName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OccName -> m OccName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OccName -> m OccName # | |
| Ord OccName Source # | |
Defined in Language.Haskell.TH.Syntax | |
| Show OccName Source # | |
| Generic OccName Source # | |
| Binary OccName Source # | |
| type Rep OccName Source # | |
Defined in Language.Haskell.TH.Syntax | |
Obtained from reifyModule and thisModule.
Instances
| Eq Module Source # | |
| Data Module Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Module -> c Module # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Module # toConstr :: Module -> Constr # dataTypeOf :: Module -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Module) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module) # gmapT :: (forall b. Data b => b -> b) -> Module -> Module # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r # gmapQ :: (forall d. Data d => d -> u) -> Module -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Module -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Module -> m Module # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module # | |
| Ord Module Source # | |
| Show Module Source # | |
| Generic Module Source # | |
| Binary Module Source # | |
| Ppr Module Source # | |
| type Rep Module Source # | |
Defined in Language.Haskell.TH.Syntax type Rep Module = D1 (MetaData "Module" "Language.Haskell.TH.Syntax" "ghc-lib-parser-8.10.2.20200808-1yGh9NazOlH8xYNIwuirq3" False) (C1 (MetaCons "Module" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PkgName) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ModName))) | |
Instances
| Eq PkgName Source # | |
| Data PkgName Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PkgName -> c PkgName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PkgName # toConstr :: PkgName -> Constr # dataTypeOf :: PkgName -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PkgName) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PkgName) # gmapT :: (forall b. Data b => b -> b) -> PkgName -> PkgName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PkgName -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PkgName -> r # gmapQ :: (forall d. Data d => d -> u) -> PkgName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PkgName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PkgName -> m PkgName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PkgName -> m PkgName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PkgName -> m PkgName # | |
| Ord PkgName Source # | |
Defined in Language.Haskell.TH.Syntax | |
| Show PkgName Source # | |
| Generic PkgName Source # | |
| Binary PkgName Source # | |
| type Rep PkgName Source # | |
Defined in Language.Haskell.TH.Syntax | |
Instances
| Eq ModName Source # | |
| Data ModName Source # | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModName -> c ModName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ModName # toConstr :: ModName -> Constr # dataTypeOf :: ModName -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ModName) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModName) # gmapT :: (forall b. Data b => b -> b) -> ModName -> ModName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModName -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModName -> r # gmapQ :: (forall d. Data d => d -> u) -> ModName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ModName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModName -> m ModName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModName -> m ModName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModName -> m ModName # | |
| Ord ModName Source # | |
Defined in Language.Haskell.TH.Syntax | |
| Show ModName Source # | |
| Generic ModName Source # | |
| Binary ModName Source # | |
| type Rep ModName Source # | |
Defined in Language.Haskell.TH.Syntax | |
class Lift (t :: TYPE r) where Source #
A Lift instance can have any of its values turned into a Template
Haskell expression. This is needed when a value used within a Template
Haskell quotation is bound outside the Oxford brackets ([| ... |] or
[|| ... ||]) but not at the top level. As an example:
add1 :: Int -> Q (TExp Int) add1 x = [|| x + 1 ||]
Template Haskell has no way of knowing what value x will take on at
splice-time, so it requires the type of x to be an instance of Lift.
A Lift instance must satisfy $(lift x) ≡ x and $$(liftTyped x) ≡ x
for all x, where $(...) and $$(...) are Template Haskell splices.
It is additionally expected that lift x ≡ unTypeQ (liftTyped x)
Lift instances can be derived automatically by use of the -XDeriveLift
GHC language extension:
{-# LANGUAGE DeriveLift #-}
module Foo where
import Language.Haskell.TH.Syntax
data Bar a = Bar1 a (Bar a) | Bar2 String
deriving LiftLevity-polymorphic since template-haskell-2.16.0.0.
Minimal complete definition
Methods
Turn a value into a Template Haskell expression, suitable for use in a splice.
lift :: r ~ LiftedRep => t -> Q Exp Source #
Turn a value into a Template Haskell expression, suitable for use in a splice.
liftTyped :: t -> Q (TExp t) Source #
Turn a value into a Template Haskell typed expression, suitable for use in a typed splice.
Since: 2.16.0.0
Instances
| Lift Bool Source # | |
| Lift Char Source # | |
| Lift Double Source # | |
| Lift Float Source # | |
| Lift Int Source # | |
| Lift Int8 Source # | |
| Lift Int16 Source # | |
| Lift Int32 Source # | |
| Lift Int64 Source # | |
| Lift Integer Source # | |
| Lift Natural Source # | |
| Lift Word Source # | |
| Lift Word8 Source # | |
| Lift Word16 Source # | |
| Lift Word32 Source # | |
| Lift Word64 Source # | |
| Lift () Source # | |
| Lift Void Source # | Since: 2.15.0.0 |
| Lift Int# Source # | Since: 2.16.0.0 |
| Lift Char# Source # | Since: 2.16.0.0 |
| Lift Word# Source # | Since: 2.16.0.0 |
| Lift Addr# Source # | Produces an Since: 2.16.0.0 |
| Lift Float# Source # | Since: 2.16.0.0 |
| Lift Double# Source # | Since: 2.16.0.0 |
| Lift a => Lift ([a] :: Type) Source # | |
| Lift a => Lift (Maybe a :: Type) Source # | |
| Integral a => Lift (Ratio a :: Type) Source # | |
| Lift a => Lift (NonEmpty a :: Type) Source # | Since: 2.15.0.0 |
| (Lift a, Lift b) => Lift (Either a b :: Type) Source # | |
| (Lift a, Lift b) => Lift ((a, b) :: Type) Source # | |
| (Lift a, Lift b, Lift c) => Lift ((a, b, c) :: Type) Source # | |
| (Lift a, Lift b, Lift c, Lift d) => Lift ((a, b, c, d) :: Type) Source # | |
| (Lift a, Lift b, Lift c, Lift d, Lift e) => Lift ((a, b, c, d, e) :: Type) Source # | |
| (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f) => Lift ((a, b, c, d, e, f) :: Type) Source # | |
| (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g) => Lift ((a, b, c, d, e, f, g) :: Type) Source # | |
| Lift (##) Source # | Since: 2.16.0.0 |
| Lift a => Lift ((#a#) :: TYPE (TupleRep (LiftedRep ': ([] :: [RuntimeRep])))) Source # | Since: 2.16.0.0 |
| (Lift a, Lift b) => Lift ((#a, b#) :: TYPE (TupleRep (LiftedRep ': (LiftedRep ': ([] :: [RuntimeRep]))))) Source # | Since: 2.16.0.0 |
| (Lift a, Lift b) => Lift ((#|#) a b :: TYPE (SumRep (LiftedRep ': (LiftedRep ': ([] :: [RuntimeRep]))))) Source # | Since: 2.16.0.0 |
| (Lift a, Lift b, Lift c) => Lift ((#a, b, c#) :: TYPE (TupleRep (LiftedRep ': (LiftedRep ': (LiftedRep ': ([] :: [RuntimeRep])))))) Source # | Since: 2.16.0.0 |
| (Lift a, Lift b, Lift c) => Lift ((#||#) a b c :: TYPE (SumRep (LiftedRep ': (LiftedRep ': (LiftedRep ': ([] :: [RuntimeRep])))))) Source # | Since: 2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d) => Lift ((#a, b, c, d#) :: TYPE (TupleRep (LiftedRep ': (LiftedRep ': (LiftedRep ': (LiftedRep ': ([] :: [RuntimeRep]))))))) Source # | Since: 2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d) => Lift ((#|||#) a b c d :: TYPE (SumRep (LiftedRep ': (LiftedRep ': (LiftedRep ': (LiftedRep ': ([] :: [RuntimeRep]))))))) Source # | Since: 2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d, Lift e) => Lift ((#a, b, c, d, e#) :: TYPE (TupleRep (LiftedRep ': (LiftedRep ': (LiftedRep ': (LiftedRep ': (LiftedRep ': ([] :: [RuntimeRep])))))))) Source # | Since: 2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d, Lift e) => Lift ((#||||#) a b c d e :: TYPE (SumRep (LiftedRep ': (LiftedRep ': (LiftedRep ': (LiftedRep ': (LiftedRep ': ([] :: [RuntimeRep])))))))) Source # | Since: 2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f) => Lift ((#a, b, c, d, e, f#) :: TYPE (TupleRep (LiftedRep ': (LiftedRep ': (LiftedRep ': (LiftedRep ': (LiftedRep ': (LiftedRep ': ([] :: [RuntimeRep]))))))))) Source # | Since: 2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f) => Lift ((#|||||#) a b c d e f :: TYPE (SumRep (LiftedRep ': (LiftedRep ': (LiftedRep ': (LiftedRep ': (LiftedRep ': (LiftedRep ': ([] :: [RuntimeRep]))))))))) Source # | Since: 2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g) => Lift ((#a, b, c, d, e, f, g#) :: TYPE (TupleRep (LiftedRep ': (LiftedRep ': (LiftedRep ': (LiftedRep ': (LiftedRep ': (LiftedRep ': (LiftedRep ': ([] :: [RuntimeRep])))))))))) Source # | Since: 2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g) => Lift ((#||||||#) a b c d e f g :: TYPE (SumRep (LiftedRep ': (LiftedRep ': (LiftedRep ': (LiftedRep ': (LiftedRep ': (LiftedRep ': (LiftedRep ': ([] :: [RuntimeRep])))))))))) Source # | Since: 2.16.0.0 |
newtype TExp (a :: TYPE (r :: RuntimeRep)) Source #
Represents an expression which has type a. Built on top of Exp, typed
expressions allow for type-safe splicing via:
- typed quotes, written as
[|| ... ||]where...is an expression; if that expression has typea, then the quotation has typeQ(TExpa) - typed splices inside of typed quotes, written as
$$(...)where...is an arbitrary expression of typeQ(TExpa)
Traditional expression quotes and splices let us construct ill-typed expressions:
>>>fmap ppr $ runQ [| True == $( [| "foo" |] ) |]GHC.Types.True GHC.Classes.== "foo">>>GHC.Types.True GHC.Classes.== "foo"<interactive> error: • Couldn't match expected type ‘Bool’ with actual type ‘[Char]’ • In the second argument of ‘(==)’, namely ‘"foo"’ In the expression: True == "foo" In an equation for ‘it’: it = True == "foo"
With typed expressions, the type error occurs when constructing the Template Haskell expression:
>>>fmap ppr $ runQ [|| True == $$( [|| "foo" ||] ) ||]<interactive> error: • Couldn't match type ‘[Char]’ with ‘Bool’ Expected type: Q (TExp Bool) Actual type: Q (TExp [Char]) • In the Template Haskell quotation [|| "foo" ||] In the expression: [|| "foo" ||] In the Template Haskell splice $$([|| "foo" ||])
Instances
class (MonadIO m, MonadFail m) => Quasi m where Source #
Minimal complete definition
qNewName, qReport, qRecover, qLookupName, qReify, qReifyFixity, qReifyType, qReifyInstances, qReifyRoles, qReifyAnnotations, qReifyModule, qReifyConStrictness, qLocation, qAddDependentFile, qAddTempFile, qAddTopDecls, qAddForeignFilePath, qAddModFinalizer, qAddCorePlugin, qGetQ, qPutQ, qIsExtEnabled, qExtsEnabled
Methods
Arguments
| :: Bool | |
| -> String | |
| -> m () | Report an error (True) or warning (False)
...but carry on; use |
Arguments
| :: m a | the error handler |
| -> m a | action which may fail |
| -> m a | Recover from the monadic |
qLookupName :: Bool -> String -> m (Maybe Name) Source #
qReify :: Name -> m Info Source #
qReifyFixity :: Name -> m (Maybe Fixity) Source #
qReifyType :: Name -> m Type Source #
qReifyInstances :: Name -> [Type] -> m [Dec] Source #
qReifyRoles :: Name -> m [Role] Source #
qReifyAnnotations :: Data a => AnnLookup -> m [a] Source #
qReifyModule :: Module -> m ModuleInfo Source #
qReifyConStrictness :: Name -> m [DecidedStrictness] Source #
qRunIO :: IO a -> m a Source #
qAddDependentFile :: FilePath -> m () Source #
qAddTempFile :: String -> m FilePath Source #
qAddTopDecls :: [Dec] -> m () Source #
qAddForeignFilePath :: ForeignSrcLang -> String -> m () Source #
qAddModFinalizer :: Q () -> m () Source #
qAddCorePlugin :: String -> m () Source #
qGetQ :: Typeable a => m (Maybe a) Source #
qPutQ :: Typeable a => a -> m () Source #
qIsExtEnabled :: Extension -> m Bool Source #
qExtsEnabled :: m [Extension] Source #
Instances
unTypeQ :: forall (r :: RuntimeRep) (a :: TYPE r). Q (TExp a) -> Q Exp Source #
Discard the type annotation and produce a plain Template Haskell expression
Levity-polymorphic since template-haskell-2.16.0.0.
unsafeTExpCoerce :: forall (r :: RuntimeRep) (a :: TYPE r). Q Exp -> Q (TExp a) Source #
Annotate the Template Haskell expression with a type
This is unsafe because GHC cannot check for you that the expression really does have the type you claim it has.
Levity-polymorphic since template-haskell-2.16.0.0.
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[VarPnm1] (LamE [VarP nm2] (VarEnm1))) )
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.
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.
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.
Recover from errors raised by reportError or fail.
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.
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.
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)bar does not have a fixity declaration, then reifyFixity 'bar returns
Nothing, so you may assume bar has defaultFixity.
reifyType :: Name -> Q Type Source #
reifyType nm attempts to find the type or kind of nm. For example,
reifyType 'not returns Bool -> Bool, and
reifyType ''Bool returns Type.
This works even if there's no explicit signature and the type or kind is inferred.
reifyInstances :: Name -> [Type] -> Q [InstanceDec] Source #
reifyInstances nm tys returns a list of visible instances of nm tys. That is,
if nm is the name of a type class, then all instances of this class at the types tys
are returned. Alternatively, if nm is the name of a data family or type family,
all instances of this family at the types tys are returned.
Note that this is a "shallow" test; the declarations returned merely have
instance heads which unify with nm tys, they need not actually be satisfiable.
reifyInstances ''Eq [contains theTupleT2 `AppT`ConT''A `AppT`ConT''B ]instance (Eq a, Eq b) => Eq (a, b)regardless of whetherAandBthemselves implementEqreifyInstances ''Show [produces every available instance ofVarT(mkName"a") ]Eq
There is one edge case: reifyInstances ''Typeable tys currently always
produces an empty list (no matter what tys are given).
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.
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.
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.
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 [ under most
circumstances, but it would return DecidedLazy, DecidedLazy][ if the
DecidedStrict, DecidedStrict]-XStrictData language extension was enabled.
isInstance :: Name -> [Type] -> Q Bool Source #
Is the list of instances returned by reifyInstances nonempty?
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.
addDependentFile :: FilePath -> Q () Source #
Record external files that runIO is using (dependent upon). The compiler can then recognize that it should re-compile the Haskell file when an external file changes.
Expects an absolute file path.
Notes:
- ghc -M does not know about these dependencies - it does not execute TH.
- The dependency is based on file content, not a modification time
addTempFile :: String -> Q FilePath Source #
Obtain a temporary file path with the given suffix. The compiler will delete this file after compilation.
addTopDecls :: [Dec] -> Q () Source #
Add additional top-level declarations. The added declarations will be type checked along with the current declaration group.
addForeignFile :: ForeignSrcLang -> String -> Q () Source #
Deprecated: Use addForeignSource instead
addForeignSource :: ForeignSrcLang -> String -> Q () Source #
Emit a foreign file which will be compiled and linked to the object for the current module. Currently only languages that can be compiled with the C compiler are supported, and the flags passed as part of -optc will be also applied to the C compiler invocation that will compile them.
Note that for non-C languages (for example C++) extern C directives
must be used to get symbols that we can access from Haskell.
To get better errors, it is recommended to use #line pragmas when emitting C files, e.g.
{-# LANGUAGE CPP #-}
...
addForeignSource LangC $ unlines
[ "#line " ++ show (562 + 1) ++ " " ++ show "libraries/template-haskell/Language/Haskell/TH/Syntax.hs"
, ...
]addForeignFilePath :: ForeignSrcLang -> FilePath -> Q () Source #
Same as addForeignSource, but expects to receive a path pointing to the
foreign file instead of a String of its contents. Consider using this in
conjunction with addTempFile.
This is a good alternative to addForeignSource when you are trying to
directly link in an object file.
addModFinalizer :: Q () -> Q () Source #
Add a finalizer that will run in the Q monad after the current module has been type checked. This only makes sense when run within a top-level splice.
The finalizer is given the local type environment at the splice point. Thus
reify is able to find the local definitions when executed inside the
finalizer.
addCorePlugin :: String -> Q () Source #
Adds a core plugin to the compilation pipeline.
addCorePlugin m has almost the same effect as passing -fplugin=m to ghc
in the command line. The major difference is that the plugin module m
must not belong to the current package. When TH executes, it is too late
to tell the compiler that we needed to compile first a plugin module in the
current package.
getQ :: Typeable a => Q (Maybe a) Source #
Get state from the Q monad. Note that the state is local to the
Haskell module in which the Template Haskell expression is executed.
putQ :: Typeable a => a -> Q () Source #
Replace the state in the Q monad. Note that the state is local to the
Haskell module in which the Template Haskell expression is executed.
isExtEnabled :: Extension -> Q Bool Source #
Determine whether the given language extension is enabled in the Q monad.
extsEnabled :: Q [Extension] Source #
List all enabled language extensions.
nothingName :: Name Source #
nonemptyName :: Name Source #
dataToQa :: forall a k q. Data a => (Name -> k) -> (Lit -> Q q) -> (k -> [Q q] -> Q q) -> (forall b. Data b => b -> Maybe (Q q)) -> a -> Q q Source #
dataToQa is an internal utility function for constructing generic
conversion functions from types with Data instances to various
quasi-quoting representations. See the source of dataToExpQ and
dataToPatQ for two example usages: mkCon, mkLit
and appQ are overloadable to account for different syntax for
expressions and patterns; antiQ allows you to override type-specific
cases, a common usage is just const Nothing, which results in
no overloading.
dataToExpQ :: Data a => (forall b. Data b => b -> Maybe (Q Exp)) -> a -> Q Exp Source #
dataToExpQ converts a value to a 'Q Exp' representation of the
same value, in the SYB style. It is generalized to take a function
override type-specific cases; see liftData for a more commonly
used variant.
dataToPatQ :: Data a => (forall b. Data b => b -> Maybe (Q Pat)) -> a -> Q Pat Source #
dataToPatQ converts a value to a 'Q Pat' representation of the same
value, in the SYB style. It takes a function to handle type-specific cases,
alternatively, pass const Nothing to get default behavior.
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.EitherJust "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.EitherJust "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.idJust VarName>>>nameSpace (mkName "id")Nothing -- only works for top-level variable names>>>nameSpace 'Data.Maybe.JustJust DataName>>>nameSpace ''Data.Maybe.MaybeJust TcClsName>>>nameSpace ''Data.Ord.OrdJust TcClsName
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") |]
mkNameG :: NameSpace -> String -> String -> String -> Name Source #
Used for 'x etc, but not available to the programmer
tupleDataName :: Int -> Name Source #
Tuple data constructor
tupleTypeName :: Int -> Name Source #
Tuple type constructor
unboxedTupleDataName :: Int -> Name Source #
Unboxed tuple data constructor
unboxedTupleTypeName :: Int -> Name Source #
Unboxed tuple type constructor
unboxedSumTypeName :: SumArity -> Name Source #
Unboxed sum type constructor
maxPrecedence :: Int Source #
Highest allowed operator precedence for Fixity constructor (answer: 9)
defaultFixity :: Fixity Source #
Default fixity: infixl 9
Language extensions
data ForeignSrcLang Source #
Foreign formats supported by GHC via TH
Constructors
| LangC | C |
| LangCxx | C++ |
| LangObjc | Objective C |
| LangObjcxx | Objective C++ |
| LangAsm | Assembly language (.s) |
| RawObject | Object (.o) |