ghc-lib-parser-9.14.1.20251220: The GHC API, decoupled from GHC versions

Safe Haskell | Ignore
Language | GHC2021

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 p)
  - | RoleAnnotD (XRoleAnnotD p) (RoleAnnotDecl p)
  - | XHsDecl !(XXHsDecl p)
- type LHsDecl p = XRec p (HsDecl p)
- data HsDataDefn pass
  - = HsDataDefn {
    - dd_ext :: XCHsDataDefn pass
    - dd_ctxt :: Maybe (LHsContext pass)
    - dd_cType :: Maybe (XRec pass CType)
    - dd_kindSig :: Maybe (LHsKind pass)
    - dd_cons :: DataDefnCons (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
- data DataDefnCons a
  - = NewTypeCon a
  - | DataTypeCons Bool [a]
- dataDefnConsNewOrData :: DataDefnCons a -> NewOrData
- isTypeDataDefnCons :: DataDefnCons a -> Bool
- firstDataDefnCon :: DataDefnCons a -> Maybe a
- 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 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)
- 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
- 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])
- familyInfoTyConFlavour :: Maybe tc -> FamilyInfo pass -> TyConFlavour tc
- 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 :: HsFamEqnPats 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 HsFamEqnPats 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)
- type LRuleDecls pass = XRec pass (RuleDecls pass)
- data RuleDecls pass
  - = HsRules {
    - rds_ext :: XCRuleDecls pass
    - rds_rules :: [LRuleDecl pass]
    }
  - | XRuleDecls !(XXRuleDecls pass)
- data RuleDecl pass
  - = HsRule {
    - rd_ext :: XHsRule pass
    - rd_name :: XRec pass RuleName
    - rd_act :: Activation
    - rd_bndrs :: RuleBndrs pass
    - rd_lhs :: XRec pass (HsExpr pass)
    - rd_rhs :: XRec pass (HsExpr pass)
    }
  - | XRuleDecl !(XXRuleDecl pass)
- type LRuleDecl pass = XRec pass (RuleDecl pass)
- 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]
- data DefaultDecl pass
  - = DefaultDecl {
    - defd_ext :: XCDefaultDecl pass
    - defd_class :: Maybe (LIdP pass)
    - defd_defaults :: [LHsType pass]
    }
  - | XDefaultDecl !(XXDefaultDecl pass)
- type LDefaultDecl pass = XRec pass (DefaultDecl pass)
- data SpliceDecoration
  - = DollarSplice
  - | BareSplice
- data SpliceDecl p
  - = SpliceDecl (XSpliceDecl p) (XRec p (HsUntypedSplice p)) SpliceDecoration
  - | 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 pass
    }
  - | ForeignExport {
    - fd_e_ext :: XForeignExport pass
    - fd_name :: LIdP pass
    - fd_sig_ty :: LHsSigType pass
    - fd_fe :: ForeignExport pass
    }
  - | XForeignDecl !(XXForeignDecl pass)
- type LForeignDecl pass = XRec pass (ForeignDecl pass)
- data ForeignImport pass
  - = CImport (XCImport pass) (XRec pass CCallConv) (XRec pass Safety) (Maybe Header) CImportSpec
  - | XForeignImport !(XXForeignImport pass)
- data ForeignExport pass
  - = CExport (XCExport pass) (XRec pass CExportSpec)
  - | XForeignExport !(XXForeignExport pass)
- data CImportSpec
  - = CLabel CLabelString
  - | CFunction CCallTarget
  - | CWrapper
- data ConDecl pass
  - = ConDeclGADT {
    - con_g_ext :: XConDeclGADT pass
    - con_names :: NonEmpty (LIdP pass)
    - con_outer_bndrs :: XRec pass (HsOuterSigTyVarBndrs pass)
    - con_inner_bndrs :: [HsForAllTelescope pass]
    - con_mb_cxt :: Maybe (LHsContext pass)
    - con_g_args :: HsConDeclGADTDetails pass
    - con_res_ty :: LHsType pass
    - con_doc :: Maybe (LHsDoc pass)
    }
  - | 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 (LHsDoc pass)
    }
  - | XConDecl !(XXConDecl pass)
- type LConDecl pass = XRec pass (ConDecl pass)
- type HsConDeclH98Details pass = HsConDetails (HsConDeclField pass) (XRec pass [LHsConDeclRecField pass])
- data HsConDeclGADTDetails pass
  - = PrefixConGADT !(XPrefixConGADT pass) [HsConDeclField pass]
  - | RecConGADT !(XRecConGADT pass) (XRec pass [LHsConDeclRecField pass])
  - | XConDeclGADTDetails !(XXConDeclGADTDetails pass)
- type family XPrefixConGADT p
- type family XRecConGADT p
- type family XXConDeclGADTDetails p
- data DocDecl pass
  - = DocCommentNext (LHsDoc pass)
  - | DocCommentPrev (LHsDoc pass)
  - | DocCommentNamed String (LHsDoc pass)
  - | DocGroup Int (LHsDoc pass)
- type LDocDecl pass = XRec pass (DocDecl pass)
- docDeclDoc :: DocDecl pass -> LHsDoc pass
- data WarnDecl pass
  - = Warning (XWarning pass) [LIdP pass] (WarningTxt pass)
  - | XWarnDecl !(XXWarnDecl pass)
- type LWarnDecl pass = XRec pass (WarnDecl pass)
- data WarnDecls pass
  - = Warnings {
    - wd_ext :: XWarnings pass
    - wd_warnings :: [LWarnDecl pass]
    }
  - | XWarnDecls !(XXWarnDecls pass)
- type LWarnDecls pass = XRec pass (WarnDecls pass)
- data AnnDecl pass
  - = HsAnnotation (XHsAnnotation pass) (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 :: 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)

# Toplevel declarations

data HsDecl p #

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 p) | Documentation comment declaration
RoleAnnotD (XRoleAnnotD p) (RoleAnnotDecl p) | Role annotation declaration
XHsDecl !(XXHsDecl p) |

#### Instances

Instances details

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

type LHsDecl p #

Arguments

= XRec p (HsDecl p) | When in a list this may have

data HsDataDefn pass #

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

type HsDeriving pass #

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

data FunDep pass #

Constructors

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

#### Instances

Instances details

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

data HsDerivingClause pass #

A single `deriving` clause of a data declaration.

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

type LHsDerivingClause pass = XRec pass (HsDerivingClause pass) #

data DerivClauseTys pass #

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

type LDerivClauseTys pass = XRec pass (DerivClauseTys pass) #

data NewOrData #

When we only care whether a data-type declaration is `data` or `newtype`, but not what constructors it has.

Constructors

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

#### Instances

Instances details

Data NewOrData # |
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) -> NewOrData -> c NewOrData # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NewOrData # toConstr :: NewOrData -> Constr # dataTypeOf :: NewOrData -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NewOrData) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NewOrData) # gmapT :: (forall b. Data b => b -> b) -> NewOrData -> NewOrData # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NewOrData -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NewOrData -> r # gmapQ :: (forall d. Data d => d -> u) -> NewOrData -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NewOrData -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NewOrData -> m NewOrData # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NewOrData -> m NewOrData # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NewOrData -> m NewOrData #
Outputable NewOrData # |
Instance details Defined in GHC.Types.Basic Methods ppr :: NewOrData -> SDoc #
Eq NewOrData # |
Instance details Defined in GHC.Types.Basic Methods (==) :: NewOrData -> NewOrData -> Bool # (/=) :: NewOrData -> NewOrData -> Bool #

data DataDefnCons a #

Whether a data-type declaration is `data` or `newtype`, and its constructors.

Constructors

NewTypeCon a |
DataTypeCons Bool [a] |

#### Instances

Instances details

Functor DataDefnCons # |
Instance details Defined in Language.Haskell.Syntax.Decls Methods fmap :: (a -> b) -> DataDefnCons a -> DataDefnCons b # (<$) :: a -> DataDefnCons b -> DataDefnCons a #
Foldable DataDefnCons # |
Instance details Defined in Language.Haskell.Syntax.Decls Methods fold :: Monoid m => DataDefnCons m -> m # foldMap :: Monoid m => (a -> m) -> DataDefnCons a -> m # foldMap' :: Monoid m => (a -> m) -> DataDefnCons a -> m # foldr :: (a -> b -> b) -> b -> DataDefnCons a -> b # foldr' :: (a -> b -> b) -> b -> DataDefnCons a -> b # foldl :: (b -> a -> b) -> b -> DataDefnCons a -> b # foldl' :: (b -> a -> b) -> b -> DataDefnCons a -> b # foldr1 :: (a -> a -> a) -> DataDefnCons a -> a # foldl1 :: (a -> a -> a) -> DataDefnCons a -> a # toList :: DataDefnCons a -> [a] # null :: DataDefnCons a -> Bool # length :: DataDefnCons a -> Int # elem :: Eq a => a -> DataDefnCons a -> Bool # maximum :: Ord a => DataDefnCons a -> a # minimum :: Ord a => DataDefnCons a -> a # sum :: Num a => DataDefnCons a -> a # product :: Num a => DataDefnCons a -> a #
Traversable DataDefnCons # |
Instance details Defined in Language.Haskell.Syntax.Decls Methods traverse :: Applicative f => (a -> f b) -> DataDefnCons a -> f (DataDefnCons b) # sequenceA :: Applicative f => DataDefnCons (f a) -> f (DataDefnCons a) # mapM :: Monad m => (a -> m b) -> DataDefnCons a -> m (DataDefnCons b) # sequence :: Monad m => DataDefnCons (m a) -> m (DataDefnCons a) #
Data a => Data (DataDefnCons a) # |
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) -> DataDefnCons a -> c (DataDefnCons a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DataDefnCons a) # toConstr :: DataDefnCons a -> Constr # dataTypeOf :: DataDefnCons a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DataDefnCons a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DataDefnCons a)) # gmapT :: (forall b. Data b => b -> b) -> DataDefnCons a -> DataDefnCons a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataDefnCons a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DataDefnCons a -> r # gmapQ :: (forall d. Data d => d -> u) -> DataDefnCons a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DataDefnCons a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DataDefnCons a -> m (DataDefnCons a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DataDefnCons a -> m (DataDefnCons a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DataDefnCons a -> m (DataDefnCons a) #
Eq a => Eq (DataDefnCons a) # |
Instance details Defined in Language.Haskell.Syntax.Decls Methods (==) :: DataDefnCons a -> DataDefnCons a -> Bool # (/=) :: DataDefnCons a -> DataDefnCons a -> Bool #

dataDefnConsNewOrData :: DataDefnCons a -> NewOrData #

isTypeDataDefnCons :: DataDefnCons a -> Bool #

Are the constructors within a `type data` declaration? See Note [Type data declarations] in GHC.Rename.Module.

firstDataDefnCon :: DataDefnCons a -> Maybe a #

Retrieve the first data constructor in a `DataDefnCons` (if one exists).

data StandaloneKindSig pass #

Constructors

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

#### Instances

Instances details

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

type LStandaloneKindSig pass = XRec pass (StandaloneKindSig pass) #

Located Standalone Kind Signature

## Class or type declarations

data TyClDecl pass #

A type or class declaration.

Constructors

FamDecl |
    type/data family T :: *->*
Fields tcdFExt :: XFamDecl pass tcdFam :: FamilyDecl pass
SynDecl | `type` declaration
Fields tcdSExt :: XSynDecl pass Post renamer, 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
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) # |
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) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyClDecl GhcPs) # toConstr :: TyClDecl GhcPs -> Constr # dataTypeOf :: TyClDecl GhcPs -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyClDecl GhcPs)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TyClDecl GhcPs)) # gmapT :: (forall b. Data b => b -> b) -> TyClDecl GhcPs -> TyClDecl GhcPs # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyClDecl GhcPs -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyClDecl GhcPs -> r # gmapQ :: (forall d. Data d => d -> u) -> TyClDecl GhcPs -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TyClDecl GhcPs -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyClDecl GhcPs -> m (TyClDecl GhcPs) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClDecl GhcPs -> m (TyClDecl GhcPs) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClDecl GhcPs -> m (TyClDecl GhcPs) #
Data (TyClDecl GhcRn) # |
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) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyClDecl GhcRn) # toConstr :: TyClDecl GhcRn -> Constr # dataTypeOf :: TyClDecl GhcRn -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyClDecl GhcRn)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TyClDecl GhcRn)) # gmapT :: (forall b. Data b => b -> b) -> TyClDecl GhcRn -> TyClDecl GhcRn # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyClDecl GhcRn -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyClDecl GhcRn -> r # gmapQ :: (forall d. Data d => d -> u) -> TyClDecl GhcRn -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TyClDecl GhcRn -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyClDecl GhcRn -> m (TyClDecl GhcRn) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClDecl GhcRn -> m (TyClDecl GhcRn) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClDecl GhcRn -> m (TyClDecl GhcRn) #
Data (TyClDecl GhcTc) # |
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) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyClDecl GhcTc) # toConstr :: TyClDecl GhcTc -> Constr # dataTypeOf :: TyClDecl GhcTc -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyClDecl GhcTc)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TyClDecl GhcTc)) # gmapT :: (forall b. Data b => b -> b) -> TyClDecl GhcTc -> TyClDecl GhcTc # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyClDecl GhcTc -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyClDecl GhcTc -> r # gmapQ :: (forall d. Data d => d -> u) -> TyClDecl GhcTc -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TyClDecl GhcTc -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyClDecl GhcTc -> m (TyClDecl GhcTc) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClDecl GhcTc -> m (TyClDecl GhcTc) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClDecl GhcTc -> m (TyClDecl GhcTc) #
OutputableBndrId p => Outputable (TyClDecl (GhcPass p)) # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: TyClDecl (GhcPass p) -> SDoc #
type Anno (TyClDecl (GhcPass p)) # |
Instance details Defined in GHC.Hs.Decls type Anno (TyClDecl (GhcPass p)) = SrcSpanAnnA

type LTyClDecl pass = XRec pass (TyClDecl pass) #

Located Declaration of a Type or Class

data TyClGroup pass #

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

isClassDecl :: TyClDecl pass -> Bool #

type class

isDataDecl :: TyClDecl pass -> Bool #

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

isSynDecl :: TyClDecl pass -> Bool #

type or type instance declaration

isFamilyDecl :: TyClDecl pass -> Bool #

type/data family declaration

isTypeFamilyDecl :: TyClDecl pass -> Bool #

type family declaration

isDataFamilyDecl :: TyClDecl pass -> Bool #

data family declaration

isOpenTypeFamilyInfo :: FamilyInfo pass -> Bool #

open type family info

isClosedTypeFamilyInfo :: FamilyInfo pass -> Bool #

closed type family info

data FamilyDecl pass #

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

#### Instances

Instances details

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

type LFamilyDecl pass = XRec pass (FamilyDecl pass) #

Located type Family Declaration

## Instance declarations

data InstDecl pass #

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

type LInstDecl pass = XRec pass (InstDecl pass) #

Located Instance Declaration

data FamilyInfo pass #

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

familyInfoTyConFlavour #

Arguments

:: Maybe tc | Just cls = this is an associated family of class cls
-> FamilyInfo pass |
-> TyConFlavour tc |

data TyFamInstDecl pass #

Type Family Instance Declaration

Constructors

TyFamInstDecl |
Fields tfid_xtn :: XCTyFamInstDecl pass tfid_eqn :: TyFamInstEqn pass
XTyFamInstDecl !(XXTyFamInstDecl pass) |

#### Instances

Instances details

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

type LTyFamInstDecl pass = XRec pass (TyFamInstDecl pass) #

Located Type Family Instance Declaration

type TyFamDefltDecl = TyFamInstDecl #

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

type LTyFamDefltDecl pass = XRec pass (TyFamDefltDecl pass) #

Located type family default declarations.

newtype DataFamInstDecl pass #

Data Family Instance Declaration

Constructors

DataFamInstDecl |
Fields dfid_eqn :: FamEqn pass (HsDataDefn pass)

#### Instances

Instances details

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

type LDataFamInstDecl pass = XRec pass (DataFamInstDecl pass) #

Located Data Family Instance Declaration

data FamEqn pass rhs #

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 :: HsFamEqnPats pass feqn_fixity :: LexicalFixity Fixity used in the declaration feqn_rhs :: rhs
XFamEqn !(XXFamEqn pass rhs) |

#### Instances

Instances details

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

type TyFamInstEqn pass = FamEqn pass (LHsType pass) #

Type Family Instance Equation

type LTyFamInstEqn pass = XRec pass (TyFamInstEqn pass) #

Located Type Family Instance Equation

type HsFamEqnPats pass = [LHsTypeArg pass] #

HsFamEqnPats represents patterns on the left-hand side of a type instance, e.g. `type instance F `k (a :: k) = a` has patterns ``k` and `(a :: k)`.

HsFamEqnPats used to be called HsTyPats but it was renamed to avoid confusion with a different notion of type patterns, see #23657.

type LClsInstDecl pass = XRec pass (ClsInstDecl pass) #

Located Class Instance Declaration

data ClsInstDecl pass #

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)
XClsInstDecl !(XXClsInstDecl pass) |

#### Instances

Instances details

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

## Standalone deriving declarations

data DerivDecl pass #

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)
XDerivDecl !(XXDerivDecl pass) |

#### Instances

Instances details

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

type LDerivDecl pass = XRec pass (DerivDecl pass) #

Located stand-alone 'deriving instance' declaration

## Deriving strategies

data DerivStrategy pass #

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

type LDerivStrategy pass = XRec pass (DerivStrategy pass) #

A `Located` `DerivStrategy`.

## `RULE` declarations

type LRuleDecls pass = XRec pass (RuleDecls pass) #

Located Rule Declarations

data RuleDecls pass #

Rule Declarations

Constructors

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

#### Instances

Instances details

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

data RuleDecl pass #

Rule Declaration

Constructors

HsRule |
Fields rd_ext :: XHsRule pass After renamer, free-vars from the LHS and RHS rd_name :: XRec pass RuleName Note [Pragma source text] in GHC.Types.SourceText rd_act :: Activation rd_bndrs :: RuleBndrs pass rd_lhs :: XRec pass (HsExpr pass) rd_rhs :: XRec pass (HsExpr pass)
XRuleDecl !(XXRuleDecl pass) |

#### Instances

Instances details

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

type LRuleDecl pass = XRec pass (RuleDecl pass) #

Located Rule Declaration

data RuleBndr pass #

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

type LRuleBndr pass = XRec pass (RuleBndr pass) #

Located Rule Binder

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

## `default` declarations

data DefaultDecl pass #

Default Declaration

Constructors

DefaultDecl |
Fields defd_ext :: XCDefaultDecl pass defd_class :: Maybe (LIdP pass) defd_defaults :: [LHsType pass]
XDefaultDecl !(XXDefaultDecl pass) |

#### Instances

Instances details

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

type LDefaultDecl pass = XRec pass (DefaultDecl pass) #

Located Default Declaration

## Template haskell declaration splice

data SpliceDecoration #

A splice can appear with various decorations wrapped around it. This data type captures explicitly how it was originally written, for use in the pretty printer.

Constructors

DollarSplice | $splice
BareSplice | bare splice

#### Instances

Instances details

Data SpliceDecoration # |
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) -> SpliceDecoration -> c SpliceDecoration # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SpliceDecoration # toConstr :: SpliceDecoration -> Constr # dataTypeOf :: SpliceDecoration -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SpliceDecoration) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SpliceDecoration) # gmapT :: (forall b. Data b => b -> b) -> SpliceDecoration -> SpliceDecoration # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpliceDecoration -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpliceDecoration -> r # gmapQ :: (forall d. Data d => d -> u) -> SpliceDecoration -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SpliceDecoration -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpliceDecoration -> m SpliceDecoration # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceDecoration -> m SpliceDecoration # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceDecoration -> m SpliceDecoration #
Show SpliceDecoration # |
Instance details Defined in Language.Haskell.Syntax.Decls Methods showsPrec :: Int -> SpliceDecoration -> ShowS # show :: SpliceDecoration -> String # showList :: [SpliceDecoration] -> ShowS #
Outputable SpliceDecoration # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: SpliceDecoration -> SDoc #
Eq SpliceDecoration # |
Instance details Defined in Language.Haskell.Syntax.Decls Methods (==) :: SpliceDecoration -> SpliceDecoration -> Bool # (/=) :: SpliceDecoration -> SpliceDecoration -> Bool #

data SpliceDecl p #

Splice Declaration

Constructors

SpliceDecl (XSpliceDecl p) (XRec p (HsUntypedSplice p)) SpliceDecoration |
XSpliceDecl !(XXSpliceDecl p) |

#### Instances

Instances details

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

type LSpliceDecl pass = XRec pass (SpliceDecl pass) #

Located Splice Declaration

## Foreign function interface declarations

data ForeignDecl pass #

Foreign Declaration

Constructors

ForeignImport |
Fields fd_i_ext :: XForeignImport pass fd_name :: LIdP pass fd_sig_ty :: LHsSigType pass fd_fi :: ForeignImport pass
ForeignExport |
Fields fd_e_ext :: XForeignExport pass fd_name :: LIdP pass fd_sig_ty :: LHsSigType pass fd_fe :: ForeignExport pass
XForeignDecl !(XXForeignDecl pass) |

#### Instances

Instances details

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

type LForeignDecl pass = XRec pass (ForeignDecl pass) #

Located Foreign Declaration

data ForeignImport pass #

Constructors

CImport (XCImport pass) (XRec pass CCallConv) (XRec pass Safety) (Maybe Header) CImportSpec |
XForeignImport !(XXForeignImport pass) |

#### Instances

Instances details

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

data ForeignExport pass #

Constructors

CExport (XCExport pass) (XRec pass CExportSpec) |
XForeignExport !(XXForeignExport pass) |

#### Instances

Instances details

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

data CImportSpec #

Constructors

CLabel CLabelString |
CFunction CCallTarget |
CWrapper |

#### Instances

Instances details

Data CImportSpec # |
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 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CImportSpec # toConstr :: CImportSpec -> Constr # dataTypeOf :: CImportSpec -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CImportSpec) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CImportSpec) # gmapT :: (forall b. Data b => b -> b) -> CImportSpec -> CImportSpec # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CImportSpec -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CImportSpec -> r # gmapQ :: (forall d. Data d => d -> u) -> CImportSpec -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CImportSpec -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CImportSpec -> m CImportSpec # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CImportSpec -> m CImportSpec # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CImportSpec -> m CImportSpec #

## Data-constructor declarations

data ConDecl pass #

    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

data Constructor Declaration

Constructors

ConDeclGADT |
Fields con_g_ext :: XConDeclGADT pass con_names :: NonEmpty (LIdP pass) con_outer_bndrs :: XRec pass (HsOuterSigTyVarBndrs pass) The outermost type variable binders, be they explicit or implicit; cf. HsSigType that also stores the outermost sig_bndrs separately from the forall telescopes in sig_body. See Note [Representing type signatures] in Language.Haskell.Syntax.Type con_inner_bndrs :: [HsForAllTelescope pass] The forall telescopes other than the outermost invisible forall. 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 (LHsDoc pass) 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 (LHsDoc pass) A possible Haddock comment.
XConDecl !(XXConDecl pass) |

#### Instances

Instances details

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

type LConDecl pass = XRec pass (ConDecl pass) #

Located data Constructor Declaration

type HsConDeclH98Details pass = HsConDetails (HsConDeclField pass) (XRec pass [LHsConDeclRecField pass]) #

The arguments in a Haskell98-style data constructor.

data HsConDeclGADTDetails pass #

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 !(XPrefixConGADT pass) [HsConDeclField pass] |
RecConGADT !(XRecConGADT pass) (XRec pass [LHsConDeclRecField pass]) |
XConDeclGADTDetails !(XXConDeclGADTDetails pass) |

#### Instances

Instances details

Data (HsConDeclGADTDetails GhcPs) # |
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) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsConDeclGADTDetails GhcPs) # toConstr :: HsConDeclGADTDetails GhcPs -> Constr # dataTypeOf :: HsConDeclGADTDetails GhcPs -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsConDeclGADTDetails GhcPs)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsConDeclGADTDetails GhcPs)) # gmapT :: (forall b. Data b => b -> b) -> HsConDeclGADTDetails GhcPs -> HsConDeclGADTDetails GhcPs # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclGADTDetails GhcPs -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclGADTDetails GhcPs -> r # gmapQ :: (forall d. Data d => d -> u) -> HsConDeclGADTDetails GhcPs -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsConDeclGADTDetails GhcPs -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsConDeclGADTDetails GhcPs -> m (HsConDeclGADTDetails GhcPs) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclGADTDetails GhcPs -> m (HsConDeclGADTDetails GhcPs) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclGADTDetails GhcPs -> m (HsConDeclGADTDetails GhcPs) #
Data (HsConDeclGADTDetails GhcRn) # |
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) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsConDeclGADTDetails GhcRn) # toConstr :: HsConDeclGADTDetails GhcRn -> Constr # dataTypeOf :: HsConDeclGADTDetails GhcRn -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsConDeclGADTDetails GhcRn)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsConDeclGADTDetails GhcRn)) # gmapT :: (forall b. Data b => b -> b) -> HsConDeclGADTDetails GhcRn -> HsConDeclGADTDetails GhcRn # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclGADTDetails GhcRn -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclGADTDetails GhcRn -> r # gmapQ :: (forall d. Data d => d -> u) -> HsConDeclGADTDetails GhcRn -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsConDeclGADTDetails GhcRn -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsConDeclGADTDetails GhcRn -> m (HsConDeclGADTDetails GhcRn) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclGADTDetails GhcRn -> m (HsConDeclGADTDetails GhcRn) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclGADTDetails GhcRn -> m (HsConDeclGADTDetails GhcRn) #
Data (HsConDeclGADTDetails GhcTc) # |
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) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsConDeclGADTDetails GhcTc) # toConstr :: HsConDeclGADTDetails GhcTc -> Constr # dataTypeOf :: HsConDeclGADTDetails GhcTc -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsConDeclGADTDetails GhcTc)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsConDeclGADTDetails GhcTc)) # gmapT :: (forall b. Data b => b -> b) -> HsConDeclGADTDetails GhcTc -> HsConDeclGADTDetails GhcTc # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclGADTDetails GhcTc -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclGADTDetails GhcTc -> r # gmapQ :: (forall d. Data d => d -> u) -> HsConDeclGADTDetails GhcTc -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsConDeclGADTDetails GhcTc -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsConDeclGADTDetails GhcTc -> m (HsConDeclGADTDetails GhcTc) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclGADTDetails GhcTc -> m (HsConDeclGADTDetails GhcTc) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclGADTDetails GhcTc -> m (HsConDeclGADTDetails GhcTc) #

type family XPrefixConGADT p #

#### Instances

Instances details

type XPrefixConGADT (GhcPass _1) # |
Instance details Defined in GHC.Hs.Decls type XPrefixConGADT (GhcPass _1) = NoExtField

type family XRecConGADT p #

#### Instances

Instances details

type XRecConGADT GhcPs # |
Instance details Defined in GHC.Hs.Decls type XRecConGADT GhcPs = TokRarrow
type XRecConGADT GhcRn # |
Instance details Defined in GHC.Hs.Decls type XRecConGADT GhcRn = NoExtField
type XRecConGADT GhcTc # |
Instance details Defined in GHC.Hs.Decls type XRecConGADT GhcTc = NoExtField

type family XXConDeclGADTDetails p #

#### Instances

Instances details

type XXConDeclGADTDetails (GhcPass _1) # |
Instance details Defined in GHC.Hs.Decls type XXConDeclGADTDetails (GhcPass _1) = DataConCantHappen

## Document comments

data DocDecl pass #

Documentation comment Declaration

Constructors

DocCommentNext (LHsDoc pass) |
DocCommentPrev (LHsDoc pass) |
DocCommentNamed String (LHsDoc pass) |
DocGroup Int (LHsDoc pass) |

#### Instances

Instances details

(Data pass, Data (IdP pass)) => Data (DocDecl pass) # |
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 pass -> c (DocDecl pass) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DocDecl pass) # toConstr :: DocDecl pass -> Constr # dataTypeOf :: DocDecl pass -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DocDecl pass)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DocDecl pass)) # gmapT :: (forall b. Data b => b -> b) -> DocDecl pass -> DocDecl pass # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DocDecl pass -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DocDecl pass -> r # gmapQ :: (forall d. Data d => d -> u) -> DocDecl pass -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DocDecl pass -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DocDecl pass -> m (DocDecl pass) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DocDecl pass -> m (DocDecl pass) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DocDecl pass -> m (DocDecl pass) #
Outputable (DocDecl name) # |
Instance details Defined in GHC.Hs.Decls Methods ppr :: DocDecl name -> SDoc #
type Anno (DocDecl (GhcPass p)) # |
Instance details Defined in GHC.Hs.Decls type Anno (DocDecl (GhcPass p)) = SrcSpanAnnA

type LDocDecl pass = XRec pass (DocDecl pass) #

Located Documentation comment Declaration

docDeclDoc :: DocDecl pass -> LHsDoc pass #

## Deprecations

data WarnDecl pass #

Warning pragma Declaration

Constructors

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

#### Instances

Instances details

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

type LWarnDecl pass = XRec pass (WarnDecl pass) #

Located Warning pragma Declaration

data WarnDecls pass #

Warning pragma Declarations

Constructors

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

#### Instances

Instances details

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

type LWarnDecls pass = XRec pass (WarnDecls pass) #

Located Warning Declarations

## Annotations

data AnnDecl pass #

Annotation Declaration

Constructors

HsAnnotation (XHsAnnotation pass) (AnnProvenance pass) (XRec pass (HsExpr pass)) |
XAnnDecl !(XXAnnDecl pass) |

#### Instances

Instances details

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

type LAnnDecl pass = XRec pass (AnnDecl pass) #

Located Annotation Declaration

data AnnProvenance pass #

Annotation Provenance

Constructors

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

#### Instances

Instances details

Data (AnnProvenance GhcPs) # |
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) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnProvenance GhcPs) # toConstr :: AnnProvenance GhcPs -> Constr # dataTypeOf :: AnnProvenance GhcPs -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AnnProvenance GhcPs)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AnnProvenance GhcPs)) # gmapT :: (forall b. Data b => b -> b) -> AnnProvenance GhcPs -> AnnProvenance GhcPs # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance GhcPs -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance GhcPs -> r # gmapQ :: (forall d. Data d => d -> u) -> AnnProvenance GhcPs -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnProvenance GhcPs -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnProvenance GhcPs -> m (AnnProvenance GhcPs) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance GhcPs -> m (AnnProvenance GhcPs) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance GhcPs -> m (AnnProvenance GhcPs) #
Data (AnnProvenance GhcRn) # |
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) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnProvenance GhcRn) # toConstr :: AnnProvenance GhcRn -> Constr # dataTypeOf :: AnnProvenance GhcRn -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AnnProvenance GhcRn)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AnnProvenance GhcRn)) # gmapT :: (forall b. Data b => b -> b) -> AnnProvenance GhcRn -> AnnProvenance GhcRn # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance GhcRn -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance GhcRn -> r # gmapQ :: (forall d. Data d => d -> u) -> AnnProvenance GhcRn -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnProvenance GhcRn -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnProvenance GhcRn -> m (AnnProvenance GhcRn) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance GhcRn -> m (AnnProvenance GhcRn) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance GhcRn -> m (AnnProvenance GhcRn) #
Data (AnnProvenance GhcTc) # |
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) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnProvenance GhcTc) # toConstr :: AnnProvenance GhcTc -> Constr # dataTypeOf :: AnnProvenance GhcTc -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AnnProvenance GhcTc)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AnnProvenance GhcTc)) # gmapT :: (forall b. Data b => b -> b) -> AnnProvenance GhcTc -> AnnProvenance GhcTc # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance GhcTc -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance GhcTc -> r # gmapQ :: (forall d. Data d => d -> u) -> AnnProvenance GhcTc -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnProvenance GhcTc -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnProvenance GhcTc -> m (AnnProvenance GhcTc) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance GhcTc -> m (AnnProvenance GhcTc) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance GhcTc -> m (AnnProvenance GhcTc) #

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

## Role annotations

data RoleAnnotDecl pass #

Role Annotation Declaration

Constructors

RoleAnnotDecl (XCRoleAnnotDecl pass) (LIdP pass) [XRec pass (Maybe Role)] |
XRoleAnnotDecl !(XXRoleAnnotDecl pass) |

#### Instances

Instances details

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

type LRoleAnnotDecl pass = XRec pass (RoleAnnotDecl pass) #

Located Role Annotation Declaration

## Injective type families

data FamilyResultSig pass #

type Family Result Signature

Constructors

NoSig (XNoSig pass) |
KindSig (XCKindSig pass) (LHsKind pass) |
TyVarSig (XTyVarSig pass) (LHsTyVarBndr () pass) |
XFamilyResultSig !(XXFamilyResultSig pass) |

#### Instances

Instances details

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

type LFamilyResultSig pass = XRec pass (FamilyResultSig pass) #

Located type Family Result Signature

data InjectivityAnn pass #

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] |
XInjectivityAnn !(XXInjectivityAnn pass) |

#### Instances

Instances details

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

type LInjectivityAnn pass = XRec pass (InjectivityAnn pass) #

Located Injectivity Annotation

# Grouping

data HsGroup p #

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