Language.Haskell.Syntax.Decls

ghc-9.2.3: The GHC API

Safe Haskell | Safe-Inferred
Language | Haskell2010

Language.Haskell.Syntax.Decls

Contents

- Toplevel declarations
  - Class or type declarations
  - Instance declarations
  - Standalone deriving declarations
  - Deriving strategies
  - `RULE` declarations
  - `default` declarations
  - Template haskell declaration splice
  - Foreign function interface declarations
  - Data-constructor declarations
  - Document comments
  - Deprecations
  - Annotations
  - Role annotations
  - Injective type families
- Grouping

Description

Abstract syntax of global declarations.

Definitions for: `SynDecl` and `ConDecl`, `ClassDecl`, `InstDecl`, `DefaultDecl` and `ForeignDecl`.

Synopsis

- data HsDecl p
  - = TyClD (XTyClD p) (TyClDecl p)
  - | InstD (XInstD p) (InstDecl p)
  - | DerivD (XDerivD p) (DerivDecl p)
  - | ValD (XValD p) (HsBind p)
  - | SigD (XSigD p) (Sig p)
  - | KindSigD (XKindSigD p) (StandaloneKindSig p)
  - | DefD (XDefD p) (DefaultDecl p)
  - | ForD (XForD p) (ForeignDecl p)
  - | WarningD (XWarningD p) (WarnDecls p)
  - | AnnD (XAnnD p) (AnnDecl p)
  - | RuleD (XRuleD p) (RuleDecls p)
  - | SpliceD (XSpliceD p) (SpliceDecl p)
  - | DocD (XDocD p) DocDecl
  - | RoleAnnotD (XRoleAnnotD p) (RoleAnnotDecl p)
  - | XHsDecl !(XXHsDecl p)
- type LHsDecl p = XRec p (HsDecl p)
- data HsDataDefn pass
  - = HsDataDefn {
    - dd_ext :: XCHsDataDefn pass
    - dd_ND :: NewOrData
    - dd_ctxt :: Maybe (LHsContext pass)
    - dd_cType :: Maybe (XRec pass CType)
    - dd_kindSig :: Maybe (LHsKind pass)
    - dd_cons :: [LConDecl pass]
    - dd_derivs :: HsDeriving pass
    }
  - | XHsDataDefn !(XXHsDataDefn pass)
- type HsDeriving pass = [LHsDerivingClause pass]
- type LHsFunDep pass = XRec pass (FunDep pass)
- data FunDep pass
  - = FunDep (XCFunDep pass) [LIdP pass] [LIdP pass]
  - | XFunDep !(XXFunDep pass)
- data HsDerivingClause pass
  - = HsDerivingClause {
    - deriv_clause_ext :: XCHsDerivingClause pass
    - deriv_clause_strategy :: Maybe (LDerivStrategy pass)
    - deriv_clause_tys :: LDerivClauseTys pass
    }
  - | XHsDerivingClause !(XXHsDerivingClause pass)
- type LHsDerivingClause pass = XRec pass (HsDerivingClause pass)
- data DerivClauseTys pass
  - = DctSingle (XDctSingle pass) (LHsSigType pass)
  - | DctMulti (XDctMulti pass) [LHsSigType pass]
  - | XDerivClauseTys !(XXDerivClauseTys pass)
- type LDerivClauseTys pass = XRec pass (DerivClauseTys pass)
- data NewOrData
  - = NewType
  - | DataType
- newOrDataToFlavour :: NewOrData -> TyConFlavour
- data StandaloneKindSig pass
  - = StandaloneKindSig (XStandaloneKindSig pass) (LIdP pass) (LHsSigType pass)
  - | XStandaloneKindSig !(XXStandaloneKindSig pass)
- type LStandaloneKindSig pass = XRec pass (StandaloneKindSig pass)
- data TyClDecl pass
  - = FamDecl {
    - tcdFExt :: XFamDecl pass
    - tcdFam :: FamilyDecl pass
    }
  - | SynDecl {
    - tcdSExt :: XSynDecl pass
    - tcdLName :: LIdP pass
    - tcdTyVars :: LHsQTyVars pass
    - tcdFixity :: LexicalFixity
    - tcdRhs :: LHsType pass
    }
  - | DataDecl {
    - tcdDExt :: XDataDecl pass
    - tcdLName :: LIdP pass
    - tcdTyVars :: LHsQTyVars pass
    - tcdFixity :: LexicalFixity
    - tcdDataDefn :: HsDataDefn pass
    }
  - | ClassDecl {
    - tcdCExt :: XClassDecl pass
    - tcdCtxt :: Maybe (LHsContext pass)
    - tcdLName :: LIdP pass
    - tcdTyVars :: LHsQTyVars pass
    - tcdFixity :: LexicalFixity
    - tcdFDs :: [LHsFunDep pass]
    - tcdSigs :: [LSig pass]
    - tcdMeths :: LHsBinds pass
    - tcdATs :: [LFamilyDecl pass]
    - tcdATDefs :: [LTyFamDefltDecl pass]
    - tcdDocs :: [LDocDecl pass]
    }
  - | XTyClDecl !(XXTyClDecl pass)
- type LTyClDecl pass = XRec pass (TyClDecl pass)
- data DataDeclRn = DataDeclRn {
  - tcdDataCusk :: Bool
  - tcdFVs :: NameSet
  }
- data TyClGroup pass
  - = TyClGroup {
    - group_ext :: XCTyClGroup pass
    - group_tyclds :: [LTyClDecl pass]
    - group_roles :: [LRoleAnnotDecl pass]
    - group_kisigs :: [LStandaloneKindSig pass]
    - group_instds :: [LInstDecl pass]
    }
  - | XTyClGroup !(XXTyClGroup pass)
- tyClGroupTyClDecls :: [TyClGroup pass] -> [LTyClDecl pass]
- tyClGroupInstDecls :: [TyClGroup pass] -> [LInstDecl pass]
- tyClGroupRoleDecls :: [TyClGroup pass] -> [LRoleAnnotDecl pass]
- tyClGroupKindSigs :: [TyClGroup pass] -> [LStandaloneKindSig pass]
- isClassDecl :: TyClDecl pass -> Bool
- isDataDecl :: TyClDecl pass -> Bool
- isSynDecl :: TyClDecl pass -> Bool
- isFamilyDecl :: TyClDecl pass -> Bool
- isTypeFamilyDecl :: TyClDecl pass -> Bool
- isDataFamilyDecl :: TyClDecl pass -> Bool
- isOpenTypeFamilyInfo :: FamilyInfo pass -> Bool
- isClosedTypeFamilyInfo :: FamilyInfo pass -> Bool
- countTyClDecls :: [TyClDecl pass] -> (Int, Int, Int, Int, Int)
- tyClDeclTyVars :: TyClDecl pass -> LHsQTyVars pass
- data FamilyDecl pass
  - = FamilyDecl {
    - fdExt :: XCFamilyDecl pass
    - fdInfo :: FamilyInfo pass
    - fdTopLevel :: TopLevelFlag
    - fdLName :: LIdP pass
    - fdTyVars :: LHsQTyVars pass
    - fdFixity :: LexicalFixity
    - fdResultSig :: LFamilyResultSig pass
    - fdInjectivityAnn :: Maybe (LInjectivityAnn pass)
    }
  - | XFamilyDecl !(XXFamilyDecl pass)
- type LFamilyDecl pass = XRec pass (FamilyDecl pass)
- data InstDecl pass
  - = ClsInstD {
    - cid_d_ext :: XClsInstD pass
    - cid_inst :: ClsInstDecl pass
    }
  - | DataFamInstD {
    - dfid_ext :: XDataFamInstD pass
    - dfid_inst :: DataFamInstDecl pass
    }
  - | TyFamInstD {
    - tfid_ext :: XTyFamInstD pass
    - tfid_inst :: TyFamInstDecl pass
    }
  - | XInstDecl !(XXInstDecl pass)
- type LInstDecl pass = XRec pass (InstDecl pass)
- data FamilyInfo pass
  - = DataFamily
  - | OpenTypeFamily
  - | ClosedTypeFamily (Maybe [LTyFamInstEqn pass])
- pprFlavour :: FamilyInfo pass -> SDoc
- data TyFamInstDecl pass
  - = TyFamInstDecl {
    - tfid_xtn :: XCTyFamInstDecl pass
    - tfid_eqn :: TyFamInstEqn pass
    }
  - | XTyFamInstDecl !(XXTyFamInstDecl pass)
- type LTyFamInstDecl pass = XRec pass (TyFamInstDecl pass)
- type TyFamDefltDecl = TyFamInstDecl
- type LTyFamDefltDecl pass = XRec pass (TyFamDefltDecl pass)
- newtype DataFamInstDecl pass = DataFamInstDecl {
  - dfid_eqn :: FamEqn pass (HsDataDefn pass)
  }
- type LDataFamInstDecl pass = XRec pass (DataFamInstDecl pass)
- data FamEqn pass rhs
  - = FamEqn {
    - feqn_ext :: XCFamEqn pass rhs
    - feqn_tycon :: LIdP pass
    - feqn_bndrs :: HsOuterFamEqnTyVarBndrs pass
    - feqn_pats :: HsTyPats pass
    - feqn_fixity :: LexicalFixity
    - feqn_rhs :: rhs
    }
  - | XFamEqn !(XXFamEqn pass rhs)
- type TyFamInstEqn pass = FamEqn pass (LHsType pass)
- type LTyFamInstEqn pass = XRec pass (TyFamInstEqn pass)
- type HsTyPats pass = [LHsTypeArg pass]
- type LClsInstDecl pass = XRec pass (ClsInstDecl pass)
- data ClsInstDecl pass
  - = ClsInstDecl {
    - cid_ext :: XCClsInstDecl pass
    - cid_poly_ty :: LHsSigType pass
    - cid_binds :: LHsBinds pass
    - cid_sigs :: [LSig pass]
    - cid_tyfam_insts :: [LTyFamInstDecl pass]
    - cid_datafam_insts :: [LDataFamInstDecl pass]
    - cid_overlap_mode :: Maybe (XRec pass OverlapMode)
    }
  - | XClsInstDecl !(XXClsInstDecl pass)
- data DerivDecl pass
  - = DerivDecl {
    - deriv_ext :: XCDerivDecl pass
    - deriv_type :: LHsSigWcType pass
    - deriv_strategy :: Maybe (LDerivStrategy pass)
    - deriv_overlap_mode :: Maybe (XRec pass OverlapMode)
    }
  - | XDerivDecl !(XXDerivDecl pass)
- type LDerivDecl pass = XRec pass (DerivDecl pass)
- data DerivStrategy pass
  - = StockStrategy (XStockStrategy pass)
  - | AnyclassStrategy (XAnyClassStrategy pass)
  - | NewtypeStrategy (XNewtypeStrategy pass)
  - | ViaStrategy (XViaStrategy pass)
- type LDerivStrategy pass = XRec pass (DerivStrategy pass)
- derivStrategyName :: DerivStrategy a -> SDoc
- type LRuleDecls pass = XRec pass (RuleDecls pass)
- data RuleDecls pass
  - = HsRules {
    - rds_ext :: XCRuleDecls pass
    - rds_src :: SourceText
    - rds_rules :: [LRuleDecl pass]
    }
  - | XRuleDecls !(XXRuleDecls pass)
- data RuleDecl pass
  - = HsRule {
    - rd_ext :: XHsRule pass
    - rd_name :: XRec pass (SourceText, RuleName)
    - rd_act :: Activation
    - rd_tyvs :: Maybe [LHsTyVarBndr () (NoGhcTc pass)]
    - rd_tmvs :: [LRuleBndr pass]
    - rd_lhs :: XRec pass (HsExpr pass)
    - rd_rhs :: XRec pass (HsExpr pass)
    }
  - | XRuleDecl !(XXRuleDecl pass)
- type LRuleDecl pass = XRec pass (RuleDecl pass)
- data HsRuleRn = HsRuleRn NameSet NameSet
- data RuleBndr pass
  - = RuleBndr (XCRuleBndr pass) (LIdP pass)
  - | RuleBndrSig (XRuleBndrSig pass) (LIdP pass) (HsPatSigType pass)
  - | XRuleBndr !(XXRuleBndr pass)
- type LRuleBndr pass = XRec pass (RuleBndr pass)
- collectRuleBndrSigTys :: [RuleBndr pass] -> [HsPatSigType pass]
- pprFullRuleName :: Located (SourceText, RuleName) -> SDoc
- data DefaultDecl pass
  - = DefaultDecl (XCDefaultDecl pass) [LHsType pass]
  - | XDefaultDecl !(XXDefaultDecl pass)
- type LDefaultDecl pass = XRec pass (DefaultDecl pass)
- data SpliceExplicitFlag
  - = ExplicitSplice
  - | ImplicitSplice
- data SpliceDecl p
  - = SpliceDecl (XSpliceDecl p) (XRec p (HsSplice p)) SpliceExplicitFlag
  - | XSpliceDecl !(XXSpliceDecl p)
- type LSpliceDecl pass = XRec pass (SpliceDecl pass)
- data ForeignDecl pass
  - = ForeignImport {
    - fd_i_ext :: XForeignImport pass
    - fd_name :: LIdP pass
    - fd_sig_ty :: LHsSigType pass
    - fd_fi :: ForeignImport
    }
  - | ForeignExport {
    - fd_e_ext :: XForeignExport pass
    - fd_name :: LIdP pass
    - fd_sig_ty :: LHsSigType pass
    - fd_fe :: ForeignExport
    }
  - | XForeignDecl !(XXForeignDecl pass)
- type LForeignDecl pass = XRec pass (ForeignDecl pass)
- data ForeignImport = CImport (Located CCallConv) (Located Safety) (Maybe Header) CImportSpec (Located SourceText)
- data ForeignExport = CExport (Located CExportSpec) (Located SourceText)
- data CImportSpec
  - = CLabel CLabelString
  - | CFunction CCallTarget
  - | CWrapper
- data ConDecl pass
  - = ConDeclGADT {
    - con_g_ext :: XConDeclGADT pass
    - con_names :: [LIdP pass]
    - con_bndrs :: XRec pass (HsOuterSigTyVarBndrs pass)
    - con_mb_cxt :: Maybe (LHsContext pass)
    - con_g_args :: HsConDeclGADTDetails pass
    - con_res_ty :: LHsType pass
    - con_doc :: Maybe LHsDocString
    }
  - | ConDeclH98 {
    - con_ext :: XConDeclH98 pass
    - con_name :: LIdP pass
    - con_forall :: Bool
    - con_ex_tvs :: [LHsTyVarBndr Specificity pass]
    - con_mb_cxt :: Maybe (LHsContext pass)
    - con_args :: HsConDeclH98Details pass
    - con_doc :: Maybe LHsDocString
    }
  - | XConDecl !(XXConDecl pass)
- type LConDecl pass = XRec pass (ConDecl pass)
- type HsConDeclH98Details pass = HsConDetails Void (HsScaled pass (LBangType pass)) (XRec pass [LConDeclField pass])
- data HsConDeclGADTDetails pass
  - = PrefixConGADT [HsScaled pass (LBangType pass)]
  - | RecConGADT (XRec pass [LConDeclField pass])
- data DocDecl
  - = DocCommentNext HsDocString
  - | DocCommentPrev HsDocString
  - | DocCommentNamed String HsDocString
  - | DocGroup Int HsDocString
- type LDocDecl pass = XRec pass DocDecl
- docDeclDoc :: DocDecl -> HsDocString
- data WarnDecl pass
  - = Warning (XWarning pass) [LIdP pass] WarningTxt
  - | XWarnDecl !(XXWarnDecl pass)
- type LWarnDecl pass = XRec pass (WarnDecl pass)
- data WarnDecls pass
  - = Warnings {
    - wd_ext :: XWarnings pass
    - wd_src :: SourceText
    - wd_warnings :: [LWarnDecl pass]
    }
  - | XWarnDecls !(XXWarnDecls pass)
- type LWarnDecls pass = XRec pass (WarnDecls pass)
- data AnnDecl pass
  - = HsAnnotation (XHsAnnotation pass) SourceText (AnnProvenance pass) (XRec pass (HsExpr pass))
  - | XAnnDecl !(XXAnnDecl pass)
- type LAnnDecl pass = XRec pass (AnnDecl pass)
- data AnnProvenance pass
  - = ValueAnnProvenance (LIdP pass)
  - | TypeAnnProvenance (LIdP pass)
  - | ModuleAnnProvenance
- annProvenanceName_maybe :: forall p. UnXRec p => AnnProvenance p -> Maybe (IdP p)
- data RoleAnnotDecl pass
  - = RoleAnnotDecl (XCRoleAnnotDecl pass) (LIdP pass) [XRec pass (Maybe Role)]
  - | XRoleAnnotDecl !(XXRoleAnnotDecl pass)
- type LRoleAnnotDecl pass = XRec pass (RoleAnnotDecl pass)
- data FamilyResultSig pass
  - = NoSig (XNoSig pass)
  - | KindSig (XCKindSig pass) (LHsKind pass)
  - | TyVarSig (XTyVarSig pass) (LHsTyVarBndr () pass)
  - | XFamilyResultSig !(XXFamilyResultSig pass)
- type LFamilyResultSig pass = XRec pass (FamilyResultSig pass)
- data InjectivityAnn pass
  - = InjectivityAnn (XCInjectivityAnn pass) (LIdP pass) [LIdP pass]
  - | XInjectivityAnn !(XXInjectivityAnn pass)
- type LInjectivityAnn pass = XRec pass (InjectivityAnn pass)
- data HsGroup p
  - = HsGroup {
    - hs_ext :: XCHsGroup p
    - hs_valds :: HsValBinds p
    - hs_splcds :: [LSpliceDecl p]
    - hs_tyclds :: [TyClGroup p]
    - hs_derivds :: [LDerivDecl p]
    - hs_fixds :: [LFixitySig p]
    - hs_defds :: [LDefaultDecl p]
    - hs_fords :: [LForeignDecl p]
    - hs_warnds :: [LWarnDecls p]
    - hs_annds :: [LAnnDecl p]
    - hs_ruleds :: [LRuleDecls p]
    - hs_docs :: [LDocDecl p]
    }
  - | XHsGroup !(XXHsGroup p)
- hsGroupInstDecls :: HsGroup id -> [LInstDecl id]

# Toplevel declarations

data HsDecl p Source #

A Haskell Declaration

Constructors

TyClD (XTyClD p) (TyClDecl p) | Type or Class Declaration
InstD (XInstD p) (InstDecl p) | Instance declaration
DerivD (XDerivD p) (DerivDecl p) | Deriving declaration
ValD (XValD p) (HsBind p) | Value declaration
SigD (XSigD p) (Sig p) | Signature declaration
KindSigD (XKindSigD p) (StandaloneKindSig p) | Standalone kind signature
DefD (XDefD p) (DefaultDecl p) | 'default' declaration
ForD (XForD p) (ForeignDecl p) | Foreign declaration
WarningD (XWarningD p) (WarnDecls p) | Warning declaration
AnnD (XAnnD p) (AnnDecl p) | Annotation declaration
RuleD (XRuleD p) (RuleDecls p) | Rule declaration
SpliceD (XSpliceD p) (SpliceDecl p) | Splice declaration (Includes quasi-quotes)
DocD (XDocD p) DocDecl | Documentation comment declaration
RoleAnnotD (XRoleAnnotD p) (RoleAnnotDecl p) | Role annotation declaration
XHsDecl !(XXHsDecl p) |

#### Instances

Instances details

Data (HsDecl GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsDecl GhcPs -> c (HsDecl GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsDecl GhcPs) Source # toConstr :: HsDecl GhcPs -> Constr Source # dataTypeOf :: HsDecl GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsDecl GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsDecl GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> HsDecl GhcPs -> HsDecl GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsDecl GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDecl GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsDecl GhcPs -> m (HsDecl GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDecl GhcPs -> m (HsDecl GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDecl GhcPs -> m (HsDecl GhcPs) Source #
Data (HsDecl GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsDecl GhcRn -> c (HsDecl GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsDecl GhcRn) Source # toConstr :: HsDecl GhcRn -> Constr Source # dataTypeOf :: HsDecl GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsDecl GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsDecl GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> HsDecl GhcRn -> HsDecl GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsDecl GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDecl GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsDecl GhcRn -> m (HsDecl GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDecl GhcRn -> m (HsDecl GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDecl GhcRn -> m (HsDecl GhcRn) Source #
Data (HsDecl GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsDecl GhcTc -> c (HsDecl GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsDecl GhcTc) Source # toConstr :: HsDecl GhcTc -> Constr Source # dataTypeOf :: HsDecl GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsDecl GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsDecl GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> HsDecl GhcTc -> HsDecl GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsDecl GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDecl GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsDecl GhcTc -> m (HsDecl GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDecl GhcTc -> m (HsDecl GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDecl GhcTc -> m (HsDecl GhcTc) Source #
OutputableBndrId p => Outputable (HsDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: HsDecl (GhcPass p) -> SDoc Source #
type Anno (HsDecl (GhcPass _1)) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (HsDecl (GhcPass _1)) = SrcSpanAnnA

type LHsDecl p Source #

Arguments

= XRec p (HsDecl p) | When in a list this may have `AnnKeywordId` : `AnnSemi`

data HsDataDefn pass Source #

Haskell Data type Definition

Constructors

HsDataDefn | Declares a data type or newtype, giving its constructors `data/newtype T a = constrs data/newtype instance T [a] = constrs`
Fields dd_ext :: XCHsDataDefn pass dd_ND :: NewOrData dd_ctxt :: Maybe (LHsContext pass) Context dd_cType :: Maybe (XRec pass CType) dd_kindSig :: Maybe (LHsKind pass) Optional kind signature. `(Just k)` for a GADT-style `data`, or `data instance` decl, with explicit kind sig Always `Nothing` for H98-syntax decls dd_cons :: [LConDecl pass] Data constructors For `data T a = T1 | T2 a` the `LConDecl`s all have `ConDeclH98`. For `data T a where { T1 :: T a }` the `LConDecls` all have `ConDeclGADT`. dd_derivs :: HsDeriving pass Optional 'deriving' clause
XHsDataDefn !(XXHsDataDefn pass) |

#### Instances

Instances details

Data (HsDataDefn GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsDataDefn GhcPs -> c (HsDataDefn GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsDataDefn GhcPs) Source # toConstr :: HsDataDefn GhcPs -> Constr Source # dataTypeOf :: HsDataDefn GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsDataDefn GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsDataDefn GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> HsDataDefn GhcPs -> HsDataDefn GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDataDefn GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDataDefn GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsDataDefn GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDataDefn GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsDataDefn GhcPs -> m (HsDataDefn GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDataDefn GhcPs -> m (HsDataDefn GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDataDefn GhcPs -> m (HsDataDefn GhcPs) Source #
Data (HsDataDefn GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsDataDefn GhcRn -> c (HsDataDefn GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsDataDefn GhcRn) Source # toConstr :: HsDataDefn GhcRn -> Constr Source # dataTypeOf :: HsDataDefn GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsDataDefn GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsDataDefn GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> HsDataDefn GhcRn -> HsDataDefn GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDataDefn GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDataDefn GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsDataDefn GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDataDefn GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsDataDefn GhcRn -> m (HsDataDefn GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDataDefn GhcRn -> m (HsDataDefn GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDataDefn GhcRn -> m (HsDataDefn GhcRn) Source #
Data (HsDataDefn GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsDataDefn GhcTc -> c (HsDataDefn GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsDataDefn GhcTc) Source # toConstr :: HsDataDefn GhcTc -> Constr Source # dataTypeOf :: HsDataDefn GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsDataDefn GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsDataDefn GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> HsDataDefn GhcTc -> HsDataDefn GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDataDefn GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDataDefn GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsDataDefn GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDataDefn GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsDataDefn GhcTc -> m (HsDataDefn GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDataDefn GhcTc -> m (HsDataDefn GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDataDefn GhcTc -> m (HsDataDefn GhcTc) Source #
OutputableBndrId p => Outputable (HsDataDefn (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: HsDataDefn (GhcPass p) -> SDoc Source #

type HsDeriving pass Source #

Arguments

= [LHsDerivingClause pass] | The optional `deriving` clauses of a data declaration. Clauses is plural because one can specify multiple deriving clauses using the `-XDerivingStrategies` language extension. The list of `LHsDerivingClause`s corresponds to exactly what the user requested to derive, in order. If no deriving clauses were specified, the list is empty.

Haskell Deriving clause

type LHsFunDep pass = XRec pass (FunDep pass) Source #

data FunDep pass Source #

Constructors

FunDep (XCFunDep pass) [LIdP pass] [LIdP pass] |
XFunDep !(XXFunDep pass) |

#### Instances

Instances details

Data (FunDep GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunDep GhcPs -> c (FunDep GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FunDep GhcPs) Source # toConstr :: FunDep GhcPs -> Constr Source # dataTypeOf :: FunDep GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FunDep GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FunDep GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> FunDep GhcPs -> FunDep GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunDep GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunDep GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> FunDep GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> FunDep GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunDep GhcPs -> m (FunDep GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep GhcPs -> m (FunDep GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep GhcPs -> m (FunDep GhcPs) Source #
Data (FunDep GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunDep GhcRn -> c (FunDep GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FunDep GhcRn) Source # toConstr :: FunDep GhcRn -> Constr Source # dataTypeOf :: FunDep GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FunDep GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FunDep GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> FunDep GhcRn -> FunDep GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunDep GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunDep GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> FunDep GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> FunDep GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunDep GhcRn -> m (FunDep GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep GhcRn -> m (FunDep GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep GhcRn -> m (FunDep GhcRn) Source #
Data (FunDep GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunDep GhcTc -> c (FunDep GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FunDep GhcTc) Source # toConstr :: FunDep GhcTc -> Constr Source # dataTypeOf :: FunDep GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FunDep GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FunDep GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> FunDep GhcTc -> FunDep GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunDep GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunDep GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> FunDep GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> FunDep GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunDep GhcTc -> m (FunDep GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep GhcTc -> m (FunDep GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep GhcTc -> m (FunDep GhcTc) Source #
OutputableBndrId p => Outputable (FunDep (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: FunDep (GhcPass p) -> SDoc Source #
type Anno (FunDep (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (FunDep (GhcPass p)) = SrcSpanAnnA

data HsDerivingClause pass Source #

A single `deriving` clause of a data declaration.

- `AnnKeywordId` : `AnnDeriving`, `AnnStock`, `AnnAnyClass`, `AnnNewtype`, `AnnOpen`,`AnnClose`

Constructors

HsDerivingClause |
Fields deriv_clause_ext :: XCHsDerivingClause pass deriv_clause_strategy :: Maybe (LDerivStrategy pass) The user-specified strategy (if any) to use when deriving `deriv_clause_tys`. deriv_clause_tys :: LDerivClauseTys pass The types to derive.
XHsDerivingClause !(XXHsDerivingClause pass) |

#### Instances

Instances details

Data (HsDerivingClause GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsDerivingClause GhcPs -> c (HsDerivingClause GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsDerivingClause GhcPs) Source # toConstr :: HsDerivingClause GhcPs -> Constr Source # dataTypeOf :: HsDerivingClause GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsDerivingClause GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsDerivingClause GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> HsDerivingClause GhcPs -> HsDerivingClause GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDerivingClause GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDerivingClause GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsDerivingClause GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDerivingClause GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsDerivingClause GhcPs -> m (HsDerivingClause GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDerivingClause GhcPs -> m (HsDerivingClause GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDerivingClause GhcPs -> m (HsDerivingClause GhcPs) Source #
Data (HsDerivingClause GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsDerivingClause GhcRn -> c (HsDerivingClause GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsDerivingClause GhcRn) Source # toConstr :: HsDerivingClause GhcRn -> Constr Source # dataTypeOf :: HsDerivingClause GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsDerivingClause GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsDerivingClause GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> HsDerivingClause GhcRn -> HsDerivingClause GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDerivingClause GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDerivingClause GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsDerivingClause GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDerivingClause GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsDerivingClause GhcRn -> m (HsDerivingClause GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDerivingClause GhcRn -> m (HsDerivingClause GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDerivingClause GhcRn -> m (HsDerivingClause GhcRn) Source #
Data (HsDerivingClause GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsDerivingClause GhcTc -> c (HsDerivingClause GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsDerivingClause GhcTc) Source # toConstr :: HsDerivingClause GhcTc -> Constr Source # dataTypeOf :: HsDerivingClause GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsDerivingClause GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsDerivingClause GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> HsDerivingClause GhcTc -> HsDerivingClause GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDerivingClause GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDerivingClause GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsDerivingClause GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDerivingClause GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsDerivingClause GhcTc -> m (HsDerivingClause GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDerivingClause GhcTc -> m (HsDerivingClause GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDerivingClause GhcTc -> m (HsDerivingClause GhcTc) Source #
OutputableBndrId p => Outputable (HsDerivingClause (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: HsDerivingClause (GhcPass p) -> SDoc Source #
type Anno (HsDerivingClause (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (HsDerivingClause (GhcPass p)) = SrcSpan

type LHsDerivingClause pass = XRec pass (HsDerivingClause pass) Source #

data DerivClauseTys pass Source #

The types mentioned in a single `deriving` clause. This can come in two forms, `DctSingle` or `DctMulti`, depending on whether the types are surrounded by enclosing parentheses or not. These parentheses are semantically different than `HsParTy`. For example, `deriving ()` means "derive zero classes" rather than "derive an instance of the 0-tuple".

`DerivClauseTys` use `LHsSigType` because `deriving` clauses can mention type variables that aren't bound by the datatype, e.g.

    data T b = ... deriving (C [a])

should produce a derived instance for `C [a] (T b)`.

Constructors

DctSingle (XDctSingle pass) (LHsSigType pass) | A `deriving` clause with a single type. Moreover, that type can only be a type constructor without any arguments. Example: `deriving Eq`
DctMulti (XDctMulti pass) [LHsSigType pass] | A `deriving` clause with a comma-separated list of types, surrounded by enclosing parentheses. Example: `deriving (Eq, C a)`
XDerivClauseTys !(XXDerivClauseTys pass) |

#### Instances

Instances details

Data (DerivClauseTys GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivClauseTys GhcPs -> c (DerivClauseTys GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DerivClauseTys GhcPs) Source # toConstr :: DerivClauseTys GhcPs -> Constr Source # dataTypeOf :: DerivClauseTys GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DerivClauseTys GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DerivClauseTys GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> DerivClauseTys GhcPs -> DerivClauseTys GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivClauseTys GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivClauseTys GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> DerivClauseTys GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivClauseTys GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivClauseTys GhcPs -> m (DerivClauseTys GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivClauseTys GhcPs -> m (DerivClauseTys GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivClauseTys GhcPs -> m (DerivClauseTys GhcPs) Source #
Data (DerivClauseTys GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivClauseTys GhcRn -> c (DerivClauseTys GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DerivClauseTys GhcRn) Source # toConstr :: DerivClauseTys GhcRn -> Constr Source # dataTypeOf :: DerivClauseTys GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DerivClauseTys GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DerivClauseTys GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> DerivClauseTys GhcRn -> DerivClauseTys GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivClauseTys GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivClauseTys GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> DerivClauseTys GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivClauseTys GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivClauseTys GhcRn -> m (DerivClauseTys GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivClauseTys GhcRn -> m (DerivClauseTys GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivClauseTys GhcRn -> m (DerivClauseTys GhcRn) Source #
Data (DerivClauseTys GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivClauseTys GhcTc -> c (DerivClauseTys GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DerivClauseTys GhcTc) Source # toConstr :: DerivClauseTys GhcTc -> Constr Source # dataTypeOf :: DerivClauseTys GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DerivClauseTys GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DerivClauseTys GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> DerivClauseTys GhcTc -> DerivClauseTys GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivClauseTys GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivClauseTys GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> DerivClauseTys GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivClauseTys GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivClauseTys GhcTc -> m (DerivClauseTys GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivClauseTys GhcTc -> m (DerivClauseTys GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivClauseTys GhcTc -> m (DerivClauseTys GhcTc) Source #
OutputableBndrId p => Outputable (DerivClauseTys (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: DerivClauseTys (GhcPass p) -> SDoc Source #
type Anno (DerivClauseTys (GhcPass _1)) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (DerivClauseTys (GhcPass _1)) = SrcSpanAnnC

type LDerivClauseTys pass = XRec pass (DerivClauseTys pass) Source #

data NewOrData Source #

Constructors

NewType |
    newtype Blah ...
DataType |
    data Blah ...

#### Instances

Instances details

Data NewOrData Source # |
Instance details Defined in Language.Haskell.Syntax.Decls Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NewOrData -> c NewOrData Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NewOrData Source # toConstr :: NewOrData -> Constr Source # dataTypeOf :: NewOrData -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NewOrData) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NewOrData) Source # gmapT :: (forall b. Data b => b -> b) -> NewOrData -> NewOrData Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NewOrData -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NewOrData -> r Source # gmapQ :: (forall d. Data d => d -> u) -> NewOrData -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> NewOrData -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NewOrData -> m NewOrData Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NewOrData -> m NewOrData Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NewOrData -> m NewOrData Source #
Outputable NewOrData Source # |
Instance details Defined in Language.Haskell.Syntax.Decls Methods ppr :: NewOrData -> SDoc Source #
Eq NewOrData Source # |
Instance details Defined in Language.Haskell.Syntax.Decls Methods (==) :: NewOrData -> NewOrData -> Bool # (/=) :: NewOrData -> NewOrData -> Bool #

newOrDataToFlavour :: NewOrData -> TyConFlavour Source #

Convert a `NewOrData` to a `TyConFlavour`

data StandaloneKindSig pass Source #

Constructors

StandaloneKindSig (XStandaloneKindSig pass) (LIdP pass) (LHsSigType pass) |
XStandaloneKindSig !(XXStandaloneKindSig pass) |

#### Instances

Instances details

Data (StandaloneKindSig GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> StandaloneKindSig GhcPs -> c (StandaloneKindSig GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (StandaloneKindSig GhcPs) Source # toConstr :: StandaloneKindSig GhcPs -> Constr Source # dataTypeOf :: StandaloneKindSig GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (StandaloneKindSig GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (StandaloneKindSig GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> StandaloneKindSig GhcPs -> StandaloneKindSig GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> StandaloneKindSig GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> StandaloneKindSig GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> StandaloneKindSig GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> StandaloneKindSig GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> StandaloneKindSig GhcPs -> m (StandaloneKindSig GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> StandaloneKindSig GhcPs -> m (StandaloneKindSig GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> StandaloneKindSig GhcPs -> m (StandaloneKindSig GhcPs) Source #
Data (StandaloneKindSig GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> StandaloneKindSig GhcRn -> c (StandaloneKindSig GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (StandaloneKindSig GhcRn) Source # toConstr :: StandaloneKindSig GhcRn -> Constr Source # dataTypeOf :: StandaloneKindSig GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (StandaloneKindSig GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (StandaloneKindSig GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> StandaloneKindSig GhcRn -> StandaloneKindSig GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> StandaloneKindSig GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> StandaloneKindSig GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> StandaloneKindSig GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> StandaloneKindSig GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> StandaloneKindSig GhcRn -> m (StandaloneKindSig GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> StandaloneKindSig GhcRn -> m (StandaloneKindSig GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> StandaloneKindSig GhcRn -> m (StandaloneKindSig GhcRn) Source #
Data (StandaloneKindSig GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> StandaloneKindSig GhcTc -> c (StandaloneKindSig GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (StandaloneKindSig GhcTc) Source # toConstr :: StandaloneKindSig GhcTc -> Constr Source # dataTypeOf :: StandaloneKindSig GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (StandaloneKindSig GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (StandaloneKindSig GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> StandaloneKindSig GhcTc -> StandaloneKindSig GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> StandaloneKindSig GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> StandaloneKindSig GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> StandaloneKindSig GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> StandaloneKindSig GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> StandaloneKindSig GhcTc -> m (StandaloneKindSig GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> StandaloneKindSig GhcTc -> m (StandaloneKindSig GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> StandaloneKindSig GhcTc -> m (StandaloneKindSig GhcTc) Source #
OutputableBndrId p => Outputable (StandaloneKindSig (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: StandaloneKindSig (GhcPass p) -> SDoc Source #
type Anno (StandaloneKindSig (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (StandaloneKindSig (GhcPass p)) = SrcSpanAnnA

type LStandaloneKindSig pass = XRec pass (StandaloneKindSig pass) Source #

Located Standalone Kind Signature

## Class or type declarations

data TyClDecl pass Source #

A type or class declaration.

Constructors

FamDecl |
    type/data family T :: *->*
`AnnKeywordId` : `AnnType`, `AnnData`, `AnnFamily`,`AnnDcolon`, `AnnWhere`,`AnnOpenP`, `AnnDcolon`,`AnnCloseP`, `AnnEqual`,`AnnRarrow`, `AnnVbar`
Fields tcdFExt :: XFamDecl pass tcdFam :: FamilyDecl pass
SynDecl | `type` declaration `AnnKeywordId` : `AnnType`, `AnnEqual`,
Fields tcdSExt :: XSynDecl pass Post renameer, FVs tcdLName :: LIdP pass Type constructor tcdTyVars :: LHsQTyVars pass Type variables; for an associated type these include outer binders tcdFixity :: LexicalFixity Fixity used in the declaration tcdRhs :: LHsType pass RHS of type declaration
DataDecl | `data` declaration `AnnKeywordId` : `AnnData`, `AnnFamily`, `AnnNewType`, `AnnNewType`,`AnnDcolon` `AnnWhere`,
Fields tcdDExt :: XDataDecl pass Post renamer, CUSK flag, FVs tcdLName :: LIdP pass Type constructor tcdTyVars :: LHsQTyVars pass Type variables; for an associated type these include outer binders tcdFixity :: LexicalFixity Fixity used in the declaration tcdDataDefn :: HsDataDefn pass
ClassDecl |
Fields tcdCExt :: XClassDecl pass Post renamer, FVs tcdCtxt :: Maybe (LHsContext pass) Context... tcdLName :: LIdP pass Type constructor tcdTyVars :: LHsQTyVars pass Type variables; for an associated type these include outer binders tcdFixity :: LexicalFixity Fixity used in the declaration tcdFDs :: [LHsFunDep pass] Functional deps tcdSigs :: [LSig pass] Methods' signatures tcdMeths :: LHsBinds pass Default methods tcdATs :: [LFamilyDecl pass] Associated types; tcdATDefs :: [LTyFamDefltDecl pass] Associated type defaults tcdDocs :: [LDocDecl pass] Haddock docs
XTyClDecl !(XXTyClDecl pass) |

#### Instances

Instances details

Data (TyClDecl GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyClDecl GhcPs -> c (TyClDecl GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyClDecl GhcPs) Source # toConstr :: TyClDecl GhcPs -> Constr Source # dataTypeOf :: TyClDecl GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyClDecl GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TyClDecl GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> TyClDecl GhcPs -> TyClDecl GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyClDecl GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyClDecl GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> TyClDecl GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> TyClDecl GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyClDecl GhcPs -> m (TyClDecl GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClDecl GhcPs -> m (TyClDecl GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClDecl GhcPs -> m (TyClDecl GhcPs) Source #
Data (TyClDecl GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyClDecl GhcRn -> c (TyClDecl GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyClDecl GhcRn) Source # toConstr :: TyClDecl GhcRn -> Constr Source # dataTypeOf :: TyClDecl GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyClDecl GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TyClDecl GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> TyClDecl GhcRn -> TyClDecl GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyClDecl GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyClDecl GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> TyClDecl GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> TyClDecl GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyClDecl GhcRn -> m (TyClDecl GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClDecl GhcRn -> m (TyClDecl GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClDecl GhcRn -> m (TyClDecl GhcRn) Source #
Data (TyClDecl GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyClDecl GhcTc -> c (TyClDecl GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyClDecl GhcTc) Source # toConstr :: TyClDecl GhcTc -> Constr Source # dataTypeOf :: TyClDecl GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyClDecl GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TyClDecl GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> TyClDecl GhcTc -> TyClDecl GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyClDecl GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyClDecl GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> TyClDecl GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> TyClDecl GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyClDecl GhcTc -> m (TyClDecl GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClDecl GhcTc -> m (TyClDecl GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClDecl GhcTc -> m (TyClDecl GhcTc) Source #
OutputableBndrId p => Outputable (TyClDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: TyClDecl (GhcPass p) -> SDoc Source #
type Anno (TyClDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (TyClDecl (GhcPass p)) = SrcSpanAnnA

type LTyClDecl pass = XRec pass (TyClDecl pass) Source #

Located Declaration of a Type or Class

data DataDeclRn Source #

Constructors

DataDeclRn |
Fields tcdDataCusk :: Bool does this have a CUSK? See Note [CUSKs: complete user-supplied kind signatures] tcdFVs :: NameSet

#### Instances

Instances details

Data DataDeclRn Source # |
Instance details Defined in Language.Haskell.Syntax.Decls Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataDeclRn -> c DataDeclRn Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DataDeclRn Source # toConstr :: DataDeclRn -> Constr Source # dataTypeOf :: DataDeclRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DataDeclRn) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataDeclRn) Source # gmapT :: (forall b. Data b => b -> b) -> DataDeclRn -> DataDeclRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataDeclRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DataDeclRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> DataDeclRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> DataDeclRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DataDeclRn -> m DataDeclRn Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DataDeclRn -> m DataDeclRn Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DataDeclRn -> m DataDeclRn Source #

data TyClGroup pass Source #

Type or Class Group

Constructors

TyClGroup |
Fields group_ext :: XCTyClGroup pass group_tyclds :: [LTyClDecl pass] group_roles :: [LRoleAnnotDecl pass] group_kisigs :: [LStandaloneKindSig pass] group_instds :: [LInstDecl pass]
XTyClGroup !(XXTyClGroup pass) |

#### Instances

Instances details

Data (TyClGroup GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyClGroup GhcPs -> c (TyClGroup GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyClGroup GhcPs) Source # toConstr :: TyClGroup GhcPs -> Constr Source # dataTypeOf :: TyClGroup GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyClGroup GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TyClGroup GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> TyClGroup GhcPs -> TyClGroup GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyClGroup GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyClGroup GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> TyClGroup GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> TyClGroup GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyClGroup GhcPs -> m (TyClGroup GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClGroup GhcPs -> m (TyClGroup GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClGroup GhcPs -> m (TyClGroup GhcPs) Source #
Data (TyClGroup GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyClGroup GhcRn -> c (TyClGroup GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyClGroup GhcRn) Source # toConstr :: TyClGroup GhcRn -> Constr Source # dataTypeOf :: TyClGroup GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyClGroup GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TyClGroup GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> TyClGroup GhcRn -> TyClGroup GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyClGroup GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyClGroup GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> TyClGroup GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> TyClGroup GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyClGroup GhcRn -> m (TyClGroup GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClGroup GhcRn -> m (TyClGroup GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClGroup GhcRn -> m (TyClGroup GhcRn) Source #
Data (TyClGroup GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyClGroup GhcTc -> c (TyClGroup GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyClGroup GhcTc) Source # toConstr :: TyClGroup GhcTc -> Constr Source # dataTypeOf :: TyClGroup GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyClGroup GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TyClGroup GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> TyClGroup GhcTc -> TyClGroup GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyClGroup GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyClGroup GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> TyClGroup GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> TyClGroup GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyClGroup GhcTc -> m (TyClGroup GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClGroup GhcTc -> m (TyClGroup GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClGroup GhcTc -> m (TyClGroup GhcTc) Source #
OutputableBndrId p => Outputable (TyClGroup (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: TyClGroup (GhcPass p) -> SDoc Source #

tyClGroupTyClDecls :: [TyClGroup pass] -> [LTyClDecl pass] Source #

tyClGroupInstDecls :: [TyClGroup pass] -> [LInstDecl pass] Source #

tyClGroupRoleDecls :: [TyClGroup pass] -> [LRoleAnnotDecl pass] Source #

tyClGroupKindSigs :: [TyClGroup pass] -> [LStandaloneKindSig pass] Source #

isClassDecl :: TyClDecl pass -> Bool Source #

type class

isDataDecl :: TyClDecl pass -> Bool Source #

`True` = argument is a `data`/`newtype` declaration.

isSynDecl :: TyClDecl pass -> Bool Source #

type or type instance declaration

isFamilyDecl :: TyClDecl pass -> Bool Source #

type/data family declaration

isTypeFamilyDecl :: TyClDecl pass -> Bool Source #

type family declaration

isDataFamilyDecl :: TyClDecl pass -> Bool Source #

data family declaration

isOpenTypeFamilyInfo :: FamilyInfo pass -> Bool Source #

open type family info

isClosedTypeFamilyInfo :: FamilyInfo pass -> Bool Source #

closed type family info

countTyClDecls :: [TyClDecl pass] -> (Int, Int, Int, Int, Int) Source #

tyClDeclTyVars :: TyClDecl pass -> LHsQTyVars pass Source #

data FamilyDecl pass Source #

type Family Declaration

Constructors

FamilyDecl |
Fields fdExt :: XCFamilyDecl pass fdInfo :: FamilyInfo pass fdTopLevel :: TopLevelFlag fdLName :: LIdP pass fdTyVars :: LHsQTyVars pass fdFixity :: LexicalFixity fdResultSig :: LFamilyResultSig pass fdInjectivityAnn :: Maybe (LInjectivityAnn pass)
XFamilyDecl !(XXFamilyDecl pass) | `AnnKeywordId` : `AnnType`, `AnnData`, `AnnFamily`, `AnnWhere`, `AnnOpenP`, `AnnDcolon`, `AnnCloseP`, `AnnEqual`, `AnnRarrow`, `AnnVbar`

#### Instances

Instances details

Data (FamilyDecl GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamilyDecl GhcPs -> c (FamilyDecl GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FamilyDecl GhcPs) Source # toConstr :: FamilyDecl GhcPs -> Constr Source # dataTypeOf :: FamilyDecl GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FamilyDecl GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FamilyDecl GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> FamilyDecl GhcPs -> FamilyDecl GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamilyDecl GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamilyDecl GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> FamilyDecl GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> FamilyDecl GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamilyDecl GhcPs -> m (FamilyDecl GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyDecl GhcPs -> m (FamilyDecl GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyDecl GhcPs -> m (FamilyDecl GhcPs) Source #
Data (FamilyDecl GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamilyDecl GhcRn -> c (FamilyDecl GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FamilyDecl GhcRn) Source # toConstr :: FamilyDecl GhcRn -> Constr Source # dataTypeOf :: FamilyDecl GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FamilyDecl GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FamilyDecl GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> FamilyDecl GhcRn -> FamilyDecl GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamilyDecl GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamilyDecl GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> FamilyDecl GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> FamilyDecl GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamilyDecl GhcRn -> m (FamilyDecl GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyDecl GhcRn -> m (FamilyDecl GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyDecl GhcRn -> m (FamilyDecl GhcRn) Source #
Data (FamilyDecl GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamilyDecl GhcTc -> c (FamilyDecl GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FamilyDecl GhcTc) Source # toConstr :: FamilyDecl GhcTc -> Constr Source # dataTypeOf :: FamilyDecl GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FamilyDecl GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FamilyDecl GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> FamilyDecl GhcTc -> FamilyDecl GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamilyDecl GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamilyDecl GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> FamilyDecl GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> FamilyDecl GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamilyDecl GhcTc -> m (FamilyDecl GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyDecl GhcTc -> m (FamilyDecl GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyDecl GhcTc -> m (FamilyDecl GhcTc) Source #
OutputableBndrId p => Outputable (FamilyDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: FamilyDecl (GhcPass p) -> SDoc Source #
type Anno (FamilyDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (FamilyDecl (GhcPass p)) = SrcSpanAnnA

type LFamilyDecl pass = XRec pass (FamilyDecl pass) Source #

Located type Family Declaration

## Instance declarations

data InstDecl pass Source #

Instance Declaration

Constructors

ClsInstD |
Fields cid_d_ext :: XClsInstD pass cid_inst :: ClsInstDecl pass
DataFamInstD |
Fields dfid_ext :: XDataFamInstD pass dfid_inst :: DataFamInstDecl pass
TyFamInstD |
Fields tfid_ext :: XTyFamInstD pass tfid_inst :: TyFamInstDecl pass
XInstDecl !(XXInstDecl pass) |

#### Instances

Instances details

Data (InstDecl GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InstDecl GhcPs -> c (InstDecl GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (InstDecl GhcPs) Source # toConstr :: InstDecl GhcPs -> Constr Source # dataTypeOf :: InstDecl GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (InstDecl GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (InstDecl GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> InstDecl GhcPs -> InstDecl GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InstDecl GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InstDecl GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> InstDecl GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> InstDecl GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> InstDecl GhcPs -> m (InstDecl GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InstDecl GhcPs -> m (InstDecl GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InstDecl GhcPs -> m (InstDecl GhcPs) Source #
Data (InstDecl GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InstDecl GhcRn -> c (InstDecl GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (InstDecl GhcRn) Source # toConstr :: InstDecl GhcRn -> Constr Source # dataTypeOf :: InstDecl GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (InstDecl GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (InstDecl GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> InstDecl GhcRn -> InstDecl GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InstDecl GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InstDecl GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> InstDecl GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> InstDecl GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> InstDecl GhcRn -> m (InstDecl GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InstDecl GhcRn -> m (InstDecl GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InstDecl GhcRn -> m (InstDecl GhcRn) Source #
Data (InstDecl GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InstDecl GhcTc -> c (InstDecl GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (InstDecl GhcTc) Source # toConstr :: InstDecl GhcTc -> Constr Source # dataTypeOf :: InstDecl GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (InstDecl GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (InstDecl GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> InstDecl GhcTc -> InstDecl GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InstDecl GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InstDecl GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> InstDecl GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> InstDecl GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> InstDecl GhcTc -> m (InstDecl GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InstDecl GhcTc -> m (InstDecl GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InstDecl GhcTc -> m (InstDecl GhcTc) Source #
OutputableBndrId p => Outputable (InstDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: InstDecl (GhcPass p) -> SDoc Source #
type Anno (InstDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (InstDecl (GhcPass p)) = SrcSpanAnnA

type LInstDecl pass = XRec pass (InstDecl pass) Source #

Located Instance Declaration

data FamilyInfo pass Source #

Constructors

DataFamily |
OpenTypeFamily |
ClosedTypeFamily (Maybe [LTyFamInstEqn pass]) | `Nothing` if we're in an hs-boot file and the user said "type family Foo x where .."

#### Instances

Instances details

Data (FamilyInfo GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamilyInfo GhcPs -> c (FamilyInfo GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FamilyInfo GhcPs) Source # toConstr :: FamilyInfo GhcPs -> Constr Source # dataTypeOf :: FamilyInfo GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FamilyInfo GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FamilyInfo GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> FamilyInfo GhcPs -> FamilyInfo GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamilyInfo GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamilyInfo GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> FamilyInfo GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> FamilyInfo GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamilyInfo GhcPs -> m (FamilyInfo GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyInfo GhcPs -> m (FamilyInfo GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyInfo GhcPs -> m (FamilyInfo GhcPs) Source #
Data (FamilyInfo GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamilyInfo GhcRn -> c (FamilyInfo GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FamilyInfo GhcRn) Source # toConstr :: FamilyInfo GhcRn -> Constr Source # dataTypeOf :: FamilyInfo GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FamilyInfo GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FamilyInfo GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> FamilyInfo GhcRn -> FamilyInfo GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamilyInfo GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamilyInfo GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> FamilyInfo GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> FamilyInfo GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamilyInfo GhcRn -> m (FamilyInfo GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyInfo GhcRn -> m (FamilyInfo GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyInfo GhcRn -> m (FamilyInfo GhcRn) Source #
Data (FamilyInfo GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamilyInfo GhcTc -> c (FamilyInfo GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FamilyInfo GhcTc) Source # toConstr :: FamilyInfo GhcTc -> Constr Source # dataTypeOf :: FamilyInfo GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FamilyInfo GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FamilyInfo GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> FamilyInfo GhcTc -> FamilyInfo GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamilyInfo GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamilyInfo GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> FamilyInfo GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> FamilyInfo GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamilyInfo GhcTc -> m (FamilyInfo GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyInfo GhcTc -> m (FamilyInfo GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyInfo GhcTc -> m (FamilyInfo GhcTc) Source #
Outputable (FamilyInfo pass) Source # |
Instance details Defined in Language.Haskell.Syntax.Decls Methods ppr :: FamilyInfo pass -> SDoc Source #

pprFlavour :: FamilyInfo pass -> SDoc Source #

data TyFamInstDecl pass Source #

Type Family Instance Declaration

Constructors

TyFamInstDecl | `AnnKeywordId` : `AnnType`, `AnnInstance`,
Fields tfid_xtn :: XCTyFamInstDecl pass tfid_eqn :: TyFamInstEqn pass
XTyFamInstDecl !(XXTyFamInstDecl pass) |

#### Instances

Instances details

Data (TyFamInstDecl GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyFamInstDecl GhcPs -> c (TyFamInstDecl GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyFamInstDecl GhcPs) Source # toConstr :: TyFamInstDecl GhcPs -> Constr Source # dataTypeOf :: TyFamInstDecl GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyFamInstDecl GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TyFamInstDecl GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> TyFamInstDecl GhcPs -> TyFamInstDecl GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyFamInstDecl GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyFamInstDecl GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> TyFamInstDecl GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> TyFamInstDecl GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyFamInstDecl GhcPs -> m (TyFamInstDecl GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyFamInstDecl GhcPs -> m (TyFamInstDecl GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyFamInstDecl GhcPs -> m (TyFamInstDecl GhcPs) Source #
Data (TyFamInstDecl GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyFamInstDecl GhcRn -> c (TyFamInstDecl GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyFamInstDecl GhcRn) Source # toConstr :: TyFamInstDecl GhcRn -> Constr Source # dataTypeOf :: TyFamInstDecl GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyFamInstDecl GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TyFamInstDecl GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> TyFamInstDecl GhcRn -> TyFamInstDecl GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyFamInstDecl GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyFamInstDecl GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> TyFamInstDecl GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> TyFamInstDecl GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyFamInstDecl GhcRn -> m (TyFamInstDecl GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyFamInstDecl GhcRn -> m (TyFamInstDecl GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyFamInstDecl GhcRn -> m (TyFamInstDecl GhcRn) Source #
Data (TyFamInstDecl GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyFamInstDecl GhcTc -> c (TyFamInstDecl GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyFamInstDecl GhcTc) Source # toConstr :: TyFamInstDecl GhcTc -> Constr Source # dataTypeOf :: TyFamInstDecl GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyFamInstDecl GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TyFamInstDecl GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> TyFamInstDecl GhcTc -> TyFamInstDecl GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyFamInstDecl GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyFamInstDecl GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> TyFamInstDecl GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> TyFamInstDecl GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyFamInstDecl GhcTc -> m (TyFamInstDecl GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyFamInstDecl GhcTc -> m (TyFamInstDecl GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyFamInstDecl GhcTc -> m (TyFamInstDecl GhcTc) Source #
OutputableBndrId p => Outputable (TyFamInstDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: TyFamInstDecl (GhcPass p) -> SDoc Source #
type Anno (TyFamInstDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (TyFamInstDecl (GhcPass p)) = SrcSpanAnnA

type LTyFamInstDecl pass = XRec pass (TyFamInstDecl pass) Source #

Located Type Family Instance Declaration

type TyFamDefltDecl = TyFamInstDecl Source #

Type family default declarations. A convenient synonym for `TyFamInstDecl`. See `Note [Type family instance declarations in HsSyn]`.

type LTyFamDefltDecl pass = XRec pass (TyFamDefltDecl pass) Source #

Located type family default declarations.

newtype DataFamInstDecl pass Source #

Data Family Instance Declaration

Constructors

DataFamInstDecl | `AnnKeywordId` : `AnnData`, `AnnNewType`,`AnnInstance`, `AnnDcolon` `AnnWhere`,`AnnOpen`, `AnnClose`
Fields dfid_eqn :: FamEqn pass (HsDataDefn pass)

#### Instances

Instances details

Data (DataFamInstDecl GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataFamInstDecl GhcPs -> c (DataFamInstDecl GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DataFamInstDecl GhcPs) Source # toConstr :: DataFamInstDecl GhcPs -> Constr Source # dataTypeOf :: DataFamInstDecl GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DataFamInstDecl GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DataFamInstDecl GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> DataFamInstDecl GhcPs -> DataFamInstDecl GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataFamInstDecl GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DataFamInstDecl GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> DataFamInstDecl GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> DataFamInstDecl GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DataFamInstDecl GhcPs -> m (DataFamInstDecl GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DataFamInstDecl GhcPs -> m (DataFamInstDecl GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DataFamInstDecl GhcPs -> m (DataFamInstDecl GhcPs) Source #
Data (DataFamInstDecl GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataFamInstDecl GhcRn -> c (DataFamInstDecl GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DataFamInstDecl GhcRn) Source # toConstr :: DataFamInstDecl GhcRn -> Constr Source # dataTypeOf :: DataFamInstDecl GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DataFamInstDecl GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DataFamInstDecl GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> DataFamInstDecl GhcRn -> DataFamInstDecl GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataFamInstDecl GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DataFamInstDecl GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> DataFamInstDecl GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> DataFamInstDecl GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DataFamInstDecl GhcRn -> m (DataFamInstDecl GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DataFamInstDecl GhcRn -> m (DataFamInstDecl GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DataFamInstDecl GhcRn -> m (DataFamInstDecl GhcRn) Source #
Data (DataFamInstDecl GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataFamInstDecl GhcTc -> c (DataFamInstDecl GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DataFamInstDecl GhcTc) Source # toConstr :: DataFamInstDecl GhcTc -> Constr Source # dataTypeOf :: DataFamInstDecl GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DataFamInstDecl GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DataFamInstDecl GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> DataFamInstDecl GhcTc -> DataFamInstDecl GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataFamInstDecl GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DataFamInstDecl GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> DataFamInstDecl GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> DataFamInstDecl GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DataFamInstDecl GhcTc -> m (DataFamInstDecl GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DataFamInstDecl GhcTc -> m (DataFamInstDecl GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DataFamInstDecl GhcTc -> m (DataFamInstDecl GhcTc) Source #
OutputableBndrId p => Outputable (DataFamInstDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: DataFamInstDecl (GhcPass p) -> SDoc Source #
type Anno (DataFamInstDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (DataFamInstDecl (GhcPass p)) = SrcSpanAnnA

type LDataFamInstDecl pass = XRec pass (DataFamInstDecl pass) Source #

Located Data Family Instance Declaration

data FamEqn pass rhs Source #

Family Equation

One equation in a type family instance declaration, data family instance declaration, or type family default. See Note [Type family instance declarations in HsSyn] See Note [Family instance declaration binders]

Constructors

FamEqn |
Fields feqn_ext :: XCFamEqn pass rhs feqn_tycon :: LIdP pass feqn_bndrs :: HsOuterFamEqnTyVarBndrs pass Optional quantified type vars feqn_pats :: HsTyPats pass feqn_fixity :: LexicalFixity Fixity used in the declaration feqn_rhs :: rhs `AnnKeywordId` : `AnnEqual`
XFamEqn !(XXFamEqn pass rhs) |

#### Instances

Instances details

Data rhs => Data (FamEqn GhcPs rhs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamEqn GhcPs rhs -> c (FamEqn GhcPs rhs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FamEqn GhcPs rhs) Source # toConstr :: FamEqn GhcPs rhs -> Constr Source # dataTypeOf :: FamEqn GhcPs rhs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FamEqn GhcPs rhs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FamEqn GhcPs rhs)) Source # gmapT :: (forall b. Data b => b -> b) -> FamEqn GhcPs rhs -> FamEqn GhcPs rhs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamEqn GhcPs rhs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamEqn GhcPs rhs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> FamEqn GhcPs rhs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> FamEqn GhcPs rhs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamEqn GhcPs rhs -> m (FamEqn GhcPs rhs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamEqn GhcPs rhs -> m (FamEqn GhcPs rhs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamEqn GhcPs rhs -> m (FamEqn GhcPs rhs) Source #
Data rhs => Data (FamEqn GhcRn rhs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamEqn GhcRn rhs -> c (FamEqn GhcRn rhs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FamEqn GhcRn rhs) Source # toConstr :: FamEqn GhcRn rhs -> Constr Source # dataTypeOf :: FamEqn GhcRn rhs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FamEqn GhcRn rhs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FamEqn GhcRn rhs)) Source # gmapT :: (forall b. Data b => b -> b) -> FamEqn GhcRn rhs -> FamEqn GhcRn rhs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamEqn GhcRn rhs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamEqn GhcRn rhs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> FamEqn GhcRn rhs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> FamEqn GhcRn rhs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamEqn GhcRn rhs -> m (FamEqn GhcRn rhs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamEqn GhcRn rhs -> m (FamEqn GhcRn rhs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamEqn GhcRn rhs -> m (FamEqn GhcRn rhs) Source #
Data rhs => Data (FamEqn GhcTc rhs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamEqn GhcTc rhs -> c (FamEqn GhcTc rhs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FamEqn GhcTc rhs) Source # toConstr :: FamEqn GhcTc rhs -> Constr Source # dataTypeOf :: FamEqn GhcTc rhs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FamEqn GhcTc rhs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FamEqn GhcTc rhs)) Source # gmapT :: (forall b. Data b => b -> b) -> FamEqn GhcTc rhs -> FamEqn GhcTc rhs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamEqn GhcTc rhs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamEqn GhcTc rhs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> FamEqn GhcTc rhs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> FamEqn GhcTc rhs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamEqn GhcTc rhs -> m (FamEqn GhcTc rhs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamEqn GhcTc rhs -> m (FamEqn GhcTc rhs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamEqn GhcTc rhs -> m (FamEqn GhcTc rhs) Source #
type Anno (FamEqn (GhcPass p) _1) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (FamEqn (GhcPass p) _1) = SrcSpanAnnA
type Anno (FamEqn (GhcPass p) _1) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (FamEqn (GhcPass p) _1) = SrcSpanAnnA
type Anno (FamEqn p (LocatedA (HsType p))) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (FamEqn p (LocatedA (HsType p))) = SrcSpanAnnA

type TyFamInstEqn pass = FamEqn pass (LHsType pass) Source #

Type Family Instance Equation

type LTyFamInstEqn pass Source #

Arguments

= XRec pass (TyFamInstEqn pass) | May have `AnnKeywordId` : `AnnSemi` when in a list

Located Type Family Instance Equation

type HsTyPats pass = [LHsTypeArg pass] Source #

Haskell Type Patterns

type LClsInstDecl pass = XRec pass (ClsInstDecl pass) Source #

Located Class Instance Declaration

data ClsInstDecl pass Source #

Class Instance Declaration

Constructors

ClsInstDecl |
Fields cid_ext :: XCClsInstDecl pass cid_poly_ty :: LHsSigType pass cid_binds :: LHsBinds pass cid_sigs :: [LSig pass] cid_tyfam_insts :: [LTyFamInstDecl pass] cid_datafam_insts :: [LDataFamInstDecl pass] cid_overlap_mode :: Maybe (XRec pass OverlapMode) `AnnKeywordId` : `AnnOpen`, `AnnClose`,
XClsInstDecl !(XXClsInstDecl pass) |

#### Instances

Instances details

Data (ClsInstDecl GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ClsInstDecl GhcPs -> c (ClsInstDecl GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ClsInstDecl GhcPs) Source # toConstr :: ClsInstDecl GhcPs -> Constr Source # dataTypeOf :: ClsInstDecl GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ClsInstDecl GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ClsInstDecl GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> ClsInstDecl GhcPs -> ClsInstDecl GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ClsInstDecl GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ClsInstDecl GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> ClsInstDecl GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> ClsInstDecl GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ClsInstDecl GhcPs -> m (ClsInstDecl GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ClsInstDecl GhcPs -> m (ClsInstDecl GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ClsInstDecl GhcPs -> m (ClsInstDecl GhcPs) Source #
Data (ClsInstDecl GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ClsInstDecl GhcRn -> c (ClsInstDecl GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ClsInstDecl GhcRn) Source # toConstr :: ClsInstDecl GhcRn -> Constr Source # dataTypeOf :: ClsInstDecl GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ClsInstDecl GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ClsInstDecl GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> ClsInstDecl GhcRn -> ClsInstDecl GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ClsInstDecl GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ClsInstDecl GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> ClsInstDecl GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> ClsInstDecl GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ClsInstDecl GhcRn -> m (ClsInstDecl GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ClsInstDecl GhcRn -> m (ClsInstDecl GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ClsInstDecl GhcRn -> m (ClsInstDecl GhcRn) Source #
Data (ClsInstDecl GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ClsInstDecl GhcTc -> c (ClsInstDecl GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ClsInstDecl GhcTc) Source # toConstr :: ClsInstDecl GhcTc -> Constr Source # dataTypeOf :: ClsInstDecl GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ClsInstDecl GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ClsInstDecl GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> ClsInstDecl GhcTc -> ClsInstDecl GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ClsInstDecl GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ClsInstDecl GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> ClsInstDecl GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> ClsInstDecl GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ClsInstDecl GhcTc -> m (ClsInstDecl GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ClsInstDecl GhcTc -> m (ClsInstDecl GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ClsInstDecl GhcTc -> m (ClsInstDecl GhcTc) Source #
OutputableBndrId p => Outputable (ClsInstDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: ClsInstDecl (GhcPass p) -> SDoc Source #
type Anno (ClsInstDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (ClsInstDecl (GhcPass p)) = SrcSpanAnnA

## Standalone deriving declarations

data DerivDecl pass Source #

Stand-alone 'deriving instance' declaration

Constructors

DerivDecl |
- Fields deriv_ext :: XCDerivDecl pass deriv_type :: LHsSigWcType pass The instance type to derive. It uses an `LHsSigWcType` because the context is allowed to be a single wildcard:
      deriving instance _ => Eq (Foo a)
Which signifies that the context should be inferred. deriv_strategy :: Maybe (LDerivStrategy pass) deriv_overlap_mode :: Maybe (XRec pass OverlapMode) `AnnKeywordId` : `AnnDeriving`, `AnnInstance`, `AnnStock`, `AnnAnyClass`, `AnnNewtype`, `AnnOpen`,`AnnClose`
XDerivDecl !(XXDerivDecl pass) |

#### Instances

Instances details

Data (DerivDecl GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivDecl GhcPs -> c (DerivDecl GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DerivDecl GhcPs) Source # toConstr :: DerivDecl GhcPs -> Constr Source # dataTypeOf :: DerivDecl GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DerivDecl GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DerivDecl GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> DerivDecl GhcPs -> DerivDecl GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivDecl GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivDecl GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> DerivDecl GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivDecl GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivDecl GhcPs -> m (DerivDecl GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivDecl GhcPs -> m (DerivDecl GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivDecl GhcPs -> m (DerivDecl GhcPs) Source #
Data (DerivDecl GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivDecl GhcRn -> c (DerivDecl GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DerivDecl GhcRn) Source # toConstr :: DerivDecl GhcRn -> Constr Source # dataTypeOf :: DerivDecl GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DerivDecl GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DerivDecl GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> DerivDecl GhcRn -> DerivDecl GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivDecl GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivDecl GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> DerivDecl GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivDecl GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivDecl GhcRn -> m (DerivDecl GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivDecl GhcRn -> m (DerivDecl GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivDecl GhcRn -> m (DerivDecl GhcRn) Source #
Data (DerivDecl GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivDecl GhcTc -> c (DerivDecl GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DerivDecl GhcTc) Source # toConstr :: DerivDecl GhcTc -> Constr Source # dataTypeOf :: DerivDecl GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DerivDecl GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DerivDecl GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> DerivDecl GhcTc -> DerivDecl GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivDecl GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivDecl GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> DerivDecl GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivDecl GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivDecl GhcTc -> m (DerivDecl GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivDecl GhcTc -> m (DerivDecl GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivDecl GhcTc -> m (DerivDecl GhcTc) Source #
OutputableBndrId p => Outputable (DerivDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: DerivDecl (GhcPass p) -> SDoc Source #
type Anno (DerivDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (DerivDecl (GhcPass p)) = SrcSpanAnnA

type LDerivDecl pass = XRec pass (DerivDecl pass) Source #

Located stand-alone 'deriving instance' declaration

## Deriving strategies

data DerivStrategy pass Source #

Which technique the user explicitly requested when deriving an instance.

Constructors

StockStrategy (XStockStrategy pass) | GHC's "standard" strategy, which is to implement a custom instance for the data type. This only works for certain types that GHC knows about (e.g., `Eq`, `Show`, `Functor` when `-XDeriveFunctor` is enabled, etc.)
AnyclassStrategy (XAnyClassStrategy pass) |
    -XDeriveAnyClass
NewtypeStrategy (XNewtypeStrategy pass) |
    -XGeneralizedNewtypeDeriving
ViaStrategy (XViaStrategy pass) |
    -XDerivingVia

#### Instances

Instances details

Data (DerivStrategy GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivStrategy GhcPs -> c (DerivStrategy GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DerivStrategy GhcPs) Source # toConstr :: DerivStrategy GhcPs -> Constr Source # dataTypeOf :: DerivStrategy GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DerivStrategy GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DerivStrategy GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> DerivStrategy GhcPs -> DerivStrategy GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> DerivStrategy GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivStrategy GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivStrategy GhcPs -> m (DerivStrategy GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy GhcPs -> m (DerivStrategy GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy GhcPs -> m (DerivStrategy GhcPs) Source #
Data (DerivStrategy GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivStrategy GhcRn -> c (DerivStrategy GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DerivStrategy GhcRn) Source # toConstr :: DerivStrategy GhcRn -> Constr Source # dataTypeOf :: DerivStrategy GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DerivStrategy GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DerivStrategy GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> DerivStrategy GhcRn -> DerivStrategy GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> DerivStrategy GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivStrategy GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivStrategy GhcRn -> m (DerivStrategy GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy GhcRn -> m (DerivStrategy GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy GhcRn -> m (DerivStrategy GhcRn) Source #
Data (DerivStrategy GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivStrategy GhcTc -> c (DerivStrategy GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DerivStrategy GhcTc) Source # toConstr :: DerivStrategy GhcTc -> Constr Source # dataTypeOf :: DerivStrategy GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DerivStrategy GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DerivStrategy GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> DerivStrategy GhcTc -> DerivStrategy GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> DerivStrategy GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivStrategy GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivStrategy GhcTc -> m (DerivStrategy GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy GhcTc -> m (DerivStrategy GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy GhcTc -> m (DerivStrategy GhcTc) Source #
OutputableBndrId p => Outputable (DerivStrategy (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: DerivStrategy (GhcPass p) -> SDoc Source #
type Anno (DerivStrategy (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (DerivStrategy (GhcPass p)) = SrcSpan

type LDerivStrategy pass = XRec pass (DerivStrategy pass) Source #

A `Located` `DerivStrategy`.

derivStrategyName :: DerivStrategy a -> SDoc Source #

A short description of a `DerivStrategy'`.

## `RULE` declarations

type LRuleDecls pass = XRec pass (RuleDecls pass) Source #

Located Rule Declarations

data RuleDecls pass Source #

Rule Declarations

Constructors

HsRules |
Fields rds_ext :: XCRuleDecls pass rds_src :: SourceText rds_rules :: [LRuleDecl pass]
XRuleDecls !(XXRuleDecls pass) |

#### Instances

Instances details

Data (RuleDecls GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleDecls GhcPs -> c (RuleDecls GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RuleDecls GhcPs) Source # toConstr :: RuleDecls GhcPs -> Constr Source # dataTypeOf :: RuleDecls GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RuleDecls GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RuleDecls GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> RuleDecls GhcPs -> RuleDecls GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecls GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecls GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> RuleDecls GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleDecls GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleDecls GhcPs -> m (RuleDecls GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecls GhcPs -> m (RuleDecls GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecls GhcPs -> m (RuleDecls GhcPs) Source #
Data (RuleDecls GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleDecls GhcRn -> c (RuleDecls GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RuleDecls GhcRn) Source # toConstr :: RuleDecls GhcRn -> Constr Source # dataTypeOf :: RuleDecls GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RuleDecls GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RuleDecls GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> RuleDecls GhcRn -> RuleDecls GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecls GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecls GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> RuleDecls GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleDecls GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleDecls GhcRn -> m (RuleDecls GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecls GhcRn -> m (RuleDecls GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecls GhcRn -> m (RuleDecls GhcRn) Source #
Data (RuleDecls GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleDecls GhcTc -> c (RuleDecls GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RuleDecls GhcTc) Source # toConstr :: RuleDecls GhcTc -> Constr Source # dataTypeOf :: RuleDecls GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RuleDecls GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RuleDecls GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> RuleDecls GhcTc -> RuleDecls GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecls GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecls GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> RuleDecls GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleDecls GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleDecls GhcTc -> m (RuleDecls GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecls GhcTc -> m (RuleDecls GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecls GhcTc -> m (RuleDecls GhcTc) Source #
OutputableBndrId p => Outputable (RuleDecls (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: RuleDecls (GhcPass p) -> SDoc Source #
type Anno (RuleDecls (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (RuleDecls (GhcPass p)) = SrcSpanAnnA

data RuleDecl pass Source #

Rule Declaration

Constructors

HsRule |
Fields rd_ext :: XHsRule pass After renamer, free-vars from the LHS and RHS rd_name :: XRec pass (SourceText, RuleName) Note [Pragma source text] in GHC.Types.Basic rd_act :: Activation rd_tyvs :: Maybe [LHsTyVarBndr () (NoGhcTc pass)] Forall'd type vars rd_tmvs :: [LRuleBndr pass] Forall'd term vars, before typechecking; after typechecking this includes all forall'd vars rd_lhs :: XRec pass (HsExpr pass) rd_rhs :: XRec pass (HsExpr pass) `AnnKeywordId` : `AnnOpen`,`AnnTilde`, `AnnVal`, `AnnClose`, `AnnForall`,`AnnDot`, `AnnEqual`,
XRuleDecl !(XXRuleDecl pass) |

#### Instances

Instances details

Data (RuleDecl GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleDecl GhcPs -> c (RuleDecl GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RuleDecl GhcPs) Source # toConstr :: RuleDecl GhcPs -> Constr Source # dataTypeOf :: RuleDecl GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RuleDecl GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RuleDecl GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> RuleDecl GhcPs -> RuleDecl GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecl GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecl GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> RuleDecl GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleDecl GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleDecl GhcPs -> m (RuleDecl GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecl GhcPs -> m (RuleDecl GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecl GhcPs -> m (RuleDecl GhcPs) Source #
Data (RuleDecl GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleDecl GhcRn -> c (RuleDecl GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RuleDecl GhcRn) Source # toConstr :: RuleDecl GhcRn -> Constr Source # dataTypeOf :: RuleDecl GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RuleDecl GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RuleDecl GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> RuleDecl GhcRn -> RuleDecl GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecl GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecl GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> RuleDecl GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleDecl GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleDecl GhcRn -> m (RuleDecl GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecl GhcRn -> m (RuleDecl GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecl GhcRn -> m (RuleDecl GhcRn) Source #
Data (RuleDecl GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleDecl GhcTc -> c (RuleDecl GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RuleDecl GhcTc) Source # toConstr :: RuleDecl GhcTc -> Constr Source # dataTypeOf :: RuleDecl GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RuleDecl GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RuleDecl GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> RuleDecl GhcTc -> RuleDecl GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecl GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecl GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> RuleDecl GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleDecl GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleDecl GhcTc -> m (RuleDecl GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecl GhcTc -> m (RuleDecl GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecl GhcTc -> m (RuleDecl GhcTc) Source #
OutputableBndrId p => Outputable (RuleDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: RuleDecl (GhcPass p) -> SDoc Source #
type Anno (RuleDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (RuleDecl (GhcPass p)) = SrcSpanAnnA

type LRuleDecl pass = XRec pass (RuleDecl pass) Source #

Located Rule Declaration

data HsRuleRn Source #

Constructors

HsRuleRn NameSet NameSet |

#### Instances

Instances details

Data HsRuleRn Source # |
Instance details Defined in Language.Haskell.Syntax.Decls Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsRuleRn -> c HsRuleRn Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsRuleRn Source # toConstr :: HsRuleRn -> Constr Source # dataTypeOf :: HsRuleRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsRuleRn) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsRuleRn) Source # gmapT :: (forall b. Data b => b -> b) -> HsRuleRn -> HsRuleRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsRuleRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsRuleRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsRuleRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsRuleRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsRuleRn -> m HsRuleRn Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsRuleRn -> m HsRuleRn Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsRuleRn -> m HsRuleRn Source #

data RuleBndr pass Source #

Rule Binder

Constructors

RuleBndr (XCRuleBndr pass) (LIdP pass) |
RuleBndrSig (XRuleBndrSig pass) (LIdP pass) (HsPatSigType pass) |
XRuleBndr !(XXRuleBndr pass) | `AnnKeywordId` : `AnnOpen`, `AnnDcolon`,`AnnClose`

#### Instances

Instances details

Data (RuleBndr GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleBndr GhcPs -> c (RuleBndr GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RuleBndr GhcPs) Source # toConstr :: RuleBndr GhcPs -> Constr Source # dataTypeOf :: RuleBndr GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RuleBndr GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RuleBndr GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> RuleBndr GhcPs -> RuleBndr GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> RuleBndr GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleBndr GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleBndr GhcPs -> m (RuleBndr GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr GhcPs -> m (RuleBndr GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr GhcPs -> m (RuleBndr GhcPs) Source #
Data (RuleBndr GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleBndr GhcRn -> c (RuleBndr GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RuleBndr GhcRn) Source # toConstr :: RuleBndr GhcRn -> Constr Source # dataTypeOf :: RuleBndr GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RuleBndr GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RuleBndr GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> RuleBndr GhcRn -> RuleBndr GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> RuleBndr GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleBndr GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleBndr GhcRn -> m (RuleBndr GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr GhcRn -> m (RuleBndr GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr GhcRn -> m (RuleBndr GhcRn) Source #
Data (RuleBndr GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleBndr GhcTc -> c (RuleBndr GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RuleBndr GhcTc) Source # toConstr :: RuleBndr GhcTc -> Constr Source # dataTypeOf :: RuleBndr GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RuleBndr GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RuleBndr GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> RuleBndr GhcTc -> RuleBndr GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> RuleBndr GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleBndr GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleBndr GhcTc -> m (RuleBndr GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr GhcTc -> m (RuleBndr GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr GhcTc -> m (RuleBndr GhcTc) Source #
OutputableBndrId p => Outputable (RuleBndr (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: RuleBndr (GhcPass p) -> SDoc Source #
type Anno (RuleBndr (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (RuleBndr (GhcPass p)) = SrcSpan

type LRuleBndr pass = XRec pass (RuleBndr pass) Source #

Located Rule Binder

collectRuleBndrSigTys :: [RuleBndr pass] -> [HsPatSigType pass] Source #

pprFullRuleName :: Located (SourceText, RuleName) -> SDoc Source #

## `default` declarations

data DefaultDecl pass Source #

Default Declaration

Constructors

DefaultDecl (XCDefaultDecl pass) [LHsType pass] | `AnnKeywordId`s : `AnnDefault`, `AnnOpen`,`AnnClose`
XDefaultDecl !(XXDefaultDecl pass) |

#### Instances

Instances details

Data (DefaultDecl GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DefaultDecl GhcPs -> c (DefaultDecl GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DefaultDecl GhcPs) Source # toConstr :: DefaultDecl GhcPs -> Constr Source # dataTypeOf :: DefaultDecl GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DefaultDecl GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DefaultDecl GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> DefaultDecl GhcPs -> DefaultDecl GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DefaultDecl GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DefaultDecl GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> DefaultDecl GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> DefaultDecl GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DefaultDecl GhcPs -> m (DefaultDecl GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DefaultDecl GhcPs -> m (DefaultDecl GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DefaultDecl GhcPs -> m (DefaultDecl GhcPs) Source #
Data (DefaultDecl GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DefaultDecl GhcRn -> c (DefaultDecl GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DefaultDecl GhcRn) Source # toConstr :: DefaultDecl GhcRn -> Constr Source # dataTypeOf :: DefaultDecl GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DefaultDecl GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DefaultDecl GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> DefaultDecl GhcRn -> DefaultDecl GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DefaultDecl GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DefaultDecl GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> DefaultDecl GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> DefaultDecl GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DefaultDecl GhcRn -> m (DefaultDecl GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DefaultDecl GhcRn -> m (DefaultDecl GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DefaultDecl GhcRn -> m (DefaultDecl GhcRn) Source #
Data (DefaultDecl GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DefaultDecl GhcTc -> c (DefaultDecl GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DefaultDecl GhcTc) Source # toConstr :: DefaultDecl GhcTc -> Constr Source # dataTypeOf :: DefaultDecl GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DefaultDecl GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DefaultDecl GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> DefaultDecl GhcTc -> DefaultDecl GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DefaultDecl GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DefaultDecl GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> DefaultDecl GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> DefaultDecl GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DefaultDecl GhcTc -> m (DefaultDecl GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DefaultDecl GhcTc -> m (DefaultDecl GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DefaultDecl GhcTc -> m (DefaultDecl GhcTc) Source #
OutputableBndrId p => Outputable (DefaultDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: DefaultDecl (GhcPass p) -> SDoc Source #
type Anno (DefaultDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (DefaultDecl (GhcPass p)) = SrcSpanAnnA

type LDefaultDecl pass = XRec pass (DefaultDecl pass) Source #

Located Default Declaration

## Template haskell declaration splice

data SpliceExplicitFlag Source #

Constructors

ExplicitSplice | = $(f x y)
ImplicitSplice | = f x y, i.e. a naked top level expression

#### Instances

Instances details

Data SpliceExplicitFlag Source # |
Instance details Defined in GHC.Types.Basic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpliceExplicitFlag -> c SpliceExplicitFlag Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SpliceExplicitFlag Source # toConstr :: SpliceExplicitFlag -> Constr Source # dataTypeOf :: SpliceExplicitFlag -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SpliceExplicitFlag) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SpliceExplicitFlag) Source # gmapT :: (forall b. Data b => b -> b) -> SpliceExplicitFlag -> SpliceExplicitFlag Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpliceExplicitFlag -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpliceExplicitFlag -> r Source # gmapQ :: (forall d. Data d => d -> u) -> SpliceExplicitFlag -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> SpliceExplicitFlag -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpliceExplicitFlag -> m SpliceExplicitFlag Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceExplicitFlag -> m SpliceExplicitFlag Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceExplicitFlag -> m SpliceExplicitFlag Source #

data SpliceDecl p Source #

Splice Declaration

Constructors

SpliceDecl (XSpliceDecl p) (XRec p (HsSplice p)) SpliceExplicitFlag |
XSpliceDecl !(XXSpliceDecl p) |

#### Instances

Instances details

Data (SpliceDecl GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpliceDecl GhcPs -> c (SpliceDecl GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SpliceDecl GhcPs) Source # toConstr :: SpliceDecl GhcPs -> Constr Source # dataTypeOf :: SpliceDecl GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (SpliceDecl GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SpliceDecl GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> SpliceDecl GhcPs -> SpliceDecl GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpliceDecl GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpliceDecl GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> SpliceDecl GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> SpliceDecl GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpliceDecl GhcPs -> m (SpliceDecl GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceDecl GhcPs -> m (SpliceDecl GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceDecl GhcPs -> m (SpliceDecl GhcPs) Source #
Data (SpliceDecl GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpliceDecl GhcRn -> c (SpliceDecl GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SpliceDecl GhcRn) Source # toConstr :: SpliceDecl GhcRn -> Constr Source # dataTypeOf :: SpliceDecl GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (SpliceDecl GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SpliceDecl GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> SpliceDecl GhcRn -> SpliceDecl GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpliceDecl GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpliceDecl GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> SpliceDecl GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> SpliceDecl GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpliceDecl GhcRn -> m (SpliceDecl GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceDecl GhcRn -> m (SpliceDecl GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceDecl GhcRn -> m (SpliceDecl GhcRn) Source #
Data (SpliceDecl GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpliceDecl GhcTc -> c (SpliceDecl GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SpliceDecl GhcTc) Source # toConstr :: SpliceDecl GhcTc -> Constr Source # dataTypeOf :: SpliceDecl GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (SpliceDecl GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SpliceDecl GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> SpliceDecl GhcTc -> SpliceDecl GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpliceDecl GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpliceDecl GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> SpliceDecl GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> SpliceDecl GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpliceDecl GhcTc -> m (SpliceDecl GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceDecl GhcTc -> m (SpliceDecl GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceDecl GhcTc -> m (SpliceDecl GhcTc) Source #
OutputableBndrId p => Outputable (SpliceDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: SpliceDecl (GhcPass p) -> SDoc Source #
type Anno (SpliceDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (SpliceDecl (GhcPass p)) = SrcSpanAnnA

type LSpliceDecl pass = XRec pass (SpliceDecl pass) Source #

Located Splice Declaration

## Foreign function interface declarations

data ForeignDecl pass Source #

Foreign Declaration

Constructors

ForeignImport |
Fields fd_i_ext :: XForeignImport pass fd_name :: LIdP pass fd_sig_ty :: LHsSigType pass fd_fi :: ForeignImport
ForeignExport | `AnnKeywordId` : `AnnForeign`, `AnnImport`,`AnnExport`, `AnnDcolon`
Fields fd_e_ext :: XForeignExport pass fd_name :: LIdP pass fd_sig_ty :: LHsSigType pass fd_fe :: ForeignExport
XForeignDecl !(XXForeignDecl pass) |

#### Instances

Instances details

Data (ForeignDecl GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForeignDecl GhcPs -> c (ForeignDecl GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ForeignDecl GhcPs) Source # toConstr :: ForeignDecl GhcPs -> Constr Source # dataTypeOf :: ForeignDecl GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ForeignDecl GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ForeignDecl GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> ForeignDecl GhcPs -> ForeignDecl GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForeignDecl GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForeignDecl GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> ForeignDecl GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> ForeignDecl GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForeignDecl GhcPs -> m (ForeignDecl GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignDecl GhcPs -> m (ForeignDecl GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignDecl GhcPs -> m (ForeignDecl GhcPs) Source #
Data (ForeignDecl GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForeignDecl GhcRn -> c (ForeignDecl GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ForeignDecl GhcRn) Source # toConstr :: ForeignDecl GhcRn -> Constr Source # dataTypeOf :: ForeignDecl GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ForeignDecl GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ForeignDecl GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> ForeignDecl GhcRn -> ForeignDecl GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForeignDecl GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForeignDecl GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> ForeignDecl GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> ForeignDecl GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForeignDecl GhcRn -> m (ForeignDecl GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignDecl GhcRn -> m (ForeignDecl GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignDecl GhcRn -> m (ForeignDecl GhcRn) Source #
Data (ForeignDecl GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForeignDecl GhcTc -> c (ForeignDecl GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ForeignDecl GhcTc) Source # toConstr :: ForeignDecl GhcTc -> Constr Source # dataTypeOf :: ForeignDecl GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ForeignDecl GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ForeignDecl GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> ForeignDecl GhcTc -> ForeignDecl GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForeignDecl GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForeignDecl GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> ForeignDecl GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> ForeignDecl GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForeignDecl GhcTc -> m (ForeignDecl GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignDecl GhcTc -> m (ForeignDecl GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignDecl GhcTc -> m (ForeignDecl GhcTc) Source #
OutputableBndrId p => Outputable (ForeignDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: ForeignDecl (GhcPass p) -> SDoc Source #
type Anno (ForeignDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (ForeignDecl (GhcPass p)) = SrcSpanAnnA

type LForeignDecl pass = XRec pass (ForeignDecl pass) Source #

Located Foreign Declaration

data ForeignImport Source #

Constructors

CImport (Located CCallConv) (Located Safety) (Maybe Header) CImportSpec (Located SourceText) |

#### Instances

Instances details

Data ForeignImport Source # |
Instance details Defined in Language.Haskell.Syntax.Decls Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForeignImport -> c ForeignImport Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ForeignImport Source # toConstr :: ForeignImport -> Constr Source # dataTypeOf :: ForeignImport -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ForeignImport) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ForeignImport) Source # gmapT :: (forall b. Data b => b -> b) -> ForeignImport -> ForeignImport Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForeignImport -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForeignImport -> r Source # gmapQ :: (forall d. Data d => d -> u) -> ForeignImport -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> ForeignImport -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForeignImport -> m ForeignImport Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignImport -> m ForeignImport Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignImport -> m ForeignImport Source #
Outputable ForeignImport Source # |
Instance details Defined in Language.Haskell.Syntax.Decls Methods ppr :: ForeignImport -> SDoc Source #

data ForeignExport Source #

Constructors

CExport (Located CExportSpec) (Located SourceText) |

#### Instances

Instances details

Data ForeignExport Source # |
Instance details Defined in Language.Haskell.Syntax.Decls Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForeignExport -> c ForeignExport Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ForeignExport Source # toConstr :: ForeignExport -> Constr Source # dataTypeOf :: ForeignExport -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ForeignExport) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ForeignExport) Source # gmapT :: (forall b. Data b => b -> b) -> ForeignExport -> ForeignExport Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForeignExport -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForeignExport -> r Source # gmapQ :: (forall d. Data d => d -> u) -> ForeignExport -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> ForeignExport -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForeignExport -> m ForeignExport Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignExport -> m ForeignExport Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignExport -> m ForeignExport Source #
Outputable ForeignExport Source # |
Instance details Defined in Language.Haskell.Syntax.Decls Methods ppr :: ForeignExport -> SDoc Source #

data CImportSpec Source #

Constructors

CLabel CLabelString |
CFunction CCallTarget |
CWrapper |

#### Instances

Instances details

Data CImportSpec Source # |
Instance details Defined in Language.Haskell.Syntax.Decls Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CImportSpec -> c CImportSpec Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CImportSpec Source # toConstr :: CImportSpec -> Constr Source # dataTypeOf :: CImportSpec -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CImportSpec) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CImportSpec) Source # gmapT :: (forall b. Data b => b -> b) -> CImportSpec -> CImportSpec Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CImportSpec -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CImportSpec -> r Source # gmapQ :: (forall d. Data d => d -> u) -> CImportSpec -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> CImportSpec -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CImportSpec -> m CImportSpec Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CImportSpec -> m CImportSpec Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CImportSpec -> m CImportSpec Source #

## Data-constructor declarations

data ConDecl pass Source #

    data T b = forall a. Eq a => MkT a b
      MkT :: forall b a. Eq a => MkT a b

    data T b where
         MkT1 :: Int -> T Int

    data T = Int MkT Int
           | MkT2

    data T a where
         Int MkT Int :: T Int

- `AnnKeywordId`s : `AnnOpen`, `AnnDotdot`,`AnnCLose`, `AnnEqual`,`AnnVbar`, `AnnDarrow`,`AnnDarrow`, `AnnForall`,`AnnDot`

data Constructor Declaration

Constructors

ConDeclGADT |
Fields con_g_ext :: XConDeclGADT pass con_names :: [LIdP pass] con_bndrs :: XRec pass (HsOuterSigTyVarBndrs pass) The outermost type variable binders, be they explicit or implicit. The `XRec` is used to anchor exact print annotations, AnnForall and AnnDot. con_mb_cxt :: Maybe (LHsContext pass) User-written context (if any) con_g_args :: HsConDeclGADTDetails pass Arguments; never infix con_res_ty :: LHsType pass Result type con_doc :: Maybe LHsDocString A possible Haddock comment.
ConDeclH98 |
Fields con_ext :: XConDeclH98 pass con_name :: LIdP pass con_forall :: Bool True = explicit user-written forall e.g. data T a = forall b. MkT b (b->a) con_ex_tvs = {b} False => con_ex_tvs is empty con_ex_tvs :: [LHsTyVarBndr Specificity pass] Existentials only con_mb_cxt :: Maybe (LHsContext pass) User-written context (if any) con_args :: HsConDeclH98Details pass Arguments; can be infix con_doc :: Maybe LHsDocString A possible Haddock comment.
XConDecl !(XXConDecl pass) |

#### Instances

Instances details

Data (ConDecl GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConDecl GhcPs -> c (ConDecl GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ConDecl GhcPs) Source # toConstr :: ConDecl GhcPs -> Constr Source # dataTypeOf :: ConDecl GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ConDecl GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ConDecl GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> ConDecl GhcPs -> ConDecl GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConDecl GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConDecl GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> ConDecl GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> ConDecl GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConDecl GhcPs -> m (ConDecl GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDecl GhcPs -> m (ConDecl GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDecl GhcPs -> m (ConDecl GhcPs) Source #
Data (ConDecl GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConDecl GhcRn -> c (ConDecl GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ConDecl GhcRn) Source # toConstr :: ConDecl GhcRn -> Constr Source # dataTypeOf :: ConDecl GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ConDecl GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ConDecl GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> ConDecl GhcRn -> ConDecl GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConDecl GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConDecl GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> ConDecl GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> ConDecl GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConDecl GhcRn -> m (ConDecl GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDecl GhcRn -> m (ConDecl GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDecl GhcRn -> m (ConDecl GhcRn) Source #
Data (ConDecl GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConDecl GhcTc -> c (ConDecl GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ConDecl GhcTc) Source # toConstr :: ConDecl GhcTc -> Constr Source # dataTypeOf :: ConDecl GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ConDecl GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ConDecl GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> ConDecl GhcTc -> ConDecl GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConDecl GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConDecl GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> ConDecl GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> ConDecl GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConDecl GhcTc -> m (ConDecl GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDecl GhcTc -> m (ConDecl GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDecl GhcTc -> m (ConDecl GhcTc) Source #
OutputableBndrId p => Outputable (ConDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: ConDecl (GhcPass p) -> SDoc Source #
type Anno (ConDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (ConDecl (GhcPass p)) = SrcSpanAnnA

type LConDecl pass Source #

Arguments

= XRec pass (ConDecl pass) | May have `AnnKeywordId` : `AnnSemi` when in a GADT constructor list

Located data Constructor Declaration

type HsConDeclH98Details pass = HsConDetails Void (HsScaled pass (LBangType pass)) (XRec pass [LConDeclField pass]) Source #

The arguments in a Haskell98-style data constructor.

data HsConDeclGADTDetails pass Source #

The arguments in a GADT constructor. Unlike Haskell98-style constructors, GADT constructors cannot be declared with infix syntax. As a result, we do not use `HsConDetails` here, as `InfixCon` would be an unrepresentable state. (There is a notion of infix GADT constructors for the purposes of derived Show instances—see Note [Infix GADT constructors] in GHC.Tc.TyCl—but that is an orthogonal concern.)

Constructors

PrefixConGADT [HsScaled pass (LBangType pass)] |
RecConGADT (XRec pass [LConDeclField pass]) |

#### Instances

Instances details

Data (HsConDeclGADTDetails GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsConDeclGADTDetails GhcPs -> c (HsConDeclGADTDetails GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsConDeclGADTDetails GhcPs) Source # toConstr :: HsConDeclGADTDetails GhcPs -> Constr Source # dataTypeOf :: HsConDeclGADTDetails GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsConDeclGADTDetails GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsConDeclGADTDetails GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> HsConDeclGADTDetails GhcPs -> HsConDeclGADTDetails GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclGADTDetails GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclGADTDetails GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsConDeclGADTDetails GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsConDeclGADTDetails GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsConDeclGADTDetails GhcPs -> m (HsConDeclGADTDetails GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclGADTDetails GhcPs -> m (HsConDeclGADTDetails GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclGADTDetails GhcPs -> m (HsConDeclGADTDetails GhcPs) Source #
Data (HsConDeclGADTDetails GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsConDeclGADTDetails GhcRn -> c (HsConDeclGADTDetails GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsConDeclGADTDetails GhcRn) Source # toConstr :: HsConDeclGADTDetails GhcRn -> Constr Source # dataTypeOf :: HsConDeclGADTDetails GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsConDeclGADTDetails GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsConDeclGADTDetails GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> HsConDeclGADTDetails GhcRn -> HsConDeclGADTDetails GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclGADTDetails GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclGADTDetails GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsConDeclGADTDetails GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsConDeclGADTDetails GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsConDeclGADTDetails GhcRn -> m (HsConDeclGADTDetails GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclGADTDetails GhcRn -> m (HsConDeclGADTDetails GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclGADTDetails GhcRn -> m (HsConDeclGADTDetails GhcRn) Source #
Data (HsConDeclGADTDetails GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsConDeclGADTDetails GhcTc -> c (HsConDeclGADTDetails GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsConDeclGADTDetails GhcTc) Source # toConstr :: HsConDeclGADTDetails GhcTc -> Constr Source # dataTypeOf :: HsConDeclGADTDetails GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsConDeclGADTDetails GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsConDeclGADTDetails GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> HsConDeclGADTDetails GhcTc -> HsConDeclGADTDetails GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclGADTDetails GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclGADTDetails GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsConDeclGADTDetails GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsConDeclGADTDetails GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsConDeclGADTDetails GhcTc -> m (HsConDeclGADTDetails GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclGADTDetails GhcTc -> m (HsConDeclGADTDetails GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclGADTDetails GhcTc -> m (HsConDeclGADTDetails GhcTc) Source #

## Document comments

data DocDecl Source #

Documentation comment Declaration

Constructors

DocCommentNext HsDocString |
DocCommentPrev HsDocString |
DocCommentNamed String HsDocString |
DocGroup Int HsDocString |

#### Instances

Instances details

Data DocDecl Source # |
Instance details Defined in Language.Haskell.Syntax.Decls Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DocDecl -> c DocDecl Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DocDecl Source # toConstr :: DocDecl -> Constr Source # dataTypeOf :: DocDecl -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DocDecl) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DocDecl) Source # gmapT :: (forall b. Data b => b -> b) -> DocDecl -> DocDecl Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DocDecl -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DocDecl -> r Source # gmapQ :: (forall d. Data d => d -> u) -> DocDecl -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> DocDecl -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DocDecl -> m DocDecl Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DocDecl -> m DocDecl Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DocDecl -> m DocDecl Source #
Outputable DocDecl Source # |
Instance details Defined in Language.Haskell.Syntax.Decls Methods ppr :: DocDecl -> SDoc Source #
type Anno DocDecl Source # |
Instance details Defined in GHC.Hs.Decls type Anno DocDecl = SrcSpanAnnA

type LDocDecl pass = XRec pass DocDecl Source #

Located Documentation comment Declaration

docDeclDoc :: DocDecl -> HsDocString Source #

## Deprecations

data WarnDecl pass Source #

Warning pragma Declaration

Constructors

Warning (XWarning pass) [LIdP pass] WarningTxt |
XWarnDecl !(XXWarnDecl pass) |

#### Instances

Instances details

Data (WarnDecl GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WarnDecl GhcPs -> c (WarnDecl GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WarnDecl GhcPs) Source # toConstr :: WarnDecl GhcPs -> Constr Source # dataTypeOf :: WarnDecl GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WarnDecl GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WarnDecl GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> WarnDecl GhcPs -> WarnDecl GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecl GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecl GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> WarnDecl GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> WarnDecl GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WarnDecl GhcPs -> m (WarnDecl GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecl GhcPs -> m (WarnDecl GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecl GhcPs -> m (WarnDecl GhcPs) Source #
Data (WarnDecl GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WarnDecl GhcRn -> c (WarnDecl GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WarnDecl GhcRn) Source # toConstr :: WarnDecl GhcRn -> Constr Source # dataTypeOf :: WarnDecl GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WarnDecl GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WarnDecl GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> WarnDecl GhcRn -> WarnDecl GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecl GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecl GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> WarnDecl GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> WarnDecl GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WarnDecl GhcRn -> m (WarnDecl GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecl GhcRn -> m (WarnDecl GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecl GhcRn -> m (WarnDecl GhcRn) Source #
Data (WarnDecl GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WarnDecl GhcTc -> c (WarnDecl GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WarnDecl GhcTc) Source # toConstr :: WarnDecl GhcTc -> Constr Source # dataTypeOf :: WarnDecl GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WarnDecl GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WarnDecl GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> WarnDecl GhcTc -> WarnDecl GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecl GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecl GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> WarnDecl GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> WarnDecl GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WarnDecl GhcTc -> m (WarnDecl GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecl GhcTc -> m (WarnDecl GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecl GhcTc -> m (WarnDecl GhcTc) Source #
OutputableBndrId p => Outputable (WarnDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: WarnDecl (GhcPass p) -> SDoc Source #
type Anno (WarnDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (WarnDecl (GhcPass p)) = SrcSpanAnnA

type LWarnDecl pass = XRec pass (WarnDecl pass) Source #

Located Warning pragma Declaration

data WarnDecls pass Source #

Warning pragma Declarations

Constructors

Warnings |
Fields wd_ext :: XWarnings pass wd_src :: SourceText wd_warnings :: [LWarnDecl pass]
XWarnDecls !(XXWarnDecls pass) |

#### Instances

Instances details

Data (WarnDecls GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WarnDecls GhcPs -> c (WarnDecls GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WarnDecls GhcPs) Source # toConstr :: WarnDecls GhcPs -> Constr Source # dataTypeOf :: WarnDecls GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WarnDecls GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WarnDecls GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> WarnDecls GhcPs -> WarnDecls GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecls GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecls GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> WarnDecls GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> WarnDecls GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WarnDecls GhcPs -> m (WarnDecls GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecls GhcPs -> m (WarnDecls GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecls GhcPs -> m (WarnDecls GhcPs) Source #
Data (WarnDecls GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WarnDecls GhcRn -> c (WarnDecls GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WarnDecls GhcRn) Source # toConstr :: WarnDecls GhcRn -> Constr Source # dataTypeOf :: WarnDecls GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WarnDecls GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WarnDecls GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> WarnDecls GhcRn -> WarnDecls GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecls GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecls GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> WarnDecls GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> WarnDecls GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WarnDecls GhcRn -> m (WarnDecls GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecls GhcRn -> m (WarnDecls GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecls GhcRn -> m (WarnDecls GhcRn) Source #
Data (WarnDecls GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WarnDecls GhcTc -> c (WarnDecls GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WarnDecls GhcTc) Source # toConstr :: WarnDecls GhcTc -> Constr Source # dataTypeOf :: WarnDecls GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WarnDecls GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WarnDecls GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> WarnDecls GhcTc -> WarnDecls GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecls GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecls GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> WarnDecls GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> WarnDecls GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WarnDecls GhcTc -> m (WarnDecls GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecls GhcTc -> m (WarnDecls GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecls GhcTc -> m (WarnDecls GhcTc) Source #
OutputableBndrId p => Outputable (WarnDecls (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: WarnDecls (GhcPass p) -> SDoc Source #
type Anno (WarnDecls (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (WarnDecls (GhcPass p)) = SrcSpanAnnA

type LWarnDecls pass = XRec pass (WarnDecls pass) Source #

Located Warning Declarations

## Annotations

data AnnDecl pass Source #

Annotation Declaration

Constructors

HsAnnotation (XHsAnnotation pass) SourceText (AnnProvenance pass) (XRec pass (HsExpr pass)) | `AnnKeywordId` : `AnnOpen`, `AnnType` `AnnModule` `AnnClose`
XAnnDecl !(XXAnnDecl pass) |

#### Instances

Instances details

Data (AnnDecl GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnDecl GhcPs -> c (AnnDecl GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnDecl GhcPs) Source # toConstr :: AnnDecl GhcPs -> Constr Source # dataTypeOf :: AnnDecl GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AnnDecl GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AnnDecl GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> AnnDecl GhcPs -> AnnDecl GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnDecl GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnDecl GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> AnnDecl GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnDecl GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnDecl GhcPs -> m (AnnDecl GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnDecl GhcPs -> m (AnnDecl GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnDecl GhcPs -> m (AnnDecl GhcPs) Source #
Data (AnnDecl GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnDecl GhcRn -> c (AnnDecl GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnDecl GhcRn) Source # toConstr :: AnnDecl GhcRn -> Constr Source # dataTypeOf :: AnnDecl GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AnnDecl GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AnnDecl GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> AnnDecl GhcRn -> AnnDecl GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnDecl GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnDecl GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> AnnDecl GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnDecl GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnDecl GhcRn -> m (AnnDecl GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnDecl GhcRn -> m (AnnDecl GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnDecl GhcRn -> m (AnnDecl GhcRn) Source #
Data (AnnDecl GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnDecl GhcTc -> c (AnnDecl GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnDecl GhcTc) Source # toConstr :: AnnDecl GhcTc -> Constr Source # dataTypeOf :: AnnDecl GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AnnDecl GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AnnDecl GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> AnnDecl GhcTc -> AnnDecl GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnDecl GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnDecl GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> AnnDecl GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnDecl GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnDecl GhcTc -> m (AnnDecl GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnDecl GhcTc -> m (AnnDecl GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnDecl GhcTc -> m (AnnDecl GhcTc) Source #
OutputableBndrId p => Outputable (AnnDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: AnnDecl (GhcPass p) -> SDoc Source #
type Anno (AnnDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (AnnDecl (GhcPass p)) = SrcSpanAnnA

type LAnnDecl pass = XRec pass (AnnDecl pass) Source #

Located Annotation Declaration

data AnnProvenance pass Source #

Annotation Provenance

Constructors

ValueAnnProvenance (LIdP pass) |
TypeAnnProvenance (LIdP pass) |
ModuleAnnProvenance |

#### Instances

Instances details

Data (AnnProvenance GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnProvenance GhcPs -> c (AnnProvenance GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnProvenance GhcPs) Source # toConstr :: AnnProvenance GhcPs -> Constr Source # dataTypeOf :: AnnProvenance GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AnnProvenance GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AnnProvenance GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> AnnProvenance GhcPs -> AnnProvenance GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> AnnProvenance GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnProvenance GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnProvenance GhcPs -> m (AnnProvenance GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance GhcPs -> m (AnnProvenance GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance GhcPs -> m (AnnProvenance GhcPs) Source #
Data (AnnProvenance GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnProvenance GhcRn -> c (AnnProvenance GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnProvenance GhcRn) Source # toConstr :: AnnProvenance GhcRn -> Constr Source # dataTypeOf :: AnnProvenance GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AnnProvenance GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AnnProvenance GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> AnnProvenance GhcRn -> AnnProvenance GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> AnnProvenance GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnProvenance GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnProvenance GhcRn -> m (AnnProvenance GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance GhcRn -> m (AnnProvenance GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance GhcRn -> m (AnnProvenance GhcRn) Source #
Data (AnnProvenance GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnProvenance GhcTc -> c (AnnProvenance GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnProvenance GhcTc) Source # toConstr :: AnnProvenance GhcTc -> Constr Source # dataTypeOf :: AnnProvenance GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AnnProvenance GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AnnProvenance GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> AnnProvenance GhcTc -> AnnProvenance GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> AnnProvenance GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnProvenance GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnProvenance GhcTc -> m (AnnProvenance GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance GhcTc -> m (AnnProvenance GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance GhcTc -> m (AnnProvenance GhcTc) Source #

annProvenanceName_maybe :: forall p. UnXRec p => AnnProvenance p -> Maybe (IdP p) Source #

## Role annotations

data RoleAnnotDecl pass Source #

Role Annotation Declaration

Constructors

RoleAnnotDecl (XCRoleAnnotDecl pass) (LIdP pass) [XRec pass (Maybe Role)] | `AnnKeywordId` : `AnnType`, `AnnRole`
XRoleAnnotDecl !(XXRoleAnnotDecl pass) |

#### Instances

Instances details

Data (RoleAnnotDecl GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RoleAnnotDecl GhcPs -> c (RoleAnnotDecl GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RoleAnnotDecl GhcPs) Source # toConstr :: RoleAnnotDecl GhcPs -> Constr Source # dataTypeOf :: RoleAnnotDecl GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RoleAnnotDecl GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RoleAnnotDecl GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> RoleAnnotDecl GhcPs -> RoleAnnotDecl GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RoleAnnotDecl GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RoleAnnotDecl GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> RoleAnnotDecl GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> RoleAnnotDecl GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RoleAnnotDecl GhcPs -> m (RoleAnnotDecl GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RoleAnnotDecl GhcPs -> m (RoleAnnotDecl GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RoleAnnotDecl GhcPs -> m (RoleAnnotDecl GhcPs) Source #
Data (RoleAnnotDecl GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RoleAnnotDecl GhcRn -> c (RoleAnnotDecl GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RoleAnnotDecl GhcRn) Source # toConstr :: RoleAnnotDecl GhcRn -> Constr Source # dataTypeOf :: RoleAnnotDecl GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RoleAnnotDecl GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RoleAnnotDecl GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> RoleAnnotDecl GhcRn -> RoleAnnotDecl GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RoleAnnotDecl GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RoleAnnotDecl GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> RoleAnnotDecl GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> RoleAnnotDecl GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RoleAnnotDecl GhcRn -> m (RoleAnnotDecl GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RoleAnnotDecl GhcRn -> m (RoleAnnotDecl GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RoleAnnotDecl GhcRn -> m (RoleAnnotDecl GhcRn) Source #
Data (RoleAnnotDecl GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RoleAnnotDecl GhcTc -> c (RoleAnnotDecl GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RoleAnnotDecl GhcTc) Source # toConstr :: RoleAnnotDecl GhcTc -> Constr Source # dataTypeOf :: RoleAnnotDecl GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RoleAnnotDecl GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RoleAnnotDecl GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> RoleAnnotDecl GhcTc -> RoleAnnotDecl GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RoleAnnotDecl GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RoleAnnotDecl GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> RoleAnnotDecl GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> RoleAnnotDecl GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RoleAnnotDecl GhcTc -> m (RoleAnnotDecl GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RoleAnnotDecl GhcTc -> m (RoleAnnotDecl GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RoleAnnotDecl GhcTc -> m (RoleAnnotDecl GhcTc) Source #
OutputableBndr (IdP (GhcPass p)) => Outputable (RoleAnnotDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: RoleAnnotDecl (GhcPass p) -> SDoc Source #
type Anno (RoleAnnotDecl (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (RoleAnnotDecl (GhcPass p)) = SrcSpanAnnA

type LRoleAnnotDecl pass = XRec pass (RoleAnnotDecl pass) Source #

Located Role Annotation Declaration

## Injective type families

data FamilyResultSig pass Source #

type Family Result Signature

Constructors

NoSig (XNoSig pass) | `AnnKeywordId` :
KindSig (XCKindSig pass) (LHsKind pass) | `AnnKeywordId` : `AnnOpenP`,`AnnDcolon`, `AnnCloseP`
TyVarSig (XTyVarSig pass) (LHsTyVarBndr () pass) | `AnnKeywordId` : `AnnOpenP`,`AnnDcolon`, `AnnCloseP`, `AnnEqual`
XFamilyResultSig !(XXFamilyResultSig pass) |

#### Instances

Instances details

Data (FamilyResultSig GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamilyResultSig GhcPs -> c (FamilyResultSig GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FamilyResultSig GhcPs) Source # toConstr :: FamilyResultSig GhcPs -> Constr Source # dataTypeOf :: FamilyResultSig GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FamilyResultSig GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FamilyResultSig GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> FamilyResultSig GhcPs -> FamilyResultSig GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamilyResultSig GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamilyResultSig GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> FamilyResultSig GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> FamilyResultSig GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamilyResultSig GhcPs -> m (FamilyResultSig GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyResultSig GhcPs -> m (FamilyResultSig GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyResultSig GhcPs -> m (FamilyResultSig GhcPs) Source #
Data (FamilyResultSig GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamilyResultSig GhcRn -> c (FamilyResultSig GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FamilyResultSig GhcRn) Source # toConstr :: FamilyResultSig GhcRn -> Constr Source # dataTypeOf :: FamilyResultSig GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FamilyResultSig GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FamilyResultSig GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> FamilyResultSig GhcRn -> FamilyResultSig GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamilyResultSig GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamilyResultSig GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> FamilyResultSig GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> FamilyResultSig GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamilyResultSig GhcRn -> m (FamilyResultSig GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyResultSig GhcRn -> m (FamilyResultSig GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyResultSig GhcRn -> m (FamilyResultSig GhcRn) Source #
Data (FamilyResultSig GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamilyResultSig GhcTc -> c (FamilyResultSig GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FamilyResultSig GhcTc) Source # toConstr :: FamilyResultSig GhcTc -> Constr Source # dataTypeOf :: FamilyResultSig GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FamilyResultSig GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FamilyResultSig GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> FamilyResultSig GhcTc -> FamilyResultSig GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamilyResultSig GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamilyResultSig GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> FamilyResultSig GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> FamilyResultSig GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamilyResultSig GhcTc -> m (FamilyResultSig GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyResultSig GhcTc -> m (FamilyResultSig GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyResultSig GhcTc -> m (FamilyResultSig GhcTc) Source #
type Anno (FamilyResultSig (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (FamilyResultSig (GhcPass p)) = SrcSpan

type LFamilyResultSig pass = XRec pass (FamilyResultSig pass) Source #

Located type Family Result Signature

data InjectivityAnn pass Source #

If the user supplied an injectivity annotation it is represented using InjectivityAnn. At the moment this is a single injectivity condition - see Note [Injectivity annotation]. `Located name` stores the LHS of injectivity condition. `[Located name]` stores the RHS of injectivity condition. Example:

type family Foo a b c = r | r -> a c where ...

This will be represented as "InjectivityAnn `r` [`a`, `c`]"

Constructors

InjectivityAnn (XCInjectivityAnn pass) (LIdP pass) [LIdP pass] | `AnnKeywordId` : `AnnRarrow`, `AnnVbar`
XInjectivityAnn !(XXInjectivityAnn pass) |

#### Instances

Instances details

Data (InjectivityAnn GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InjectivityAnn GhcPs -> c (InjectivityAnn GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (InjectivityAnn GhcPs) Source # toConstr :: InjectivityAnn GhcPs -> Constr Source # dataTypeOf :: InjectivityAnn GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (InjectivityAnn GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (InjectivityAnn GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> InjectivityAnn GhcPs -> InjectivityAnn GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityAnn GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityAnn GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> InjectivityAnn GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> InjectivityAnn GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> InjectivityAnn GhcPs -> m (InjectivityAnn GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityAnn GhcPs -> m (InjectivityAnn GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityAnn GhcPs -> m (InjectivityAnn GhcPs) Source #
Data (InjectivityAnn GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InjectivityAnn GhcRn -> c (InjectivityAnn GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (InjectivityAnn GhcRn) Source # toConstr :: InjectivityAnn GhcRn -> Constr Source # dataTypeOf :: InjectivityAnn GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (InjectivityAnn GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (InjectivityAnn GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> InjectivityAnn GhcRn -> InjectivityAnn GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityAnn GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityAnn GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> InjectivityAnn GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> InjectivityAnn GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> InjectivityAnn GhcRn -> m (InjectivityAnn GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityAnn GhcRn -> m (InjectivityAnn GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityAnn GhcRn -> m (InjectivityAnn GhcRn) Source #
Data (InjectivityAnn GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InjectivityAnn GhcTc -> c (InjectivityAnn GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (InjectivityAnn GhcTc) Source # toConstr :: InjectivityAnn GhcTc -> Constr Source # dataTypeOf :: InjectivityAnn GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (InjectivityAnn GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (InjectivityAnn GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> InjectivityAnn GhcTc -> InjectivityAnn GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityAnn GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityAnn GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> InjectivityAnn GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> InjectivityAnn GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> InjectivityAnn GhcTc -> m (InjectivityAnn GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityAnn GhcTc -> m (InjectivityAnn GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityAnn GhcTc -> m (InjectivityAnn GhcTc) Source #
type Anno (InjectivityAnn (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls type Anno (InjectivityAnn (GhcPass p)) = SrcSpan

type LInjectivityAnn pass = XRec pass (InjectivityAnn pass) Source #

Located Injectivity Annotation

# Grouping

data HsGroup p Source #

Haskell Group

A `HsDecl` is categorised into a `HsGroup` before being fed to the renamer.

Constructors

HsGroup |
Fields hs_ext :: XCHsGroup p hs_valds :: HsValBinds p hs_splcds :: [LSpliceDecl p] hs_tyclds :: [TyClGroup p] hs_derivds :: [LDerivDecl p] hs_fixds :: [LFixitySig p] hs_defds :: [LDefaultDecl p] hs_fords :: [LForeignDecl p] hs_warnds :: [LWarnDecls p] hs_annds :: [LAnnDecl p] hs_ruleds :: [LRuleDecls p] hs_docs :: [LDocDecl p]
XHsGroup !(XXHsGroup p) |

#### Instances

Instances details

Data (HsGroup GhcPs) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsGroup GhcPs -> c (HsGroup GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsGroup GhcPs) Source # toConstr :: HsGroup GhcPs -> Constr Source # dataTypeOf :: HsGroup GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsGroup GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsGroup GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> HsGroup GhcPs -> HsGroup GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsGroup GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsGroup GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsGroup GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsGroup GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsGroup GhcPs -> m (HsGroup GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGroup GhcPs -> m (HsGroup GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGroup GhcPs -> m (HsGroup GhcPs) Source #
Data (HsGroup GhcRn) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsGroup GhcRn -> c (HsGroup GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsGroup GhcRn) Source # toConstr :: HsGroup GhcRn -> Constr Source # dataTypeOf :: HsGroup GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsGroup GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsGroup GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> HsGroup GhcRn -> HsGroup GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsGroup GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsGroup GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsGroup GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsGroup GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsGroup GhcRn -> m (HsGroup GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGroup GhcRn -> m (HsGroup GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGroup GhcRn -> m (HsGroup GhcRn) Source #
Data (HsGroup GhcTc) Source # |
Instance details Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsGroup GhcTc -> c (HsGroup GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsGroup GhcTc) Source # toConstr :: HsGroup GhcTc -> Constr Source # dataTypeOf :: HsGroup GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsGroup GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsGroup GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> HsGroup GhcTc -> HsGroup GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsGroup GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsGroup GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsGroup GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsGroup GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsGroup GhcTc -> m (HsGroup GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGroup GhcTc -> m (HsGroup GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGroup GhcTc -> m (HsGroup GhcTc) Source #
OutputableBndrId p => Outputable (HsGroup (GhcPass p)) Source # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: HsGroup (GhcPass p) -> SDoc Source #

hsGroupInstDecls :: HsGroup id -> [LInstDecl id] Source #