ghc-8.4.1: The GHC API

Safe HaskellNone
LanguageHaskell2010

HsDecls

Contents

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

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

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.

Constructors

HsDerivingClause 

Fields

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

Class or type declarations

data TyClDecl pass Source #

A type or class declaration.

Constructors

FamDecl
type/data family T :: *->*

Fields

SynDecl

type declaration

Fields

DataDecl

data declaration

Fields

ClassDecl

Fields

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

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 #

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

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

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

DataFamInstD 

Fields

TyFamInstD 

Fields

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

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

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

type LTyFamInstDecl pass = Located (TyFamInstDecl pass) Source #

Located Type Family Instance Declaration

newtype DataFamInstDecl pass Source #

Data Family Instance Declaration

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

type LDataFamInstDecl pass = Located (DataFamInstDecl pass) Source #

Located Data Family Instance Declaration

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

Fields

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

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

Standalone deriving declarations

data DerivDecl pass Source #

Deriving Declaration

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

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

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

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

VECTORISE declarations

data VectDecl pass Source #

Vectorise Declaration

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

default declarations

data DefaultDecl pass Source #

Default Declaration

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

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

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

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

type LForeignDecl pass = Located (ForeignDecl pass) Source #

Located Foreign Declaration

data ForeignImport Source #

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

data ForeignExport Source #

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

data CImportSpec Source #

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

data Constructor Declaration

Constructors

ConDeclGADT 

Fields

ConDeclH98 

Fields

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

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

Document comments

data DocDecl Source #

Documentation comment Declaration

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

type LDocDecl = Located DocDecl Source #

Located Documentation comment Declaration

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

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

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

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

Role annotations

data RoleAnnotDecl pass Source #

Role Annotation Declaration

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

type LRoleAnnotDecl pass = Located (RoleAnnotDecl pass) Source #

Located Role Annotation Declaration

Injective type families

data FamilyResultSig pass Source #

type Family Result Signature

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]"

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.

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 #