Safe Haskell	None
Language	Haskell2010

HsDecls

Contents

Toplevel declarations
Grouping

Description

Abstract syntax of global declarations.

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

Synopsis

data HsDecl id
- = TyClD (TyClDecl id)
- | InstD (InstDecl id)
- | DerivD (DerivDecl id)
- | ValD (HsBind id)
- | SigD (Sig id)
- | DefD (DefaultDecl id)
- | ForD (ForeignDecl id)
- | WarningD (WarnDecls id)
- | AnnD (AnnDecl id)
- | RuleD (RuleDecls id)
- | VectD (VectDecl id)
- | SpliceD (SpliceDecl id)
- | DocD DocDecl
- | RoleAnnotD (RoleAnnotDecl id)
type LHsDecl id = Located (HsDecl id)
data HsDataDefn pass = HsDataDefn {
- dd_ND :: NewOrData
- dd_ctxt :: LHsContext pass
- dd_cType :: Maybe (Located CType)
- dd_kindSig :: Maybe (LHsKind pass)
- dd_cons :: [LConDecl pass]
- dd_derivs :: HsDeriving pass
}
type HsDeriving pass = Located [LHsDerivingClause pass]
data HsDerivingClause pass = HsDerivingClause {
- deriv_clause_strategy :: Maybe (Located DerivStrategy)
- deriv_clause_tys :: Located [LHsSigType pass]
}
type LHsDerivingClause pass = Located (HsDerivingClause pass)
data TyClDecl pass
- = FamDecl {
  - tcdFam :: FamilyDecl pass
  }
- | SynDecl {
  - tcdLName :: Located (IdP pass)
  - tcdTyVars :: LHsQTyVars pass
  - tcdFixity :: LexicalFixity
  - tcdRhs :: LHsType pass
  - tcdFVs :: PostRn pass NameSet
  }
- | DataDecl {
  - tcdLName :: Located (IdP pass)
  - tcdTyVars :: LHsQTyVars pass
  - tcdFixity :: LexicalFixity
  - tcdDataDefn :: HsDataDefn pass
  - tcdDataCusk :: PostRn pass Bool
  - tcdFVs :: PostRn pass NameSet
  }
- | ClassDecl {
  - tcdCtxt :: LHsContext pass
  - tcdLName :: Located (IdP pass)
  - tcdTyVars :: LHsQTyVars pass
  - tcdFixity :: LexicalFixity
  - tcdFDs :: [Located (FunDep (Located (IdP pass)))]
  - tcdSigs :: [LSig pass]
  - tcdMeths :: LHsBinds pass
  - tcdATs :: [LFamilyDecl pass]
  - tcdATDefs :: [LTyFamDefltEqn pass]
  - tcdDocs :: [LDocDecl]
  - tcdFVs :: PostRn pass NameSet
  }
type LTyClDecl pass = Located (TyClDecl pass)
data TyClGroup pass = TyClGroup {
- group_tyclds :: [LTyClDecl pass]
- group_roles :: [LRoleAnnotDecl pass]
- group_instds :: [LInstDecl pass]
}
mkTyClGroup :: [LTyClDecl pass] -> [LInstDecl pass] -> TyClGroup pass
emptyTyClGroup :: TyClGroup pass
tyClGroupTyClDecls :: [TyClGroup pass] -> [LTyClDecl pass]
tyClGroupInstDecls :: [TyClGroup pass] -> [LInstDecl pass]
tyClGroupRoleDecls :: [TyClGroup pass] -> [LRoleAnnotDecl pass]
isClassDecl :: TyClDecl pass -> Bool
isDataDecl :: TyClDecl pass -> Bool
isSynDecl :: TyClDecl pass -> Bool
tcdName :: TyClDecl pass -> IdP pass
isFamilyDecl :: TyClDecl pass -> Bool
isTypeFamilyDecl :: TyClDecl pass -> Bool
isDataFamilyDecl :: TyClDecl pass -> Bool
isOpenTypeFamilyInfo :: FamilyInfo pass -> Bool
isClosedTypeFamilyInfo :: FamilyInfo pass -> Bool
tyFamInstDeclName :: TyFamInstDecl pass -> IdP pass
tyFamInstDeclLName :: TyFamInstDecl pass -> Located (IdP pass)
countTyClDecls :: [TyClDecl pass] -> (Int, Int, Int, Int, Int)
pprTyClDeclFlavour :: TyClDecl a -> SDoc
tyClDeclLName :: TyClDecl pass -> Located (IdP pass)
tyClDeclTyVars :: TyClDecl pass -> LHsQTyVars pass
hsDeclHasCusk :: TyClDecl GhcRn -> Bool
famDeclHasCusk :: Maybe Bool -> FamilyDecl pass -> Bool
data FamilyDecl pass = FamilyDecl {
- fdInfo :: FamilyInfo pass
- fdLName :: Located (IdP pass)
- fdTyVars :: LHsQTyVars pass
- fdFixity :: LexicalFixity
- fdResultSig :: LFamilyResultSig pass
- fdInjectivityAnn :: Maybe (LInjectivityAnn pass)
}
type LFamilyDecl pass = Located (FamilyDecl pass)
data InstDecl pass
- = ClsInstD {
  - cid_inst :: ClsInstDecl pass
  }
- | DataFamInstD {
  - dfid_inst :: DataFamInstDecl pass
  }
- | TyFamInstD {
  - tfid_inst :: TyFamInstDecl pass
  }
type LInstDecl pass = Located (InstDecl pass)
data NewOrData
- = NewType
- | DataType
data FamilyInfo pass
- = DataFamily
- | OpenTypeFamily
- | ClosedTypeFamily (Maybe [LTyFamInstEqn pass])
newtype TyFamInstDecl pass = TyFamInstDecl {
- tfid_eqn :: TyFamInstEqn pass
}
type LTyFamInstDecl pass = Located (TyFamInstDecl pass)
instDeclDataFamInsts :: [LInstDecl pass] -> [DataFamInstDecl pass]
newtype DataFamInstDecl pass = DataFamInstDecl {
- dfid_eqn :: FamInstEqn pass (HsDataDefn pass)
}
type LDataFamInstDecl pass = Located (DataFamInstDecl pass)
pprDataFamInstFlavour :: DataFamInstDecl pass -> SDoc
pprFamInstLHS :: (SourceTextX pass, OutputableBndrId pass) => Located (IdP pass) -> HsTyPats pass -> LexicalFixity -> HsContext pass -> Maybe (LHsKind pass) -> SDoc
type FamInstEqn pass rhs = HsImplicitBndrs pass (FamEqn pass (HsTyPats pass) rhs)
type LFamInstEqn pass rhs = Located (FamInstEqn pass rhs)
data FamEqn pass pats rhs = FamEqn {
- feqn_tycon :: Located (IdP pass)
- feqn_pats :: pats
- feqn_fixity :: LexicalFixity
- feqn_rhs :: rhs
}
type TyFamInstEqn pass = FamInstEqn pass (LHsType pass)
type LTyFamInstEqn pass = Located (TyFamInstEqn pass)
type TyFamDefltEqn pass = FamEqn pass (LHsQTyVars pass) (LHsType pass)
type LTyFamDefltEqn pass = Located (TyFamDefltEqn pass)
type HsTyPats pass = [LHsType pass]
type LClsInstDecl pass = Located (ClsInstDecl pass)
data ClsInstDecl pass = ClsInstDecl {
- 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 (Located OverlapMode)
}
data DerivDecl pass = DerivDecl {
- deriv_type :: LHsSigType pass
- deriv_strategy :: Maybe (Located DerivStrategy)
- deriv_overlap_mode :: Maybe (Located OverlapMode)
}
type LDerivDecl pass = Located (DerivDecl pass)
type LRuleDecls pass = Located (RuleDecls pass)
data RuleDecls pass = HsRules {
- rds_src :: SourceText
- rds_rules :: [LRuleDecl pass]
}
data RuleDecl pass = HsRule (Located (SourceText, RuleName)) Activation [LRuleBndr pass] (Located (HsExpr pass)) (PostRn pass NameSet) (Located (HsExpr pass)) (PostRn pass NameSet)
type LRuleDecl pass = Located (RuleDecl pass)
data RuleBndr pass
- = RuleBndr (Located (IdP pass))
- | RuleBndrSig (Located (IdP pass)) (LHsSigWcType pass)
type LRuleBndr pass = Located (RuleBndr pass)
collectRuleBndrSigTys :: [RuleBndr pass] -> [LHsSigWcType pass]
flattenRuleDecls :: [LRuleDecls pass] -> [LRuleDecl pass]
pprFullRuleName :: Located (SourceText, RuleName) -> SDoc
data VectDecl pass
- = HsVect SourceText (Located (IdP pass)) (LHsExpr pass)
- | HsNoVect SourceText (Located (IdP pass))
- | HsVectTypeIn SourceText Bool (Located (IdP pass)) (Maybe (Located (IdP pass)))
- | HsVectTypeOut Bool TyCon (Maybe TyCon)
- | HsVectClassIn SourceText (Located (IdP pass))
- | HsVectClassOut Class
- | HsVectInstIn (LHsSigType pass)
- | HsVectInstOut ClsInst
type LVectDecl pass = Located (VectDecl pass)
lvectDeclName :: NamedThing (IdP pass) => LVectDecl pass -> Name
lvectInstDecl :: LVectDecl pass -> Bool
data DefaultDecl pass = DefaultDecl [LHsType pass]
type LDefaultDecl pass = Located (DefaultDecl pass)
data SpliceExplicitFlag
- = ExplicitSplice
- | ImplicitSplice
data SpliceDecl id = SpliceDecl (Located (HsSplice id)) SpliceExplicitFlag
type LSpliceDecl pass = Located (SpliceDecl pass)
data ForeignDecl pass
- = ForeignImport {
  - fd_name :: Located (IdP pass)
  - fd_sig_ty :: LHsSigType pass
  - fd_co :: PostTc pass Coercion
  - fd_fi :: ForeignImport
  }
- | ForeignExport {
  - fd_name :: Located (IdP pass)
  - fd_sig_ty :: LHsSigType pass
  - fd_co :: PostTc pass Coercion
  - fd_fe :: ForeignExport
  }
type LForeignDecl pass = Located (ForeignDecl pass)
data ForeignImport = CImport (Located CCallConv) (Located Safety) (Maybe Header) CImportSpec (Located SourceText)
data ForeignExport = CExport (Located CExportSpec) (Located SourceText)
noForeignImportCoercionYet :: PlaceHolder
noForeignExportCoercionYet :: PlaceHolder
data CImportSpec
- = CLabel CLabelString
- | CFunction CCallTarget
- | CWrapper
data ConDecl pass
- = ConDeclGADT {
  - con_names :: [Located (IdP pass)]
  - con_type :: LHsSigType pass
  - con_doc :: Maybe LHsDocString
  }
- | ConDeclH98 {
  - con_name :: Located (IdP pass)
  - con_qvars :: Maybe (LHsQTyVars pass)
  - con_cxt :: Maybe (LHsContext pass)
  - con_details :: HsConDeclDetails pass
  - con_doc :: Maybe LHsDocString
  }
type LConDecl pass = Located (ConDecl pass)
type HsConDeclDetails pass = HsConDetails (LBangType pass) (Located [LConDeclField pass])
hsConDeclArgTys :: HsConDeclDetails pass -> [LBangType pass]
getConNames :: ConDecl pass -> [Located (IdP pass)]
getConDetails :: ConDecl pass -> HsConDeclDetails pass
gadtDeclDetails :: LHsSigType pass -> (HsConDeclDetails pass, LHsType pass, LHsContext pass, [LHsTyVarBndr pass])
data DocDecl
- = DocCommentNext HsDocString
- | DocCommentPrev HsDocString
- | DocCommentNamed String HsDocString
- | DocGroup Int HsDocString
type LDocDecl = Located DocDecl
docDeclDoc :: DocDecl -> HsDocString
data WarnDecl pass = Warning [Located (IdP pass)] WarningTxt
type LWarnDecl pass = Located (WarnDecl pass)
data WarnDecls pass = Warnings {
- wd_src :: SourceText
- wd_warnings :: [LWarnDecl pass]
}
type LWarnDecls pass = Located (WarnDecls pass)
data AnnDecl pass = HsAnnotation SourceText (AnnProvenance (IdP pass)) (Located (HsExpr pass))
type LAnnDecl pass = Located (AnnDecl pass)
data AnnProvenance name
- = ValueAnnProvenance (Located name)
- | TypeAnnProvenance (Located name)
- | ModuleAnnProvenance
annProvenanceName_maybe :: AnnProvenance name -> Maybe name
data RoleAnnotDecl pass = RoleAnnotDecl (Located (IdP pass)) [Located (Maybe Role)]
type LRoleAnnotDecl pass = Located (RoleAnnotDecl pass)
roleAnnotDeclName :: RoleAnnotDecl pass -> IdP pass
data FamilyResultSig pass
- = NoSig
- | KindSig (LHsKind pass)
- | TyVarSig (LHsTyVarBndr pass)
type LFamilyResultSig pass = Located (FamilyResultSig pass)
data InjectivityAnn pass = InjectivityAnn (Located (IdP pass)) [Located (IdP pass)]
type LInjectivityAnn pass = Located (InjectivityAnn pass)
resultVariableName :: FamilyResultSig a -> Maybe (IdP a)
data HsGroup id = HsGroup {
- hs_valds :: HsValBinds id
- hs_splcds :: [LSpliceDecl id]
- hs_tyclds :: [TyClGroup id]
- hs_derivds :: [LDerivDecl id]
- hs_fixds :: [LFixitySig id]
- hs_defds :: [LDefaultDecl id]
- hs_fords :: [LForeignDecl id]
- hs_warnds :: [LWarnDecls id]
- hs_annds :: [LAnnDecl id]
- hs_ruleds :: [LRuleDecls id]
- hs_vects :: [LVectDecl id]
- hs_docs :: [LDocDecl]
}
emptyRdrGroup :: HsGroup a
emptyRnGroup :: HsGroup a
appendGroups :: HsGroup a -> HsGroup a -> HsGroup a
hsGroupInstDecls :: HsGroup id -> [LInstDecl id]

Toplevel declarations

data HsDecl id Source #

A Haskell Declaration

Constructors

TyClD (TyClDecl id)	Type or Class Declaration
InstD (InstDecl id)	Instance declaration
DerivD (DerivDecl id)	Deriving declaration
ValD (HsBind id)	Value declaration
SigD (Sig id)	Signature declaration
DefD (DefaultDecl id)	'default' declaration
ForD (ForeignDecl id)	Foreign declaration
WarningD (WarnDecls id)	Warning declaration
AnnD (AnnDecl id)	Annotation declaration
RuleD (RuleDecls id)	Rule declaration
VectD (VectDecl id)	Vectorise declaration
SpliceD (SpliceDecl id)	Splice declaration (Includes quasi-quotes)
DocD DocDecl	Documentation comment declaration
RoleAnnotD (RoleAnnotDecl id)	Role annotation declaration

Instances

DataId id => Data (HsDecl id) Source #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsDecl id -> c (HsDecl id) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsDecl id) # toConstr :: HsDecl id -> Constr # dataTypeOf :: HsDecl id -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsDecl id)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsDecl id)) # gmapT :: (forall b. Data b => b -> b) -> HsDecl id -> HsDecl id # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl id -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl id -> r # gmapQ :: (forall d. Data d => d -> u) -> HsDecl id -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDecl id -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsDecl id -> m (HsDecl id) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDecl id -> m (HsDecl id) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDecl id -> m (HsDecl id) #
(SourceTextX pass, OutputableBndrId pass) => Outputable (HsDecl pass) Source #
Instance details Methods ppr :: HsDecl pass -> SDoc Source # pprPrec :: Rational -> HsDecl pass -> SDoc Source #

type LHsDecl id Source #

Arguments

= Located (HsDecl id)

When in a list this may have

AnnKeywordId : AnnSemi

data HsDataDefn pass Source #

Haskell Data type Definition

Constructors

HsDataDefn

Declares a data type or newtype, giving its constructors data/newtype T a = constrs data/newtype instance T [a] = constrs

Fields

dd_ND :: NewOrData
dd_ctxt :: LHsContext pass
Context
dd_cType :: Maybe (Located CType)
dd_kindSig :: Maybe (LHsKind pass)
Optional kind signature.
(Just k) for a GADT-style data, or data instance decl, with explicit kind sig
Always Nothing for H98-syntax decls
dd_cons :: [LConDecl pass]
Data constructors
For data T a = T1 | T2 a the LConDecls all have ConDeclH98. For data T a where { T1 :: T a } the LConDecls all have ConDeclGADT.
dd_derivs :: HsDeriving pass
Optional 'deriving' claues

Instances

DataId id => Data (HsDataDefn id) Source #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsDataDefn id -> c (HsDataDefn id) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsDataDefn id) # toConstr :: HsDataDefn id -> Constr # dataTypeOf :: HsDataDefn id -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsDataDefn id)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsDataDefn id)) # gmapT :: (forall b. Data b => b -> b) -> HsDataDefn id -> HsDataDefn id # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDataDefn id -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDataDefn id -> r # gmapQ :: (forall d. Data d => d -> u) -> HsDataDefn id -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDataDefn id -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsDataDefn id -> m (HsDataDefn id) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDataDefn id -> m (HsDataDefn id) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDataDefn id -> m (HsDataDefn id) #
(SourceTextX pass, OutputableBndrId pass) => Outputable (HsDataDefn pass) Source #
Instance details Methods ppr :: HsDataDefn pass -> SDoc Source # pprPrec :: Rational -> HsDataDefn pass -> SDoc Source #

type HsDeriving pass Source #

Arguments

= Located [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 LHsDerivingClauses corresponds to exactly what the user requested to derive, in order. If no deriving clauses were specified, the list is empty.

Haskell Deriving clause

data HsDerivingClause pass Source #

A single deriving clause of a data declaration.

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

Constructors

HsDerivingClause

Fields

deriv_clause_strategy :: Maybe (Located DerivStrategy)
The user-specified strategy (if any) to use when deriving deriv_clause_tys.
deriv_clause_tys :: Located [LHsSigType pass]
The types to derive.
It uses LHsSigTypes because, with -XGeneralizedNewtypeDeriving, we 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).

Instances

DataId id => Data (HsDerivingClause id) Source #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsDerivingClause id -> c (HsDerivingClause id) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsDerivingClause id) # toConstr :: HsDerivingClause id -> Constr # dataTypeOf :: HsDerivingClause id -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsDerivingClause id)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsDerivingClause id)) # gmapT :: (forall b. Data b => b -> b) -> HsDerivingClause id -> HsDerivingClause id # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDerivingClause id -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDerivingClause id -> r # gmapQ :: (forall d. Data d => d -> u) -> HsDerivingClause id -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDerivingClause id -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsDerivingClause id -> m (HsDerivingClause id) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDerivingClause id -> m (HsDerivingClause id) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDerivingClause id -> m (HsDerivingClause id) #
(SourceTextX pass, OutputableBndrId pass) => Outputable (HsDerivingClause pass) Source #
Instance details Methods ppr :: HsDerivingClause pass -> SDoc Source # pprPrec :: Rational -> HsDerivingClause pass -> SDoc Source #

type LHsDerivingClause pass = Located (HsDerivingClause pass) Source #

Class or type declarations

data TyClDecl pass Source #

A type or class declaration.

Constructors

FamDecl	type/data family T :: -> `AnnKeywordId` : `AnnType`, `AnnData`, `AnnFamily`,`AnnDcolon`, `AnnWhere`,`AnnOpenP`, `AnnDcolon`,`AnnCloseP`, `AnnEqual`,`AnnRarrow`, `AnnVbar`
Fields tcdFam :: FamilyDecl pass
SynDecl	`type` declaration `AnnKeywordId` : `AnnType`, `AnnEqual`,
Fields tcdLName :: Located (IdP 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 tcdFVs :: PostRn pass NameSet
DataDecl	`data` declaration `AnnKeywordId` : `AnnData`, `AnnFamily`, `AnnNewType`, `AnnNewType`,`AnnDcolon` `AnnWhere`,
Fields tcdLName :: Located (IdP 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 tcdDataCusk :: PostRn pass Bool does this have a CUSK? tcdFVs :: PostRn pass NameSet
ClassDecl	`AnnKeywordId` : `AnnClass`, `AnnWhere`,`AnnOpen`, `AnnClose` The tcdFDs will have `AnnVbar`, `AnnComma` `AnnRarrow`
Fields tcdCtxt :: LHsContext pass Context... tcdLName :: Located (IdP pass) Type constructor tcdTyVars :: LHsQTyVars pass Type variables; for an associated type these include outer binders tcdFixity :: LexicalFixity Fixity used in the declaration tcdFDs :: [Located (FunDep (Located (IdP pass)))] Functional deps tcdSigs :: [LSig pass] Methods' signatures tcdMeths :: LHsBinds pass Default methods tcdATs :: [LFamilyDecl pass] Associated types; tcdATDefs :: [LTyFamDefltEqn pass] Associated type defaults tcdDocs :: [LDocDecl] Haddock docs tcdFVs :: PostRn pass NameSet

Instances

DataId id => Data (TyClDecl id) Source #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyClDecl id -> c (TyClDecl id) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyClDecl id) # toConstr :: TyClDecl id -> Constr # dataTypeOf :: TyClDecl id -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyClDecl id)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TyClDecl id)) # gmapT :: (forall b. Data b => b -> b) -> TyClDecl id -> TyClDecl id # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyClDecl id -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyClDecl id -> r # gmapQ :: (forall d. Data d => d -> u) -> TyClDecl id -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TyClDecl id -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyClDecl id -> m (TyClDecl id) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClDecl id -> m (TyClDecl id) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClDecl id -> m (TyClDecl id) #
(SourceTextX pass, OutputableBndrId pass) => Outputable (TyClDecl pass) Source #
Instance details Methods ppr :: TyClDecl pass -> SDoc Source # pprPrec :: Rational -> TyClDecl pass -> SDoc Source #

type LTyClDecl pass = Located (TyClDecl pass) Source #

Located Declaration of a Type or Class

data TyClGroup pass Source #

Type or Class Group

Constructors

TyClGroup
Fields group_tyclds :: [LTyClDecl pass] group_roles :: [LRoleAnnotDecl pass] group_instds :: [LInstDecl pass]

Instances

DataId id => Data (TyClGroup id) Source #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyClGroup id -> c (TyClGroup id) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyClGroup id) # toConstr :: TyClGroup id -> Constr # dataTypeOf :: TyClGroup id -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyClGroup id)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TyClGroup id)) # gmapT :: (forall b. Data b => b -> b) -> TyClGroup id -> TyClGroup id # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyClGroup id -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyClGroup id -> r # gmapQ :: (forall d. Data d => d -> u) -> TyClGroup id -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TyClGroup id -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyClGroup id -> m (TyClGroup id) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClGroup id -> m (TyClGroup id) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClGroup id -> m (TyClGroup id) #
(SourceTextX pass, OutputableBndrId pass) => Outputable (TyClGroup pass) Source #
Instance details Methods ppr :: TyClGroup pass -> SDoc Source # pprPrec :: Rational -> TyClGroup pass -> SDoc Source #

mkTyClGroup :: [LTyClDecl pass] -> [LInstDecl pass] -> TyClGroup pass Source #

emptyTyClGroup :: TyClGroup pass Source #

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

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

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

isClassDecl :: TyClDecl pass -> Bool Source #

type class

isDataDecl :: TyClDecl pass -> Bool Source #

True = argument is a data/newtype declaration.

isSynDecl :: TyClDecl pass -> Bool Source #

type or type instance declaration

tcdName :: TyClDecl pass -> IdP pass Source #

isFamilyDecl :: TyClDecl pass -> Bool Source #

type/data family declaration

isTypeFamilyDecl :: TyClDecl pass -> Bool Source #

type family declaration

isDataFamilyDecl :: TyClDecl pass -> Bool Source #

data family declaration

isOpenTypeFamilyInfo :: FamilyInfo pass -> Bool Source #

open type family info

isClosedTypeFamilyInfo :: FamilyInfo pass -> Bool Source #

closed type family info

tyFamInstDeclName :: TyFamInstDecl pass -> IdP pass Source #

tyFamInstDeclLName :: TyFamInstDecl pass -> Located (IdP pass) Source #

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

pprTyClDeclFlavour :: TyClDecl a -> SDoc Source #

tyClDeclLName :: TyClDecl pass -> Located (IdP pass) Source #

tyClDeclTyVars :: TyClDecl pass -> LHsQTyVars pass Source #

hsDeclHasCusk :: TyClDecl GhcRn -> Bool Source #

Does this declaration have a complete, user-supplied kind signature? See Note [Complete user-supplied kind signatures]

famDeclHasCusk Source #

Arguments

:: Maybe Bool	if associated, does the enclosing class have a CUSK?
-> FamilyDecl pass
-> Bool

Does this family declaration have a complete, user-supplied kind signature?

data FamilyDecl pass Source #

type Family Declaration

Constructors

FamilyDecl	`AnnKeywordId` : `AnnType`, `AnnData`, `AnnFamily`, `AnnWhere`, `AnnOpenP`, `AnnDcolon`, `AnnCloseP`, `AnnEqual`, `AnnRarrow`, `AnnVbar`
Fields fdInfo :: FamilyInfo pass fdLName :: Located (IdP pass) fdTyVars :: LHsQTyVars pass fdFixity :: LexicalFixity fdResultSig :: LFamilyResultSig pass fdInjectivityAnn :: Maybe (LInjectivityAnn pass)

Instances

DataId id => Data (FamilyDecl id) Source #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamilyDecl id -> c (FamilyDecl id) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FamilyDecl id) # toConstr :: FamilyDecl id -> Constr # dataTypeOf :: FamilyDecl id -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FamilyDecl id)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FamilyDecl id)) # gmapT :: (forall b. Data b => b -> b) -> FamilyDecl id -> FamilyDecl id # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamilyDecl id -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamilyDecl id -> r # gmapQ :: (forall d. Data d => d -> u) -> FamilyDecl id -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FamilyDecl id -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamilyDecl id -> m (FamilyDecl id) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyDecl id -> m (FamilyDecl id) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyDecl id -> m (FamilyDecl id) #
(SourceTextX pass, OutputableBndrId pass) => Outputable (FamilyDecl pass) Source #
Instance details Methods ppr :: FamilyDecl pass -> SDoc Source # pprPrec :: Rational -> FamilyDecl pass -> SDoc Source #

type LFamilyDecl pass = Located (FamilyDecl pass) Source #

Located type Family Declaration

Instance declarations

data InstDecl pass Source #

Instance Declaration

Constructors

ClsInstD
Fields cid_inst :: ClsInstDecl pass
DataFamInstD
Fields dfid_inst :: DataFamInstDecl pass
TyFamInstD
Fields tfid_inst :: TyFamInstDecl pass

Instances

DataId id => Data (InstDecl id) Source #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InstDecl id -> c (InstDecl id) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (InstDecl id) # toConstr :: InstDecl id -> Constr # dataTypeOf :: InstDecl id -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (InstDecl id)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (InstDecl id)) # gmapT :: (forall b. Data b => b -> b) -> InstDecl id -> InstDecl id # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InstDecl id -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InstDecl id -> r # gmapQ :: (forall d. Data d => d -> u) -> InstDecl id -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> InstDecl id -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> InstDecl id -> m (InstDecl id) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InstDecl id -> m (InstDecl id) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InstDecl id -> m (InstDecl id) #
(SourceTextX pass, OutputableBndrId pass) => Outputable (InstDecl pass) Source #
Instance details Methods ppr :: InstDecl pass -> SDoc Source # pprPrec :: Rational -> InstDecl pass -> SDoc Source #

type LInstDecl pass = Located (InstDecl pass) Source #

Located Instance Declaration

data NewOrData Source #

Constructors

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

Instances

Eq NewOrData Source #
Instance details Methods (==) :: NewOrData -> NewOrData -> Bool # (/=) :: NewOrData -> NewOrData -> Bool #
Data NewOrData Source #
Instance details 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 :: (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 Source #
Instance details Methods ppr :: NewOrData -> SDoc Source # pprPrec :: Rational -> NewOrData -> SDoc Source #

data FamilyInfo pass Source #

Constructors

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

Instances

DataId pass => Data (FamilyInfo pass) Source #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamilyInfo pass -> c (FamilyInfo pass) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FamilyInfo pass) # toConstr :: FamilyInfo pass -> Constr # dataTypeOf :: FamilyInfo pass -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FamilyInfo pass)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FamilyInfo pass)) # gmapT :: (forall b. Data b => b -> b) -> FamilyInfo pass -> FamilyInfo pass # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamilyInfo pass -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamilyInfo pass -> r # gmapQ :: (forall d. Data d => d -> u) -> FamilyInfo pass -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FamilyInfo pass -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamilyInfo pass -> m (FamilyInfo pass) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyInfo pass -> m (FamilyInfo pass) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyInfo pass -> m (FamilyInfo pass) #
Outputable (FamilyInfo pass) Source #
Instance details Methods ppr :: FamilyInfo pass -> SDoc Source # pprPrec :: Rational -> FamilyInfo pass -> SDoc Source #

newtype TyFamInstDecl pass Source #

Type Family Instance Declaration

Constructors

TyFamInstDecl	`AnnKeywordId` : `AnnType`, `AnnInstance`,
Fields tfid_eqn :: TyFamInstEqn pass

Instances

DataId pass => Data (TyFamInstDecl pass) Source #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyFamInstDecl pass -> c (TyFamInstDecl pass) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyFamInstDecl pass) # toConstr :: TyFamInstDecl pass -> Constr # dataTypeOf :: TyFamInstDecl pass -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyFamInstDecl pass)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TyFamInstDecl pass)) # gmapT :: (forall b. Data b => b -> b) -> TyFamInstDecl pass -> TyFamInstDecl pass # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyFamInstDecl pass -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyFamInstDecl pass -> r # gmapQ :: (forall d. Data d => d -> u) -> TyFamInstDecl pass -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TyFamInstDecl pass -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyFamInstDecl pass -> m (TyFamInstDecl pass) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyFamInstDecl pass -> m (TyFamInstDecl pass) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyFamInstDecl pass -> m (TyFamInstDecl pass) #
(SourceTextX pass, OutputableBndrId pass) => Outputable (TyFamInstDecl pass) Source #
Instance details Methods ppr :: TyFamInstDecl pass -> SDoc Source # pprPrec :: Rational -> TyFamInstDecl pass -> SDoc Source #

type LTyFamInstDecl pass = Located (TyFamInstDecl pass) Source #

Located Type Family Instance Declaration

instDeclDataFamInsts :: [LInstDecl pass] -> [DataFamInstDecl pass] Source #

newtype DataFamInstDecl pass Source #

Data Family Instance Declaration

Constructors

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

Instances

DataId pass => Data (DataFamInstDecl pass) Source #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataFamInstDecl pass -> c (DataFamInstDecl pass) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DataFamInstDecl pass) # toConstr :: DataFamInstDecl pass -> Constr # dataTypeOf :: DataFamInstDecl pass -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DataFamInstDecl pass)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DataFamInstDecl pass)) # gmapT :: (forall b. Data b => b -> b) -> DataFamInstDecl pass -> DataFamInstDecl pass # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataFamInstDecl pass -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DataFamInstDecl pass -> r # gmapQ :: (forall d. Data d => d -> u) -> DataFamInstDecl pass -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DataFamInstDecl pass -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DataFamInstDecl pass -> m (DataFamInstDecl pass) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DataFamInstDecl pass -> m (DataFamInstDecl pass) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DataFamInstDecl pass -> m (DataFamInstDecl pass) #
(SourceTextX pass, OutputableBndrId pass) => Outputable (DataFamInstDecl pass) Source #
Instance details Methods ppr :: DataFamInstDecl pass -> SDoc Source # pprPrec :: Rational -> DataFamInstDecl pass -> SDoc Source #

type LDataFamInstDecl pass = Located (DataFamInstDecl pass) Source #

Located Data Family Instance Declaration

pprDataFamInstFlavour :: DataFamInstDecl pass -> SDoc Source #

pprFamInstLHS :: (SourceTextX pass, OutputableBndrId pass) => Located (IdP pass) -> HsTyPats pass -> LexicalFixity -> HsContext pass -> Maybe (LHsKind pass) -> SDoc Source #

type FamInstEqn pass rhs Source #

Arguments

= HsImplicitBndrs pass (FamEqn pass (HsTyPats pass) rhs)

Here, the pats are type patterns (with kind and type bndrs). See Note [Family instance declaration binders]

Family Instance Equation

type LFamInstEqn pass rhs = Located (FamInstEqn pass rhs) Source #

Located Family Instance Equation

data FamEqn pass pats rhs Source #

Family Equation

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

Constructors

FamEqn	`AnnKeywordId` : `AnnEqual`
Fields feqn_tycon :: Located (IdP pass) feqn_pats :: pats feqn_fixity :: LexicalFixity Fixity used in the declaration feqn_rhs :: rhs

Instances

(DataId pass, Data pats, Data rhs) => Data (FamEqn pass pats rhs) Source #

Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamEqn pass pats rhs -> c (FamEqn pass pats rhs) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FamEqn pass pats rhs) #

toConstr :: FamEqn pass pats rhs -> Constr #

dataTypeOf :: FamEqn pass pats rhs -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FamEqn pass pats rhs)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FamEqn pass pats rhs)) #

gmapT :: (forall b. Data b => b -> b) -> FamEqn pass pats rhs -> FamEqn pass pats rhs #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamEqn pass pats rhs -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamEqn pass pats rhs -> r #

gmapQ :: (forall d. Data d => d -> u) -> FamEqn pass pats rhs -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FamEqn pass pats rhs -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamEqn pass pats rhs -> m (FamEqn pass pats rhs) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamEqn pass pats rhs -> m (FamEqn pass pats rhs) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamEqn pass pats rhs -> m (FamEqn pass pats rhs) #

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

Type Family Instance Equation

type LTyFamInstEqn pass Source #

Arguments

= Located (TyFamInstEqn pass)

May have AnnKeywordId : AnnSemi when in a list

Located Type Family Instance Equation

type TyFamDefltEqn pass = FamEqn pass (LHsQTyVars pass) (LHsType pass) Source #

Type Family Default Equation

type LTyFamDefltEqn pass = Located (TyFamDefltEqn pass) Source #

Located Type Family Default Equation

type HsTyPats pass = [LHsType pass] Source #

Haskell Type Patterns

type LClsInstDecl pass = Located (ClsInstDecl pass) Source #

Located Class Instance Declaration

data ClsInstDecl pass Source #

Class Instance Declaration

Constructors

ClsInstDecl	`AnnKeywordId` : `AnnInstance`, `AnnWhere`, `AnnOpen`,`AnnClose`,
Fields 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 (Located OverlapMode) `AnnKeywordId` : `AnnOpen`, `AnnClose`,

Instances

DataId id => Data (ClsInstDecl id) Source #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ClsInstDecl id -> c (ClsInstDecl id) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ClsInstDecl id) # toConstr :: ClsInstDecl id -> Constr # dataTypeOf :: ClsInstDecl id -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ClsInstDecl id)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ClsInstDecl id)) # gmapT :: (forall b. Data b => b -> b) -> ClsInstDecl id -> ClsInstDecl id # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ClsInstDecl id -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ClsInstDecl id -> r # gmapQ :: (forall d. Data d => d -> u) -> ClsInstDecl id -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ClsInstDecl id -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ClsInstDecl id -> m (ClsInstDecl id) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ClsInstDecl id -> m (ClsInstDecl id) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ClsInstDecl id -> m (ClsInstDecl id) #
(SourceTextX pass, OutputableBndrId pass) => Outputable (ClsInstDecl pass) Source #
Instance details Methods ppr :: ClsInstDecl pass -> SDoc Source # pprPrec :: Rational -> ClsInstDecl pass -> SDoc Source #

Standalone deriving declarations

data DerivDecl pass Source #

Deriving Declaration

Constructors

DerivDecl
Fields deriv_type :: LHsSigType pass deriv_strategy :: Maybe (Located DerivStrategy) deriv_overlap_mode :: Maybe (Located OverlapMode) `AnnKeywordId` : `AnnDeriving`, `AnnInstance`, `AnnStock`, `AnnAnyClass`, `AnnNewtype`, `AnnOpen`,`AnnClose`

Instances

DataId pass => Data (DerivDecl pass) Source #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivDecl pass -> c (DerivDecl pass) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DerivDecl pass) # toConstr :: DerivDecl pass -> Constr # dataTypeOf :: DerivDecl pass -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DerivDecl pass)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DerivDecl pass)) # gmapT :: (forall b. Data b => b -> b) -> DerivDecl pass -> DerivDecl pass # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivDecl pass -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivDecl pass -> r # gmapQ :: (forall d. Data d => d -> u) -> DerivDecl pass -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivDecl pass -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivDecl pass -> m (DerivDecl pass) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivDecl pass -> m (DerivDecl pass) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivDecl pass -> m (DerivDecl pass) #
(SourceTextX pass, OutputableBndrId pass) => Outputable (DerivDecl pass) Source #
Instance details Methods ppr :: DerivDecl pass -> SDoc Source # pprPrec :: Rational -> DerivDecl pass -> SDoc Source #

type LDerivDecl pass = Located (DerivDecl pass) Source #

Located Deriving Declaration

`RULE` declarations

type LRuleDecls pass = Located (RuleDecls pass) Source #

Located Rule Declarations

data RuleDecls pass Source #

Rule Declarations

Constructors

HsRules
Fields rds_src :: SourceText rds_rules :: [LRuleDecl pass]

Instances

DataId pass => Data (RuleDecls pass) Source #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleDecls pass -> c (RuleDecls pass) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RuleDecls pass) # toConstr :: RuleDecls pass -> Constr # dataTypeOf :: RuleDecls pass -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RuleDecls pass)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RuleDecls pass)) # gmapT :: (forall b. Data b => b -> b) -> RuleDecls pass -> RuleDecls pass # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecls pass -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecls pass -> r # gmapQ :: (forall d. Data d => d -> u) -> RuleDecls pass -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleDecls pass -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleDecls pass -> m (RuleDecls pass) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecls pass -> m (RuleDecls pass) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecls pass -> m (RuleDecls pass) #
(SourceTextX pass, OutputableBndrId pass) => Outputable (RuleDecls pass) Source #
Instance details Methods ppr :: RuleDecls pass -> SDoc Source # pprPrec :: Rational -> RuleDecls pass -> SDoc Source #

data RuleDecl pass Source #

Rule Declaration

Constructors

HsRule (Located (SourceText, RuleName)) Activation [LRuleBndr pass] (Located (HsExpr pass)) (PostRn pass NameSet) (Located (HsExpr pass)) (PostRn pass NameSet)

AnnKeywordId : AnnOpen,AnnTilde, AnnVal, AnnClose, AnnForall,AnnDot, AnnEqual,

Instances

DataId pass => Data (RuleDecl pass) Source #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleDecl pass -> c (RuleDecl pass) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RuleDecl pass) # toConstr :: RuleDecl pass -> Constr # dataTypeOf :: RuleDecl pass -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RuleDecl pass)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RuleDecl pass)) # gmapT :: (forall b. Data b => b -> b) -> RuleDecl pass -> RuleDecl pass # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecl pass -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecl pass -> r # gmapQ :: (forall d. Data d => d -> u) -> RuleDecl pass -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleDecl pass -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleDecl pass -> m (RuleDecl pass) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecl pass -> m (RuleDecl pass) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecl pass -> m (RuleDecl pass) #
(SourceTextX pass, OutputableBndrId pass) => Outputable (RuleDecl pass) Source #
Instance details Methods ppr :: RuleDecl pass -> SDoc Source # pprPrec :: Rational -> RuleDecl pass -> SDoc Source #

type LRuleDecl pass = Located (RuleDecl pass) Source #

Located Rule Declaration

data RuleBndr pass Source #

Rule Binder

Constructors

RuleBndr (Located (IdP pass))
RuleBndrSig (Located (IdP pass)) (LHsSigWcType pass)	`AnnKeywordId` : `AnnOpen`, `AnnDcolon`,`AnnClose`

Instances

DataId pass => Data (RuleBndr pass) Source #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleBndr pass -> c (RuleBndr pass) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RuleBndr pass) # toConstr :: RuleBndr pass -> Constr # dataTypeOf :: RuleBndr pass -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RuleBndr pass)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RuleBndr pass)) # gmapT :: (forall b. Data b => b -> b) -> RuleBndr pass -> RuleBndr pass # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr pass -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr pass -> r # gmapQ :: (forall d. Data d => d -> u) -> RuleBndr pass -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleBndr pass -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleBndr pass -> m (RuleBndr pass) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr pass -> m (RuleBndr pass) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr pass -> m (RuleBndr pass) #
(SourceTextX pass, OutputableBndrId pass) => Outputable (RuleBndr pass) Source #
Instance details Methods ppr :: RuleBndr pass -> SDoc Source # pprPrec :: Rational -> RuleBndr pass -> SDoc Source #

type LRuleBndr pass = Located (RuleBndr pass) Source #

Located Rule Binder

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

flattenRuleDecls :: [LRuleDecls pass] -> [LRuleDecl pass] Source #

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

`VECTORISE` declarations

data VectDecl pass Source #

Vectorise Declaration

Constructors

HsVect SourceText (Located (IdP pass)) (LHsExpr pass)	`AnnKeywordId` : `AnnOpen`, `AnnEqual`,`AnnClose`
HsNoVect SourceText (Located (IdP pass))	`AnnKeywordId` : `AnnOpen`, `AnnClose`
HsVectTypeIn SourceText Bool (Located (IdP pass)) (Maybe (Located (IdP pass)))	`AnnKeywordId` : `AnnOpen`, `AnnType`,`AnnClose`, `AnnEqual`
HsVectTypeOut Bool TyCon (Maybe TyCon)
HsVectClassIn SourceText (Located (IdP pass))	`AnnKeywordId` : `AnnOpen`, `AnnClass`,`AnnClose`,
HsVectClassOut Class
HsVectInstIn (LHsSigType pass)
HsVectInstOut ClsInst

Instances

DataId pass => Data (VectDecl pass) Source #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VectDecl pass -> c (VectDecl pass) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (VectDecl pass) # toConstr :: VectDecl pass -> Constr # dataTypeOf :: VectDecl pass -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (VectDecl pass)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (VectDecl pass)) # gmapT :: (forall b. Data b => b -> b) -> VectDecl pass -> VectDecl pass # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VectDecl pass -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VectDecl pass -> r # gmapQ :: (forall d. Data d => d -> u) -> VectDecl pass -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VectDecl pass -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VectDecl pass -> m (VectDecl pass) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VectDecl pass -> m (VectDecl pass) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VectDecl pass -> m (VectDecl pass) #
(SourceTextX pass, OutputableBndrId pass) => Outputable (VectDecl pass) Source #
Instance details Methods ppr :: VectDecl pass -> SDoc Source # pprPrec :: Rational -> VectDecl pass -> SDoc Source #

type LVectDecl pass = Located (VectDecl pass) Source #

Located Vectorise Declaration

lvectDeclName :: NamedThing (IdP pass) => LVectDecl pass -> Name Source #

lvectInstDecl :: LVectDecl pass -> Bool Source #

`default` declarations

data DefaultDecl pass Source #

Default Declaration

Constructors

DefaultDecl [LHsType pass]

AnnKeywordIds : AnnDefault, AnnOpen,AnnClose

Instances

DataId pass => Data (DefaultDecl pass) Source #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DefaultDecl pass -> c (DefaultDecl pass) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DefaultDecl pass) # toConstr :: DefaultDecl pass -> Constr # dataTypeOf :: DefaultDecl pass -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DefaultDecl pass)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DefaultDecl pass)) # gmapT :: (forall b. Data b => b -> b) -> DefaultDecl pass -> DefaultDecl pass # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DefaultDecl pass -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DefaultDecl pass -> r # gmapQ :: (forall d. Data d => d -> u) -> DefaultDecl pass -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DefaultDecl pass -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DefaultDecl pass -> m (DefaultDecl pass) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DefaultDecl pass -> m (DefaultDecl pass) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DefaultDecl pass -> m (DefaultDecl pass) #
(SourceTextX pass, OutputableBndrId pass) => Outputable (DefaultDecl pass) Source #
Instance details Methods ppr :: DefaultDecl pass -> SDoc Source # pprPrec :: Rational -> DefaultDecl pass -> SDoc Source #

type LDefaultDecl pass = Located (DefaultDecl pass) Source #

Located Default Declaration

Template haskell declaration splice

data SpliceExplicitFlag Source #

Constructors

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

Instances

Data SpliceExplicitFlag Source #

Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpliceExplicitFlag -> c SpliceExplicitFlag #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SpliceExplicitFlag #

toConstr :: SpliceExplicitFlag -> Constr #

dataTypeOf :: SpliceExplicitFlag -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SpliceExplicitFlag) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SpliceExplicitFlag) #

gmapT :: (forall b. Data b => b -> b) -> SpliceExplicitFlag -> SpliceExplicitFlag #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpliceExplicitFlag -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpliceExplicitFlag -> r #

gmapQ :: (forall d. Data d => d -> u) -> SpliceExplicitFlag -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SpliceExplicitFlag -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpliceExplicitFlag -> m SpliceExplicitFlag #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceExplicitFlag -> m SpliceExplicitFlag #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceExplicitFlag -> m SpliceExplicitFlag #

data SpliceDecl id Source #

Splice Declaration

Constructors

SpliceDecl (Located (HsSplice id)) SpliceExplicitFlag

Instances

DataId id => Data (SpliceDecl id) Source #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpliceDecl id -> c (SpliceDecl id) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SpliceDecl id) # toConstr :: SpliceDecl id -> Constr # dataTypeOf :: SpliceDecl id -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (SpliceDecl id)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SpliceDecl id)) # gmapT :: (forall b. Data b => b -> b) -> SpliceDecl id -> SpliceDecl id # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpliceDecl id -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpliceDecl id -> r # gmapQ :: (forall d. Data d => d -> u) -> SpliceDecl id -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SpliceDecl id -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpliceDecl id -> m (SpliceDecl id) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceDecl id -> m (SpliceDecl id) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceDecl id -> m (SpliceDecl id) #
(SourceTextX pass, OutputableBndrId pass) => Outputable (SpliceDecl pass) Source #
Instance details Methods ppr :: SpliceDecl pass -> SDoc Source # pprPrec :: Rational -> SpliceDecl pass -> SDoc Source #

type LSpliceDecl pass = Located (SpliceDecl pass) Source #

Located Splice Declaration

Foreign function interface declarations

data ForeignDecl pass Source #

Foreign Declaration

Constructors

ForeignImport
Fields fd_name :: Located (IdP pass) fd_sig_ty :: LHsSigType pass fd_co :: PostTc pass Coercion fd_fi :: ForeignImport
ForeignExport	`AnnKeywordId` : `AnnForeign`, `AnnImport`,`AnnExport`, `AnnDcolon`
Fields fd_name :: Located (IdP pass) fd_sig_ty :: LHsSigType pass fd_co :: PostTc pass Coercion fd_fe :: ForeignExport

Instances

DataId pass => Data (ForeignDecl pass) Source #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForeignDecl pass -> c (ForeignDecl pass) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ForeignDecl pass) # toConstr :: ForeignDecl pass -> Constr # dataTypeOf :: ForeignDecl pass -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ForeignDecl pass)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ForeignDecl pass)) # gmapT :: (forall b. Data b => b -> b) -> ForeignDecl pass -> ForeignDecl pass # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForeignDecl pass -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForeignDecl pass -> r # gmapQ :: (forall d. Data d => d -> u) -> ForeignDecl pass -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ForeignDecl pass -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForeignDecl pass -> m (ForeignDecl pass) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignDecl pass -> m (ForeignDecl pass) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignDecl pass -> m (ForeignDecl pass) #
(SourceTextX pass, OutputableBndrId pass) => Outputable (ForeignDecl pass) Source #
Instance details Methods ppr :: ForeignDecl pass -> SDoc Source # pprPrec :: Rational -> ForeignDecl pass -> SDoc Source #

type LForeignDecl pass = Located (ForeignDecl pass) Source #

Located Foreign Declaration

data ForeignImport Source #

Constructors

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

Instances

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

data ForeignExport Source #

Constructors

CExport (Located CExportSpec) (Located SourceText)

Instances

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

noForeignImportCoercionYet :: PlaceHolder Source #

noForeignExportCoercionYet :: PlaceHolder Source #

data CImportSpec Source #

Constructors

CLabel CLabelString
CFunction CCallTarget
CWrapper

Instances

Data CImportSpec Source #

Instance details

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 :: (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 Source #

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

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

data T = Int MkT Int
       | MkT2

data T a where
     Int MkT Int :: T Int

AnnKeywordIds : AnnOpen, AnnDotdot,AnnCLose, AnnEqual,AnnVbar, AnnDarrow,AnnDarrow, AnnForall,AnnDot

data Constructor Declaration

Constructors

ConDeclGADT
Fields con_names :: [Located (IdP pass)] con_type :: LHsSigType pass The type after the ‘::’ con_doc :: Maybe LHsDocString A possible Haddock comment.
ConDeclH98
Fields con_name :: Located (IdP pass) con_qvars :: Maybe (LHsQTyVars pass) con_cxt :: Maybe (LHsContext pass) User-written context (if any) con_details :: HsConDeclDetails pass Arguments con_doc :: Maybe LHsDocString A possible Haddock comment.

Instances

DataId pass => Data (ConDecl pass) Source #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConDecl pass -> c (ConDecl pass) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ConDecl pass) # toConstr :: ConDecl pass -> Constr # dataTypeOf :: ConDecl pass -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ConDecl pass)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ConDecl pass)) # gmapT :: (forall b. Data b => b -> b) -> ConDecl pass -> ConDecl pass # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConDecl pass -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConDecl pass -> r # gmapQ :: (forall d. Data d => d -> u) -> ConDecl pass -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ConDecl pass -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConDecl pass -> m (ConDecl pass) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDecl pass -> m (ConDecl pass) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDecl pass -> m (ConDecl pass) #
(SourceTextX pass, OutputableBndrId pass) => Outputable (ConDecl pass) Source #
Instance details Methods ppr :: ConDecl pass -> SDoc Source # pprPrec :: Rational -> ConDecl pass -> SDoc Source #

type LConDecl pass Source #

Arguments

= Located (ConDecl pass)

May have AnnKeywordId : AnnSemi when in a GADT constructor list

Located data Constructor Declaration

type HsConDeclDetails pass = HsConDetails (LBangType pass) (Located [LConDeclField pass]) Source #

Haskell data Constructor Declaration Details

hsConDeclArgTys :: HsConDeclDetails pass -> [LBangType pass] Source #

getConNames :: ConDecl pass -> [Located (IdP pass)] Source #

getConDetails :: ConDecl pass -> HsConDeclDetails pass Source #

gadtDeclDetails :: LHsSigType pass -> (HsConDeclDetails pass, LHsType pass, LHsContext pass, [LHsTyVarBndr pass]) Source #

Document comments

data DocDecl Source #

Documentation comment Declaration

Constructors

DocCommentNext HsDocString
DocCommentPrev HsDocString
DocCommentNamed String HsDocString
DocGroup Int HsDocString

Instances

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

type LDocDecl = Located DocDecl Source #

Located Documentation comment Declaration

docDeclDoc :: DocDecl -> HsDocString Source #

Deprecations

data WarnDecl pass Source #

Warning pragma Declaration

Constructors

Warning [Located (IdP pass)] WarningTxt

Instances

DataId pass => Data (WarnDecl pass) Source #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WarnDecl pass -> c (WarnDecl pass) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WarnDecl pass) # toConstr :: WarnDecl pass -> Constr # dataTypeOf :: WarnDecl pass -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WarnDecl pass)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WarnDecl pass)) # gmapT :: (forall b. Data b => b -> b) -> WarnDecl pass -> WarnDecl pass # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecl pass -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecl pass -> r # gmapQ :: (forall d. Data d => d -> u) -> WarnDecl pass -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> WarnDecl pass -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WarnDecl pass -> m (WarnDecl pass) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecl pass -> m (WarnDecl pass) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecl pass -> m (WarnDecl pass) #
OutputableBndr (IdP pass) => Outputable (WarnDecl pass) Source #
Instance details Methods ppr :: WarnDecl pass -> SDoc Source # pprPrec :: Rational -> WarnDecl pass -> SDoc Source #

type LWarnDecl pass = Located (WarnDecl pass) Source #

Located Warning pragma Declaration

data WarnDecls pass Source #

Warning pragma Declarations

Constructors

Warnings
Fields wd_src :: SourceText wd_warnings :: [LWarnDecl pass]

Instances

DataId pass => Data (WarnDecls pass) Source #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WarnDecls pass -> c (WarnDecls pass) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WarnDecls pass) # toConstr :: WarnDecls pass -> Constr # dataTypeOf :: WarnDecls pass -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WarnDecls pass)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WarnDecls pass)) # gmapT :: (forall b. Data b => b -> b) -> WarnDecls pass -> WarnDecls pass # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecls pass -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecls pass -> r # gmapQ :: (forall d. Data d => d -> u) -> WarnDecls pass -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> WarnDecls pass -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WarnDecls pass -> m (WarnDecls pass) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecls pass -> m (WarnDecls pass) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecls pass -> m (WarnDecls pass) #
OutputableBndr (IdP pass) => Outputable (WarnDecls pass) Source #
Instance details Methods ppr :: WarnDecls pass -> SDoc Source # pprPrec :: Rational -> WarnDecls pass -> SDoc Source #

type LWarnDecls pass = Located (WarnDecls pass) Source #

Located Warning Declarations

Annotations

data AnnDecl pass Source #

Annotation Declaration

Constructors

HsAnnotation SourceText (AnnProvenance (IdP pass)) (Located (HsExpr pass))

AnnKeywordId : AnnOpen, AnnType AnnModule AnnClose

Instances

DataId pass => Data (AnnDecl pass) Source #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnDecl pass -> c (AnnDecl pass) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnDecl pass) # toConstr :: AnnDecl pass -> Constr # dataTypeOf :: AnnDecl pass -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AnnDecl pass)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AnnDecl pass)) # gmapT :: (forall b. Data b => b -> b) -> AnnDecl pass -> AnnDecl pass # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnDecl pass -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnDecl pass -> r # gmapQ :: (forall d. Data d => d -> u) -> AnnDecl pass -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnDecl pass -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnDecl pass -> m (AnnDecl pass) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnDecl pass -> m (AnnDecl pass) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnDecl pass -> m (AnnDecl pass) #
(SourceTextX pass, OutputableBndrId pass) => Outputable (AnnDecl pass) Source #
Instance details Methods ppr :: AnnDecl pass -> SDoc Source # pprPrec :: Rational -> AnnDecl pass -> SDoc Source #

type LAnnDecl pass = Located (AnnDecl pass) Source #

Located Annotation Declaration

data AnnProvenance name Source #

Annotation Provenance

Constructors

ValueAnnProvenance (Located name)
TypeAnnProvenance (Located name)
ModuleAnnProvenance

Instances

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

annProvenanceName_maybe :: AnnProvenance name -> Maybe name Source #

Role annotations

data RoleAnnotDecl pass Source #

Role Annotation Declaration

Constructors

RoleAnnotDecl (Located (IdP pass)) [Located (Maybe Role)]

AnnKeywordId : AnnType, AnnRole

Instances

DataId pass => Data (RoleAnnotDecl pass) Source #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RoleAnnotDecl pass -> c (RoleAnnotDecl pass) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RoleAnnotDecl pass) # toConstr :: RoleAnnotDecl pass -> Constr # dataTypeOf :: RoleAnnotDecl pass -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RoleAnnotDecl pass)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RoleAnnotDecl pass)) # gmapT :: (forall b. Data b => b -> b) -> RoleAnnotDecl pass -> RoleAnnotDecl pass # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RoleAnnotDecl pass -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RoleAnnotDecl pass -> r # gmapQ :: (forall d. Data d => d -> u) -> RoleAnnotDecl pass -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RoleAnnotDecl pass -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RoleAnnotDecl pass -> m (RoleAnnotDecl pass) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RoleAnnotDecl pass -> m (RoleAnnotDecl pass) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RoleAnnotDecl pass -> m (RoleAnnotDecl pass) #
OutputableBndr (IdP pass) => Outputable (RoleAnnotDecl pass) Source #
Instance details Methods ppr :: RoleAnnotDecl pass -> SDoc Source # pprPrec :: Rational -> RoleAnnotDecl pass -> SDoc Source #

type LRoleAnnotDecl pass = Located (RoleAnnotDecl pass) Source #

Located Role Annotation Declaration

roleAnnotDeclName :: RoleAnnotDecl pass -> IdP pass Source #

Injective type families

data FamilyResultSig pass Source #

type Family Result Signature

Constructors

NoSig	`AnnKeywordId` :
KindSig (LHsKind pass)	`AnnKeywordId` : `AnnOpenP`,`AnnDcolon`, `AnnCloseP`
TyVarSig (LHsTyVarBndr pass)	`AnnKeywordId` : `AnnOpenP`,`AnnDcolon`, `AnnCloseP`, `AnnEqual`

Instances

DataId pass => Data (FamilyResultSig pass) Source #

Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamilyResultSig pass -> c (FamilyResultSig pass) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FamilyResultSig pass) #

toConstr :: FamilyResultSig pass -> Constr #

dataTypeOf :: FamilyResultSig pass -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FamilyResultSig pass)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FamilyResultSig pass)) #

gmapT :: (forall b. Data b => b -> b) -> FamilyResultSig pass -> FamilyResultSig pass #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamilyResultSig pass -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamilyResultSig pass -> r #

gmapQ :: (forall d. Data d => d -> u) -> FamilyResultSig pass -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FamilyResultSig pass -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamilyResultSig pass -> m (FamilyResultSig pass) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyResultSig pass -> m (FamilyResultSig pass) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyResultSig pass -> m (FamilyResultSig pass) #

type LFamilyResultSig pass = Located (FamilyResultSig pass) Source #

Located type Family Result Signature

data InjectivityAnn pass Source #

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

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

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

Constructors

InjectivityAnn (Located (IdP pass)) [Located (IdP pass)]

AnnKeywordId : AnnRarrow, AnnVbar

Instances

DataId pass => Data (InjectivityAnn pass) Source #

Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InjectivityAnn pass -> c (InjectivityAnn pass) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (InjectivityAnn pass) #

toConstr :: InjectivityAnn pass -> Constr #

dataTypeOf :: InjectivityAnn pass -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (InjectivityAnn pass)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (InjectivityAnn pass)) #

gmapT :: (forall b. Data b => b -> b) -> InjectivityAnn pass -> InjectivityAnn pass #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityAnn pass -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityAnn pass -> r #

gmapQ :: (forall d. Data d => d -> u) -> InjectivityAnn pass -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> InjectivityAnn pass -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InjectivityAnn pass -> m (InjectivityAnn pass) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityAnn pass -> m (InjectivityAnn pass) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityAnn pass -> m (InjectivityAnn pass) #

type LInjectivityAnn pass = Located (InjectivityAnn pass) Source #

Located Injectivity Annotation

resultVariableName :: FamilyResultSig a -> Maybe (IdP a) Source #

Maybe return name of the result type variable

Grouping

data HsGroup id Source #

Haskell Group

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

Constructors

HsGroup
Fields hs_valds :: HsValBinds id hs_splcds :: [LSpliceDecl id] hs_tyclds :: [TyClGroup id] hs_derivds :: [LDerivDecl id] hs_fixds :: [LFixitySig id] hs_defds :: [LDefaultDecl id] hs_fords :: [LForeignDecl id] hs_warnds :: [LWarnDecls id] hs_annds :: [LAnnDecl id] hs_ruleds :: [LRuleDecls id] hs_vects :: [LVectDecl id] hs_docs :: [LDocDecl]

Instances

DataId id => Data (HsGroup id) Source #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsGroup id -> c (HsGroup id) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsGroup id) # toConstr :: HsGroup id -> Constr # dataTypeOf :: HsGroup id -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsGroup id)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsGroup id)) # gmapT :: (forall b. Data b => b -> b) -> HsGroup id -> HsGroup id # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsGroup id -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsGroup id -> r # gmapQ :: (forall d. Data d => d -> u) -> HsGroup id -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsGroup id -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsGroup id -> m (HsGroup id) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGroup id -> m (HsGroup id) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGroup id -> m (HsGroup id) #
(SourceTextX pass, OutputableBndrId pass) => Outputable (HsGroup pass) Source #
Instance details Methods ppr :: HsGroup pass -> SDoc Source # pprPrec :: Rational -> HsGroup pass -> SDoc Source #