| Copyright | (C) 2014 Richard Eisenberg |
|---|---|
| License | BSD-style (see LICENSE) |
| Maintainer | Ryan Scott |
| Stability | experimental |
| Portability | non-portable |
| Safe Haskell | Safe-Inferred |
| Language | Haskell2010 |
Language.Haskell.TH.Desugar
Description
Desugars full Template Haskell syntax into a smaller core syntax for further processing.
Synopsis
- data DExp
- data DLetDec
- data DPat
- data DType
- data DForallTelescope
- type DKind = DType
- type DCxt = [DPred]
- type DPred = DType
- data DTyVarBndr flag
- type DTyVarBndrSpec = DTyVarBndr Specificity
- type DTyVarBndrUnit = DTyVarBndr ()
- data Specificity
- type DTyVarBndrVis = DTyVarBndr BndrVis
- type BndrVis = ()
- pattern BndrReq :: BndrVis
- pattern BndrInvis :: BndrVis
- data DMatch = DMatch DPat DExp
- data DClause = DClause [DPat] DExp
- data DDec
- = DLetDec DLetDec
- | DDataD DataFlavor DCxt Name [DTyVarBndrVis] (Maybe DKind) [DCon] [DDerivClause]
- | DTySynD Name [DTyVarBndrVis] DType
- | DClassD DCxt Name [DTyVarBndrVis] [FunDep] [DDec]
- | DInstanceD (Maybe Overlap) (Maybe [DTyVarBndrUnit]) DCxt DType [DDec]
- | DForeignD DForeign
- | DOpenTypeFamilyD DTypeFamilyHead
- | DClosedTypeFamilyD DTypeFamilyHead [DTySynEqn]
- | DDataFamilyD Name [DTyVarBndrVis] (Maybe DKind)
- | DDataInstD DataFlavor DCxt (Maybe [DTyVarBndrUnit]) DType (Maybe DKind) [DCon] [DDerivClause]
- | DTySynInstD DTySynEqn
- | DRoleAnnotD Name [Role]
- | DStandaloneDerivD (Maybe DDerivStrategy) (Maybe [DTyVarBndrUnit]) DCxt DType
- | DDefaultSigD Name DType
- | DPatSynD Name PatSynArgs DPatSynDir DPat
- | DPatSynSigD Name DPatSynType
- | DKiSigD Name DKind
- | DDefaultD [DType]
- data DDerivClause = DDerivClause (Maybe DDerivStrategy) DCxt
- data DDerivStrategy
- data DPatSynDir
- = DUnidir
- | DImplBidir
- | DExplBidir [DClause]
- type DPatSynType = DType
- data Overlap
- data PatSynArgs
- = PrefixPatSyn [Name]
- | InfixPatSyn Name Name
- | RecordPatSyn [Name]
- data DataFlavor
- data DTypeFamilyHead = DTypeFamilyHead Name [DTyVarBndrVis] DFamilyResultSig (Maybe InjectivityAnn)
- data DFamilyResultSig
- data InjectivityAnn = InjectivityAnn Name [Name]
- data DCon = DCon [DTyVarBndrSpec] DCxt Name DConFields DType
- data DConFields
- type DDeclaredInfix = Bool
- type DBangType = (Bang, DType)
- type DVarBangType = (Name, Bang, DType)
- data Bang = Bang SourceUnpackedness SourceStrictness
- data SourceUnpackedness
- data SourceStrictness
- data DForeign
- data DPragma
- data DRuleBndr
- data DTySynEqn = DTySynEqn (Maybe [DTyVarBndrUnit]) DType DType
- data DInfo
- type DInstanceDec = DDec
- data Role
- data AnnTarget
- class Desugar th ds | ds -> th where
- dsExp :: DsMonad q => Exp -> q DExp
- dsDecs :: DsMonad q => [Dec] -> q [DDec]
- dsType :: DsMonad q => Type -> q DType
- dsInfo :: DsMonad q => Info -> q DInfo
- dsPatOverExp :: DsMonad q => Pat -> DExp -> q (DPat, DExp)
- dsPatsOverExp :: DsMonad q => [Pat] -> DExp -> q ([DPat], DExp)
- dsPatX :: DsMonad q => Pat -> q (DPat, [(Name, DExp)])
- dsLetDecs :: DsMonad q => [Dec] -> q ([DLetDec], DExp -> DExp)
- dsTvb :: DsMonad q => TyVarBndr_ flag -> q (DTyVarBndr flag)
- dsTvbSpec :: DsMonad q => TyVarBndrSpec -> q DTyVarBndrSpec
- dsTvbUnit :: DsMonad q => TyVarBndrUnit -> q DTyVarBndrUnit
- dsTvbVis :: DsMonad q => TyVarBndrVis -> q DTyVarBndrVis
- dsCxt :: DsMonad q => Cxt -> q DCxt
- dsCon :: DsMonad q => [DTyVarBndrVis] -> DType -> Con -> q [DCon]
- dsForeign :: DsMonad q => Foreign -> q DForeign
- dsPragma :: DsMonad q => Pragma -> q DPragma
- dsRuleBndr :: DsMonad q => RuleBndr -> q DRuleBndr
- type PatM q = WriterT [(Name, DExp)] q
- dsPred :: DsMonad q => Pred -> q DCxt
- dsPat :: DsMonad q => Pat -> PatM q DPat
- dsDec :: DsMonad q => Dec -> q [DDec]
- dsDataDec :: DsMonad q => DataFlavor -> Cxt -> Name -> [TyVarBndrVis] -> Maybe Kind -> [Con] -> [DerivingClause] -> q [DDec]
- dsDataInstDec :: DsMonad q => DataFlavor -> Cxt -> Name -> Maybe [TyVarBndrUnit] -> [TypeArg] -> Maybe Kind -> [Con] -> [DerivingClause] -> q [DDec]
- type DerivingClause = DerivClause
- dsDerivClause :: DsMonad q => DerivingClause -> q DDerivClause
- dsLetDec :: DsMonad q => Dec -> q ([DLetDec], DExp -> DExp)
- dsMatches :: DsMonad q => Name -> [Match] -> q [DMatch]
- dsBody :: DsMonad q => Body -> [Dec] -> DExp -> q DExp
- dsGuards :: DsMonad q => [(Guard, Exp)] -> DExp -> q DExp
- dsDoStmts :: forall q. DsMonad q => Maybe ModName -> [Stmt] -> q DExp
- dsComp :: DsMonad q => [Stmt] -> q DExp
- dsClauses :: DsMonad q => MatchContext -> [Clause] -> q [DClause]
- dsBangType :: DsMonad q => BangType -> q DBangType
- dsVarBangType :: DsMonad q => VarBangType -> q DVarBangType
- dsTypeFamilyHead :: DsMonad q => TypeFamilyHead -> q DTypeFamilyHead
- dsFamilyResultSig :: DsMonad q => FamilyResultSig -> q DFamilyResultSig
- dsPatSynDir :: DsMonad q => Name -> PatSynDir -> q DPatSynDir
- dsTypeArg :: DsMonad q => TypeArg -> q DTypeArg
- module Language.Haskell.TH.Desugar.Sweeten
- expand :: (DsMonad q, Data a) => a -> q a
- expandType :: DsMonad q => DType -> q DType
- reifyWithWarning :: (Quasi q, MonadFail q) => Name -> q Info
- withLocalDeclarations :: DsMonad q => [Dec] -> DsM q a -> q a
- dsReify :: DsMonad q => Name -> q (Maybe DInfo)
- dsReifyType :: DsMonad q => Name -> q (Maybe DType)
- reifyWithLocals_maybe :: DsMonad q => Name -> q (Maybe Info)
- reifyWithLocals :: DsMonad q => Name -> q Info
- reifyFixityWithLocals :: DsMonad q => Name -> q (Maybe Fixity)
- reifyTypeWithLocals_maybe :: DsMonad q => Name -> q (Maybe Type)
- reifyTypeWithLocals :: DsMonad q => Name -> q Type
- lookupValueNameWithLocals :: DsMonad q => String -> q (Maybe Name)
- lookupTypeNameWithLocals :: DsMonad q => String -> q (Maybe Name)
- mkDataNameWithLocals :: DsMonad q => String -> q Name
- mkTypeNameWithLocals :: DsMonad q => String -> q Name
- reifyNameSpace :: DsMonad q => Name -> q (Maybe NameSpace)
- class (Quasi m, MonadFail m) => DsMonad m where
- localDeclarations :: m [Dec]
- data DsM q a
- scExp :: DsMonad q => DExp -> q DExp
- scLetDec :: DsMonad q => DLetDec -> q DLetDec
- module Language.Haskell.TH.Desugar.Subst
- fvDType :: DType -> OSet Name
- extractBoundNamesDPat :: DPat -> OSet Name
- applyDExp :: DExp -> [DExp] -> DExp
- dPatToDExp :: DPat -> DExp
- removeWilds :: DsMonad q => DPat -> q DPat
- getDataD :: DsMonad q => String -> Name -> q (DataFlavor, [TyVarBndrVis], [Con])
- dataConNameToDataName :: DsMonad q => Name -> q Name
- dataConNameToCon :: DsMonad q => Name -> q Con
- nameOccursIn :: Data a => Name -> a -> Bool
- allNamesIn :: Data a => a -> [Name]
- flattenDValD :: Quasi q => DLetDec -> q [DLetDec]
- getRecordSelectors :: DsMonad q => [DCon] -> q [DLetDec]
- mkTypeName :: Quasi q => String -> q Name
- mkDataName :: Quasi q => String -> q Name
- newUniqueName :: Quasi q => String -> q Name
- mkTupleDExp :: [DExp] -> DExp
- mkTupleDPat :: [DPat] -> DPat
- maybeDLetE :: [DLetDec] -> DExp -> DExp
- maybeDCaseE :: MatchContext -> DExp -> [DMatch] -> DExp
- mkDLamEFromDPats :: Quasi q => [DPat] -> DExp -> q DExp
- tupleNameDegree_maybe :: Name -> Maybe Int
- unboxedSumNameDegree_maybe :: Name -> Maybe Int
- unboxedTupleNameDegree_maybe :: Name -> Maybe Int
- isTypeKindName :: Name -> Bool
- typeKindName :: Name
- bindIP :: forall name a r. a -> (IP name a => r) -> r
- mkExtraDKindBinders :: forall q. DsMonad q => DKind -> q [DTyVarBndrVis]
- dTyVarBndrToDType :: DTyVarBndr flag -> DType
- changeDTVFlags :: newFlag -> [DTyVarBndr oldFlag] -> [DTyVarBndr newFlag]
- toposortTyVarsOf :: [DType] -> [DTyVarBndrUnit]
- toposortKindVarsOfTvbs :: [DTyVarBndr flag] -> [DTyVarBndrUnit]
- data FunArgs
- data ForallTelescope
- data VisFunArg
- filterVisFunArgs :: FunArgs -> [VisFunArg]
- ravelType :: FunArgs -> Type -> Type
- unravelType :: Type -> (FunArgs, Type)
- data DFunArgs
- data DVisFunArg
- filterDVisFunArgs :: DFunArgs -> [DVisFunArg]
- ravelDType :: DFunArgs -> DType -> DType
- unravelDType :: DType -> (DFunArgs, DType)
- data TypeArg
- applyType :: Type -> [TypeArg] -> Type
- filterTANormals :: [TypeArg] -> [Type]
- tyVarBndrVisToTypeArg :: TyVarBndrVis -> TypeArg
- tyVarBndrVisToTypeArgWithSig :: TyVarBndrVis -> TypeArg
- unfoldType :: Type -> (Type, [TypeArg])
- data DTypeArg
- applyDType :: DType -> [DTypeArg] -> DType
- filterDTANormals :: [DTypeArg] -> [DType]
- dTyVarBndrVisToDTypeArg :: DTyVarBndrVis -> DTypeArg
- dTyVarBndrVisToDTypeArgWithSig :: DTyVarBndrVis -> DTypeArg
- unfoldDType :: DType -> (DType, [DTypeArg])
- extractBoundNamesStmt :: Stmt -> OSet Name
- extractBoundNamesDec :: Dec -> OSet Name
- extractBoundNamesPat :: Pat -> OSet Name
Desugared data types
Corresponds to TH's Exp type. Note that DLamE takes names, not patterns.
Constructors
| DVarE Name | |
| DConE Name | |
| DLitE Lit | |
| DAppE DExp DExp | |
| DAppTypeE DExp DType | |
| DLamE [Name] DExp | |
| DCaseE DExp [DMatch] | |
| DLetE [DLetDec] DExp | |
| DSigE DExp DType | |
| DStaticE DExp | |
| DTypedBracketE DExp | |
| DTypedSpliceE DExp |
Instances
Declarations as used in a let statement.
Constructors
| DFunD Name [DClause] | |
| DValD DPat DExp | |
| DSigD Name DType | |
| DInfixD Fixity Name | |
| DPragmaD DPragma |
Instances
Corresponds to TH's Pat type.
Constructors
| DLitP Lit | |
| DVarP Name | |
| DConP Name [DType] [DPat] | |
| DTildeP DPat | |
| DBangP DPat | |
| DSigP DPat DType | |
| DWildP |
Instances
Corresponds to TH's Type type, used to represent
types and kinds.
Constructors
| DForallT DForallTelescope DType | |
| DConstrainedT DCxt DType | |
| DAppT DType DType | |
| DAppKindT DType DKind | |
| DSigT DType DKind | |
| DVarT Name | |
| DConT Name | |
| DArrowT | |
| DLitT TyLit | |
| DWildCardT |
Instances
data DForallTelescope Source #
The type variable binders in a forall.
Constructors
| DForallVis [DTyVarBndrUnit] | A visible |
| DForallInvis [DTyVarBndrSpec] | An invisible |
Instances
data DTyVarBndr flag Source #
Corresponds to TH's TyVarBndr
Instances
| Functor DTyVarBndr Source # | |
Defined in Language.Haskell.TH.Desugar.AST Methods fmap :: (a -> b) -> DTyVarBndr a -> DTyVarBndr b # (<$) :: a -> DTyVarBndr b -> DTyVarBndr a # | |
| Data flag => Data (DTyVarBndr flag) Source # | |
Defined in Language.Haskell.TH.Desugar.AST Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DTyVarBndr flag -> c (DTyVarBndr flag) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DTyVarBndr flag) # toConstr :: DTyVarBndr flag -> Constr # dataTypeOf :: DTyVarBndr flag -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DTyVarBndr flag)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DTyVarBndr flag)) # gmapT :: (forall b. Data b => b -> b) -> DTyVarBndr flag -> DTyVarBndr flag # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DTyVarBndr flag -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DTyVarBndr flag -> r # gmapQ :: (forall d. Data d => d -> u) -> DTyVarBndr flag -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DTyVarBndr flag -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DTyVarBndr flag -> m (DTyVarBndr flag) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DTyVarBndr flag -> m (DTyVarBndr flag) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DTyVarBndr flag -> m (DTyVarBndr flag) # | |
| Generic (DTyVarBndr flag) Source # | |
Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep (DTyVarBndr flag) :: Type -> Type # Methods from :: DTyVarBndr flag -> Rep (DTyVarBndr flag) x # to :: Rep (DTyVarBndr flag) x -> DTyVarBndr flag # | |
| Show flag => Show (DTyVarBndr flag) Source # | |
Defined in Language.Haskell.TH.Desugar.AST Methods showsPrec :: Int -> DTyVarBndr flag -> ShowS # show :: DTyVarBndr flag -> String # showList :: [DTyVarBndr flag] -> ShowS # | |
| Eq flag => Eq (DTyVarBndr flag) Source # | |
Defined in Language.Haskell.TH.Desugar.AST Methods (==) :: DTyVarBndr flag -> DTyVarBndr flag -> Bool # (/=) :: DTyVarBndr flag -> DTyVarBndr flag -> Bool # | |
| Lift flag => Lift (DTyVarBndr flag :: Type) Source # | |
Defined in Language.Haskell.TH.Desugar.AST Methods lift :: Quote m => DTyVarBndr flag -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => DTyVarBndr flag -> Code m (DTyVarBndr flag) # | |
| Desugar (TyVarBndr flag) (DTyVarBndr flag) Source # | This instance is only instance |
Defined in Language.Haskell.TH.Desugar | |
| type Rep (DTyVarBndr flag) Source # | |
Defined in Language.Haskell.TH.Desugar.AST type Rep (DTyVarBndr flag) = D1 ('MetaData "DTyVarBndr" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.16-CQDZE9IhmYTBDpt9fLaD0r" 'False) (C1 ('MetaCons "DPlainTV" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 flag)) :+: C1 ('MetaCons "DKindedTV" '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 DKind)))) | |
type DTyVarBndrSpec = DTyVarBndr Specificity Source #
Corresponds to TH's TyVarBndrSpec
type DTyVarBndrUnit = DTyVarBndr () Source #
Corresponds to TH's TyVarBndrUnit
data Specificity #
Constructors
| SpecifiedSpec | a |
| InferredSpec | {a} |
Instances
type DTyVarBndrVis = DTyVarBndr BndrVis Source #
Corresponds to TH's TyVarBndrVis
pattern BndrInvis :: BndrVis #
Because pre-9.8 GHCs do not support invisible binders in type-level declarations, this compatibility shim is defined in a somewhat unusual way:
- As a pattern,
BndrInviswill never match on pre-9.8 GHCs. That way, if you write pattern matches like this:
case flag of
BndrInvis -> ...
BndrVis -> ...
Then the first branch will never be taken on pre-9.8 GHCs.
BndrInvisis a unidirectional pattern synonym on pre-9.8 GHCs, so it cannot be used as an expression on these GHC versions. This is done in an effort to avoid pitfalls that could occur ifBndrInviswere defined like so:
pattern BndrInvis = ()
If this were the definition, then a user could write code involving
BndrInvis that would construct an invisible type-level binder on GHC 9.8
or later, but a visible type-level binder on older GHCs! This would be
disastrous, so we prevent the user from doing such a thing.
Corresponds to TH's Match type.
Instances
| Data DMatch Source # | |
Defined in Language.Haskell.TH.Desugar.AST Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DMatch -> c DMatch # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DMatch # toConstr :: DMatch -> Constr # dataTypeOf :: DMatch -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DMatch) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DMatch) # gmapT :: (forall b. Data b => b -> b) -> DMatch -> DMatch # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DMatch -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DMatch -> r # gmapQ :: (forall d. Data d => d -> u) -> DMatch -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DMatch -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DMatch -> m DMatch # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DMatch -> m DMatch # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DMatch -> m DMatch # | |
| Generic DMatch Source # | |
| Show DMatch Source # | |
| Eq DMatch Source # | |
| Lift DMatch Source # | |
| type Rep DMatch Source # | |
Defined in Language.Haskell.TH.Desugar.AST type Rep DMatch = D1 ('MetaData "DMatch" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.16-CQDZE9IhmYTBDpt9fLaD0r" 'False) (C1 ('MetaCons "DMatch" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DPat) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DExp))) | |
Corresponds to TH's Clause type.
Instances
| Data DClause Source # | |
Defined in Language.Haskell.TH.Desugar.AST Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DClause -> c DClause # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DClause # toConstr :: DClause -> Constr # dataTypeOf :: DClause -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DClause) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DClause) # gmapT :: (forall b. Data b => b -> b) -> DClause -> DClause # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DClause -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DClause -> r # gmapQ :: (forall d. Data d => d -> u) -> DClause -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DClause -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DClause -> m DClause # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DClause -> m DClause # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DClause -> m DClause # | |
| Generic DClause Source # | |
| Show DClause Source # | |
| Eq DClause Source # | |
| Lift DClause Source # | |
| type Rep DClause Source # | |
Defined in Language.Haskell.TH.Desugar.AST type Rep DClause = D1 ('MetaData "DClause" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.16-CQDZE9IhmYTBDpt9fLaD0r" 'False) (C1 ('MetaCons "DClause" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DPat]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DExp))) | |
Corresponds to TH's Dec type.
Constructors
| DLetDec DLetDec | |
| DDataD DataFlavor DCxt Name [DTyVarBndrVis] (Maybe DKind) [DCon] [DDerivClause] | An ordinary (i.e., non-data family) data type declaration. Note
that desugaring upholds the following properties regarding the
|
| DTySynD Name [DTyVarBndrVis] DType | |
| DClassD DCxt Name [DTyVarBndrVis] [FunDep] [DDec] | |
| DInstanceD (Maybe Overlap) (Maybe [DTyVarBndrUnit]) DCxt DType [DDec] | Note that the |
| DForeignD DForeign | |
| DOpenTypeFamilyD DTypeFamilyHead | |
| DClosedTypeFamilyD DTypeFamilyHead [DTySynEqn] | |
| DDataFamilyD Name [DTyVarBndrVis] (Maybe DKind) | |
| DDataInstD DataFlavor DCxt (Maybe [DTyVarBndrUnit]) DType (Maybe DKind) [DCon] [DDerivClause] | A data family instance declaration. Note that desugaring
upholds the following properties regarding the
|
| DTySynInstD DTySynEqn | |
| DRoleAnnotD Name [Role] | |
| DStandaloneDerivD (Maybe DDerivStrategy) (Maybe [DTyVarBndrUnit]) DCxt DType | Note that the |
| DDefaultSigD Name DType | |
| DPatSynD Name PatSynArgs DPatSynDir DPat | |
| DPatSynSigD Name DPatSynType | |
| DKiSigD Name DKind | |
| DDefaultD [DType] |
Instances
data DDerivClause Source #
Corresponds to TH's DerivClause type.
Constructors
| DDerivClause (Maybe DDerivStrategy) DCxt |
Instances
data DDerivStrategy Source #
Corresponds to TH's DerivStrategy type.
Constructors
| DStockStrategy | A "standard" derived instance |
| DAnyclassStrategy | -XDeriveAnyClass |
| DNewtypeStrategy | -XGeneralizedNewtypeDeriving |
| DViaStrategy DType | -XDerivingVia |
Instances
data DPatSynDir Source #
Corresponds to TH's PatSynDir type
Constructors
| DUnidir | pattern P x {<-} p |
| DImplBidir | pattern P x {=} p |
| DExplBidir [DClause] | pattern P x {<-} p where P x = e |
Instances
| Data DPatSynDir Source # | |
Defined in Language.Haskell.TH.Desugar.AST Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DPatSynDir -> c DPatSynDir # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DPatSynDir # toConstr :: DPatSynDir -> Constr # dataTypeOf :: DPatSynDir -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DPatSynDir) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DPatSynDir) # gmapT :: (forall b. Data b => b -> b) -> DPatSynDir -> DPatSynDir # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DPatSynDir -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DPatSynDir -> r # gmapQ :: (forall d. Data d => d -> u) -> DPatSynDir -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DPatSynDir -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DPatSynDir -> m DPatSynDir # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DPatSynDir -> m DPatSynDir # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DPatSynDir -> m DPatSynDir # | |
| Generic DPatSynDir Source # | |
Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DPatSynDir :: Type -> Type # | |
| Show DPatSynDir Source # | |
Defined in Language.Haskell.TH.Desugar.AST Methods showsPrec :: Int -> DPatSynDir -> ShowS # show :: DPatSynDir -> String # showList :: [DPatSynDir] -> ShowS # | |
| Eq DPatSynDir Source # | |
Defined in Language.Haskell.TH.Desugar.AST | |
| Lift DPatSynDir Source # | |
Defined in Language.Haskell.TH.Desugar.AST Methods lift :: Quote m => DPatSynDir -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => DPatSynDir -> Code m DPatSynDir # | |
| type Rep DPatSynDir Source # | |
Defined in Language.Haskell.TH.Desugar.AST type Rep DPatSynDir = D1 ('MetaData "DPatSynDir" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.16-CQDZE9IhmYTBDpt9fLaD0r" 'False) (C1 ('MetaCons "DUnidir" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "DImplBidir" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DExplBidir" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DClause])))) | |
type DPatSynType = DType Source #
Corresponds to TH's PatSynType 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 | |
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 | |
| Show Overlap | |
| Eq Overlap | |
| Ord Overlap | |
Defined in Language.Haskell.TH.Syntax | |
| type Rep Overlap | |
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 PatSynArgs #
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 DataFlavor Source #
Is a data type or data instance declaration a newtype declaration, a
data declaration, or a type data declaration?
Instances
| Data DataFlavor Source # | |
Defined in Language.Haskell.TH.Desugar.Util Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataFlavor -> c DataFlavor # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DataFlavor # toConstr :: DataFlavor -> Constr # dataTypeOf :: DataFlavor -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DataFlavor) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataFlavor) # gmapT :: (forall b. Data b => b -> b) -> DataFlavor -> DataFlavor # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataFlavor -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DataFlavor -> r # gmapQ :: (forall d. Data d => d -> u) -> DataFlavor -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DataFlavor -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DataFlavor -> m DataFlavor # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DataFlavor -> m DataFlavor # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DataFlavor -> m DataFlavor # | |
| Generic DataFlavor Source # | |
Defined in Language.Haskell.TH.Desugar.Util Associated Types type Rep DataFlavor :: Type -> Type # | |
| Show DataFlavor Source # | |
Defined in Language.Haskell.TH.Desugar.Util Methods showsPrec :: Int -> DataFlavor -> ShowS # show :: DataFlavor -> String # showList :: [DataFlavor] -> ShowS # | |
| Eq DataFlavor Source # | |
Defined in Language.Haskell.TH.Desugar.Util | |
| Lift DataFlavor Source # | |
Defined in Language.Haskell.TH.Desugar.Util Methods lift :: Quote m => DataFlavor -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => DataFlavor -> Code m DataFlavor # | |
| type Rep DataFlavor Source # | |
Defined in Language.Haskell.TH.Desugar.Util type Rep DataFlavor = D1 ('MetaData "DataFlavor" "Language.Haskell.TH.Desugar.Util" "th-desugar-1.16-CQDZE9IhmYTBDpt9fLaD0r" 'False) (C1 ('MetaCons "Newtype" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Data" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TypeData" 'PrefixI 'False) (U1 :: Type -> Type))) | |
data DTypeFamilyHead Source #
Corresponds to TH's TypeFamilyHead type
Constructors
| DTypeFamilyHead Name [DTyVarBndrVis] DFamilyResultSig (Maybe InjectivityAnn) |
Instances
data DFamilyResultSig Source #
Corresponds to TH's FamilyResultSig type
Constructors
| DNoSig | |
| DKindSig DKind | |
| DTyVarSig DTyVarBndrUnit |
Instances
data InjectivityAnn #
Injectivity annotation
Constructors
| InjectivityAnn Name [Name] |
Instances
Corresponds to TH's Con type. Unlike Con, all DCons reflect GADT
syntax. This is beneficial for th-desugar's since it means
that all data type declarations can support explicit return kinds, so
one does not need to represent them with something like Maybe DKindDCon and Con to keep in mind:
- Unlike
ForallC, where the meaning of theTyVarBndrs changes depending on whether it's followed byGadtC/RecGadtCor not, the meaning of theDTyVarBndrs in aDConis always the same: it is the list of universally and existentially quantified type variables. Note that it is not guaranteed that one set of type variables will appear before the other. - A
DConalways has an explicit return type.
Constructors
| DCon [DTyVarBndrSpec] DCxt Name DConFields DType | The GADT result type |
Instances
| Data DCon Source # | |
Defined in Language.Haskell.TH.Desugar.AST Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DCon -> c DCon # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DCon # dataTypeOf :: DCon -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DCon) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DCon) # gmapT :: (forall b. Data b => b -> b) -> DCon -> DCon # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DCon -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DCon -> r # gmapQ :: (forall d. Data d => d -> u) -> DCon -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DCon -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DCon -> m DCon # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DCon -> m DCon # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DCon -> m DCon # | |
| Generic DCon Source # | |
| Show DCon Source # | |
| Eq DCon Source # | |
| Lift DCon Source # | |
| type Rep DCon Source # | |
Defined in Language.Haskell.TH.Desugar.AST type Rep DCon = D1 ('MetaData "DCon" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.16-CQDZE9IhmYTBDpt9fLaD0r" 'False) (C1 ('MetaCons "DCon" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DTyVarBndrSpec]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DCxt)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DConFields) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DType))))) | |
data DConFields Source #
A list of fields either for a standard data constructor or a record data constructor.
Constructors
| DNormalC DDeclaredInfix [DBangType] | |
| DRecC [DVarBangType] |
Instances
type DDeclaredInfix = Bool Source #
True if a constructor is declared infix. For normal ADTs, this means
that is was written in infix style. For example, both of the constructors
below are declared infix.
data Infix = Int Fixity Int | Int :*: Int
Whereas neither of these constructors are declared infix:
data Prefix = Prefix Int Int | (:+:) Int Int
For GADTs, detecting whether a constructor is declared infix is a bit trickier, as one cannot write a GADT constructor "infix-style" like one can for normal ADT constructors. GHC considers a GADT constructor to be declared infix if it meets the following three criteria:
- Its name uses operator syntax (e.g.,
(:*:)). - It has exactly two fields (without record syntax).
- It has a programmer-specified fixity declaration.
For example, in the following GADT:
infixl 5 :**:, :&&:, :^^:, ActuallyPrefix
data InfixGADT a where
(:**:) :: Int -> b -> InfixGADT (Maybe b) -- Only this one is infix
ActuallyPrefix :: Char -> Bool -> InfixGADT Double
(:&&:) :: { infixGADT1 :: b, infixGADT2 :: Int } -> InfixGADT b :: Int -> Int -> Int -> InfixGADT Int
(:!!:) :: Char -> Char -> InfixGADT Char
Only the (:**:) constructor is declared infix. The other constructors
are not declared infix, because:
ActuallyPrefixdoes not use operator syntax (criterion 1).(:&&:)uses record syntax (criterion 2).(:^^:)does not have exactly two fields (criterion 2).(:!!:)does not have a programmer-specified fixity declaration (criterion 3).
Constructors
| Bang SourceUnpackedness SourceStrictness | C { {-# UNPACK #-} !}a |
Instances
| Data Bang | |
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 | |
| Show Bang | |
| Eq Bang | |
| Ord Bang | |
| Ppr Bang | |
| type Rep Bang | |
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))) | |
data SourceUnpackedness #
Constructors
| NoSourceUnpackedness | C a |
| SourceNoUnpack | C { {-# NOUNPACK #-} } a |
| SourceUnpack | C { {-# UNPACK #-} } a |
Instances
data SourceStrictness #
Constructors
| NoSourceStrictness | C a |
| SourceLazy | C {~}a |
| SourceStrict | C {!}a |
Instances
Corresponds to TH's Foreign type.
Instances
Corresponds to TH's Pragma type.
Constructors
Instances
Corresponds to TH's RuleBndr type.
Constructors
| DRuleVar Name | |
| DTypedRuleVar Name DType |
Instances
| Data DRuleBndr Source # | |
Defined in Language.Haskell.TH.Desugar.AST Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DRuleBndr -> c DRuleBndr # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DRuleBndr # toConstr :: DRuleBndr -> Constr # dataTypeOf :: DRuleBndr -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DRuleBndr) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DRuleBndr) # gmapT :: (forall b. Data b => b -> b) -> DRuleBndr -> DRuleBndr # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DRuleBndr -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DRuleBndr -> r # gmapQ :: (forall d. Data d => d -> u) -> DRuleBndr -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DRuleBndr -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DRuleBndr -> m DRuleBndr # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DRuleBndr -> m DRuleBndr # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DRuleBndr -> m DRuleBndr # | |
| Generic DRuleBndr Source # | |
| Show DRuleBndr Source # | |
| Eq DRuleBndr Source # | |
| Lift DRuleBndr Source # | |
| type Rep DRuleBndr Source # | |
Defined in Language.Haskell.TH.Desugar.AST type Rep DRuleBndr = D1 ('MetaData "DRuleBndr" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.16-CQDZE9IhmYTBDpt9fLaD0r" 'False) (C1 ('MetaCons "DRuleVar" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)) :+: C1 ('MetaCons "DTypedRuleVar" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DType))) | |
Corresponds to TH's TySynEqn type (to store type family equations).
Constructors
| DTySynEqn (Maybe [DTyVarBndrUnit]) DType DType |
Instances
| Data DTySynEqn Source # | |
Defined in Language.Haskell.TH.Desugar.AST Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DTySynEqn -> c DTySynEqn # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DTySynEqn # toConstr :: DTySynEqn -> Constr # dataTypeOf :: DTySynEqn -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DTySynEqn) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DTySynEqn) # gmapT :: (forall b. Data b => b -> b) -> DTySynEqn -> DTySynEqn # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DTySynEqn -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DTySynEqn -> r # gmapQ :: (forall d. Data d => d -> u) -> DTySynEqn -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DTySynEqn -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DTySynEqn -> m DTySynEqn # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DTySynEqn -> m DTySynEqn # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DTySynEqn -> m DTySynEqn # | |
| Generic DTySynEqn Source # | |
| Show DTySynEqn Source # | |
| Eq DTySynEqn Source # | |
| Lift DTySynEqn Source # | |
| type Rep DTySynEqn Source # | |
Defined in Language.Haskell.TH.Desugar.AST type Rep DTySynEqn = D1 ('MetaData "DTySynEqn" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.16-CQDZE9IhmYTBDpt9fLaD0r" 'False) (C1 ('MetaCons "DTySynEqn" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe [DTyVarBndrUnit])) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DType) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DType)))) | |
Corresponds to TH's Info type.
Constructors
| DTyConI DDec (Maybe [DInstanceDec]) | |
| DVarI Name DType (Maybe Name) | The |
| DTyVarI Name DKind | |
| DPrimTyConI Name Int Bool | The |
| DPatSynI Name DPatSynType |
Instances
type DInstanceDec Source #
Arguments
| = DDec | Guaranteed to be an instance declaration |
Role annotations
Constructors
| NominalR | nominal |
| RepresentationalR | representational |
| PhantomR | phantom |
| InferR | _ |
Instances
| Data Role | |
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 | |
| Show Role | |
| Eq Role | |
| Ord Role | |
| Ppr Role | |
| type Rep Role | |
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))) | |
Constructors
| ModuleAnnotation | |
| TypeAnnotation Name | |
| ValueAnnotation Name |
Instances
| Data AnnTarget | |
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 | |
| Show AnnTarget | |
| Eq AnnTarget | |
| Ord AnnTarget | |
| type Rep AnnTarget | |
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)))) | |
The Desugar class
class Desugar th ds | ds -> th where Source #
This class relates a TH type with its th-desugar type and allows conversions back and forth. The functional dependency goes only one way because we define the following instances on old versions of GHC:
instanceDesugarTyVarBndrSpecDTyVarBndrSpecinstanceDesugarTyVarBndrUnitDTyVarBndrUnit
Prior to GHC 9.0, TyVarBndrSpec and TyVarBndrUnit are simply type
synonyms for TyVarBndr, so making the functional dependencies
bidirectional would cause these instances to be rejected.
Instances
| Desugar Cxt DCxt Source # | |
| Desugar Exp DExp Source # | |
| Desugar Type DType Source # | |
| Desugar TypeArg DTypeArg Source # | |
| Desugar (TyVarBndr flag) (DTyVarBndr flag) Source # | This instance is only instance |
Defined in Language.Haskell.TH.Desugar | |
| Desugar [Dec] [DDec] Source # | |
Main desugaring functions
dsPatOverExp :: DsMonad q => Pat -> DExp -> q (DPat, DExp) Source #
Desugar a pattern, along with processing a (desugared) expression that is the entire scope of the variables bound in the pattern.
dsPatsOverExp :: DsMonad q => [Pat] -> DExp -> q ([DPat], DExp) Source #
Desugar multiple patterns. Like dsPatOverExp.
dsPatX :: DsMonad q => Pat -> q (DPat, [(Name, DExp)]) Source #
Desugar a pattern, returning a list of (Name, DExp) pairs of extra variables that must be bound within the scope of the pattern
dsLetDecs :: DsMonad q => [Dec] -> q ([DLetDec], DExp -> DExp) Source #
Desugar Decs that can appear in a let expression. See the
documentation for dsLetDec for an explanation of what the return type
represents.
dsTvb :: DsMonad q => TyVarBndr_ flag -> q (DTyVarBndr flag) Source #
Desugar a TyVarBndr.
dsTvbSpec :: DsMonad q => TyVarBndrSpec -> q DTyVarBndrSpec Source #
Desugar a TyVarBndrSpec.
dsTvbUnit :: DsMonad q => TyVarBndrUnit -> q DTyVarBndrUnit Source #
Desugar a TyVarBndrUnit.
dsTvbVis :: DsMonad q => TyVarBndrVis -> q DTyVarBndrVis Source #
Desugar a TyVarBndrVis.
Arguments
| :: DsMonad q | |
| => [DTyVarBndrVis] | The universally quantified type variables (used if desugaring a non-GADT constructor). |
| -> DType | The original data declaration's type (used if desugaring a non-GADT constructor). |
| -> Con | |
| -> q [DCon] |
Desugar a single Con.
Because we always desugar Cons to GADT syntax (see the documentation for
DCon), it is not always possible to desugar with just a Con alone.
For instance, we must desugar:
data Foo a = forall b. MkFoo b
To this:
data Foo a :: Type where MkFoo :: forall a b. b -> Foo a
If our only argument was forall b. MkFoo b, it would be somewhat awkward
to figure out (1) what the set of universally quantified type variables
([a]) was, and (2) what the return type (Foo a) was. For this reason,
we require passing these as arguments. (If we desugar an actual GADT
constructor, these arguments are ignored.)
Secondary desugaring functions
type PatM q = WriterT [(Name, DExp)] q Source #
Desugaring a pattern also returns the list of variables bound in as-patterns and the values they should be bound to. This variables must be brought into scope in the "body" of the pattern.
dsDec :: DsMonad q => Dec -> q [DDec] Source #
Desugar a single Dec, perhaps producing multiple DDecs
dsDataDec :: DsMonad q => DataFlavor -> Cxt -> Name -> [TyVarBndrVis] -> Maybe Kind -> [Con] -> [DerivingClause] -> q [DDec] Source #
dsDataInstDec :: DsMonad q => DataFlavor -> Cxt -> Name -> Maybe [TyVarBndrUnit] -> [TypeArg] -> Maybe Kind -> [Con] -> [DerivingClause] -> q [DDec] Source #
Desugar a DataInstD or a NewtypeInstD.
type DerivingClause = DerivClause Source #
A backwards-compatible type synonym for the thing representing a single
derived class in a deriving clause. (This is a DerivClause, Pred, or
Name depending on the GHC version.)
dsDerivClause :: DsMonad q => DerivingClause -> q DDerivClause Source #
Desugar a DerivingClause.
dsLetDec :: DsMonad q => Dec -> q ([DLetDec], DExp -> DExp) Source #
Desugar a single Dec that can appear in a let expression.
This produces the following output:
- One or more
DLetDecs (a singleDeccan produce multipleDLetDecs in the event of a value declaration that binds multiple things by way of pattern matching. - A function of type
DExp->DExpDLetDecs. This function prepends binding forms for any implicit params that were bound in the argumentDec. (If no implicit params are bound, this is simply theidfunction.)
For instance, if the argument to dsLetDec is the ?x = 42 part of this
expression:
let { ?x = 42 } in ?x
Then the output is:
let new_x_val = 42
\z ->
bindIP@"x" new_x_val z
This way, the expression
let { new_x_val = 42 } in can be
formed. The implicit param binders always come after all the other
bindIP @"x" new_x_val (ip @"x")DLetDecs to support parallel assignment of implicit params.
Arguments
| :: DsMonad q | |
| => Name | Name of the scrutinee, which must be a bare var |
| -> [Match] | Matches of the |
| -> q [DMatch] |
Desugar a list of matches for a case statement
Arguments
| :: DsMonad q | |
| => Body | body to desugar |
| -> [Dec] | "where" declarations |
| -> DExp | what to do if the guards don't match |
| -> q DExp |
Desugar a Body
Arguments
| :: DsMonad q | |
| => [(Guard, Exp)] | Guarded expressions |
| -> DExp | What to do if none of the guards match |
| -> q DExp |
Desugar guarded expressions
dsDoStmts :: forall q. DsMonad q => Maybe ModName -> [Stmt] -> q DExp Source #
Desugar the Stmts in a do expression
Arguments
| :: DsMonad q | |
| => MatchContext | The context in which the clauses arise |
| -> [Clause] | Clauses to desugar |
| -> q [DClause] |
Desugar clauses to a function definition
dsVarBangType :: DsMonad q => VarBangType -> q DVarBangType Source #
Desugar a VarBangType.
dsTypeFamilyHead :: DsMonad q => TypeFamilyHead -> q DTypeFamilyHead Source #
Desugar a TypeFamilyHead
dsFamilyResultSig :: DsMonad q => FamilyResultSig -> q DFamilyResultSig Source #
Desugar a FamilyResultSig
dsPatSynDir :: DsMonad q => Name -> PatSynDir -> q DPatSynDir Source #
Desugar a PatSynDir. (Available only with GHC 8.2+)
Converting desugared AST back to TH AST
Expanding type synonyms
expandType :: DsMonad q => DType -> q DType Source #
Expands all type synonyms in a desugared type. Also expands open type family applications. (In GHCs before 7.10, this part does not work if there are any variables.) Attempts to expand closed type family applications, but aborts the moment it spots anything strange, like a nested type family application or type variable.
Reification
reifyWithWarning :: (Quasi q, MonadFail q) => Name -> q Info Source #
Reify a declaration, warning the user about splices if the reify fails. The warning says that reification can fail if you try to reify a type in the same splice as it is declared.
Local reification
template-haskell reification functions like reify and qReify, as well as
th-desugar's reifyWithWarning, only look through declarations that either
(1) have already been typechecked in the current module, or (2) are in scope
because of imports. We refer to this as global reification. Sometimes,
however, you may wish to reify declarations that have been quoted but not
yet been typechecked, such as in the following example:
example :: IO ()
example = putStrLn
$(do decs <- [d| data Foo = MkFoo |]
info <- reify (mkName "Foo")
stringE $ pprint info)
Because Foo only exists in a TH quote, it is not available globally. As a
result, the call to reify (mkName "Foo")
To make this sort of example possible, th-desugar extends global reification
with local reification. A function that performs local reification (such
as dsReify, reifyWithLocals, or similar functions that have a DsMonad
context) looks through both typechecked (or imported) declarations and quoted
declarations that are currently in scope. One can add quoted declarations in
the current scope by using the withLocalDeclarations function. Here is an
example of how to repair the example above using withLocalDeclarations:
example2 :: IO ()
example2 = putStrLn
$(do decs <- [d| data Foo = MkFoo |]
info <- withLocalDeclarations decs $
reifyWithLocals (mkName "Foo")
stringE $ pprint info)
Note that withLocalDeclarations should only be used to add quoted
declarations with names that are not duplicates of existing global or local
declarations. Adding duplicate declarations through withLocalDeclarations
is undefined behavior and should be avoided. This is unlikely to happen if
you are only using withLocalDeclarations in conjunction with TH quotes,
however. For instance, this is not an example of duplicate declarations:
data T = MkT1
$(do decs <- [d| data T = MkT2 |]
info <- withLocalDeclarations decs ...
...)
The quoted data T = MkT2 does not conflict with the top-level data T = Mk1
since declaring a data type within TH quotes gives it a fresh, unique name that
distinguishes it from any other data types already in scope.
withLocalDeclarations :: DsMonad q => [Dec] -> DsM q a -> q a Source #
Add a list of declarations to be considered when reifying local declarations.
dsReify :: DsMonad q => Name -> q (Maybe DInfo) Source #
Like reify, but safer and desugared. Uses local declarations where
available.
dsReifyType :: DsMonad q => Name -> q (Maybe DType) Source #
Like reifyType, but safer and desugared. Uses local declarations where
available.
reifyWithLocals_maybe :: DsMonad q => Name -> q (Maybe Info) Source #
Like reify from Template Haskell, but looks also in any not-yet-typechecked
declarations. To establish this list of not-yet-typechecked declarations,
use withLocalDeclarations. Returns Nothing if reification fails.
Note that no inferred type information is available from local declarations;
bottoms may be used if necessary.
reifyWithLocals :: DsMonad q => Name -> q Info Source #
Like reifyWithLocals_maybe, but throws an exception upon failure,
warning the user about separating splices.
reifyFixityWithLocals :: DsMonad q => Name -> q (Maybe Fixity) Source #
Like reifyWithLocals_maybe, but for fixities. Note that a return value
of Nothing might mean that the name is not in scope, or it might mean
that the name has no assigned fixity. (Use reifyWithLocals_maybe if
you really need to tell the difference.)
reifyTypeWithLocals_maybe :: DsMonad q => Name -> q (Maybe Type) Source #
Like reifyWithLocals_maybe but for types and kinds. Note that a return
value of Nothing might mean that the name is not in scope, or it might
mean that the full type of the name cannot be determined. (Use
reifyWithLocals_maybe if you really need to tell the difference.)
reifyTypeWithLocals :: DsMonad q => Name -> q Type Source #
Like reifyTypeWithLocals_maybe, but throws an exception upon failure,
warning the user about separating splices.
lookupValueNameWithLocals :: DsMonad q => String -> q (Maybe Name) Source #
Like lookupValueName from Template Haskell, but looks also in Names of
not-yet-typechecked declarations. To establish this list of not-yet-typechecked
declarations, use withLocalDeclarations. Returns Nothing if no value
with the same name can be found.
lookupTypeNameWithLocals :: DsMonad q => String -> q (Maybe Name) Source #
Like lookupTypeName from Template Haskell, but looks also in Names of
not-yet-typechecked declarations. To establish this list of not-yet-typechecked
declarations, use withLocalDeclarations. Returns Nothing if no type
with the same name can be found.
mkDataNameWithLocals :: DsMonad q => String -> q Name Source #
Like TH's lookupValueName, but if this name is not bound, then we assume
it is declared in the current module.
Unlike mkDataName, this also consults the local declarations in scope when
determining if the name is currently bound.
mkTypeNameWithLocals :: DsMonad q => String -> q Name Source #
Like TH's lookupTypeName, but if this name is not bound, then we assume
it is declared in the current module.
Unlike mkTypeName, this also consults the local declarations in scope when
determining if the name is currently bound.
reifyNameSpace :: DsMonad q => Name -> q (Maybe NameSpace) Source #
Determines a Name's NameSpace. If the NameSpace is attached to
the Name itself (i.e., it is unambiguous), then that NameSpace is
immediately returned. Otherwise, reification is used to lookup up the
NameSpace (consulting local declarations if necessary).
Note that if a Name lives in two different NameSpaces (which can
genuinely happen--for instance, mkName "=="== is both
a function and a type family), then this function will simply return
whichever NameSpace is discovered first via reification. If you wish
to find a Name in a particular NameSpace, use the
lookupValueNameWithLocals or lookupTypeNameWithLocals functions.
class (Quasi m, MonadFail m) => DsMonad m where Source #
A DsMonad stores some list of declarations that should be considered
in scope. DsM is the prototypical inhabitant of DsMonad.
Instances
| DsMonad IO Source # | |
Defined in Language.Haskell.TH.Desugar.Reify Methods localDeclarations :: IO [Dec] Source # | |
| DsMonad Q Source # | |
Defined in Language.Haskell.TH.Desugar.Reify Methods localDeclarations :: Q [Dec] Source # | |
| (Quasi q, MonadFail q) => DsMonad (DsM q) Source # | |
Defined in Language.Haskell.TH.Desugar.Reify Methods localDeclarations :: DsM q [Dec] Source # | |
| DsMonad m => DsMonad (ReaderT r m) Source # | |
Defined in Language.Haskell.TH.Desugar.Reify Methods localDeclarations :: ReaderT r m [Dec] Source # | |
| DsMonad m => DsMonad (StateT s m) Source # | |
Defined in Language.Haskell.TH.Desugar.Reify Methods localDeclarations :: StateT s m [Dec] Source # | |
| (DsMonad m, Monoid w) => DsMonad (WriterT w m) Source # | |
Defined in Language.Haskell.TH.Desugar.Reify Methods localDeclarations :: WriterT w m [Dec] Source # | |
| (DsMonad m, Monoid w) => DsMonad (RWST r w s m) Source # | |
Defined in Language.Haskell.TH.Desugar.Reify Methods localDeclarations :: RWST r w s m [Dec] Source # | |
A convenient implementation of the DsMonad class. Use by calling
withLocalDeclarations.
Instances
Nested pattern flattening
scExp :: DsMonad q => DExp -> q DExp Source #
Remove all nested pattern-matches within this expression. This also
removes all DTildePas and DBangPas. After this is run, every pattern
is guaranteed to be either a DConPa with bare variables as arguments,
a DLitPa, or a DWildPa.
Capture-avoiding substitution and utilities
Free variable calculation
extractBoundNamesDPat :: DPat -> OSet Name Source #
Extract the term variables bound by a DPat.
This does not extract any type variables bound by pattern signatures.
Utility functions
removeWilds :: DsMonad q => DPat -> q DPat Source #
Remove all wildcards from a pattern, replacing any wildcard with a fresh variable
Arguments
| :: DsMonad q | |
| => String | Print this out on failure |
| -> Name | Name of the datatype ( |
| -> q (DataFlavor, [TyVarBndrVis], [Con]) |
Extract the DataFlavor, TyVarBndrs and constructors given the Name
of a type.
dataConNameToDataName :: DsMonad q => Name -> q Name Source #
From the name of a data constructor, retrive the datatype definition it is a part of.
dataConNameToCon :: DsMonad q => Name -> q Con Source #
From the name of a data constructor, retrieve its definition as a Con
nameOccursIn :: Data a => Name -> a -> Bool Source #
Check if a name occurs anywhere within a TH tree.
allNamesIn :: Data a => a -> [Name] Source #
Extract all Names mentioned in a TH tree.
flattenDValD :: Quasi q => DLetDec -> q [DLetDec] Source #
If the declaration passed in is a DValD, creates new, equivalent
declarations such that the DPat in all DValDs is just a plain
DVarPa. Other declarations are passed through unchanged.
Note that the declarations that come out of this function are rather
less efficient than those that come in: they have many more pattern
matches.
getRecordSelectors :: DsMonad q => [DCon] -> q [DLetDec] Source #
Produces DLetDecs representing the record selector functions from
the provided DCons.
Note that if the same record selector appears in multiple constructors,
getRecordSelectors will return only one binding for that selector.
For example, if you had:
data X = X1 {y :: Symbol} | X2 {y :: Symbol}
Then calling getRecordSelectors on [X1, X2] will return:
[ DSigD y (DAppT (DAppT DArrowT (DConT X)) (DConT Symbol))
, DFunD y [ DClause [DConP X1 [DVarP field]] (DVarE field)
, DClause [DConP X2 [DVarP field]] (DVarE field) ] ]
instead of returning one binding for X1 and another binding for X2.
getRecordSelectors does not attempt to filter out "naughty" record
selectors—that is, records whose field types mention existentially
quantified type variables that do not appear in the constructor's return
type. Here is an example of a naughty record selector:
data Some :: (Type -> Type) -> Type where
MkSome :: { getSome :: f a } -> Some f
GHC itself will not allow the use of getSome as a top-level function due
to its type f a mentioning the existential variable a, but
getRecordSelectors will return it nonetheless. Ultimately, this design
choice is a practical one, as detecting which type variables are existential
in Template Haskell is difficult in the general case.
mkTypeName :: Quasi q => String -> q Name Source #
Like TH's lookupTypeName, but if this name is not bound, then we assume
it is declared in the current module.
mkDataName :: Quasi q => String -> q Name Source #
Like TH's lookupDataName, but if this name is not bound, then we assume
it is declared in the current module.
newUniqueName :: Quasi q => String -> q Name Source #
Like newName, but even more unique (unique across different splices),
and with unique nameBases. Precondition: the string is a valid Haskell
alphanumeric identifier (could be upper- or lower-case).
mkTupleDExp :: [DExp] -> DExp Source #
mkTupleDPat :: [DPat] -> DPat Source #
maybeDCaseE :: MatchContext -> DExp -> [DMatch] -> DExp Source #
If matches is non-empty, make a case statement; otherwise make an error statement
tupleNameDegree_maybe :: Name -> Maybe Int Source #
Extract the degree of a tuple Name.
In addition to recognizing tuple syntax (e.g., ''(,,)), this also
recognizes the following:
In recent versions of GHC, ''() is a synonym for ''Unit, ''(,) is a
synonym for ''Tuple2, and so on. As a result, we must check for ''Unit
and ''TupleN in tupleDegree_maybe to be thorough. (There is no special
tuple syntax for ''Solo/'MkSolo, but we check them here as well for the
sake of completeness.)
unboxedTupleNameDegree_maybe :: Name -> Maybe Int Source #
Extract the degree of an unboxed tuple Name.
isTypeKindName :: Name -> Bool Source #
bindIP :: forall name a r. a -> (IP name a => r) -> r Source #
Get an implicit param constraint (IP name a, which is the desugared
form of (?name :: a)) from an explicit value.
This function is only available with GHC 8.0 or later.
mkExtraDKindBinders :: forall q. DsMonad q => DKind -> q [DTyVarBndrVis] Source #
Create new kind variable binder names corresponding to the return kind of a data type. This is useful when you have a data type like:
data Foo :: forall k. k -> Type -> Type where ...
But you want to be able to refer to the type Foo a b.
mkExtraDKindBinders will take the kind forall k. k -> Type -> Type,
discover that is has two visible argument kinds, and return as a result
two new kind variable binders [a :: k, b :: Type], where a and b
are fresh type variable names.
This expands kind synonyms if necessary.
dTyVarBndrToDType :: DTyVarBndr flag -> DType Source #
Convert a DTyVarBndr into a DType
changeDTVFlags :: newFlag -> [DTyVarBndr oldFlag] -> [DTyVarBndr newFlag] Source #
Set the flag in a list of DTyVarBndrs. This is often useful in contexts
where one needs to re-use a list of DTyVarBndrs from one flag setting to
another flag setting. For example, in order to re-use the DTyVarBndrs bound
by a DDataD in a DForallT, one can do the following:
case x ofDDataD_ _ _ tvbs _ _ _ ->DForallT(DForallInvis(changeDTVFlagsSpecifiedSpectvbs)) ...
toposortTyVarsOf :: [DType] -> [DTyVarBndrUnit] Source #
Take a list of DTypes, find their free variables, and sort them in
reverse topological order to ensure that they are well scoped. In other
words, the free variables are ordered such that:
- Whenever an explicit kind signature of the form
(A :: K)is encountered, the free variables ofKwill always appear to the left of the free variables ofAin the returned result. - The constraint in (1) notwithstanding, free variables will appear in left-to-right order of their original appearance.
On older GHCs, this takes measures to avoid returning explicitly bound
kind variables, which was not possible before TypeInType.
toposortKindVarsOfTvbs :: [DTyVarBndr flag] -> [DTyVarBndrUnit] Source #
Take a telescope of DTyVarBndrs, find the free variables in their kinds,
and sort them in reverse topological order to ensure that they are well
scoped. Because the argument list is assumed to be telescoping, kind
variables that are bound earlier in the list are not returned. For example,
this:
toposortKindVarsOfTvbs [a :: k, b :: Proxy a]
Will return [k], not [k, a], since a is bound earlier by a :: k.
FunArgs and VisFunArg
The list of arguments in a function Type.
Constructors
| FANil | No more arguments. |
| FAForalls ForallTelescope FunArgs | A series of |
| FACxt Cxt FunArgs | A series of constraint arguments followed by |
| FAAnon Type FunArgs | An anonymous argument followed by an arrow. For example, the |
Instances
| Data FunArgs Source # | |
Defined in Language.Haskell.TH.Desugar.Util Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunArgs -> c FunArgs # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FunArgs # toConstr :: FunArgs -> Constr # dataTypeOf :: FunArgs -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FunArgs) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunArgs) # gmapT :: (forall b. Data b => b -> b) -> FunArgs -> FunArgs # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunArgs -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunArgs -> r # gmapQ :: (forall d. Data d => d -> u) -> FunArgs -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FunArgs -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunArgs -> m FunArgs # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunArgs -> m FunArgs # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunArgs -> m FunArgs # | |
| Show FunArgs Source # | |
| Eq FunArgs Source # | |
data ForallTelescope Source #
The type variable binders in a forall. This is not used by the TH AST
itself, but this is used as an intermediate data type in FAForalls.
Constructors
| ForallVis [TyVarBndrUnit] | A visible |
| ForallInvis [TyVarBndrSpec] | An invisible |
Instances
A visible function argument type (i.e., one that must be supplied
explicitly in the source code). This is in contrast to invisible
arguments (e.g., the c in c => r), which are instantiated without
the need for explicit user input.
Constructors
| VisFADep TyVarBndrUnit | A visible |
| VisFAAnon Type | An anonymous argument followed by an arrow (e.g., |
Instances
| Data VisFunArg Source # | |
Defined in Language.Haskell.TH.Desugar.Util Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VisFunArg -> c VisFunArg # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VisFunArg # toConstr :: VisFunArg -> Constr # dataTypeOf :: VisFunArg -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c VisFunArg) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VisFunArg) # gmapT :: (forall b. Data b => b -> b) -> VisFunArg -> VisFunArg # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VisFunArg -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VisFunArg -> r # gmapQ :: (forall d. Data d => d -> u) -> VisFunArg -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VisFunArg -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VisFunArg -> m VisFunArg # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VisFunArg -> m VisFunArg # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VisFunArg -> m VisFunArg # | |
| Show VisFunArg Source # | |
| Eq VisFunArg Source # | |
filterVisFunArgs :: FunArgs -> [VisFunArg] Source #
Filter the visible function arguments from a list of FunArgs.
ravelType :: FunArgs -> Type -> Type Source #
Reconstruct an arrow Type from its argument and result types.
DFunArgs and DVisFunArg
The list of arguments in a function DType.
Constructors
| DFANil | No more arguments. |
| DFAForalls DForallTelescope DFunArgs | A series of |
| DFACxt DCxt DFunArgs | A series of constraint arguments followed by |
| DFAAnon DType DFunArgs | An anonymous argument followed by an arrow. For example, the |
Instances
data DVisFunArg Source #
A visible function argument type (i.e., one that must be supplied
explicitly in the source code). This is in contrast to invisible
arguments (e.g., the c in c => r), which are instantiated without
the need for explicit user input.
Constructors
| DVisFADep DTyVarBndrUnit | A visible |
| DVisFAAnon DType | An anonymous argument followed by an arrow (e.g., |
Instances
| Data DVisFunArg Source # | |
Defined in Language.Haskell.TH.Desugar.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DVisFunArg -> c DVisFunArg # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DVisFunArg # toConstr :: DVisFunArg -> Constr # dataTypeOf :: DVisFunArg -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DVisFunArg) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DVisFunArg) # gmapT :: (forall b. Data b => b -> b) -> DVisFunArg -> DVisFunArg # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DVisFunArg -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DVisFunArg -> r # gmapQ :: (forall d. Data d => d -> u) -> DVisFunArg -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DVisFunArg -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DVisFunArg -> m DVisFunArg # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DVisFunArg -> m DVisFunArg # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DVisFunArg -> m DVisFunArg # | |
| Generic DVisFunArg Source # | |
Defined in Language.Haskell.TH.Desugar.Core Associated Types type Rep DVisFunArg :: Type -> Type # | |
| Show DVisFunArg Source # | |
Defined in Language.Haskell.TH.Desugar.Core Methods showsPrec :: Int -> DVisFunArg -> ShowS # show :: DVisFunArg -> String # showList :: [DVisFunArg] -> ShowS # | |
| Eq DVisFunArg Source # | |
Defined in Language.Haskell.TH.Desugar.Core | |
| type Rep DVisFunArg Source # | |
Defined in Language.Haskell.TH.Desugar.Core type Rep DVisFunArg = D1 ('MetaData "DVisFunArg" "Language.Haskell.TH.Desugar.Core" "th-desugar-1.16-CQDZE9IhmYTBDpt9fLaD0r" 'False) (C1 ('MetaCons "DVisFADep" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DTyVarBndrUnit)) :+: C1 ('MetaCons "DVisFAAnon" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DType))) | |
filterDVisFunArgs :: DFunArgs -> [DVisFunArg] Source #
Filter the visible function arguments from a list of DFunArgs.
ravelDType :: DFunArgs -> DType -> DType Source #
Reconstruct an arrow DType from its argument and result types.
TypeArg
An argument to a type, either a normal type (TANormal) or a visible
kind application (TyArg).
TypeArg is useful when decomposing an application of a Type to its
arguments (e.g., in unfoldType).
Instances
| Data TypeArg Source # | |
Defined in Language.Haskell.TH.Desugar.Util Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypeArg -> c TypeArg # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TypeArg # toConstr :: TypeArg -> Constr # dataTypeOf :: TypeArg -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TypeArg) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeArg) # gmapT :: (forall b. Data b => b -> b) -> TypeArg -> TypeArg # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypeArg -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypeArg -> r # gmapQ :: (forall d. Data d => d -> u) -> TypeArg -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeArg -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeArg -> m TypeArg # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeArg -> m TypeArg # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeArg -> m TypeArg # | |
| Show TypeArg Source # | |
| Eq TypeArg Source # | |
| Desugar TypeArg DTypeArg Source # | |
filterTANormals :: [TypeArg] -> [Type] Source #
Filter the normal type arguments from a list of TypeArgs.
tyVarBndrVisToTypeArg :: TyVarBndrVis -> TypeArg Source #
Convert a TyVarBndrVis to a TypeArg. That is, convert a binder with a
BndrReq visibility to a TANormal and a binder with BndrInvis
visibility to a TyArg.
If given a KindedTV, the resulting TypeArg will omit the kind signature.
Use tyVarBndrVisToTypeArgWithSig if you want to preserve the kind
signature.
tyVarBndrVisToTypeArgWithSig :: TyVarBndrVis -> TypeArg Source #
Convert a TyVarBndrVis to a TypeArg. That is, convert a binder with a
BndrReq visibility to a TANormal and a binder with BndrInvis
visibility to a TyArg.
If given a KindedTV, the resulting TypeArg will preserve the kind
signature. Use tyVarBndrVisToTypeArg if you want to omit the kind
signature.
unfoldType :: Type -> (Type, [TypeArg]) Source #
Decompose an applied type into its individual components. For example, this:
Proxy @Type Char
would be unfolded to this:
(ConT''Proxy, [TyArg(ConT''Type),TANormal(ConT''Char)])
This process forgets about infix application, so both of these types:
Int :++: Int (:++:) Int Int
will be unfolded to this:
(ConT''(:+:), [TANormal(ConT''Int),TANormal(ConT''Int)])
This function should only be used after all UInfixT and PromotedUInfixT
types have been resolved (e.g., via th-abstraction's
resolveInfixT
function).
DTypeArg
An argument to a type, either a normal type (DTANormal) or a visible
kind application (DTyArg).
DTypeArg does not appear directly in the th-desugar AST, but it is
useful when decomposing an application of a DType to its arguments.
Instances
| Data DTypeArg Source # | |
Defined in Language.Haskell.TH.Desugar.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DTypeArg -> c DTypeArg # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DTypeArg # toConstr :: DTypeArg -> Constr # dataTypeOf :: DTypeArg -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DTypeArg) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DTypeArg) # gmapT :: (forall b. Data b => b -> b) -> DTypeArg -> DTypeArg # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DTypeArg -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DTypeArg -> r # gmapQ :: (forall d. Data d => d -> u) -> DTypeArg -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DTypeArg -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DTypeArg -> m DTypeArg # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DTypeArg -> m DTypeArg # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DTypeArg -> m DTypeArg # | |
| Generic DTypeArg Source # | |
| Show DTypeArg Source # | |
| Eq DTypeArg Source # | |
| Desugar TypeArg DTypeArg Source # | |
| type Rep DTypeArg Source # | |
Defined in Language.Haskell.TH.Desugar.Core type Rep DTypeArg = D1 ('MetaData "DTypeArg" "Language.Haskell.TH.Desugar.Core" "th-desugar-1.16-CQDZE9IhmYTBDpt9fLaD0r" 'False) (C1 ('MetaCons "DTANormal" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DType)) :+: C1 ('MetaCons "DTyArg" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DKind))) | |
filterDTANormals :: [DTypeArg] -> [DType] Source #
Filter the normal type arguments from a list of DTypeArgs.
dTyVarBndrVisToDTypeArg :: DTyVarBndrVis -> DTypeArg Source #
Convert a DTyVarBndrVis to a DTypeArg. That is, convert a binder with a
BndrReq visibility to a DTANormal and a binder with BndrInvis
visibility to a DTyArg.
If given a DKindedTV, the resulting DTypeArg will omit the kind
signature. Use dTyVarBndrVisToDTypeArgWithSig if you want to preserve the
kind signature.
dTyVarBndrVisToDTypeArgWithSig :: DTyVarBndrVis -> DTypeArg Source #
Convert a DTyVarBndrVis to a DTypeArg. That is, convert a binder with a
BndrReq visibility to a DTANormal and a binder with BndrInvis
visibility to a DTyArg.
If given a DKindedTV, the resulting DTypeArg will preserve the kind
signature. Use dTyVarBndrVisToDTypeArg if you want to omit the kind
signature.