| 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
Description
Abstract syntax definitions for Template Haskell.
Synopsis
- data Foreign
- data Type
- = ForallT [TyVarBndr Specificity] 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
- | PromotedInfixT Type Name Type
- | PromotedUInfixT Type Name Type
- | ParensT Type
- | TupleT Int
- | UnboxedTupleT Int
- | UnboxedSumT SumArity
- | ArrowT
- | MulArrowT
- | EqualityT
- | ListT
- | PromotedTupleT Int
- | PromotedNilT
- | PromotedConsT
- | StarT
- | ConstraintT
- | LitT TyLit
- | WildCardT
- | ImplicitParamT String Type
- data Module = Module PkgName ModName
- data SourceUnpackedness
- data SourceStrictness
- data DecidedStrictness
- type Unlifted = Bool
- class Lift (t :: TYPE r) where
- data Fixity = Fixity Int FixityDirection
- data NameIs
- data Con
- recover :: Q a -> Q a -> Q a
- reportError :: String -> Q ()
- runIO :: IO a -> Q a
- type Strict = Bang
- data Safety
- = Unsafe
- | Safe
- | Interruptible
- newtype Q a = Q {}
- runQ :: Quasi m => Q a -> m a
- class Monad m => Quote (m :: Type -> Type) where
- reportWarning :: String -> Q ()
- report :: Bool -> String -> Q ()
- location :: Q Loc
- data Loc = Loc {}
- reify :: Name -> Q Info
- reifyModule :: Module -> Q ModuleInfo
- newDeclarationGroup :: Q [Dec]
- data Info
- data ModuleInfo = ModuleInfo [Module]
- type InstanceDec = Dec
- type ParentName = Name
- type SumAlt = Int
- type SumArity = Int
- type Arity = Int
- extsEnabled :: Q [Extension]
- isExtEnabled :: Extension -> Q Bool
- lookupTypeName :: String -> Q (Maybe Name)
- lookupValueName :: String -> Q (Maybe Name)
- reifyFixity :: Name -> Q (Maybe Fixity)
- reifyType :: Name -> Q Type
- reifyInstances :: Name -> [Type] -> Q [InstanceDec]
- isInstance :: Name -> [Type] -> Q Bool
- reifyRoles :: Name -> Q [Role]
- reifyAnnotations :: Data a => AnnLookup -> Q [a]
- data AnnLookup
- reifyConStrictness :: Name -> Q [DecidedStrictness]
- newtype TExp (a :: TYPE r) = TExp {}
- newtype Code (m :: Type -> Type) (a :: TYPE r) = Code {
- examineCode :: m (TExp a)
- unTypeCode :: forall a m. Quote m => Code m a -> m Exp
- unsafeCodeCoerce :: forall a m. Quote m => m Exp -> Code m a
- hoistCode :: Monad m => (forall x. m x -> n x) -> Code m a -> Code n a
- bindCode :: Monad m => m a -> (a -> Code m b) -> Code m b
- bindCode_ :: Monad m => m a -> Code m b -> Code m b
- joinCode :: Monad m => m (Code m a) -> Code m a
- liftCode :: forall a m. m (TExp a) -> Code m a
- data Name = Name OccName NameFlavour
- data NameSpace
- mkName :: String -> Name
- nameBase :: Name -> String
- nameModule :: Name -> Maybe String
- namePackage :: Name -> Maybe String
- nameSpace :: Name -> Maybe NameSpace
- tupleTypeName :: Int -> Name
- tupleDataName :: Int -> Name
- unboxedTupleTypeName :: Int -> Name
- unboxedTupleDataName :: Int -> Name
- unboxedSumTypeName :: SumArity -> Name
- unboxedSumDataName :: SumAlt -> SumArity -> Name
- data Dec
- = FunD Name [Clause]
- | ValD Pat Body [Dec]
- | DataD Cxt Name [TyVarBndr BndrVis] (Maybe Kind) [Con] [DerivClause]
- | NewtypeD Cxt Name [TyVarBndr BndrVis] (Maybe Kind) Con [DerivClause]
- | TypeDataD Name [TyVarBndr BndrVis] (Maybe Kind) [Con]
- | TySynD Name [TyVarBndr BndrVis] Type
- | ClassD Cxt Name [TyVarBndr BndrVis] [FunDep] [Dec]
- | InstanceD (Maybe Overlap) Cxt Type [Dec]
- | SigD Name Type
- | KiSigD Name Kind
- | ForeignD Foreign
- | InfixD Fixity NamespaceSpecifier Name
- | DefaultD [Type]
- | PragmaD Pragma
- | DataFamilyD Name [TyVarBndr BndrVis] (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 Clause = Clause [ArgPat] Body [Dec]
- data Bang = Bang SourceUnpackedness SourceStrictness
- data Callconv
- = CCall
- | StdCall
- | CApi
- | Prim
- | JavaScript
- data Pragma
- data Inline
- data RuleMatch
- data Phases
- data RuleBndr
- data AnnTarget
- data FunDep = FunDep [Name] [Name]
- data TySynEqn = TySynEqn (Maybe [TyVarBndr ()]) Type Type
- data TypeFamilyHead = TypeFamilyHead Name [TyVarBndr BndrVis] FamilyResultSig (Maybe InjectivityAnn)
- data FixityDirection
- data NamespaceSpecifier
- defaultFixity :: Fixity
- maxPrecedence :: Int
- data PatSynDir
- data PatSynArgs
- = PrefixPatSyn [Name]
- | InfixPatSyn Name Name
- | RecordPatSyn [Name]
- data Exp
- = VarE Name
- | ConE Name
- | LitE Lit
- | AppE Exp Exp
- | AppTypeE Exp Type
- | InfixE (Maybe Exp) Exp (Maybe Exp)
- | UInfixE Exp Exp Exp
- | ParensE Exp
- | LamE [ArgPat] Exp
- | LamCaseE [Match]
- | LamCasesE [Clause]
- | TupE [Maybe Exp]
- | UnboxedTupE [Maybe Exp]
- | UnboxedSumE Exp SumAlt SumArity
- | CondE Exp Exp Exp
- | MultiIfE [(Guard, Exp)]
- | LetE [Dec] Exp
- | CaseE Exp [Match]
- | DoE (Maybe ModName) [Stmt]
- | MDoE (Maybe ModName) [Stmt]
- | CompE [Stmt]
- | ArithSeqE Range
- | ListE [Exp]
- | SigE Exp Type
- | RecConE Name [FieldExp]
- | RecUpdE Exp [FieldExp]
- | StaticE Exp
- | UnboundVarE Name
- | LabelE String
- | ImplicitParamVarE String
- | GetFieldE Exp String
- | ProjectionE (NonEmpty String)
- | TypedBracketE Exp
- | TypedSpliceE Exp
- | TypeE Type
- data Match = Match Pat Body [Dec]
- data Body
- data Guard
- data Stmt
- data Range
- data Lit
- data Pat
- data ArgPat
- type FieldExp = (Name, Exp)
- type FieldPat = (Name, Pat)
- data TyVarBndr flag
- data TyLit
- type Kind = Type
- type Cxt = [Pred]
- type Pred = Type
- data Role
- data Specificity
- data BndrVis
- data FamilyResultSig
- data InjectivityAnn = InjectivityAnn Name [Name]
- type PatSynType = Type
- type BangType = (Bang, Type)
- type VarBangType = (Name, Bang, Type)
- putDoc :: DocLoc -> String -> Q ()
- getDoc :: DocLoc -> Q (Maybe String)
- data DocLoc
- data DerivClause = DerivClause (Maybe DerivStrategy) Cxt
- data DerivStrategy
- data Overlap
- type Uniq = Integer
- showName' :: NameIs -> Name -> String
- data NameFlavour
- dataToQa :: (Quote m, Data a) => (Name -> k) -> (Lit -> m q) -> (k -> [m q] -> m q) -> (forall b. Data b => b -> Maybe (m q)) -> a -> m q
- dataToExpQ :: (Quote m, Data a) => (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
- dataToPatQ :: (Quote m, Data a) => (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
- data Bytes = Bytes {
- bytesPtr :: ForeignPtr Word8
- bytesOffset :: Word
- bytesSize :: Word
- class (MonadIO m, MonadFail m) => Quasi (m :: Type -> Type) 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
- qGetPackageRoot :: m FilePath
- 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]
- qPutDoc :: DocLoc -> String -> m ()
- qGetDoc :: DocLoc -> m (Maybe String)
- newNameIO :: String -> IO Name
- badIO :: String -> IO a
- counter :: IORef Uniq
- mkNameU :: String -> Uniq -> Name
- unTypeQ :: forall a m. Quote m => m (TExp a) -> m Exp
- unsafeTExpCoerce :: forall a m. Quote m => m Exp -> m (TExp a)
- lookupName :: Bool -> String -> Q (Maybe Name)
- getPackageRoot :: Q FilePath
- makeRelativeToProject :: FilePath -> Q FilePath
- 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 ()
- sequenceQ :: Monad m => forall a. [m a] -> m [a]
- trueName :: Name
- falseName :: Name
- addrToByteArrayName :: Name
- addrToByteArray :: Int -> Addr# -> ByteArray
- nothingName :: Name
- justName :: Name
- leftName :: Name
- rightName :: Name
- liftString :: Quote m => String -> m Exp
- nonemptyName :: Name
- oneName :: Name
- manyName :: Name
- mkOccName :: String -> OccName
- mkPkgName :: String -> PkgName
- mkModName :: String -> ModName
- mkNameG_v :: String -> String -> String -> Name
- mkNameG_d :: String -> String -> String -> Name
- showName :: Name -> String
- liftData :: (Quote m, Data a) => a -> m Exp
- newtype ModName = ModName String
- newtype PkgName = PkgName String
- newtype OccName = OccName String
- modString :: ModName -> String
- pkgString :: PkgName -> String
- occString :: OccName -> String
- thenCmp :: Ordering -> Ordering -> Ordering
- mkNameL :: String -> Uniq -> Name
- mkNameQ :: String -> String -> Name
- mkNameG :: NameSpace -> String -> String -> String -> Name
- mkNameS :: String -> Name
- mkNameG_tc :: String -> String -> String -> Name
- mkNameG_fld :: String -> String -> String -> String -> Name
- mk_tup_name :: Int -> NameSpace -> Bool -> Name
- type CharPos = (Int, Int)
- eqBytes :: Bytes -> Bytes -> Bool
- compareBytes :: Bytes -> Bytes -> Ordering
- memcmp :: Ptr a -> Ptr b -> CSize -> IO CInt
- type StrictType = BangType
- type VarStrictType = VarBangType
- cmpEq :: Ordering -> Bool
- get_cons_names :: Con -> [Name]
- module Language.Haskell.TH.LanguageExtensions
- data ForeignSrcLang
Documentation
Instances
Constructors
| ForallT [TyVarBndr Specificity] Cxt Type | forall <vars>. <ctxt> => <type> |
| ForallVisT [TyVarBndr ()] Type | forall <vars> -> <type> |
| AppT Type Type | T a b |
| AppKindT Type Kind | T @k t |
| SigT Type Kind | t :: k |
| VarT Name | a |
| ConT Name | T |
| PromotedT Name | 'T |
| InfixT Type Name Type | T + T |
| UInfixT Type Name Type | T + T |
| PromotedInfixT Type Name Type | T :+: T |
| PromotedUInfixT Type Name Type | T :+: T |
| ParensT Type | (T) |
| TupleT Int |
|
| UnboxedTupleT Int |
|
| UnboxedSumT SumArity |
|
| ArrowT | -> |
| MulArrowT | %n -> Generalised arrow type with multiplicity argument |
| EqualityT | ~ |
| ListT | [] |
| PromotedTupleT Int |
|
| PromotedNilT | '[] |
| PromotedConsT | '(:) |
| StarT | * |
| ConstraintT | Constraint |
| LitT TyLit |
|
| WildCardT | _ |
| ImplicitParamT String Type | ?x :: t |
Instances
| Data Type 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) -> Type -> c Type # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Type # dataTypeOf :: Type -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Type) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type) # gmapT :: (forall b. Data b => b -> b) -> Type -> Type # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r # gmapQ :: (forall d. Data d => d -> u) -> Type -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Type -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Type -> m Type # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type # | |||||
| Generic Type Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show Type Source # | |||||
| Eq Type Source # | |||||
| Ord Type Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
| Ppr Type Source # | |||||
| type Rep Type Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep Type = D1 ('MetaData "Type" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((((C1 ('MetaCons "ForallT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TyVarBndr Specificity]) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Cxt) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) :+: (C1 ('MetaCons "ForallVisT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TyVarBndr ()]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :+: C1 ('MetaCons "AppT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)))) :+: ((C1 ('MetaCons "AppKindT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Kind)) :+: C1 ('MetaCons "SigT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Kind))) :+: (C1 ('MetaCons "VarT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)) :+: C1 ('MetaCons "ConT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name))))) :+: ((C1 ('MetaCons "PromotedT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)) :+: (C1 ('MetaCons "InfixT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) :+: C1 ('MetaCons "UInfixT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))))) :+: ((C1 ('MetaCons "PromotedInfixT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) :+: C1 ('MetaCons "PromotedUInfixT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)))) :+: (C1 ('MetaCons "ParensT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :+: C1 ('MetaCons "TupleT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int)))))) :+: (((C1 ('MetaCons "UnboxedTupleT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int)) :+: (C1 ('MetaCons "UnboxedSumT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SumArity)) :+: C1 ('MetaCons "ArrowT" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "MulArrowT" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "EqualityT" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "ListT" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PromotedTupleT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int))))) :+: ((C1 ('MetaCons "PromotedNilT" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "PromotedConsT" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "StarT" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "ConstraintT" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "LitT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 TyLit))) :+: (C1 ('MetaCons "WildCardT" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ImplicitParamT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))))))) | |||||
Obtained from reifyModule and thisModule.
Instances
| 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 :: forall r r'. (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 # | |||||
| Generic Module Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show Module Source # | |||||
| Eq Module Source # | |||||
| Ord 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" "template-haskell" '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))) | |||||
data SourceUnpackedness Source #
SourceUnpackedness corresponds to unpack annotations found in the source code.
This may not agree with the annotations returned by reifyConStrictness.
See reifyConStrictness for more information.
Constructors
| NoSourceUnpackedness | C a |
| SourceNoUnpack | C { {-# NOUNPACK #-} } a |
| SourceUnpack | C { {-# UNPACK #-} } a |
Instances
| Data SourceUnpackedness 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) -> SourceUnpackedness -> c SourceUnpackedness # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceUnpackedness # toConstr :: SourceUnpackedness -> Constr # dataTypeOf :: SourceUnpackedness -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SourceUnpackedness) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceUnpackedness) # gmapT :: (forall b. Data b => b -> b) -> SourceUnpackedness -> SourceUnpackedness # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r # gmapQ :: (forall d. Data d => d -> u) -> SourceUnpackedness -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceUnpackedness -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness # | |||||
| Generic SourceUnpackedness Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
Methods from :: SourceUnpackedness -> Rep SourceUnpackedness x # to :: Rep SourceUnpackedness x -> SourceUnpackedness # | |||||
| Show SourceUnpackedness Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> SourceUnpackedness -> ShowS # show :: SourceUnpackedness -> String # showList :: [SourceUnpackedness] -> ShowS # | |||||
| Eq SourceUnpackedness Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods (==) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source # (/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source # | |||||
| Ord SourceUnpackedness Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering Source # (<) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source # (<=) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source # (>) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source # (>=) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source # max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness Source # min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness Source # | |||||
| Ppr SourceUnpackedness Source # | |||||
Defined in Language.Haskell.TH.Ppr | |||||
| type Rep SourceUnpackedness Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep SourceUnpackedness = D1 ('MetaData "SourceUnpackedness" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "NoSourceUnpackedness" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "SourceNoUnpack" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SourceUnpack" 'PrefixI 'False) (U1 :: Type -> Type))) | |||||
data SourceStrictness Source #
SourceStrictness corresponds to strictness annotations found in the source code.
This may not agree with the annotations returned by reifyConStrictness.
See reifyConStrictness for more information.
Constructors
| NoSourceStrictness | C a |
| SourceLazy | C {~}a |
| SourceStrict | C {!}a |
Instances
| Data SourceStrictness 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) -> SourceStrictness -> c SourceStrictness # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceStrictness # toConstr :: SourceStrictness -> Constr # dataTypeOf :: SourceStrictness -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SourceStrictness) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceStrictness) # gmapT :: (forall b. Data b => b -> b) -> SourceStrictness -> SourceStrictness # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r # gmapQ :: (forall d. Data d => d -> u) -> SourceStrictness -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceStrictness -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness # | |||||
| Generic SourceStrictness Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
Methods from :: SourceStrictness -> Rep SourceStrictness x # to :: Rep SourceStrictness x -> SourceStrictness # | |||||
| Show SourceStrictness Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> SourceStrictness -> ShowS # show :: SourceStrictness -> String # showList :: [SourceStrictness] -> ShowS # | |||||
| Eq SourceStrictness Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods (==) :: SourceStrictness -> SourceStrictness -> Bool Source # (/=) :: SourceStrictness -> SourceStrictness -> Bool Source # | |||||
| Ord SourceStrictness Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods compare :: SourceStrictness -> SourceStrictness -> Ordering Source # (<) :: SourceStrictness -> SourceStrictness -> Bool Source # (<=) :: SourceStrictness -> SourceStrictness -> Bool Source # (>) :: SourceStrictness -> SourceStrictness -> Bool Source # (>=) :: SourceStrictness -> SourceStrictness -> Bool Source # max :: SourceStrictness -> SourceStrictness -> SourceStrictness Source # min :: SourceStrictness -> SourceStrictness -> SourceStrictness Source # | |||||
| Ppr SourceStrictness Source # | |||||
Defined in Language.Haskell.TH.Ppr | |||||
| type Rep SourceStrictness Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep SourceStrictness = D1 ('MetaData "SourceStrictness" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "NoSourceStrictness" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "SourceLazy" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SourceStrict" 'PrefixI 'False) (U1 :: Type -> Type))) | |||||
data DecidedStrictness Source #
Unlike SourceStrictness and SourceUnpackedness, DecidedStrictness
refers to the strictness annotations that the compiler chooses for a data constructor
field, which may be different from what is written in source code.
Note that non-unpacked strict fields are assigned DecidedLazy when a bang would be inappropriate,
such as the field of a newtype constructor and fields that have an unlifted type.
See reifyConStrictness for more information.
Constructors
| DecidedLazy | Field inferred to not have a bang. |
| DecidedStrict | Field inferred to have a bang. |
| DecidedUnpack | Field inferred to be unpacked. |
Instances
| Data DecidedStrictness 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) -> DecidedStrictness -> c DecidedStrictness # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DecidedStrictness # toConstr :: DecidedStrictness -> Constr # dataTypeOf :: DecidedStrictness -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DecidedStrictness) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DecidedStrictness) # gmapT :: (forall b. Data b => b -> b) -> DecidedStrictness -> DecidedStrictness # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r # gmapQ :: (forall d. Data d => d -> u) -> DecidedStrictness -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DecidedStrictness -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness # | |||||
| Generic DecidedStrictness Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
Methods from :: DecidedStrictness -> Rep DecidedStrictness x # to :: Rep DecidedStrictness x -> DecidedStrictness # | |||||
| Show DecidedStrictness Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> DecidedStrictness -> ShowS # show :: DecidedStrictness -> String # showList :: [DecidedStrictness] -> ShowS # | |||||
| Eq DecidedStrictness Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods (==) :: DecidedStrictness -> DecidedStrictness -> Bool Source # (/=) :: DecidedStrictness -> DecidedStrictness -> Bool Source # | |||||
| Ord DecidedStrictness Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods compare :: DecidedStrictness -> DecidedStrictness -> Ordering Source # (<) :: DecidedStrictness -> DecidedStrictness -> Bool Source # (<=) :: DecidedStrictness -> DecidedStrictness -> Bool Source # (>) :: DecidedStrictness -> DecidedStrictness -> Bool Source # (>=) :: DecidedStrictness -> DecidedStrictness -> Bool Source # max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness Source # min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness Source # | |||||
| Ppr DecidedStrictness Source # | |||||
Defined in Language.Haskell.TH.Ppr | |||||
| type Rep DecidedStrictness Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep DecidedStrictness = D1 ('MetaData "DecidedStrictness" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "DecidedLazy" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "DecidedStrict" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DecidedUnpack" 'PrefixI 'False) (U1 :: Type -> Type))) | |||||
In PrimTyConI, is the type constructor unlifted?
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 -> Code Q 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 ≡ unTypeCode (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 LiftRepresentation-polymorphic since template-haskell-2.16.0.0.
Minimal complete definition
Methods
lift :: Quote m => t -> m Exp Source #
Turn a value into a Template Haskell expression, suitable for use in a splice.
liftTyped :: forall (m :: Type -> Type). Quote m => t -> Code m t Source #
Turn a value into a Template Haskell typed expression, suitable for use in a typed splice.
Since: template-haskell-2.16.0.0
Instances
| Lift Addr# Source # | Produces an Since: template-haskell-2.16.0.0 |
| Lift Double# Source # | Since: template-haskell-2.16.0.0 |
| Lift Float# Source # | Since: template-haskell-2.16.0.0 |
| Lift Int# Source # | Since: template-haskell-2.16.0.0 |
| Lift ByteArray Source # | Since: template-haskell-2.19.0.0 |
| Lift Void Source # | Since: template-haskell-2.15.0.0 |
| Lift Int16 Source # | |
| Lift Int32 Source # | |
| Lift Int64 Source # | |
| Lift Int8 Source # | |
| Lift Word16 Source # | |
| Lift Word32 Source # | |
| Lift Word64 Source # | |
| Lift Word8 Source # | |
| Lift Integer Source # | |
| Lift Natural Source # | |
| Lift () Source # | |
| Lift Bool Source # | |
| Lift Char Source # | |
| Lift Double Source # | |
| Lift Float Source # | |
| Lift Int Source # | |
| Lift Word Source # | |
| Lift Char# Source # | Since: template-haskell-2.16.0.0 |
| Lift Word# Source # | Since: template-haskell-2.16.0.0 |
| Lift (# #) Source # | Since: template-haskell-2.16.0.0 |
| Lift a => Lift (NonEmpty a :: Type) Source # | Since: template-haskell-2.15.0.0 |
| Integral a => Lift (Ratio a :: Type) Source # | |
| Lift a => Lift (Maybe a :: Type) Source # | |
| Lift a => Lift ([a] :: Type) Source # | |
| Lift (Fixed a :: Type) Source # | |
| (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 a => Lift ((# a #) :: TYPE ('TupleRep '[LiftedRep])) Source # | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b) => Lift ((# a | b #) :: TYPE ('SumRep '[LiftedRep, LiftedRep])) Source # | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b) => Lift ((# a, b #) :: TYPE ('TupleRep '[LiftedRep, LiftedRep])) Source # | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c) => Lift ((# a | b | c #) :: TYPE ('SumRep '[LiftedRep, LiftedRep, LiftedRep])) Source # | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c) => Lift ((# a, b, c #) :: TYPE ('TupleRep '[LiftedRep, LiftedRep, LiftedRep])) Source # | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d) => Lift ((# a | b | c | d #) :: TYPE ('SumRep '[LiftedRep, LiftedRep, LiftedRep, LiftedRep])) Source # | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d) => Lift ((# a, b, c, d #) :: TYPE ('TupleRep '[LiftedRep, LiftedRep, LiftedRep, LiftedRep])) Source # | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d, Lift e) => Lift ((# a | b | c | d | e #) :: TYPE ('SumRep '[LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep])) Source # | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d, Lift e) => Lift ((# a, b, c, d, e #) :: TYPE ('TupleRep '[LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep])) Source # | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f) => Lift ((# a | b | c | d | e | f #) :: TYPE ('SumRep '[LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep])) Source # | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f) => Lift ((# a, b, c, d, e, f #) :: TYPE ('TupleRep '[LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep])) Source # | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g) => Lift ((# a | b | c | d | e | f | g #) :: TYPE ('SumRep '[LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep])) Source # | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g) => Lift ((# a, b, c, d, e, f, g #) :: TYPE ('TupleRep '[LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep])) Source # | Since: template-haskell-2.16.0.0 |
Constructors
| Fixity Int FixityDirection |
Instances
| 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 :: forall r r'. (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 # | |||||
| Generic Fixity Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show Fixity Source # | |||||
| Eq Fixity Source # | |||||
| Ord Fixity Source # | |||||
| type Rep Fixity Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep Fixity = D1 ('MetaData "Fixity" "Language.Haskell.TH.Syntax" "template-haskell" '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))) | |||||
A 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.
Multiplicity annotations for data types are currently not supported in Template Haskell (i.e. all fields represented by Template Haskell will be linear).
Constructors
| NormalC Name [BangType] | C Int a |
| RecC Name [VarBangType] | C { v :: Int, w :: a } |
| InfixC BangType Name BangType | Int :+ a |
| ForallC [TyVarBndr Specificity] Cxt Con | forall a. Eq a => C [a] |
| GadtC | |
| RecGadtC | C :: { v :: Int } -> T b Int |
Fields
| |
Instances
| Data Con 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) -> Con -> c Con # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Con # dataTypeOf :: Con -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Con) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Con) # gmapT :: (forall b. Data b => b -> b) -> Con -> Con # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r # gmapQ :: (forall d. Data d => d -> u) -> Con -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Con -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Con -> m Con # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Con -> m Con # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Con -> m Con # | |||||
| Generic Con Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show Con Source # | |||||
| Eq Con Source # | |||||
| Ord Con Source # | |||||
| Ppr Con Source # | |||||
| type Rep Con Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep Con = D1 ('MetaData "Con" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((C1 ('MetaCons "NormalC" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [BangType])) :+: (C1 ('MetaCons "RecC" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [VarBangType])) :+: C1 ('MetaCons "InfixC" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 BangType) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 BangType))))) :+: (C1 ('MetaCons "ForallC" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TyVarBndr Specificity]) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Cxt) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Con))) :+: (C1 ('MetaCons "GadtC" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name]) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [BangType]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) :+: C1 ('MetaCons "RecGadtC" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name]) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [VarBangType]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)))))) | |||||
Recover from errors raised by reportError or fail.
reportError :: String -> Q () Source #
Report an error to the user, but allow the current splice's computation to carry on. To abort the computation, use fail.
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.
Constructors
| Unsafe | |
| Safe | |
| Interruptible |
Instances
| 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 :: forall r r'. (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 # | |||||
| Generic Safety Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show Safety Source # | |||||
| Eq Safety Source # | |||||
| Ord Safety Source # | |||||
| type Rep Safety Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
Instances
| MonadIO Q Source # | |
| Applicative Q Source # | |
| Functor Q Source # | |
| Monad Q Source # | |
| MonadFail Q Source # | |
Defined in Language.Haskell.TH.Syntax | |
| MonadFix Q Source # | If the function passed to Since: template-haskell-2.17.0.0 |
Defined in Language.Haskell.TH.Syntax | |
| Quasi Q Source # | |
Defined in Language.Haskell.TH.Syntax Methods qNewName :: String -> Q Name Source # qReport :: Bool -> String -> Q () Source # qRecover :: Q a -> Q a -> Q a Source # qLookupName :: Bool -> String -> Q (Maybe Name) Source # qReify :: Name -> Q Info Source # qReifyFixity :: Name -> Q (Maybe Fixity) Source # qReifyType :: Name -> Q Type Source # qReifyInstances :: Name -> [Type] -> Q [Dec] Source # qReifyRoles :: Name -> Q [Role] Source # qReifyAnnotations :: Data a => AnnLookup -> Q [a] Source # qReifyModule :: Module -> Q ModuleInfo Source # qReifyConStrictness :: Name -> Q [DecidedStrictness] Source # qRunIO :: IO a -> Q a Source # qGetPackageRoot :: Q FilePath Source # qAddDependentFile :: FilePath -> Q () Source # qAddTempFile :: String -> Q FilePath Source # qAddTopDecls :: [Dec] -> Q () Source # qAddForeignFilePath :: ForeignSrcLang -> String -> Q () Source # qAddModFinalizer :: Q () -> Q () Source # qAddCorePlugin :: String -> Q () Source # qGetQ :: Typeable a => Q (Maybe a) Source # qPutQ :: Typeable a => a -> Q () Source # qIsExtEnabled :: Extension -> Q Bool Source # qExtsEnabled :: Q [Extension] Source # | |
| Quote Q Source # | |
| Monoid a => Monoid (Q a) Source # | Since: template-haskell-2.17.0.0 |
| Semigroup a => Semigroup (Q a) Source # | Since: template-haskell-2.17.0.0 |
class Monad m => Quote (m :: Type -> Type) where Source #
The Quote class implements the minimal interface which is necessary for
desugaring quotations.
- The
Monad msuperclass is needed to stitch together the different AST fragments. newNameis used when desugaring binding structures such as lambdas to generate fresh names.
Therefore the type of an untyped quotation in GHC is `Quote m => m Exp`
For many years the type of a quotation was fixed to be `Q Exp` but by
more precisely specifying the minimal interface it enables the Exp to
be extracted purely from the quotation without interacting with Q.
Methods
newName :: String -> m Name Source #
Generate a fresh name, which cannot be captured.
For example, this:
f = $(do
nm1 <- newName "x"
let nm2 = mkName "x"
return (LamE [VarP nm1] (LamE [VarP nm2] (VarE nm1)))
)will produce the splice
f = \x0 -> \x -> x0
In particular, the occurrence VarE nm1 refers to the binding VarP nm1,
and is not captured by the binding VarP nm2.
Although names generated by newName cannot be captured, they can
capture other names. For example, this:
g = $(do nm1 <- newName "x" let nm2 = mkName "x" return (LamE [VarP nm2] (LamE [VarP nm1] (VarE nm2))) )
will produce the splice
g = \x -> \x0 -> x0
since the occurrence VarE nm2 is captured by the innermost binding
of x, namely VarP nm1.
reportWarning :: String -> Q () Source #
Report a warning to the user, and carry on.
report :: Bool -> String -> Q () Source #
Deprecated: Use reportError or reportWarning instead
Report an error (True) or warning (False),
but carry on; use fail to stop.
Constructors
| Loc | |
Fields
| |
Instances
| 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 :: forall r r'. (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 # | |||||
| Generic Loc Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show Loc Source # | |||||
| Eq Loc Source # | |||||
| Ord 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" "template-haskell" '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))))) | |||||
reify :: Name -> Q Info Source #
reify looks up information about the Name. It will fail with
a compile error if the Name is not visible. A Name is visible if it is
imported or defined in a prior top-level declaration group. See the
documentation for newDeclarationGroup for more details.
It is sometimes useful to construct the argument name using lookupTypeName or lookupValueName
to ensure that we are reifying from the right namespace. For instance, in this context:
data D = D
which D does reify (mkName "D") return information about? (Answer: D-the-type, but don't rely on it.)
To ensure we get information about D-the-value, use lookupValueName:
do Just nm <- lookupValueName "D" reify nm
and to get information about D-the-type, use lookupTypeName.
reifyModule :: Module -> Q ModuleInfo Source #
reifyModule mod looks up information about module mod. To
look up the current module, call this function with the return
value of thisModule.
newDeclarationGroup :: Q [Dec] Source #
Template Haskell is capable of reifying information about types and terms defined in previous declaration groups. Top-level declaration splices break up declaration groups.
For an example, consider this code block. We define a datatype X and
then try to call reify on the datatype.
module Check where
data X = X
deriving Eq
$(do
info <- reify ''X
runIO $ print info
)
This code fails to compile, noting that X is not available for reification at the site of reify. We can fix this by creating a new declaration group using an empty top-level splice:
data X = X
deriving Eq
$(pure [])
$(do
info <- reify ''X
runIO $ print info
)
We provide newDeclarationGroup as a means of documenting this behavior
and providing a name for the pattern.
Since top level splices infer the presence of the $( ... ) brackets, we can also write:
data X = X
deriving Eq
newDeclarationGroup
$(do
info <- reify ''X
runIO $ print info
)
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
| Data Info 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) -> Info -> c Info # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Info # dataTypeOf :: Info -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Info) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Info) # gmapT :: (forall b. Data b => b -> b) -> Info -> Info # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r # gmapQ :: (forall d. Data d => d -> u) -> Info -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Info -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Info -> m Info # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Info -> m Info # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Info -> m Info # | |||||
| Generic Info Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show Info Source # | |||||
| Eq Info Source # | |||||
| Ord Info Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
| Ppr Info Source # | |||||
| type Rep Info Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep Info = D1 ('MetaData "Info" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (((C1 ('MetaCons "ClassI" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Dec) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [InstanceDec])) :+: C1 ('MetaCons "ClassOpI" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ParentName)))) :+: (C1 ('MetaCons "TyConI" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Dec)) :+: C1 ('MetaCons "FamilyI" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Dec) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [InstanceDec])))) :+: ((C1 ('MetaCons "PrimTyConI" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Arity) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Unlifted))) :+: C1 ('MetaCons "DataConI" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ParentName)))) :+: (C1 ('MetaCons "PatSynI" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 PatSynType)) :+: (C1 ('MetaCons "VarI" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Dec)))) :+: C1 ('MetaCons "TyVarI" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)))))) | |||||
data ModuleInfo Source #
Obtained from reifyModule in the Q Monad.
Constructors
| ModuleInfo [Module] | Contains the import list of the module. |
Instances
| Data ModuleInfo 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) -> ModuleInfo -> c ModuleInfo # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ModuleInfo # toConstr :: ModuleInfo -> Constr # dataTypeOf :: ModuleInfo -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ModuleInfo) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleInfo) # gmapT :: (forall b. Data b => b -> b) -> ModuleInfo -> ModuleInfo # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r # gmapQ :: (forall d. Data d => d -> u) -> ModuleInfo -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ModuleInfo -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo # | |||||
| Generic ModuleInfo Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show ModuleInfo Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> ModuleInfo -> ShowS # show :: ModuleInfo -> String # showList :: [ModuleInfo] -> ShowS # | |||||
| Eq ModuleInfo Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods (==) :: ModuleInfo -> ModuleInfo -> Bool Source # (/=) :: ModuleInfo -> ModuleInfo -> Bool Source # | |||||
| Ord ModuleInfo Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods compare :: ModuleInfo -> ModuleInfo -> Ordering Source # (<) :: ModuleInfo -> ModuleInfo -> Bool Source # (<=) :: ModuleInfo -> ModuleInfo -> Bool Source # (>) :: ModuleInfo -> ModuleInfo -> Bool Source # (>=) :: ModuleInfo -> ModuleInfo -> Bool Source # max :: ModuleInfo -> ModuleInfo -> ModuleInfo Source # min :: ModuleInfo -> ModuleInfo -> ModuleInfo Source # | |||||
| Ppr ModuleInfo Source # | |||||
Defined in Language.Haskell.TH.Ppr | |||||
| type Rep ModuleInfo Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep ModuleInfo = D1 ('MetaData "ModuleInfo" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "ModuleInfo" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Module]))) | |||||
type InstanceDec = Dec Source #
InstanceDec describes a single instance of a class or type function.
It is just a Dec, but guaranteed to be one of the following:
InstanceD(with empty[)Dec]DataInstDorNewtypeInstD(with empty derived[)Name]TySynInstD
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:
In UnboxedSumE, UnboxedSumT, and UnboxedSumP, the total number of
SumAlts. For example, (#|#) has a SumArity of 2.
In PrimTyConI, arity of the type constructor
extsEnabled :: Q [Extension] Source #
List all enabled language extensions.
isExtEnabled :: Extension -> Q Bool Source #
Determine whether the given language extension is enabled in the Q monad.
lookupTypeName :: String -> Q (Maybe Name) Source #
Look up the given name in the (type namespace of the) current splice's scope. See Language.Haskell.TH.Syntax for more details.
lookupValueName :: String -> Q (Maybe Name) Source #
Look up the given name in the (value namespace of the) current splice's scope. See Language.Haskell.TH.Syntax for more details.
reifyFixity :: Name -> Q (Maybe Fixity) Source #
reifyFixity nm attempts to find a fixity declaration for nm. For
example, if the function foo has the fixity declaration infixr 7 foo, then
reifyFixity 'foo would return Just (Fixity 7 InfixR)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 all visible instances (see below for "visible")
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") ]Show
There is one edge case: reifyInstances ''Typeable tys currently always
produces an empty list (no matter what tys are given).
In principle, the *visible* instances are
* all instances defined in a prior top-level declaration group
(see docs on newDeclarationGroup), or
* all instances defined in any module transitively imported by the
module being compiled
However, actually searching all modules transitively below the one being
compiled is unreasonably expensive, so reifyInstances will report only the
instance for modules that GHC has had some cause to visit during this
compilation. This is a shortcoming: reifyInstances might fail to report
instances for a type that is otherwise unusued, or instances defined in a
different component. You can work around this shortcoming by explicitly importing the modules
whose instances you want to be visible. GHC issue #20529
has some discussion around this.
isInstance :: Name -> [Type] -> Q Bool Source #
Is the list of instances returned by reifyInstances nonempty?
If you're confused by an instance not being visible despite being
defined in the same module and above the splice in question, see the
docs for newDeclarationGroup for a possible explanation.
reifyRoles :: Name -> Q [Role] Source #
reifyRoles nm returns the list of roles associated with the parameters
(both visible and invisible) of
the tycon nm. Fails if nm cannot be found or is not a tycon.
The returned list should never contain InferR.
An invisible parameter to a tycon is often a kind parameter. For example, if we have
type Proxy :: forall k. k -> Type data Proxy a = MkProxy
and reifyRoles Proxy, we will get [. The NominalR, PhantomR]NominalR is
the role of the invisible k parameter. Kind parameters are always nominal.
reifyAnnotations :: Data a => AnnLookup -> Q [a] Source #
reifyAnnotations target returns the list of annotations
associated with target. Only the annotations that are
appropriately typed is returned. So if you have Int and String
annotations for the same target, you have to call this function twice.
Annotation target for reifyAnnotations
Constructors
| AnnLookupModule Module | |
| AnnLookupName Name |
Instances
| 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 :: forall r r'. (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 # | |||||
| Generic AnnLookup Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show AnnLookup Source # | |||||
| Eq AnnLookup Source # | |||||
| Ord AnnLookup Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
| type Rep AnnLookup Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep AnnLookup = D1 ('MetaData "AnnLookup" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "AnnLookupModule" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Module)) :+: C1 ('MetaCons "AnnLookupName" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name))) | |||||
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.
newtype TExp (a :: TYPE r) Source #
Typed wrapper around an Exp.
This is the typed representation of terms produced by typed quotes.
Representation-polymorphic since template-haskell-2.16.0.0.
newtype Code (m :: Type -> Type) (a :: TYPE r) Source #
Represents an expression which has type a, built in monadic context m. Built on top of TExp, 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 typeQuote m => Code m a - typed splices inside of typed quotes, written as
$$(...)where...is an arbitrary expression of typeQuote m => Code m a
Traditional expression quotes and splices let us construct ill-typed expressions:
>>>fmap ppr $ runQ (unTypeCode [| 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 (unTypeCode [|| True == $$( [|| "foo" ||] ) ||])<interactive> error: • Couldn't match type ‘[Char]’ with ‘Bool’ Expected type: Code Q Bool Actual type: Code Q [Char] • In the Template Haskell quotation [|| "foo" ||] In the expression: [|| "foo" ||] In the Template Haskell splice $$([|| "foo" ||])
Constructors
| Code | |
Fields
| |
unTypeCode :: forall a m. Quote m => Code m a -> m Exp Source #
Extract the untyped representation from the typed representation
unsafeCodeCoerce :: forall a m. Quote m => m Exp -> Code m a Source #
Unsafely convert an untyped code representation into a typed code representation.
hoistCode :: Monad m => (forall x. m x -> n x) -> Code m a -> Code n a Source #
Modify the ambient monad used during code generation. For example, you
can use hoistCode to handle a state effect:
handleState :: Code (StateT Int Q) a -> Code Q a
handleState = hoistCode (flip runState 0)
bindCode :: Monad m => m a -> (a -> Code m b) -> Code m b Source #
Variant of (>>=) which allows effectful computations to be injected into code generation.
bindCode_ :: Monad m => m a -> Code m b -> Code m b Source #
Variant of (>>) which allows effectful computations to be injected into code generation.
joinCode :: Monad m => m (Code m a) -> Code m a Source #
A useful combinator for embedding monadic actions into Code
myCode :: ... => Code m a
myCode = joinCode $ do
x <- someSideEffect
return (makeCodeWith x)
liftCode :: forall a m. m (TExp a) -> Code m a Source #
Lift a monadic action producing code into the typed Code
representation
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
| 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 :: forall r r'. (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 # | |||||
| Generic Name Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show Name Source # | |||||
| Eq Name Source # | |||||
| Ord Name Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
| Ppr Name Source # | |||||
| type Rep Name Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep Name = D1 ('MetaData "Name" "Language.Haskell.TH.Syntax" "template-haskell" '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))) | |||||
Constructors
| VarName | Variables |
| DataName | Data constructors |
| TcClsName | Type constructors and classes; Haskell has them in the same name space for now. |
| FldName | |
Instances
| 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 :: forall r r'. (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 # | |||||
| Generic NameSpace Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show NameSpace Source # | |||||
| Eq NameSpace Source # | |||||
| Ord NameSpace Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
| type Rep NameSpace Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep NameSpace = D1 ('MetaData "NameSpace" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((C1 ('MetaCons "VarName" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DataName" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "TcClsName" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "FldName" 'PrefixI 'True) (S1 ('MetaSel ('Just "fldParent") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 String)))) | |||||
mkName :: String -> Name Source #
Generate a capturable name. Occurrences of such names will be resolved according to the Haskell scoping rules at the occurrence site.
For example:
f = [| pi + $(varE (mkName "pi")) |] ... g = let pi = 3 in $f
In this case, g is desugared to
g = Prelude.pi + 3
Note that mkName may be used with qualified names:
mkName "Prelude.pi"
See also dyn for a useful combinator. The above example could
be rewritten using dyn as
f = [| pi + $(dyn "pi") |]
nameBase :: Name -> String Source #
The name without its module prefix.
Examples
>>>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
tupleTypeName :: Int -> Name Source #
Tuple type constructor
tupleDataName :: Int -> Name Source #
Tuple data constructor
unboxedTupleTypeName :: Int -> Name Source #
Unboxed tuple type constructor
unboxedTupleDataName :: Int -> Name Source #
Unboxed tuple data constructor
unboxedSumTypeName :: SumArity -> Name Source #
Unboxed sum type constructor
Constructors
| FunD Name [Clause] | { f p1 p2 = b where decs } |
| ValD Pat Body [Dec] | { p = b where decs } |
| DataD Cxt Name [TyVarBndr BndrVis] (Maybe Kind) [Con] [DerivClause] | { data Cxt x => T x = A x | B (T x)
deriving (Z,W)
deriving stock Eq } |
| NewtypeD Cxt Name [TyVarBndr BndrVis] (Maybe Kind) Con [DerivClause] | { newtype Cxt x => T x = A (B x)
deriving (Z,W Q)
deriving stock Eq } |
| TypeDataD Name [TyVarBndr BndrVis] (Maybe Kind) [Con] | { type data T x = A x | B (T x) } |
| TySynD Name [TyVarBndr BndrVis] Type | { type T x = (x,x) } |
| ClassD Cxt Name [TyVarBndr BndrVis] [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 NamespaceSpecifier Name | { infix 3 data foo } |
| DefaultD [Type] | { default (Integer, Double) } |
| PragmaD | pragmas |
Fields
| |
| DataFamilyD | data families (may also appear in [Dec] of |
| DataInstD Cxt (Maybe [TyVarBndr ()]) Type (Maybe Kind) [Con] [DerivClause] | { data instance Cxt x => T [x]
= A x | B (T x)
deriving (Z,W)
deriving stock Eq } |
| NewtypeInstD Cxt (Maybe [TyVarBndr ()]) Type (Maybe Kind) Con [DerivClause] | { newtype instance Cxt x => T [x]
= A (B x)
deriving (Z,W)
deriving stock Eq } |
| TySynInstD TySynEqn | { type instance ... } |
| OpenTypeFamilyD | open type families (may also appear in [Dec] of |
Fields
| |
| ClosedTypeFamilyD TypeFamilyHead [TySynEqn] | { type family F a b = (r :: *) | r -> a where ... } |
| RoleAnnotD Name [Role] | { type role T nominal representational } |
| StandaloneDerivD (Maybe DerivStrategy) Cxt Type | { deriving stock instance Ord a => Ord (Foo a) } |
| DefaultSigD Name Type | { default size :: Data a => a -> Int } |
| PatSynD | Pattern Synonyms |
Fields
| |
| 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
| Data Dec 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) -> Dec -> c Dec # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Dec # dataTypeOf :: Dec -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Dec) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Dec) # gmapT :: (forall b. Data b => b -> b) -> Dec -> Dec # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r # gmapQ :: (forall d. Data d => d -> u) -> Dec -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Dec -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Dec -> m Dec # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Dec -> m Dec # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Dec -> m Dec # | |||||
| Generic Dec Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show Dec Source # | |||||
| Eq Dec Source # | |||||
| Ord Dec Source # | |||||
| Ppr Dec Source # | |||||
| type Rep Dec Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep Dec = D1 ('MetaData "Dec" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((((C1 ('MetaCons "FunD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Clause])) :+: (C1 ('MetaCons "ValD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Body) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Dec]))) :+: C1 ('MetaCons "DataD" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Cxt) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TyVarBndr BndrVis]))) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Kind)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Con]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DerivClause])))))) :+: (C1 ('MetaCons "NewtypeD" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Cxt) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TyVarBndr BndrVis]))) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Kind)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Con) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DerivClause])))) :+: (C1 ('MetaCons "TypeDataD" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TyVarBndr BndrVis])) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Kind)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Con]))) :+: C1 ('MetaCons "TySynD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TyVarBndr BndrVis]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)))))) :+: ((C1 ('MetaCons "ClassD" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Cxt) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TyVarBndr BndrVis]) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [FunDep]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Dec])))) :+: (C1 ('MetaCons "InstanceD" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Overlap)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Cxt)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Dec]))) :+: C1 ('MetaCons "SigD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)))) :+: ((C1 ('MetaCons "KiSigD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Kind)) :+: C1 ('MetaCons "ForeignD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Foreign))) :+: (C1 ('MetaCons "InfixD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Fixity) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NamespaceSpecifier) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name))) :+: C1 ('MetaCons "DefaultD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Type])))))) :+: (((C1 ('MetaCons "PragmaD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pragma)) :+: (C1 ('MetaCons "DataFamilyD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TyVarBndr BndrVis]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Kind)))) :+: C1 ('MetaCons "DataInstD" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Cxt) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe [TyVarBndr ()])) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Kind)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Con]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DerivClause])))))) :+: (C1 ('MetaCons "NewtypeInstD" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Cxt) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe [TyVarBndr ()])) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Kind)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Con) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DerivClause])))) :+: (C1 ('MetaCons "TySynInstD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 TySynEqn)) :+: C1 ('MetaCons "OpenTypeFamilyD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 TypeFamilyHead))))) :+: ((C1 ('MetaCons "ClosedTypeFamilyD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 TypeFamilyHead) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TySynEqn])) :+: (C1 ('MetaCons "RoleAnnotD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Role])) :+: C1 ('MetaCons "StandaloneDerivD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe DerivStrategy)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Cxt) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))))) :+: ((C1 ('MetaCons "DefaultSigD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :+: C1 ('MetaCons "PatSynD" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 PatSynArgs)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 PatSynDir) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat)))) :+: (C1 ('MetaCons "PatSynSigD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 PatSynType)) :+: C1 ('MetaCons "ImplicitParamBindD" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp))))))) | |||||
Instances
| 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 :: forall r r'. (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 # | |||||
| Generic Clause Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show Clause Source # | |||||
| Eq Clause Source # | |||||
| Ord 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" "template-haskell" 'False) (C1 ('MetaCons "Clause" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [ArgPat]) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Body) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Dec])))) | |||||
Constructors
| Bang SourceUnpackedness SourceStrictness | C { {-# UNPACK #-} !}a |
Instances
| 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 :: forall r r'. (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 # | |||||
| Generic Bang Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show Bang Source # | |||||
| Eq Bang Source # | |||||
| Ord Bang Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
| Ppr Bang Source # | |||||
| type Rep Bang Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep Bang = D1 ('MetaData "Bang" "Language.Haskell.TH.Syntax" "template-haskell" '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))) | |||||
Constructors
| CCall | |
| StdCall | |
| CApi | |
| Prim | |
| JavaScript |
Instances
| 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 :: forall r r'. (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 # | |||||
| Generic Callconv Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show Callconv Source # | |||||
| Eq Callconv Source # | |||||
| Ord Callconv Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
| type Rep Callconv Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep Callconv = D1 ('MetaData "Callconv" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((C1 ('MetaCons "CCall" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "StdCall" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "CApi" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Prim" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "JavaScript" 'PrefixI 'False) (U1 :: Type -> Type)))) | |||||
Constructors
| InlineP Name Inline RuleMatch Phases | |
| OpaqueP Name | |
| 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 ] #-} } |
| SCCP Name (Maybe String) | { {-# SCC fun "optional_name" #-} } |
Instances
| Data Pragma 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) -> Pragma -> c Pragma # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Pragma # toConstr :: Pragma -> Constr # dataTypeOf :: Pragma -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Pragma) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pragma) # gmapT :: (forall b. Data b => b -> b) -> Pragma -> Pragma # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pragma -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pragma -> r # gmapQ :: (forall d. Data d => d -> u) -> Pragma -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Pragma -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Pragma -> m Pragma # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Pragma -> m Pragma # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Pragma -> m Pragma # | |||||
| Generic Pragma Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show Pragma Source # | |||||
| Eq Pragma Source # | |||||
| Ord Pragma Source # | |||||
| Ppr Pragma Source # | |||||
| type Rep Pragma Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep Pragma = D1 ('MetaData "Pragma" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (((C1 ('MetaCons "InlineP" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Inline)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 RuleMatch) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Phases))) :+: C1 ('MetaCons "OpaqueP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name))) :+: (C1 ('MetaCons "SpecialiseP" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Inline)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Phases))) :+: C1 ('MetaCons "SpecialiseInstP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)))) :+: ((C1 ('MetaCons "RuleP" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe [TyVarBndr ()])) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [RuleBndr]))) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Phases)))) :+: C1 ('MetaCons "AnnP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 AnnTarget) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp))) :+: (C1 ('MetaCons "LineP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)) :+: (C1 ('MetaCons "CompleteP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Name))) :+: C1 ('MetaCons "SCCP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe String))))))) | |||||
Instances
| 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 :: forall r r'. (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 # | |||||
| Generic Inline Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show Inline Source # | |||||
| Eq Inline Source # | |||||
| Ord Inline Source # | |||||
| Ppr Inline Source # | |||||
| type Rep Inline Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
Instances
| 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 :: forall r r'. (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 # | |
| Generic RuleMatch Source # | |
Defined in Language.Haskell.TH.Syntax | |
| Show RuleMatch Source # | |
| Eq RuleMatch Source # | |
| Ord RuleMatch Source # | |
Defined in Language.Haskell.TH.Syntax | |
| Ppr RuleMatch Source # | |
| type Rep RuleMatch Source # | |
Constructors
| AllPhases | |
| FromPhase Int | |
| BeforePhase Int |
Instances
| 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 :: forall r r'. (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 # | |||||
| Generic Phases Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show Phases Source # | |||||
| Eq Phases Source # | |||||
| Ord 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" "template-haskell" 'False) (C1 ('MetaCons "AllPhases" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "FromPhase" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int)) :+: C1 ('MetaCons "BeforePhase" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int)))) | |||||
Constructors
| RuleVar Name | |
| TypedRuleVar Name Type |
Instances
| 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 :: forall r r'. (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 # | |||||
| Generic RuleBndr Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show RuleBndr Source # | |||||
| Eq RuleBndr Source # | |||||
| Ord RuleBndr Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
| Ppr RuleBndr Source # | |||||
| type Rep RuleBndr Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep RuleBndr = D1 ('MetaData "RuleBndr" "Language.Haskell.TH.Syntax" "template-haskell" '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
| ModuleAnnotation | |
| TypeAnnotation Name | |
| ValueAnnotation Name |
Instances
| 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 :: forall r r'. (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 # | |||||
| Generic AnnTarget Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show AnnTarget Source # | |||||
| Eq AnnTarget Source # | |||||
| Ord AnnTarget Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
| type Rep AnnTarget Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep AnnTarget = D1 ('MetaData "AnnTarget" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "ModuleAnnotation" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "TypeAnnotation" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)) :+: C1 ('MetaCons "ValueAnnotation" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)))) | |||||
Instances
| 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 :: forall r r'. (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 # | |||||
| Generic FunDep Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show FunDep Source # | |||||
| Eq FunDep Source # | |||||
| Ord 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" "template-haskell" 'False) (C1 ('MetaCons "FunDep" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name]))) | |||||
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
| 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 :: forall r r'. (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 # | |||||
| Generic TySynEqn Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show TySynEqn Source # | |||||
| Eq TySynEqn Source # | |||||
| Ord TySynEqn Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
| type Rep TySynEqn Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep TySynEqn = D1 ('MetaData "TySynEqn" "Language.Haskell.TH.Syntax" "template-haskell" '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 BndrVis] FamilyResultSig (Maybe InjectivityAnn) |
Instances
| Data TypeFamilyHead 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) -> TypeFamilyHead -> c TypeFamilyHead # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TypeFamilyHead # toConstr :: TypeFamilyHead -> Constr # dataTypeOf :: TypeFamilyHead -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TypeFamilyHead) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeFamilyHead) # gmapT :: (forall b. Data b => b -> b) -> TypeFamilyHead -> TypeFamilyHead # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r # gmapQ :: (forall d. Data d => d -> u) -> TypeFamilyHead -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeFamilyHead -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeFamilyHead -> m TypeFamilyHead # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeFamilyHead -> m TypeFamilyHead # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeFamilyHead -> m TypeFamilyHead # | |||||
| Generic TypeFamilyHead Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
Methods from :: TypeFamilyHead -> Rep TypeFamilyHead x # to :: Rep TypeFamilyHead x -> TypeFamilyHead # | |||||
| Show TypeFamilyHead Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> TypeFamilyHead -> ShowS # show :: TypeFamilyHead -> String # showList :: [TypeFamilyHead] -> ShowS # | |||||
| Eq TypeFamilyHead Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods (==) :: TypeFamilyHead -> TypeFamilyHead -> Bool Source # (/=) :: TypeFamilyHead -> TypeFamilyHead -> Bool Source # | |||||
| Ord TypeFamilyHead Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods compare :: TypeFamilyHead -> TypeFamilyHead -> Ordering Source # (<) :: TypeFamilyHead -> TypeFamilyHead -> Bool Source # (<=) :: TypeFamilyHead -> TypeFamilyHead -> Bool Source # (>) :: TypeFamilyHead -> TypeFamilyHead -> Bool Source # (>=) :: TypeFamilyHead -> TypeFamilyHead -> Bool Source # max :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead Source # min :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead Source # | |||||
| type Rep TypeFamilyHead Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep TypeFamilyHead = D1 ('MetaData "TypeFamilyHead" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "TypeFamilyHead" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TyVarBndr BndrVis])) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 FamilyResultSig) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe InjectivityAnn))))) | |||||
data FixityDirection Source #
Instances
| Data FixityDirection 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) -> FixityDirection -> c FixityDirection # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FixityDirection # toConstr :: FixityDirection -> Constr # dataTypeOf :: FixityDirection -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FixityDirection) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FixityDirection) # gmapT :: (forall b. Data b => b -> b) -> FixityDirection -> FixityDirection # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r # gmapQ :: (forall d. Data d => d -> u) -> FixityDirection -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FixityDirection -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection # | |||||
| Generic FixityDirection Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
Methods from :: FixityDirection -> Rep FixityDirection x # to :: Rep FixityDirection x -> FixityDirection # | |||||
| Show FixityDirection Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> FixityDirection -> ShowS # show :: FixityDirection -> String # showList :: [FixityDirection] -> ShowS # | |||||
| Eq FixityDirection Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods (==) :: FixityDirection -> FixityDirection -> Bool Source # (/=) :: FixityDirection -> FixityDirection -> Bool Source # | |||||
| Ord FixityDirection Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods compare :: FixityDirection -> FixityDirection -> Ordering Source # (<) :: FixityDirection -> FixityDirection -> Bool Source # (<=) :: FixityDirection -> FixityDirection -> Bool Source # (>) :: FixityDirection -> FixityDirection -> Bool Source # (>=) :: FixityDirection -> FixityDirection -> Bool Source # max :: FixityDirection -> FixityDirection -> FixityDirection Source # min :: FixityDirection -> FixityDirection -> FixityDirection Source # | |||||
| type Rep FixityDirection Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep FixityDirection = D1 ('MetaData "FixityDirection" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "InfixL" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "InfixR" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "InfixN" 'PrefixI 'False) (U1 :: Type -> Type))) | |||||
data NamespaceSpecifier Source #
A way to specify a namespace to look in when GHC needs to find a name's source
Constructors
| NoNamespaceSpecifier | Name may be everything; If there are two names in different namespaces, then consider both |
| TypeNamespaceSpecifier | Name should be a type-level entity, such as a data type, type alias, type family, type class, or type variable |
| DataNamespaceSpecifier | Name should be a term-level entity, such as a function, data constructor, or pattern synonym |
Instances
| Data NamespaceSpecifier 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) -> NamespaceSpecifier -> c NamespaceSpecifier # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NamespaceSpecifier # toConstr :: NamespaceSpecifier -> Constr # dataTypeOf :: NamespaceSpecifier -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NamespaceSpecifier) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NamespaceSpecifier) # gmapT :: (forall b. Data b => b -> b) -> NamespaceSpecifier -> NamespaceSpecifier # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NamespaceSpecifier -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NamespaceSpecifier -> r # gmapQ :: (forall d. Data d => d -> u) -> NamespaceSpecifier -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NamespaceSpecifier -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NamespaceSpecifier -> m NamespaceSpecifier # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NamespaceSpecifier -> m NamespaceSpecifier # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NamespaceSpecifier -> m NamespaceSpecifier # | |||||
| Generic NamespaceSpecifier Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
Methods from :: NamespaceSpecifier -> Rep NamespaceSpecifier x # to :: Rep NamespaceSpecifier x -> NamespaceSpecifier # | |||||
| Show NamespaceSpecifier Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> NamespaceSpecifier -> ShowS # show :: NamespaceSpecifier -> String # showList :: [NamespaceSpecifier] -> ShowS # | |||||
| Eq NamespaceSpecifier Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods (==) :: NamespaceSpecifier -> NamespaceSpecifier -> Bool Source # (/=) :: NamespaceSpecifier -> NamespaceSpecifier -> Bool Source # | |||||
| Ord NamespaceSpecifier Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods compare :: NamespaceSpecifier -> NamespaceSpecifier -> Ordering Source # (<) :: NamespaceSpecifier -> NamespaceSpecifier -> Bool Source # (<=) :: NamespaceSpecifier -> NamespaceSpecifier -> Bool Source # (>) :: NamespaceSpecifier -> NamespaceSpecifier -> Bool Source # (>=) :: NamespaceSpecifier -> NamespaceSpecifier -> Bool Source # max :: NamespaceSpecifier -> NamespaceSpecifier -> NamespaceSpecifier Source # min :: NamespaceSpecifier -> NamespaceSpecifier -> NamespaceSpecifier Source # | |||||
| type Rep NamespaceSpecifier Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep NamespaceSpecifier = D1 ('MetaData "NamespaceSpecifier" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "NoNamespaceSpecifier" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "TypeNamespaceSpecifier" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DataNamespaceSpecifier" 'PrefixI 'False) (U1 :: Type -> Type))) | |||||
defaultFixity :: Fixity Source #
Default fixity: infixl 9
maxPrecedence :: Int Source #
Highest allowed operator precedence for Fixity constructor (answer: 9)
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
| 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 :: forall r r'. (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 # | |||||
| Generic PatSynDir Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show PatSynDir Source # | |||||
| Eq PatSynDir Source # | |||||
| Ord PatSynDir Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
| Ppr PatSynDir Source # | |||||
| type Rep PatSynDir Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep PatSynDir = D1 ('MetaData "PatSynDir" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "Unidir" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "ImplBidir" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ExplBidir" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Clause])))) | |||||
data PatSynArgs Source #
A pattern synonym's argument type.
Constructors
| PrefixPatSyn [Name] | pattern P {x y z} = p |
| InfixPatSyn Name Name | pattern {x P y} = p |
| RecordPatSyn [Name] | pattern P { {x,y,z} } = p |
Instances
| Data PatSynArgs 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) -> PatSynArgs -> c PatSynArgs # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PatSynArgs # toConstr :: PatSynArgs -> Constr # dataTypeOf :: PatSynArgs -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PatSynArgs) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatSynArgs) # gmapT :: (forall b. Data b => b -> b) -> PatSynArgs -> PatSynArgs # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PatSynArgs -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PatSynArgs -> r # gmapQ :: (forall d. Data d => d -> u) -> PatSynArgs -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PatSynArgs -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs # | |||||
| Generic PatSynArgs Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show PatSynArgs Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> PatSynArgs -> ShowS # show :: PatSynArgs -> String # showList :: [PatSynArgs] -> ShowS # | |||||
| Eq PatSynArgs Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods (==) :: PatSynArgs -> PatSynArgs -> Bool Source # (/=) :: PatSynArgs -> PatSynArgs -> Bool Source # | |||||
| Ord PatSynArgs Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods compare :: PatSynArgs -> PatSynArgs -> Ordering Source # (<) :: PatSynArgs -> PatSynArgs -> Bool Source # (<=) :: PatSynArgs -> PatSynArgs -> Bool Source # (>) :: PatSynArgs -> PatSynArgs -> Bool Source # (>=) :: PatSynArgs -> PatSynArgs -> Bool Source # max :: PatSynArgs -> PatSynArgs -> PatSynArgs Source # min :: PatSynArgs -> PatSynArgs -> PatSynArgs Source # | |||||
| Ppr PatSynArgs Source # | |||||
Defined in Language.Haskell.TH.Ppr | |||||
| type Rep PatSynArgs Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep PatSynArgs = D1 ('MetaData "PatSynArgs" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "PrefixPatSyn" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name])) :+: (C1 ('MetaCons "InfixPatSyn" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)) :+: C1 ('MetaCons "RecordPatSyn" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name])))) | |||||
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 [ArgPat] Exp | { \ p1 p2 -> e } |
| LamCaseE [Match] | { \case m1; m2 } |
| LamCasesE [Clause] | { \cases 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 (Maybe ModName) [Stmt] |
|
| MDoE (Maybe ModName) [Stmt] |
|
| 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 |
|
| GetFieldE Exp String |
|
| ProjectionE (NonEmpty String) |
|
| TypedBracketE Exp | [|| e ||] |
| TypedSpliceE Exp | $$e |
| TypeE Type | { type t } |
Instances
| Data Exp 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) -> Exp -> c Exp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Exp # dataTypeOf :: Exp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Exp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp) # gmapT :: (forall b. Data b => b -> b) -> Exp -> Exp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r # gmapQ :: (forall d. Data d => d -> u) -> Exp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Exp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Exp -> m Exp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp -> m Exp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp -> m Exp # | |||||
| Generic Exp Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show Exp Source # | |||||
| Eq Exp Source # | |||||
| Ord Exp Source # | |||||
| Ppr Exp Source # | |||||
| type Rep Exp Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep Exp = D1 ('MetaData "Exp" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (((((C1 ('MetaCons "VarE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)) :+: C1 ('MetaCons "ConE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name))) :+: (C1 ('MetaCons "LitE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Lit)) :+: C1 ('MetaCons "AppE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp)))) :+: ((C1 ('MetaCons "AppTypeE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :+: C1 ('MetaCons "InfixE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Exp)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Exp))))) :+: (C1 ('MetaCons "UInfixE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp))) :+: C1 ('MetaCons "ParensE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp))))) :+: (((C1 ('MetaCons "LamE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [ArgPat]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp)) :+: C1 ('MetaCons "LamCaseE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Match]))) :+: (C1 ('MetaCons "LamCasesE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Clause])) :+: C1 ('MetaCons "TupE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Maybe Exp])))) :+: ((C1 ('MetaCons "UnboxedTupE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Maybe Exp])) :+: C1 ('MetaCons "UnboxedSumE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SumAlt) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SumArity)))) :+: (C1 ('MetaCons "CondE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp))) :+: (C1 ('MetaCons "MultiIfE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(Guard, Exp)])) :+: C1 ('MetaCons "LetE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Dec]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp))))))) :+: ((((C1 ('MetaCons "CaseE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Match])) :+: C1 ('MetaCons "DoE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe ModName)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Stmt]))) :+: (C1 ('MetaCons "MDoE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe ModName)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Stmt])) :+: C1 ('MetaCons "CompE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Stmt])))) :+: ((C1 ('MetaCons "ArithSeqE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Range)) :+: C1 ('MetaCons "ListE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Exp]))) :+: (C1 ('MetaCons "SigE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :+: (C1 ('MetaCons "RecConE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [FieldExp])) :+: C1 ('MetaCons "RecUpdE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [FieldExp])))))) :+: (((C1 ('MetaCons "StaticE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp)) :+: C1 ('MetaCons "UnboundVarE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name))) :+: (C1 ('MetaCons "LabelE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)) :+: C1 ('MetaCons "ImplicitParamVarE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)))) :+: ((C1 ('MetaCons "GetFieldE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)) :+: C1 ('MetaCons "ProjectionE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (NonEmpty String)))) :+: (C1 ('MetaCons "TypedBracketE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp)) :+: (C1 ('MetaCons "TypedSpliceE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp)) :+: C1 ('MetaCons "TypeE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)))))))) | |||||
Instances
| 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 :: forall r r'. (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 # | |||||
| Generic Match Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show Match Source # | |||||
| Eq Match Source # | |||||
| Ord Match Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
| Ppr Match Source # | |||||
| type Rep Match Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep Match = D1 ('MetaData "Match" "Language.Haskell.TH.Syntax" "template-haskell" '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])))) | |||||
Constructors
| GuardedB [(Guard, Exp)] | f p { | e1 = e2
| e3 = e4 }
where ds |
| NormalB Exp | f p { = e } where ds |
Instances
| 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 :: forall r r'. (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 # | |||||
| Generic Body Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show Body Source # | |||||
| Eq Body Source # | |||||
| Ord Body Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
| type Rep Body Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep Body = D1 ('MetaData "Body" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "GuardedB" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(Guard, Exp)])) :+: C1 ('MetaCons "NormalB" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp))) | |||||
Instances
| 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 :: forall r r'. (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 # | |||||
| Generic Guard Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show Guard Source # | |||||
| Eq Guard Source # | |||||
| Ord Guard Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
| type Rep Guard Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep Guard = D1 ('MetaData "Guard" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "NormalG" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp)) :+: C1 ('MetaCons "PatG" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Stmt]))) | |||||
Constructors
| BindS Pat Exp | p <- e |
| LetS [Dec] | { let { x=e1; y=e2 } } |
| NoBindS Exp | e |
| ParS [[Stmt]] |
|
| RecS [Stmt] | rec { s1; s2 } |
Instances
| Data Stmt 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) -> Stmt -> c Stmt # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Stmt # dataTypeOf :: Stmt -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Stmt) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stmt) # gmapT :: (forall b. Data b => b -> b) -> Stmt -> Stmt # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r # gmapQ :: (forall d. Data d => d -> u) -> Stmt -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Stmt -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Stmt -> m Stmt # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Stmt -> m Stmt # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Stmt -> m Stmt # | |||||
| Generic Stmt Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show Stmt Source # | |||||
| Eq Stmt Source # | |||||
| Ord Stmt Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
| Ppr Stmt Source # | |||||
| type Rep Stmt Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep Stmt = D1 ('MetaData "Stmt" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((C1 ('MetaCons "BindS" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp)) :+: C1 ('MetaCons "LetS" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Dec]))) :+: (C1 ('MetaCons "NoBindS" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp)) :+: (C1 ('MetaCons "ParS" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [[Stmt]])) :+: C1 ('MetaCons "RecS" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Stmt]))))) | |||||
Instances
| Data Range 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) -> Range -> c Range # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Range # dataTypeOf :: Range -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Range) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Range) # gmapT :: (forall b. Data b => b -> b) -> Range -> Range # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r # gmapQ :: (forall d. Data d => d -> u) -> Range -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Range -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Range -> m Range # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Range -> m Range # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Range -> m Range # | |||||
| Generic Range Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show Range Source # | |||||
| Eq Range Source # | |||||
| Ord Range Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
| Ppr Range Source # | |||||
| type Rep Range Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep Range = D1 ('MetaData "Range" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((C1 ('MetaCons "FromR" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp)) :+: C1 ('MetaCons "FromThenR" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp))) :+: (C1 ('MetaCons "FromToR" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp)) :+: C1 ('MetaCons "FromThenToR" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp))))) | |||||
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 Lit 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) -> Lit -> c Lit # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Lit # dataTypeOf :: Lit -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Lit) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lit) # gmapT :: (forall b. Data b => b -> b) -> Lit -> Lit # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r # gmapQ :: (forall d. Data d => d -> u) -> Lit -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Lit -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Lit -> m Lit # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Lit -> m Lit # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Lit -> m Lit # | |||||
| Generic Lit Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show Lit Source # | |||||
| Eq Lit Source # | |||||
| Ord Lit Source # | |||||
| Ppr Lit Source # | |||||
| type Rep Lit Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep Lit = D1 ('MetaData "Lit" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (((C1 ('MetaCons "CharL" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Char)) :+: C1 ('MetaCons "StringL" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String))) :+: (C1 ('MetaCons "IntegerL" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Integer)) :+: (C1 ('MetaCons "RationalL" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Rational)) :+: C1 ('MetaCons "IntPrimL" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Integer))))) :+: ((C1 ('MetaCons "WordPrimL" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Integer)) :+: (C1 ('MetaCons "FloatPrimL" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Rational)) :+: C1 ('MetaCons "DoublePrimL" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Rational)))) :+: (C1 ('MetaCons "StringPrimL" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Word8])) :+: (C1 ('MetaCons "BytesPrimL" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bytes)) :+: C1 ('MetaCons "CharPrimL" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Char)))))) | |||||
Pattern in Haskell given in {}
Constructors
| LitP Lit | { 5 or 'c' } |
| VarP Name | { x } |
| TupP [Pat] | { (p1,p2) } |
| UnboxedTupP [Pat] | { (# p1,p2 #) } |
| UnboxedSumP Pat SumAlt SumArity | { (#|p|#) } |
| ConP Name [Type] [Pat] | data T1 = C1 t1 t2; {C1 @ty1 p1 p2} = e |
| InfixP Pat Name Pat | foo ({x :+ y}) = e |
| UInfixP Pat Name Pat | foo ({x :+ y}) = e |
| 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 } |
| TypeP Type | { type p } |
Instances
| Data Pat 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) -> Pat -> c Pat # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Pat # dataTypeOf :: Pat -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Pat) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat) # gmapT :: (forall b. Data b => b -> b) -> Pat -> Pat # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r # gmapQ :: (forall d. Data d => d -> u) -> Pat -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Pat -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Pat -> m Pat # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Pat -> m Pat # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Pat -> m Pat # | |||||
| Generic Pat Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show Pat Source # | |||||
| Eq Pat Source # | |||||
| Ord Pat Source # | |||||
| Ppr Pat Source # | |||||
| type Rep Pat Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep Pat = D1 ('MetaData "Pat" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((((C1 ('MetaCons "LitP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Lit)) :+: C1 ('MetaCons "VarP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name))) :+: (C1 ('MetaCons "TupP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Pat])) :+: C1 ('MetaCons "UnboxedTupP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Pat])))) :+: ((C1 ('MetaCons "UnboxedSumP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SumAlt) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SumArity))) :+: C1 ('MetaCons "ConP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Type]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Pat])))) :+: (C1 ('MetaCons "InfixP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat))) :+: (C1 ('MetaCons "UInfixP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat))) :+: C1 ('MetaCons "ParensP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat)))))) :+: (((C1 ('MetaCons "TildeP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat)) :+: C1 ('MetaCons "BangP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat))) :+: (C1 ('MetaCons "AsP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat)) :+: C1 ('MetaCons "WildP" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "RecP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [FieldPat])) :+: C1 ('MetaCons "ListP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Pat]))) :+: (C1 ('MetaCons "SigP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :+: (C1 ('MetaCons "ViewP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat)) :+: C1 ('MetaCons "TypeP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))))))) | |||||
Instances
| Data ArgPat 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) -> ArgPat -> c ArgPat # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ArgPat # toConstr :: ArgPat -> Constr # dataTypeOf :: ArgPat -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ArgPat) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArgPat) # gmapT :: (forall b. Data b => b -> b) -> ArgPat -> ArgPat # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ArgPat -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ArgPat -> r # gmapQ :: (forall d. Data d => d -> u) -> ArgPat -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ArgPat -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ArgPat -> m ArgPat # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ArgPat -> m ArgPat # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ArgPat -> m ArgPat # | |||||
| Generic ArgPat Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show ArgPat Source # | |||||
| Eq ArgPat Source # | |||||
| Ord ArgPat Source # | |||||
| Ppr ArgPat Source # | |||||
| type Rep ArgPat Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep ArgPat = D1 ('MetaData "ArgPat" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "VisAP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat)) :+: C1 ('MetaCons "InvisAP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) | |||||
The flag type parameter is instantiated to one of the following types:
Specificity(examples:ForallC,ForallT)BndrVis(examples:DataD,ClassD, etc.)(), a catch-all type for other forms of binders, includingForallVisT,DataInstD,RuleP, andTyVarSig
Instances
| Functor TyVarBndr Source # | |||||
| Foldable TyVarBndr Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods fold :: Monoid m => TyVarBndr m -> m # foldMap :: Monoid m => (a -> m) -> TyVarBndr a -> m # foldMap' :: Monoid m => (a -> m) -> TyVarBndr a -> m # foldr :: (a -> b -> b) -> b -> TyVarBndr a -> b # foldr' :: (a -> b -> b) -> b -> TyVarBndr a -> b # foldl :: (b -> a -> b) -> b -> TyVarBndr a -> b # foldl' :: (b -> a -> b) -> b -> TyVarBndr a -> b # foldr1 :: (a -> a -> a) -> TyVarBndr a -> a # foldl1 :: (a -> a -> a) -> TyVarBndr a -> a # toList :: TyVarBndr a -> [a] # length :: TyVarBndr a -> Int # elem :: Eq a => a -> TyVarBndr a -> Bool # maximum :: Ord a => TyVarBndr a -> a # minimum :: Ord a => TyVarBndr a -> a # | |||||
| Traversable TyVarBndr Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
| Data flag => Data (TyVarBndr flag) 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) -> TyVarBndr flag -> c (TyVarBndr flag) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyVarBndr flag) # toConstr :: TyVarBndr flag -> Constr # dataTypeOf :: TyVarBndr flag -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyVarBndr flag)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TyVarBndr flag)) # gmapT :: (forall b. Data b => b -> b) -> TyVarBndr flag -> TyVarBndr flag # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyVarBndr flag -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyVarBndr flag -> r # gmapQ :: (forall d. Data d => d -> u) -> TyVarBndr flag -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TyVarBndr flag -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyVarBndr flag -> m (TyVarBndr flag) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyVarBndr flag -> m (TyVarBndr flag) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyVarBndr flag -> m (TyVarBndr flag) # | |||||
| Generic (TyVarBndr flag) Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show flag => Show (TyVarBndr flag) Source # | |||||
| Eq flag => Eq (TyVarBndr flag) Source # | |||||
| Ord flag => Ord (TyVarBndr flag) Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods compare :: TyVarBndr flag -> TyVarBndr flag -> Ordering Source # (<) :: TyVarBndr flag -> TyVarBndr flag -> Bool Source # (<=) :: TyVarBndr flag -> TyVarBndr flag -> Bool Source # (>) :: TyVarBndr flag -> TyVarBndr flag -> Bool Source # (>=) :: TyVarBndr flag -> TyVarBndr flag -> Bool Source # max :: TyVarBndr flag -> TyVarBndr flag -> TyVarBndr flag Source # min :: TyVarBndr flag -> TyVarBndr flag -> TyVarBndr flag Source # | |||||
| PprFlag flag => Ppr (TyVarBndr flag) Source # | |||||
| type Rep (TyVarBndr flag) Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep (TyVarBndr flag) = D1 ('MetaData "TyVarBndr" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "PlainTV" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 flag)) :+: C1 ('MetaCons "KindedTV" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 flag) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Kind)))) | |||||
Instances
| 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 :: forall r r'. (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 # | |||||
| Generic TyLit Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show TyLit Source # | |||||
| Eq TyLit Source # | |||||
| Ord TyLit Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
| Ppr TyLit Source # | |||||
| type Rep TyLit Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep TyLit = D1 ('MetaData "TyLit" "Language.Haskell.TH.Syntax" "template-haskell" '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)) :+: C1 ('MetaCons "CharTyLit" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Char)))) | |||||
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.
Since the advent of ConstraintKinds, constraints are really just types.
Equality constraints use the EqualityT constructor. Constraints may also
be tuples of other constraints.
Role annotations
Constructors
| NominalR | nominal |
| RepresentationalR | representational |
| PhantomR | phantom |
| InferR | _ |
Instances
| 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 :: forall r r'. (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 # | |||||
| Generic Role Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show Role Source # | |||||
| Eq Role Source # | |||||
| Ord Role Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
| Ppr Role Source # | |||||
| type Rep Role Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep Role = D1 ('MetaData "Role" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((C1 ('MetaCons "NominalR" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "RepresentationalR" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "PhantomR" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "InferR" 'PrefixI 'False) (U1 :: Type -> Type))) | |||||
data Specificity Source #
Constructors
| SpecifiedSpec | a |
| InferredSpec | {a} |
Instances
| Data Specificity 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) -> Specificity -> c Specificity # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Specificity # toConstr :: Specificity -> Constr # dataTypeOf :: Specificity -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Specificity) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Specificity) # gmapT :: (forall b. Data b => b -> b) -> Specificity -> Specificity # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Specificity -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Specificity -> r # gmapQ :: (forall d. Data d => d -> u) -> Specificity -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Specificity -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Specificity -> m Specificity # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Specificity -> m Specificity # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Specificity -> m Specificity # | |||||
| Generic Specificity Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show Specificity Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Specificity -> ShowS # show :: Specificity -> String # showList :: [Specificity] -> ShowS # | |||||
| Eq Specificity Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods (==) :: Specificity -> Specificity -> Bool Source # (/=) :: Specificity -> Specificity -> Bool Source # | |||||
| Ord Specificity Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods compare :: Specificity -> Specificity -> Ordering Source # (<) :: Specificity -> Specificity -> Bool Source # (<=) :: Specificity -> Specificity -> Bool Source # (>) :: Specificity -> Specificity -> Bool Source # (>=) :: Specificity -> Specificity -> Bool Source # max :: Specificity -> Specificity -> Specificity Source # min :: Specificity -> Specificity -> Specificity Source # | |||||
| DefaultBndrFlag Specificity Source # | |||||
Defined in Language.Haskell.TH.Lib Methods | |||||
| PprFlag Specificity Source # | |||||
Defined in Language.Haskell.TH.Ppr Methods pprTyVarBndr :: TyVarBndr Specificity -> Doc Source # | |||||
| type Rep Specificity Source # | |||||
Instances
| Data BndrVis 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) -> BndrVis -> c BndrVis # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c BndrVis # toConstr :: BndrVis -> Constr # dataTypeOf :: BndrVis -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c BndrVis) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BndrVis) # gmapT :: (forall b. Data b => b -> b) -> BndrVis -> BndrVis # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BndrVis -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BndrVis -> r # gmapQ :: (forall d. Data d => d -> u) -> BndrVis -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> BndrVis -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> BndrVis -> m BndrVis # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BndrVis -> m BndrVis # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BndrVis -> m BndrVis # | |
| Generic BndrVis Source # | |
Defined in Language.Haskell.TH.Syntax | |
| Show BndrVis Source # | |
| Eq BndrVis Source # | |
| Ord BndrVis Source # | |
Defined in Language.Haskell.TH.Syntax | |
| DefaultBndrFlag BndrVis Source # | |
Defined in Language.Haskell.TH.Lib Methods | |
| PprFlag BndrVis Source # | |
Defined in Language.Haskell.TH.Ppr | |
| type Rep BndrVis Source # | |
data FamilyResultSig Source #
Type family result signature
Instances
| Data FamilyResultSig 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) -> FamilyResultSig -> c FamilyResultSig # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FamilyResultSig # toConstr :: FamilyResultSig -> Constr # dataTypeOf :: FamilyResultSig -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FamilyResultSig) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FamilyResultSig) # gmapT :: (forall b. Data b => b -> b) -> FamilyResultSig -> FamilyResultSig # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r # gmapQ :: (forall d. Data d => d -> u) -> FamilyResultSig -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FamilyResultSig -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamilyResultSig -> m FamilyResultSig # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyResultSig -> m FamilyResultSig # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyResultSig -> m FamilyResultSig # | |||||
| Generic FamilyResultSig Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
Methods from :: FamilyResultSig -> Rep FamilyResultSig x # to :: Rep FamilyResultSig x -> FamilyResultSig # | |||||
| Show FamilyResultSig Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> FamilyResultSig -> ShowS # show :: FamilyResultSig -> String # showList :: [FamilyResultSig] -> ShowS # | |||||
| Eq FamilyResultSig Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods (==) :: FamilyResultSig -> FamilyResultSig -> Bool Source # (/=) :: FamilyResultSig -> FamilyResultSig -> Bool Source # | |||||
| Ord FamilyResultSig Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods compare :: FamilyResultSig -> FamilyResultSig -> Ordering Source # (<) :: FamilyResultSig -> FamilyResultSig -> Bool Source # (<=) :: FamilyResultSig -> FamilyResultSig -> Bool Source # (>) :: FamilyResultSig -> FamilyResultSig -> Bool Source # (>=) :: FamilyResultSig -> FamilyResultSig -> Bool Source # max :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig Source # min :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig Source # | |||||
| Ppr FamilyResultSig Source # | |||||
Defined in Language.Haskell.TH.Ppr | |||||
| type Rep FamilyResultSig Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep FamilyResultSig = D1 ('MetaData "FamilyResultSig" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "NoSig" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "KindSig" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Kind)) :+: C1 ('MetaCons "TyVarSig" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (TyVarBndr ()))))) | |||||
data InjectivityAnn Source #
Injectivity annotation
Constructors
| InjectivityAnn Name [Name] |
Instances
| Data InjectivityAnn 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) -> InjectivityAnn -> c InjectivityAnn # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c InjectivityAnn # toConstr :: InjectivityAnn -> Constr # dataTypeOf :: InjectivityAnn -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c InjectivityAnn) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InjectivityAnn) # gmapT :: (forall b. Data b => b -> b) -> InjectivityAnn -> InjectivityAnn # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r # gmapQ :: (forall d. Data d => d -> u) -> InjectivityAnn -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> InjectivityAnn -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> InjectivityAnn -> m InjectivityAnn # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityAnn -> m InjectivityAnn # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityAnn -> m InjectivityAnn # | |||||
| Generic InjectivityAnn Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
Methods from :: InjectivityAnn -> Rep InjectivityAnn x # to :: Rep InjectivityAnn x -> InjectivityAnn # | |||||
| Show InjectivityAnn Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> InjectivityAnn -> ShowS # show :: InjectivityAnn -> String # showList :: [InjectivityAnn] -> ShowS # | |||||
| Eq InjectivityAnn Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods (==) :: InjectivityAnn -> InjectivityAnn -> Bool Source # (/=) :: InjectivityAnn -> InjectivityAnn -> Bool Source # | |||||
| Ord InjectivityAnn Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods compare :: InjectivityAnn -> InjectivityAnn -> Ordering Source # (<) :: InjectivityAnn -> InjectivityAnn -> Bool Source # (<=) :: InjectivityAnn -> InjectivityAnn -> Bool Source # (>) :: InjectivityAnn -> InjectivityAnn -> Bool Source # (>=) :: InjectivityAnn -> InjectivityAnn -> Bool Source # max :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn Source # min :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn Source # | |||||
| Ppr InjectivityAnn Source # | |||||
Defined in Language.Haskell.TH.Ppr | |||||
| type Rep InjectivityAnn Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep InjectivityAnn = D1 ('MetaData "InjectivityAnn" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "InjectivityAnn" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name]))) | |||||
type PatSynType = Type Source #
A pattern synonym's type. Note that a pattern synonym's fully specified type has a peculiar shape coming with two forall quantifiers and two constraint contexts. For example, consider the pattern synonym
pattern P x1 x2 ... xn = <some-pattern>
P's complete type is of the following form
pattern P :: forall universals. required constraints
=> forall existentials. provided constraints
=> t1 -> t2 -> ... -> tn -> 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.
putDoc :: DocLoc -> String -> Q () Source #
Add Haddock documentation to the specified location. This will overwrite
any documentation at the location if it already exists. This will reify the
specified name, so it must be in scope when you call it. If you want to add
documentation to something that you are currently splicing, you can use
addModFinalizer e.g.
do let nm = mkName "x" addModFinalizer $ putDoc (DeclDoc nm) "Hello" [d| $(varP nm) = 42 |]
The helper functions withDecDoc and withDecsDoc will do this for you, as
will the funD_doc and other _doc combinators.
You most likely want to have the -haddock flag turned on when using this.
Adding documentation to anything outside of the current module will cause an
error.
getDoc :: DocLoc -> Q (Maybe String) Source #
Retrieves the Haddock documentation at the specified location, if one
exists.
It can be used to read documentation on things defined outside of the current
module, provided that those modules were compiled with the -haddock flag.
A location at which to attach Haddock documentation.
Note that adding documentation to a Name defined oustide of the current
module will cause an error.
Constructors
| ModuleDoc | At the current module's header. |
| DeclDoc Name | At a declaration, not necessarily top level. |
| ArgDoc Name Int | At a specific argument of a function, indexed by its position. |
| InstDoc Type | At a class or family instance. |
Instances
| Data DocLoc 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) -> DocLoc -> c DocLoc # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DocLoc # toConstr :: DocLoc -> Constr # dataTypeOf :: DocLoc -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DocLoc) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DocLoc) # gmapT :: (forall b. Data b => b -> b) -> DocLoc -> DocLoc # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DocLoc -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DocLoc -> r # gmapQ :: (forall d. Data d => d -> u) -> DocLoc -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DocLoc -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DocLoc -> m DocLoc # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DocLoc -> m DocLoc # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DocLoc -> m DocLoc # | |||||
| Generic DocLoc Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show DocLoc Source # | |||||
| Eq DocLoc Source # | |||||
| Ord DocLoc Source # | |||||
| type Rep DocLoc Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep DocLoc = D1 ('MetaData "DocLoc" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((C1 ('MetaCons "ModuleDoc" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DeclDoc" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name))) :+: (C1 ('MetaCons "ArgDoc" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int)) :+: C1 ('MetaCons "InstDoc" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)))) | |||||
data DerivClause Source #
A single deriving clause at the end of a datatype.
Constructors
| DerivClause (Maybe DerivStrategy) Cxt | { deriving stock (Eq, Ord) } |
Instances
| Data DerivClause 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) -> DerivClause -> c DerivClause # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DerivClause # toConstr :: DerivClause -> Constr # dataTypeOf :: DerivClause -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DerivClause) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DerivClause) # gmapT :: (forall b. Data b => b -> b) -> DerivClause -> DerivClause # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivClause -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivClause -> r # gmapQ :: (forall d. Data d => d -> u) -> DerivClause -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivClause -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause # | |||||
| Generic DerivClause Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show DerivClause Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> DerivClause -> ShowS # show :: DerivClause -> String # showList :: [DerivClause] -> ShowS # | |||||
| Eq DerivClause Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods (==) :: DerivClause -> DerivClause -> Bool Source # (/=) :: DerivClause -> DerivClause -> Bool Source # | |||||
| Ord DerivClause Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods compare :: DerivClause -> DerivClause -> Ordering Source # (<) :: DerivClause -> DerivClause -> Bool Source # (<=) :: DerivClause -> DerivClause -> Bool Source # (>) :: DerivClause -> DerivClause -> Bool Source # (>=) :: DerivClause -> DerivClause -> Bool Source # max :: DerivClause -> DerivClause -> DerivClause Source # min :: DerivClause -> DerivClause -> DerivClause Source # | |||||
| type Rep DerivClause Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep DerivClause = D1 ('MetaData "DerivClause" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "DerivClause" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe DerivStrategy)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Cxt))) | |||||
data DerivStrategy Source #
What the user explicitly requests when deriving an instance.
Constructors
| StockStrategy | A "standard" derived instance |
| AnyclassStrategy | -XDeriveAnyClass |
| NewtypeStrategy | -XGeneralizedNewtypeDeriving |
| ViaStrategy Type | -XDerivingVia |
Instances
| Data DerivStrategy 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) -> DerivStrategy -> c DerivStrategy # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DerivStrategy # toConstr :: DerivStrategy -> Constr # dataTypeOf :: DerivStrategy -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DerivStrategy) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DerivStrategy) # gmapT :: (forall b. Data b => b -> b) -> DerivStrategy -> DerivStrategy # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r # gmapQ :: (forall d. Data d => d -> u) -> DerivStrategy -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivStrategy -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy # | |||||
| Generic DerivStrategy Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show DerivStrategy Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> DerivStrategy -> ShowS # show :: DerivStrategy -> String # showList :: [DerivStrategy] -> ShowS # | |||||
| Eq DerivStrategy Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods (==) :: DerivStrategy -> DerivStrategy -> Bool Source # (/=) :: DerivStrategy -> DerivStrategy -> Bool Source # | |||||
| Ord DerivStrategy Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods compare :: DerivStrategy -> DerivStrategy -> Ordering Source # (<) :: DerivStrategy -> DerivStrategy -> Bool Source # (<=) :: DerivStrategy -> DerivStrategy -> Bool Source # (>) :: DerivStrategy -> DerivStrategy -> Bool Source # (>=) :: DerivStrategy -> DerivStrategy -> Bool Source # max :: DerivStrategy -> DerivStrategy -> DerivStrategy Source # min :: DerivStrategy -> DerivStrategy -> DerivStrategy Source # | |||||
| type Rep DerivStrategy Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep DerivStrategy = D1 ('MetaData "DerivStrategy" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((C1 ('MetaCons "StockStrategy" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "AnyclassStrategy" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "NewtypeStrategy" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ViaStrategy" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)))) | |||||
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
| 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 :: forall r r'. (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 # | |||||
| Generic Overlap Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show Overlap Source # | |||||
| Eq Overlap Source # | |||||
| Ord Overlap Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
| type Rep Overlap Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep Overlap = D1 ('MetaData "Overlap" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((C1 ('MetaCons "Overlappable" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Overlapping" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Overlaps" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Incoherent" 'PrefixI 'False) (U1 :: Type -> Type))) | |||||
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
| Data NameFlavour 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) -> NameFlavour -> c NameFlavour # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NameFlavour # toConstr :: NameFlavour -> Constr # dataTypeOf :: NameFlavour -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NameFlavour) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameFlavour) # gmapT :: (forall b. Data b => b -> b) -> NameFlavour -> NameFlavour # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NameFlavour -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NameFlavour -> r # gmapQ :: (forall d. Data d => d -> u) -> NameFlavour -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NameFlavour -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour # | |||||
| Generic NameFlavour Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show NameFlavour Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> NameFlavour -> ShowS # show :: NameFlavour -> String # showList :: [NameFlavour] -> ShowS # | |||||
| Eq NameFlavour Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods (==) :: NameFlavour -> NameFlavour -> Bool Source # (/=) :: NameFlavour -> NameFlavour -> Bool Source # | |||||
| Ord NameFlavour Source # | |||||
Defined in Language.Haskell.TH.Syntax Methods compare :: NameFlavour -> NameFlavour -> Ordering Source # (<) :: NameFlavour -> NameFlavour -> Bool Source # (<=) :: NameFlavour -> NameFlavour -> Bool Source # (>) :: NameFlavour -> NameFlavour -> Bool Source # (>=) :: NameFlavour -> NameFlavour -> Bool Source # max :: NameFlavour -> NameFlavour -> NameFlavour Source # min :: NameFlavour -> NameFlavour -> NameFlavour Source # | |||||
| type Rep NameFlavour Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep NameFlavour = D1 ('MetaData "NameFlavour" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((C1 ('MetaCons "NameS" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NameQ" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ModName))) :+: (C1 ('MetaCons "NameU" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Uniq)) :+: (C1 ('MetaCons "NameL" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Uniq)) :+: C1 ('MetaCons "NameG" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NameSpace) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 PkgName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ModName)))))) | |||||
dataToQa :: (Quote m, Data a) => (Name -> k) -> (Lit -> m q) -> (k -> [m q] -> m q) -> (forall b. Data b => b -> Maybe (m q)) -> a -> m q Source #
dataToQa is an internal utility function for constructing generic
conversion functions from types with Data instances to various
quasi-quoting representations. See the source of dataToExpQ and
dataToPatQ for two example usages: mkCon, mkLit
and appQ are overloadable to account for different syntax for
expressions and patterns; antiQ allows you to override type-specific
cases, a common usage is just const Nothing, which results in
no overloading.
dataToExpQ :: (Quote m, Data a) => (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp Source #
dataToExpQ converts a value to a Exp representation of the
same value, in the SYB style. It is generalized to take a function
override type-specific cases; see liftData for a more commonly
used variant.
dataToPatQ :: (Quote m, Data a) => (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat Source #
dataToPatQ converts a value to a Pat representation of the same
value, in the SYB style. It takes a function to handle type-specific cases,
alternatively, pass const Nothing to get default behavior.
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
| 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 :: forall r r'. (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 # | |||||
| Generic Bytes Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show Bytes Source # | |||||
| Eq Bytes Source # | |||||
| Ord Bytes Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
| type Rep Bytes Source # | |||||
Defined in Language.Haskell.TH.Syntax type Rep Bytes = D1 ('MetaData "Bytes" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "Bytes" 'PrefixI 'True) (S1 ('MetaSel ('Just "bytesPtr") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (ForeignPtr Word8)) :*: (S1 ('MetaSel ('Just "bytesOffset") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Word) :*: S1 ('MetaSel ('Just "bytesSize") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Word)))) | |||||
class (MonadIO m, MonadFail m) => Quasi (m :: Type -> Type) where Source #
Minimal complete definition
qNewName, qReport, qRecover, qLookupName, qReify, qReifyFixity, qReifyType, qReifyInstances, qReifyRoles, qReifyAnnotations, qReifyModule, qReifyConStrictness, qLocation, qGetPackageRoot, qAddDependentFile, qAddTempFile, qAddTopDecls, qAddForeignFilePath, qAddModFinalizer, qAddCorePlugin, qGetQ, qPutQ, qIsExtEnabled, qExtsEnabled, qPutDoc, qGetDoc
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 #
qGetPackageRoot :: m FilePath Source #
qAddDependentFile :: FilePath -> m () Source #
qAddTempFile :: String -> m FilePath Source #
qAddTopDecls :: [Dec] -> m () Source #
qAddForeignFilePath :: ForeignSrcLang -> String -> m () Source #
qAddModFinalizer :: Q () -> m () Source #
qAddCorePlugin :: String -> m () Source #
qGetQ :: Typeable a => m (Maybe a) Source #
qPutQ :: Typeable a => a -> m () Source #
qIsExtEnabled :: Extension -> m Bool Source #
qExtsEnabled :: m [Extension] Source #
Instances
| Quasi IO Source # | |
Defined in Language.Haskell.TH.Syntax Methods qNewName :: String -> IO Name Source # qReport :: Bool -> String -> IO () Source # qRecover :: IO a -> IO a -> IO a Source # qLookupName :: Bool -> String -> IO (Maybe Name) Source # qReify :: Name -> IO Info Source # qReifyFixity :: Name -> IO (Maybe Fixity) Source # qReifyType :: Name -> IO Type Source # qReifyInstances :: Name -> [Type] -> IO [Dec] Source # qReifyRoles :: Name -> IO [Role] Source # qReifyAnnotations :: Data a => AnnLookup -> IO [a] Source # qReifyModule :: Module -> IO ModuleInfo Source # qReifyConStrictness :: Name -> IO [DecidedStrictness] Source # qRunIO :: IO a -> IO a Source # qGetPackageRoot :: IO FilePath Source # qAddDependentFile :: FilePath -> IO () Source # qAddTempFile :: String -> IO FilePath Source # qAddTopDecls :: [Dec] -> IO () Source # qAddForeignFilePath :: ForeignSrcLang -> String -> IO () Source # qAddModFinalizer :: Q () -> IO () Source # qAddCorePlugin :: String -> IO () Source # qGetQ :: Typeable a => IO (Maybe a) Source # qPutQ :: Typeable a => a -> IO () Source # qIsExtEnabled :: Extension -> IO Bool Source # qExtsEnabled :: IO [Extension] Source # | |
| Quasi Q Source # | |
Defined in Language.Haskell.TH.Syntax Methods qNewName :: String -> Q Name Source # qReport :: Bool -> String -> Q () Source # qRecover :: Q a -> Q a -> Q a Source # qLookupName :: Bool -> String -> Q (Maybe Name) Source # qReify :: Name -> Q Info Source # qReifyFixity :: Name -> Q (Maybe Fixity) Source # qReifyType :: Name -> Q Type Source # qReifyInstances :: Name -> [Type] -> Q [Dec] Source # qReifyRoles :: Name -> Q [Role] Source # qReifyAnnotations :: Data a => AnnLookup -> Q [a] Source # qReifyModule :: Module -> Q ModuleInfo Source # qReifyConStrictness :: Name -> Q [DecidedStrictness] Source # qRunIO :: IO a -> Q a Source # qGetPackageRoot :: Q FilePath Source # qAddDependentFile :: FilePath -> Q () Source # qAddTempFile :: String -> Q FilePath Source # qAddTopDecls :: [Dec] -> Q () Source # qAddForeignFilePath :: ForeignSrcLang -> String -> Q () Source # qAddModFinalizer :: Q () -> Q () Source # qAddCorePlugin :: String -> Q () Source # qGetQ :: Typeable a => Q (Maybe a) Source # qPutQ :: Typeable a => a -> Q () Source # qIsExtEnabled :: Extension -> Q Bool Source # qExtsEnabled :: Q [Extension] Source # | |
unTypeQ :: forall a m. Quote m => m (TExp a) -> m Exp Source #
Discard the type annotation and produce a plain Template Haskell expression
Representation-polymorphic since template-haskell-2.16.0.0.
unsafeTExpCoerce :: forall a m. Quote m => m Exp -> m (TExp a) Source #
Annotate the Template Haskell expression with a type
This is unsafe because GHC cannot check for you that the expression really does have the type you claim it has.
Representation-polymorphic since template-haskell-2.16.0.0.
getPackageRoot :: Q FilePath Source #
Get the package root for the current package which is being compiled. This can be set explicitly with the -package-root flag but is normally just the current working directory.
The motivation for this flag is to provide a principled means to remove the assumption from splices that they will be executed in the directory where the cabal file resides. Projects such as haskell-language-server can't and don't change directory when compiling files but instead set the -package-root flag appropriately.
makeRelativeToProject :: FilePath -> Q FilePath Source #
The input is a filepath, which if relative is offset by the package root.
addDependentFile :: FilePath -> Q () Source #
Record external files that runIO is using (dependent upon). The compiler can then recognize that it should re-compile the Haskell file when an external file changes.
Expects an absolute file path.
Notes:
- ghc -M does not know about these dependencies - it does not execute TH.
- The dependency is based on file content, not a modification time
addTempFile :: String -> Q FilePath Source #
Obtain a temporary file path with the given suffix. The compiler will delete this file after compilation.
addTopDecls :: [Dec] -> Q () Source #
Add additional top-level declarations. The added declarations will be type checked along with the current declaration group.
addForeignFile :: ForeignSrcLang -> String -> Q () Source #
Deprecated: Use addForeignSource instead
addForeignSource :: ForeignSrcLang -> String -> Q () Source #
Emit a foreign file which will be compiled and linked to the object for the current module. Currently only languages that can be compiled with the C compiler are supported, and the flags passed as part of -optc will be also applied to the C compiler invocation that will compile them.
Note that for non-C languages (for example C++) extern C directives
must be used to get symbols that we can access from Haskell.
To get better errors, it is recommended to use #line pragmas when emitting C files, e.g.
{-# LANGUAGE CPP #-}
...
addForeignSource LangC $ unlines
[ "#line " ++ show (844 + 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.
nothingName :: Name Source #
nonemptyName :: Name Source #
Instances
| 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 :: forall r r'. (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 # | |||||
| Generic ModName Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show ModName Source # | |||||
| Eq ModName Source # | |||||
| Ord ModName Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
| type Rep ModName Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
Instances
| 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 :: forall r r'. (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 # | |||||
| Generic PkgName Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show PkgName Source # | |||||
| Eq PkgName Source # | |||||
| Ord PkgName Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
| type Rep PkgName Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
Instances
| 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 :: forall r r'. (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 # | |||||
| Generic OccName Source # | |||||
Defined in Language.Haskell.TH.Syntax Associated Types
| |||||
| Show OccName Source # | |||||
| Eq OccName Source # | |||||
| Ord OccName Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
| type Rep OccName Source # | |||||
Defined in Language.Haskell.TH.Syntax | |||||
mkNameG :: NameSpace -> String -> String -> String -> Name Source #
Used for 'x etc, but not available to the programmer
type StrictType = BangType Source #
As of template-haskell-2.11.0.0, StrictType has been replaced by
BangType.
type VarStrictType = VarBangType Source #
As of template-haskell-2.11.0.0, VarStrictType has been replaced by
VarBangType.
get_cons_names :: Con -> [Name] Source #
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) |
| LangJs | JavaScript |
| RawObject | Object (.o) |
Instances
| Generic ForeignSrcLang | |||||
Defined in GHC.ForeignSrcLang.Type Associated Types
Methods from :: ForeignSrcLang -> Rep ForeignSrcLang x # to :: Rep ForeignSrcLang x -> ForeignSrcLang # | |||||
| Show ForeignSrcLang | |||||
Defined in GHC.ForeignSrcLang.Type Methods showsPrec :: Int -> ForeignSrcLang -> ShowS # show :: ForeignSrcLang -> String # showList :: [ForeignSrcLang] -> ShowS # | |||||
| Eq ForeignSrcLang | |||||
Defined in GHC.ForeignSrcLang.Type Methods (==) :: ForeignSrcLang -> ForeignSrcLang -> Bool Source # (/=) :: ForeignSrcLang -> ForeignSrcLang -> Bool Source # | |||||
| type Rep ForeignSrcLang | |||||
Defined in GHC.ForeignSrcLang.Type type Rep ForeignSrcLang = D1 ('MetaData "ForeignSrcLang" "GHC.ForeignSrcLang.Type" "ghc-boot-th-9.10.0.20240328-8276" 'False) ((C1 ('MetaCons "LangC" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "LangCxx" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "LangObjc" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "LangObjcxx" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "LangAsm" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "LangJs" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "RawObject" 'PrefixI 'False) (U1 :: Type -> Type)))) | |||||
Notes
Unresolved Infix
When implementing antiquotation for quasiquoters, one often wants to parse strings into expressions:
parse :: String -> Maybe Exp
But how should we parse a + b * c? If we don't know the fixities of
+ and *, we don't know whether to parse it as a + (b * c) or (a
+ b) * c.
In cases like this, use UInfixE, UInfixP, UInfixT, or PromotedUInfixT,
which stand for "unresolved infix expressionpatterntype/promoted
constructor", respectively. When the compiler is given a splice containing a
tree of UInfixE applications such as
UInfixE (UInfixE e1 op1 e2) op2 (UInfixE e3 op3 e4)
it will look up and the fixities of the relevant operators and reassociate the tree as necessary.
- trees will not be reassociated across
ParensE,ParensP, orParensT, which are of use for parsing expressions like
(a + b * c) + d * e
InfixE,InfixP,InfixT, andPromotedInfixTexpressions are never reassociated.- The
UInfixEconstructor doesn't support sections. Sections such as(a *)have no ambiguity, soInfixEsuffices. For longer sections such as(a + b * c -), use anInfixEconstructor for the outer-most section, and useUInfixEconstructors for all other operators:
InfixE Just (UInfixE ...a + b * c...) op Nothing
Sections such as (a + b +) and ((a + b) +) should be rendered
into Exps differently:
(+ a + b) ---> InfixE Nothing + (Just $ UInfixE a + b)
-- will result in a fixity error if (+) is left-infix
(+ (a + b)) ---> InfixE Nothing + (Just $ ParensE $ UInfixE a + b)
-- no fixity errors- Quoted expressions such as
[| a * b + c |] :: Q Exp [p| a : b : c |] :: Q Pat [t| T + T |] :: Q Type
will never contain UInfixE, UInfixP, UInfixT, PromotedUInfixT,
InfixT, 'PromotedInfixT, ParensE, ParensP, or ParensT constructors.