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

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 #
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) #
OutputableBndrId name => Outputable (HsDecl name) Source #
Methods ppr :: HsDecl name -> SDoc Source # pprPrec :: Rational -> HsDecl name -> SDoc Source #

type LHsDecl id Source #

Arguments

= Located (HsDecl id)

When in a list this may have

AnnKeywordId : AnnSemi

data HsDataDefn name 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 name
Context
dd_cType :: Maybe (Located CType)
dd_kindSig :: Maybe (LHsKind name)
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 name]
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 name
Optional 'deriving' claues

Instances

DataId id => Data (HsDataDefn id) Source #
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) #
OutputableBndrId name => Outputable (HsDataDefn name) Source #
Methods ppr :: HsDataDefn name -> SDoc Source # pprPrec :: Rational -> HsDataDefn name -> SDoc Source #

type HsDeriving name Source #

Arguments

= Located [LHsDerivingClause name]

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 name 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 name]
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 #
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) #
OutputableBndrId name => Outputable (HsDerivingClause name) Source #
Methods ppr :: HsDerivingClause name -> SDoc Source # pprPrec :: Rational -> HsDerivingClause name -> SDoc Source #

type LHsDerivingClause name = Located (HsDerivingClause name) Source #

Class or type declarations

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

Instances

DataId id => Data (TyClDecl id) Source #
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) #
OutputableBndrId name => Outputable (TyClDecl name) Source #
Methods ppr :: TyClDecl name -> SDoc Source # pprPrec :: Rational -> TyClDecl name -> SDoc Source #

type LTyClDecl name = Located (TyClDecl name) Source #

Located Declaration of a Type or Class

data TyClGroup name Source #

Type or Class Group

Constructors

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

Instances

DataId id => Data (TyClGroup id) Source #
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) #
OutputableBndrId name => Outputable (TyClGroup name) Source #
Methods ppr :: TyClGroup name -> SDoc Source # pprPrec :: Rational -> TyClGroup name -> SDoc Source #

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

emptyTyClGroup :: TyClGroup name Source #

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

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

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

isClassDecl :: TyClDecl name -> Bool Source #

type class

isDataDecl :: TyClDecl name -> Bool Source #

True = argument is a data/newtype declaration.

isSynDecl :: TyClDecl name -> Bool Source #

type or type instance declaration

tcdName :: TyClDecl name -> name Source #

isFamilyDecl :: TyClDecl name -> Bool Source #

type/data family declaration

isTypeFamilyDecl :: TyClDecl name -> Bool Source #

type family declaration

isDataFamilyDecl :: TyClDecl name -> Bool Source #

data family declaration

isOpenTypeFamilyInfo :: FamilyInfo name -> Bool Source #

open type family info

isClosedTypeFamilyInfo :: FamilyInfo name -> Bool Source #

closed type family info

tyFamInstDeclName :: TyFamInstDecl name -> name Source #

tyFamInstDeclLName :: TyFamInstDecl name -> Located name Source #

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

pprTyClDeclFlavour :: TyClDecl a -> SDoc Source #

tyClDeclLName :: TyClDecl name -> Located name Source #

tyClDeclTyVars :: TyClDecl name -> LHsQTyVars name Source #

hsDeclHasCusk :: TyClDecl Name -> 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 name
-> Bool

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

data FamilyDecl name Source #

type Family Declaration

Constructors

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

Instances

DataId id => Data (FamilyDecl id) Source #
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) #
OutputableBndrId name => Outputable (FamilyDecl name) Source #
Methods ppr :: FamilyDecl name -> SDoc Source # pprPrec :: Rational -> FamilyDecl name -> SDoc Source #

type LFamilyDecl name = Located (FamilyDecl name) Source #

Located type Family Declaration

Instance declarations

data InstDecl name Source #

Instance Declaration

Constructors

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

Instances

DataId id => Data (InstDecl id) Source #
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) #
OutputableBndrId name => Outputable (InstDecl name) Source #
Methods ppr :: InstDecl name -> SDoc Source # pprPrec :: Rational -> InstDecl name -> SDoc Source #

type LInstDecl name = Located (InstDecl name) Source #

Located Instance Declaration

data NewOrData Source #

Constructors

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

Instances

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

data FamilyInfo name Source #

Constructors

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

Instances

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

data TyFamInstDecl name Source #

Type Family Instance Declaration

Constructors

TyFamInstDecl	`AnnKeywordId` : `AnnType`, `AnnInstance`,
Fields tfid_eqn :: LTyFamInstEqn name tfid_fvs :: PostRn name NameSet

Instances

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

type LTyFamInstDecl name = Located (TyFamInstDecl name) Source #

Located Type Family Instance Declaration

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

data DataFamInstDecl name Source #

Data Family Instance Declaration

Constructors

DataFamInstDecl	`AnnKeywordId` : `AnnData`, `AnnNewType`,`AnnInstance`, `AnnDcolon` `AnnWhere`,`AnnOpen`, `AnnClose`
Fields dfid_tycon :: Located name dfid_pats :: HsTyPats name dfid_fixity :: LexicalFixity Fixity used in the declaration dfid_defn :: HsDataDefn name dfid_fvs :: PostRn name NameSet

Instances

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

type LDataFamInstDecl name = Located (DataFamInstDecl name) Source #

Located Data Family Instance Declaration

pprDataFamInstFlavour :: DataFamInstDecl name -> SDoc Source #

data TyFamEqn name pats Source #

Type Family Equation

One equation in a type family instance declaration See Note [Type family instance declarations in HsSyn]

Constructors

TyFamEqn	`AnnKeywordId` : `AnnEqual`
Fields tfe_tycon :: Located name tfe_pats :: pats tfe_fixity :: LexicalFixity Fixity used in the declaration tfe_rhs :: LHsType name

Instances

(DataId name, Data pats) => Data (TyFamEqn name pats) Source #

type TyFamInstEqn name = TyFamEqn name (HsTyPats name) Source #

Type Family Instance Equation

type LTyFamInstEqn name Source #

Arguments

= Located (TyFamInstEqn name)

May have AnnKeywordId : AnnSemi when in a list

Located Type Family Instance Equation

type TyFamDefltEqn name = TyFamEqn name (LHsQTyVars name) Source #

Type Family Default Equation

type LTyFamDefltEqn name = Located (TyFamDefltEqn name) Source #

Located Type Family Default Equation

type HsTyPats name Source #

Arguments

= HsImplicitBndrs name [LHsType name]

Type patterns (with kind and type bndrs) See Note [Family instance declaration binders]

Haskell Type Patterns

type LClsInstDecl name = Located (ClsInstDecl name) Source #

Located Class Instance Declaration

data ClsInstDecl name Source #

Class Instance Declaration

Constructors

ClsInstDecl	`AnnKeywordId` : `AnnInstance`, `AnnWhere`, `AnnOpen`,`AnnClose`,
Fields cid_poly_ty :: LHsSigType name cid_binds :: LHsBinds name cid_sigs :: [LSig name] cid_tyfam_insts :: [LTyFamInstDecl name] cid_datafam_insts :: [LDataFamInstDecl name] cid_overlap_mode :: Maybe (Located OverlapMode) `AnnKeywordId` : `AnnOpen`, `AnnClose`,

Instances

DataId id => Data (ClsInstDecl id) Source #
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) #
OutputableBndrId name => Outputable (ClsInstDecl name) Source #
Methods ppr :: ClsInstDecl name -> SDoc Source # pprPrec :: Rational -> ClsInstDecl name -> SDoc Source #

Standalone deriving declarations

data DerivDecl name Source #

Deriving Declaration

Constructors

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

Instances

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

type LDerivDecl name = Located (DerivDecl name) Source #

Located Deriving Declaration

`RULE` declarations

type LRuleDecls name = Located (RuleDecls name) Source #

Located Rule Declarations

data RuleDecls name Source #

Rule Declarations

Constructors

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

Instances

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

data RuleDecl name Source #

Rule Declaration

Constructors

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

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

Instances

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

type LRuleDecl name = Located (RuleDecl name) Source #

Located Rule Declaration

data RuleBndr name Source #

Rule Binder

Constructors

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

Instances

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

type LRuleBndr name = Located (RuleBndr name) Source #

Located Rule Binder

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

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

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

`VECTORISE` declarations

data VectDecl name Source #

Vectorise Declaration

Constructors

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

Instances

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

type LVectDecl name = Located (VectDecl name) Source #

Located Vectorise Declaration

lvectDeclName :: NamedThing name => LVectDecl name -> Name Source #

lvectInstDecl :: LVectDecl name -> Bool Source #

`default` declarations

data DefaultDecl name Source #

Default Declaration

Constructors

DefaultDecl [LHsType name]

AnnKeywordIds : AnnDefault, AnnOpen,AnnClose

Instances

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

type LDefaultDecl name = Located (DefaultDecl name) 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 #

data SpliceDecl id Source #

Splice Declaration

Constructors

SpliceDecl (Located (HsSplice id)) SpliceExplicitFlag

Instances

DataId id => Data (SpliceDecl id) Source #
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) #
OutputableBndrId name => Outputable (SpliceDecl name) Source #
Methods ppr :: SpliceDecl name -> SDoc Source # pprPrec :: Rational -> SpliceDecl name -> SDoc Source #

type LSpliceDecl name = Located (SpliceDecl name) Source #

Located Splice Declaration

Foreign function interface declarations

data ForeignDecl name Source #

Foreign Declaration

Constructors

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

Instances

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

type LForeignDecl name = Located (ForeignDecl name) Source #

Located Foreign Declaration

data ForeignImport Source #

Constructors

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

Instances

Data ForeignImport Source #
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 #
Methods ppr :: ForeignImport -> SDoc Source # pprPrec :: Rational -> ForeignImport -> SDoc Source #

data ForeignExport Source #

Constructors

CExport (Located CExportSpec) (Located SourceText)

Instances

Data ForeignExport Source #
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 #
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 #

Data-constructor declarations

data ConDecl name 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 name] con_type :: LHsSigType name The type after the ‘::’ con_doc :: Maybe LHsDocString A possible Haddock comment.
ConDeclH98
Fields con_name :: Located name con_qvars :: Maybe (LHsQTyVars name) con_cxt :: Maybe (LHsContext name) User-written context (if any) con_details :: HsConDeclDetails name Arguments con_doc :: Maybe LHsDocString A possible Haddock comment.

Instances

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

type LConDecl name Source #

Arguments

= Located (ConDecl name)

May have AnnKeywordId : AnnSemi when in a GADT constructor list

Located data Constructor Declaration

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

Haskell data Constructor Declaration Details

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

getConNames :: ConDecl name -> [Located name] Source #

getConDetails :: ConDecl name -> HsConDeclDetails name Source #

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

Document comments

data DocDecl Source #

Documentation comment Declaration

Constructors

DocCommentNext HsDocString
DocCommentPrev HsDocString
DocCommentNamed String HsDocString
DocGroup Int HsDocString

Instances

Data DocDecl Source #
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 #
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 name Source #

Warning pragma Declaration

Constructors

Warning [Located name] WarningTxt

Instances

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

type LWarnDecl name = Located (WarnDecl name) Source #

Located Warning pragma Declaration

data WarnDecls name Source #

Warning pragma Declarations

Constructors

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

Instances

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

type LWarnDecls name = Located (WarnDecls name) Source #

Located Warning Declarations

Annotations

data AnnDecl name Source #

Annotation Declaration

Constructors

HsAnnotation SourceText (AnnProvenance name) (Located (HsExpr name))

AnnKeywordId : AnnOpen, AnnType AnnModule AnnClose

Instances

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

type LAnnDecl name = Located (AnnDecl name) Source #

Located Annotation Declaration

data AnnProvenance name Source #

Annotation Provenance

Constructors

ValueAnnProvenance (Located name)
TypeAnnProvenance (Located name)
ModuleAnnProvenance

Instances

Functor AnnProvenance Source #
Methods fmap :: (a -> b) -> AnnProvenance a -> AnnProvenance b # (<$) :: a -> AnnProvenance b -> AnnProvenance a #
Foldable AnnProvenance Source #
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 #
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 name => Data (AnnProvenance name) Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnProvenance name -> c (AnnProvenance name) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnProvenance name) # toConstr :: AnnProvenance name -> Constr # dataTypeOf :: AnnProvenance name -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (AnnProvenance name)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AnnProvenance name)) # gmapT :: (forall b. Data b => b -> b) -> AnnProvenance name -> AnnProvenance name # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance name -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance name -> r # gmapQ :: (forall d. Data d => d -> u) -> AnnProvenance name -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnProvenance name -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnProvenance name -> m (AnnProvenance name) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance name -> m (AnnProvenance name) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance name -> m (AnnProvenance name) #

annProvenanceName_maybe :: AnnProvenance name -> Maybe name Source #

Role annotations

data RoleAnnotDecl name Source #

Role Annotation Declaration

Constructors

RoleAnnotDecl (Located name) [Located (Maybe Role)]

AnnKeywordId : AnnType, AnnRole

Instances

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

type LRoleAnnotDecl name = Located (RoleAnnotDecl name) Source #

Located Role Annotation Declaration

roleAnnotDeclName :: RoleAnnotDecl name -> name Source #

Injective type families

data FamilyResultSig name Source #

type Family Result Signature

Constructors

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

Instances

DataId name => Data (FamilyResultSig name) Source #

type LFamilyResultSig name = Located (FamilyResultSig name) Source #

Located type Family Result Signature

data InjectivityAnn name 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 name) [Located name]

AnnKeywordId : AnnRarrow, AnnVbar

Instances

Data name => Data (InjectivityAnn name) Source #

type LInjectivityAnn name = Located (InjectivityAnn name) Source #

Located Injectivity Annotation

resultVariableName :: FamilyResultSig a -> Maybe 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 #
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) #
OutputableBndrId name => Outputable (HsGroup name) Source #
Methods ppr :: HsGroup name -> SDoc Source # pprPrec :: Rational -> HsGroup name -> SDoc Source #