ghc-lib-parser-9.8.2.20240223: The GHC API, decoupled from GHC versions
Safe HaskellNone
LanguageHaskell2010

Language.Haskell.Syntax.Decls

Description

Abstract syntax of global declarations.

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

Synopsis

Toplevel declarations

data HsDecl p Source #

A Haskell Declaration

Constructors

TyClD (XTyClD p) (TyClDecl p)

Type or Class Declaration

InstD (XInstD p) (InstDecl p)

Instance declaration

DerivD (XDerivD p) (DerivDecl p)

Deriving declaration

ValD (XValD p) (HsBind p)

Value declaration

SigD (XSigD p) (Sig p)

Signature declaration

KindSigD (XKindSigD p) (StandaloneKindSig p)

Standalone kind signature

DefD (XDefD p) (DefaultDecl p)

'default' declaration

ForD (XForD p) (ForeignDecl p)

Foreign declaration

WarningD (XWarningD p) (WarnDecls p)

Warning declaration

AnnD (XAnnD p) (AnnDecl p)

Annotation declaration

RuleD (XRuleD p) (RuleDecls p)

Rule declaration

SpliceD (XSpliceD p) (SpliceDecl p)

Splice declaration (Includes quasi-quotes)

DocD (XDocD p) (DocDecl p)

Documentation comment declaration

RoleAnnotD (XRoleAnnotD p) (RoleAnnotDecl p)

Role annotation declaration

XHsDecl !(XXHsDecl p) 

Instances

Instances details
Data (HsDecl GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsDecl GhcPs -> c (HsDecl GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsDecl GhcPs)

toConstr :: HsDecl GhcPs -> Constr

dataTypeOf :: HsDecl GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsDecl GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> HsDecl GhcPs -> HsDecl GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> HsDecl GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDecl GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsDecl GhcPs -> m (HsDecl GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDecl GhcPs -> m (HsDecl GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDecl GhcPs -> m (HsDecl GhcPs)

Data (HsDecl GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsDecl GhcRn -> c (HsDecl GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsDecl GhcRn)

toConstr :: HsDecl GhcRn -> Constr

dataTypeOf :: HsDecl GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsDecl GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> HsDecl GhcRn -> HsDecl GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> HsDecl GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDecl GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsDecl GhcRn -> m (HsDecl GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDecl GhcRn -> m (HsDecl GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDecl GhcRn -> m (HsDecl GhcRn)

Data (HsDecl GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsDecl GhcTc -> c (HsDecl GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsDecl GhcTc)

toConstr :: HsDecl GhcTc -> Constr

dataTypeOf :: HsDecl GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsDecl GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> HsDecl GhcTc -> HsDecl GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> HsDecl GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDecl GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsDecl GhcTc -> m (HsDecl GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDecl GhcTc -> m (HsDecl GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDecl GhcTc -> m (HsDecl GhcTc)

OutputableBndrId p => Outputable (HsDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: HsDecl (GhcPass p) -> SDoc Source #

type Anno (HsDecl (GhcPass _1)) Source # 
Instance details

Defined in GHC.Hs.Decls

type LHsDecl p Source #

Arguments

 = XRec p (HsDecl p)

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

XHsDataDefn !(XXHsDataDefn pass) 

Instances

Instances details
Data (HsDataDefn GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsDataDefn GhcPs -> c (HsDataDefn GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsDataDefn GhcPs)

toConstr :: HsDataDefn GhcPs -> Constr

dataTypeOf :: HsDataDefn GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsDataDefn GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> HsDataDefn GhcPs -> HsDataDefn GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDataDefn GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDataDefn GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> HsDataDefn GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDataDefn GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsDataDefn GhcPs -> m (HsDataDefn GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDataDefn GhcPs -> m (HsDataDefn GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDataDefn GhcPs -> m (HsDataDefn GhcPs)

Data (HsDataDefn GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsDataDefn GhcRn -> c (HsDataDefn GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsDataDefn GhcRn)

toConstr :: HsDataDefn GhcRn -> Constr

dataTypeOf :: HsDataDefn GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsDataDefn GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> HsDataDefn GhcRn -> HsDataDefn GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDataDefn GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDataDefn GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> HsDataDefn GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDataDefn GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsDataDefn GhcRn -> m (HsDataDefn GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDataDefn GhcRn -> m (HsDataDefn GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDataDefn GhcRn -> m (HsDataDefn GhcRn)

Data (HsDataDefn GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsDataDefn GhcTc -> c (HsDataDefn GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsDataDefn GhcTc)

toConstr :: HsDataDefn GhcTc -> Constr

dataTypeOf :: HsDataDefn GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsDataDefn GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> HsDataDefn GhcTc -> HsDataDefn GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDataDefn GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDataDefn GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> HsDataDefn GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDataDefn GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsDataDefn GhcTc -> m (HsDataDefn GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDataDefn GhcTc -> m (HsDataDefn GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDataDefn GhcTc -> m (HsDataDefn GhcTc)

OutputableBndrId p => Outputable (HsDataDefn (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: HsDataDefn (GhcPass p) -> SDoc Source #

type HsDeriving pass Source #

Arguments

 = [LHsDerivingClause pass]

The optional deriving clauses of a data declaration. Clauses is plural because one can specify multiple deriving clauses using the -XDerivingStrategies language extension.

The list of 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

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

data FunDep pass Source #

Constructors

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

Instances

Instances details
Data (FunDep GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunDep GhcPs -> c (FunDep GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FunDep GhcPs)

toConstr :: FunDep GhcPs -> Constr

dataTypeOf :: FunDep GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FunDep GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> FunDep GhcPs -> FunDep GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunDep GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunDep GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> FunDep GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> FunDep GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunDep GhcPs -> m (FunDep GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep GhcPs -> m (FunDep GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep GhcPs -> m (FunDep GhcPs)

Data (FunDep GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunDep GhcRn -> c (FunDep GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FunDep GhcRn)

toConstr :: FunDep GhcRn -> Constr

dataTypeOf :: FunDep GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FunDep GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> FunDep GhcRn -> FunDep GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunDep GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunDep GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> FunDep GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> FunDep GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunDep GhcRn -> m (FunDep GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep GhcRn -> m (FunDep GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep GhcRn -> m (FunDep GhcRn)

Data (FunDep GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunDep GhcTc -> c (FunDep GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FunDep GhcTc)

toConstr :: FunDep GhcTc -> Constr

dataTypeOf :: FunDep GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FunDep GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> FunDep GhcTc -> FunDep GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunDep GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunDep GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> FunDep GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> FunDep GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunDep GhcTc -> m (FunDep GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep GhcTc -> m (FunDep GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep GhcTc -> m (FunDep GhcTc)

OutputableBndrId p => Outputable (FunDep (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: FunDep (GhcPass p) -> SDoc Source #

type Anno (FunDep (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

data HsDerivingClause pass Source #

A single deriving clause of a data declaration.

Constructors

HsDerivingClause 

Fields

XHsDerivingClause !(XXHsDerivingClause pass) 

Instances

Instances details
Data (HsDerivingClause GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsDerivingClause GhcPs -> c (HsDerivingClause GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsDerivingClause GhcPs)

toConstr :: HsDerivingClause GhcPs -> Constr

dataTypeOf :: HsDerivingClause GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsDerivingClause GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> HsDerivingClause GhcPs -> HsDerivingClause GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDerivingClause GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDerivingClause GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> HsDerivingClause GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDerivingClause GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsDerivingClause GhcPs -> m (HsDerivingClause GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDerivingClause GhcPs -> m (HsDerivingClause GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDerivingClause GhcPs -> m (HsDerivingClause GhcPs)

Data (HsDerivingClause GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsDerivingClause GhcRn -> c (HsDerivingClause GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsDerivingClause GhcRn)

toConstr :: HsDerivingClause GhcRn -> Constr

dataTypeOf :: HsDerivingClause GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsDerivingClause GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> HsDerivingClause GhcRn -> HsDerivingClause GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDerivingClause GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDerivingClause GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> HsDerivingClause GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDerivingClause GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsDerivingClause GhcRn -> m (HsDerivingClause GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDerivingClause GhcRn -> m (HsDerivingClause GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDerivingClause GhcRn -> m (HsDerivingClause GhcRn)

Data (HsDerivingClause GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsDerivingClause GhcTc -> c (HsDerivingClause GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsDerivingClause GhcTc)

toConstr :: HsDerivingClause GhcTc -> Constr

dataTypeOf :: HsDerivingClause GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsDerivingClause GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> HsDerivingClause GhcTc -> HsDerivingClause GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDerivingClause GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDerivingClause GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> HsDerivingClause GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDerivingClause GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsDerivingClause GhcTc -> m (HsDerivingClause GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDerivingClause GhcTc -> m (HsDerivingClause GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDerivingClause GhcTc -> m (HsDerivingClause GhcTc)

OutputableBndrId p => Outputable (HsDerivingClause (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

type Anno (HsDerivingClause (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

data DerivClauseTys pass Source #

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

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

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

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

Constructors

DctSingle (XDctSingle pass) (LHsSigType pass)

A deriving clause with a single type. Moreover, that type can only be a type constructor without any arguments.

Example: deriving Eq

DctMulti (XDctMulti pass) [LHsSigType pass]

A deriving clause with a comma-separated list of types, surrounded by enclosing parentheses.

Example: deriving (Eq, C a)

XDerivClauseTys !(XXDerivClauseTys pass) 

Instances

Instances details
Data (DerivClauseTys GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivClauseTys GhcPs -> c (DerivClauseTys GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DerivClauseTys GhcPs)

toConstr :: DerivClauseTys GhcPs -> Constr

dataTypeOf :: DerivClauseTys GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DerivClauseTys GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> DerivClauseTys GhcPs -> DerivClauseTys GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivClauseTys GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivClauseTys GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> DerivClauseTys GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivClauseTys GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivClauseTys GhcPs -> m (DerivClauseTys GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivClauseTys GhcPs -> m (DerivClauseTys GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivClauseTys GhcPs -> m (DerivClauseTys GhcPs)

Data (DerivClauseTys GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivClauseTys GhcRn -> c (DerivClauseTys GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DerivClauseTys GhcRn)

toConstr :: DerivClauseTys GhcRn -> Constr

dataTypeOf :: DerivClauseTys GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DerivClauseTys GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> DerivClauseTys GhcRn -> DerivClauseTys GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivClauseTys GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivClauseTys GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> DerivClauseTys GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivClauseTys GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivClauseTys GhcRn -> m (DerivClauseTys GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivClauseTys GhcRn -> m (DerivClauseTys GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivClauseTys GhcRn -> m (DerivClauseTys GhcRn)

Data (DerivClauseTys GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivClauseTys GhcTc -> c (DerivClauseTys GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DerivClauseTys GhcTc)

toConstr :: DerivClauseTys GhcTc -> Constr

dataTypeOf :: DerivClauseTys GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DerivClauseTys GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> DerivClauseTys GhcTc -> DerivClauseTys GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivClauseTys GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivClauseTys GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> DerivClauseTys GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivClauseTys GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivClauseTys GhcTc -> m (DerivClauseTys GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivClauseTys GhcTc -> m (DerivClauseTys GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivClauseTys GhcTc -> m (DerivClauseTys GhcTc)

OutputableBndrId p => Outputable (DerivClauseTys (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

type Anno (DerivClauseTys (GhcPass _1)) Source # 
Instance details

Defined in GHC.Hs.Decls

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

data NewOrData Source #

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

Constructors

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

Instances

Instances details
Data NewOrData Source # 
Instance details

Defined in Language.Haskell.Syntax.Decls

Methods

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

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

toConstr :: NewOrData -> Constr

dataTypeOf :: NewOrData -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> NewOrData -> NewOrData

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

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

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

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

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

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

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

Outputable NewOrData Source # 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: NewOrData -> SDoc Source #

Eq NewOrData Source # 
Instance details

Defined in Language.Haskell.Syntax.Decls

data DataDefnCons a Source #

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

Constructors

NewTypeCon a 
DataTypeCons Bool [a] 

Instances

Instances details
Foldable DataDefnCons Source # 
Instance details

Defined in Language.Haskell.Syntax.Decls

Methods

fold :: Monoid m => DataDefnCons m -> m

foldMap :: Monoid m => (a -> m) -> DataDefnCons a -> m #

foldMap' :: Monoid m => (a -> m) -> DataDefnCons a -> m

foldr :: (a -> b -> b) -> b -> DataDefnCons a -> b #

foldr' :: (a -> b -> b) -> b -> DataDefnCons a -> b

foldl :: (b -> a -> b) -> b -> DataDefnCons a -> b #

foldl' :: (b -> a -> b) -> b -> DataDefnCons a -> b #

foldr1 :: (a -> a -> a) -> DataDefnCons a -> a #

foldl1 :: (a -> a -> a) -> DataDefnCons a -> a #

toList :: DataDefnCons a -> [a]

null :: DataDefnCons a -> Bool #

length :: DataDefnCons a -> Int #

elem :: Eq a => a -> DataDefnCons a -> Bool #

maximum :: Ord a => DataDefnCons a -> a #

minimum :: Ord a => DataDefnCons a -> a #

sum :: Num a => DataDefnCons a -> a #

product :: Num a => DataDefnCons a -> a #

Traversable DataDefnCons Source # 
Instance details

Defined in Language.Haskell.Syntax.Decls

Methods

traverse :: Applicative f => (a -> f b) -> DataDefnCons a -> f (DataDefnCons b) #

sequenceA :: Applicative f => DataDefnCons (f a) -> f (DataDefnCons a) #

mapM :: Monad m => (a -> m b) -> DataDefnCons a -> m (DataDefnCons b) #

sequence :: Monad m => DataDefnCons (m a) -> m (DataDefnCons a) #

Functor DataDefnCons Source # 
Instance details

Defined in Language.Haskell.Syntax.Decls

Methods

fmap :: (a -> b) -> DataDefnCons a -> DataDefnCons b #

(<$) :: a -> DataDefnCons b -> DataDefnCons a #

Data a => Data (DataDefnCons a) Source # 
Instance details

Defined in Language.Haskell.Syntax.Decls

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataDefnCons a -> c (DataDefnCons a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DataDefnCons a)

toConstr :: DataDefnCons a -> Constr

dataTypeOf :: DataDefnCons a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DataDefnCons a))

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

gmapT :: (forall b. Data b => b -> b) -> DataDefnCons a -> DataDefnCons a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataDefnCons a -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DataDefnCons a -> r

gmapQ :: (forall d. Data d => d -> u) -> DataDefnCons a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DataDefnCons a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DataDefnCons a -> m (DataDefnCons a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DataDefnCons a -> m (DataDefnCons a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DataDefnCons a -> m (DataDefnCons a)

Eq a => Eq (DataDefnCons a) Source # 
Instance details

Defined in Language.Haskell.Syntax.Decls

isTypeDataDefnCons :: DataDefnCons a -> Bool Source #

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

firstDataDefnCon :: DataDefnCons a -> Maybe a Source #

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

data StandaloneKindSig pass Source #

Instances

Instances details
Data (StandaloneKindSig GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> StandaloneKindSig GhcPs -> c (StandaloneKindSig GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (StandaloneKindSig GhcPs)

toConstr :: StandaloneKindSig GhcPs -> Constr

dataTypeOf :: StandaloneKindSig GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (StandaloneKindSig GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> StandaloneKindSig GhcPs -> StandaloneKindSig GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> StandaloneKindSig GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> StandaloneKindSig GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> StandaloneKindSig GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> StandaloneKindSig GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> StandaloneKindSig GhcPs -> m (StandaloneKindSig GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> StandaloneKindSig GhcPs -> m (StandaloneKindSig GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> StandaloneKindSig GhcPs -> m (StandaloneKindSig GhcPs)

Data (StandaloneKindSig GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> StandaloneKindSig GhcRn -> c (StandaloneKindSig GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (StandaloneKindSig GhcRn)

toConstr :: StandaloneKindSig GhcRn -> Constr

dataTypeOf :: StandaloneKindSig GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (StandaloneKindSig GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> StandaloneKindSig GhcRn -> StandaloneKindSig GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> StandaloneKindSig GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> StandaloneKindSig GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> StandaloneKindSig GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> StandaloneKindSig GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> StandaloneKindSig GhcRn -> m (StandaloneKindSig GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> StandaloneKindSig GhcRn -> m (StandaloneKindSig GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> StandaloneKindSig GhcRn -> m (StandaloneKindSig GhcRn)

Data (StandaloneKindSig GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> StandaloneKindSig GhcTc -> c (StandaloneKindSig GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (StandaloneKindSig GhcTc)

toConstr :: StandaloneKindSig GhcTc -> Constr

dataTypeOf :: StandaloneKindSig GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (StandaloneKindSig GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> StandaloneKindSig GhcTc -> StandaloneKindSig GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> StandaloneKindSig GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> StandaloneKindSig GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> StandaloneKindSig GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> StandaloneKindSig GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> StandaloneKindSig GhcTc -> m (StandaloneKindSig GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> StandaloneKindSig GhcTc -> m (StandaloneKindSig GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> StandaloneKindSig GhcTc -> m (StandaloneKindSig GhcTc)

OutputableBndrId p => Outputable (StandaloneKindSig (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

type Anno (StandaloneKindSig (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

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

Located Standalone Kind Signature

Class or type declarations

data TyClDecl pass Source #

A type or class declaration.

Constructors

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

Fields

SynDecl

type declaration

Fields

DataDecl

data declaration

Fields

ClassDecl

Fields

XTyClDecl !(XXTyClDecl pass) 

Instances

Instances details
Data (TyClDecl GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyClDecl GhcPs -> c (TyClDecl GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyClDecl GhcPs)

toConstr :: TyClDecl GhcPs -> Constr

dataTypeOf :: TyClDecl GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyClDecl GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> TyClDecl GhcPs -> TyClDecl GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyClDecl GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyClDecl GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> TyClDecl GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyClDecl GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyClDecl GhcPs -> m (TyClDecl GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClDecl GhcPs -> m (TyClDecl GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClDecl GhcPs -> m (TyClDecl GhcPs)

Data (TyClDecl GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyClDecl GhcRn -> c (TyClDecl GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyClDecl GhcRn)

toConstr :: TyClDecl GhcRn -> Constr

dataTypeOf :: TyClDecl GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyClDecl GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> TyClDecl GhcRn -> TyClDecl GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyClDecl GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyClDecl GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> TyClDecl GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyClDecl GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyClDecl GhcRn -> m (TyClDecl GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClDecl GhcRn -> m (TyClDecl GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClDecl GhcRn -> m (TyClDecl GhcRn)

Data (TyClDecl GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyClDecl GhcTc -> c (TyClDecl GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyClDecl GhcTc)

toConstr :: TyClDecl GhcTc -> Constr

dataTypeOf :: TyClDecl GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyClDecl GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> TyClDecl GhcTc -> TyClDecl GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyClDecl GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyClDecl GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> TyClDecl GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyClDecl GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyClDecl GhcTc -> m (TyClDecl GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClDecl GhcTc -> m (TyClDecl GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClDecl GhcTc -> m (TyClDecl GhcTc)

OutputableBndrId p => Outputable (TyClDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: TyClDecl (GhcPass p) -> SDoc Source #

type Anno (TyClDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

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

Located Declaration of a Type or Class

data TyClGroup pass Source #

Type or Class Group

Instances

Instances details
Data (TyClGroup GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyClGroup GhcPs -> c (TyClGroup GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyClGroup GhcPs)

toConstr :: TyClGroup GhcPs -> Constr

dataTypeOf :: TyClGroup GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyClGroup GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> TyClGroup GhcPs -> TyClGroup GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyClGroup GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyClGroup GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> TyClGroup GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyClGroup GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyClGroup GhcPs -> m (TyClGroup GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClGroup GhcPs -> m (TyClGroup GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClGroup GhcPs -> m (TyClGroup GhcPs)

Data (TyClGroup GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyClGroup GhcRn -> c (TyClGroup GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyClGroup GhcRn)

toConstr :: TyClGroup GhcRn -> Constr

dataTypeOf :: TyClGroup GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyClGroup GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> TyClGroup GhcRn -> TyClGroup GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyClGroup GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyClGroup GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> TyClGroup GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyClGroup GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyClGroup GhcRn -> m (TyClGroup GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClGroup GhcRn -> m (TyClGroup GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClGroup GhcRn -> m (TyClGroup GhcRn)

Data (TyClGroup GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyClGroup GhcTc -> c (TyClGroup GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyClGroup GhcTc)

toConstr :: TyClGroup GhcTc -> Constr

dataTypeOf :: TyClGroup GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyClGroup GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> TyClGroup GhcTc -> TyClGroup GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyClGroup GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyClGroup GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> TyClGroup GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyClGroup GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyClGroup GhcTc -> m (TyClGroup GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClGroup GhcTc -> m (TyClGroup GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyClGroup GhcTc -> m (TyClGroup GhcTc)

OutputableBndrId p => Outputable (TyClGroup (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: TyClGroup (GhcPass p) -> SDoc Source #

isClassDecl :: TyClDecl pass -> Bool Source #

type class

isDataDecl :: TyClDecl pass -> Bool Source #

True = argument is a data/newtype declaration.

isSynDecl :: TyClDecl pass -> Bool Source #

type or type instance declaration

isFamilyDecl :: TyClDecl pass -> Bool Source #

type/data family declaration

isTypeFamilyDecl :: TyClDecl pass -> Bool Source #

type family declaration

isDataFamilyDecl :: TyClDecl pass -> Bool Source #

data family declaration

isOpenTypeFamilyInfo :: FamilyInfo pass -> Bool Source #

open type family info

isClosedTypeFamilyInfo :: FamilyInfo pass -> Bool Source #

closed type family info

data FamilyDecl pass Source #

type Family Declaration

Instances

Instances details
Data (FamilyDecl GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamilyDecl GhcPs -> c (FamilyDecl GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FamilyDecl GhcPs)

toConstr :: FamilyDecl GhcPs -> Constr

dataTypeOf :: FamilyDecl GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FamilyDecl GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> FamilyDecl GhcPs -> FamilyDecl GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamilyDecl GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamilyDecl GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> FamilyDecl GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> FamilyDecl GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamilyDecl GhcPs -> m (FamilyDecl GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyDecl GhcPs -> m (FamilyDecl GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyDecl GhcPs -> m (FamilyDecl GhcPs)

Data (FamilyDecl GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamilyDecl GhcRn -> c (FamilyDecl GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FamilyDecl GhcRn)

toConstr :: FamilyDecl GhcRn -> Constr

dataTypeOf :: FamilyDecl GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FamilyDecl GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> FamilyDecl GhcRn -> FamilyDecl GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamilyDecl GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamilyDecl GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> FamilyDecl GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> FamilyDecl GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamilyDecl GhcRn -> m (FamilyDecl GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyDecl GhcRn -> m (FamilyDecl GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyDecl GhcRn -> m (FamilyDecl GhcRn)

Data (FamilyDecl GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamilyDecl GhcTc -> c (FamilyDecl GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FamilyDecl GhcTc)

toConstr :: FamilyDecl GhcTc -> Constr

dataTypeOf :: FamilyDecl GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FamilyDecl GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> FamilyDecl GhcTc -> FamilyDecl GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamilyDecl GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamilyDecl GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> FamilyDecl GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> FamilyDecl GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamilyDecl GhcTc -> m (FamilyDecl GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyDecl GhcTc -> m (FamilyDecl GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyDecl GhcTc -> m (FamilyDecl GhcTc)

OutputableBndrId p => Outputable (FamilyDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: FamilyDecl (GhcPass p) -> SDoc Source #

type Anno (FamilyDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

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

Located type Family Declaration

Instance declarations

data InstDecl pass Source #

Instance Declaration

Instances

Instances details
Data (InstDecl GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InstDecl GhcPs -> c (InstDecl GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (InstDecl GhcPs)

toConstr :: InstDecl GhcPs -> Constr

dataTypeOf :: InstDecl GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (InstDecl GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> InstDecl GhcPs -> InstDecl GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InstDecl GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InstDecl GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> InstDecl GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> InstDecl GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InstDecl GhcPs -> m (InstDecl GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InstDecl GhcPs -> m (InstDecl GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InstDecl GhcPs -> m (InstDecl GhcPs)

Data (InstDecl GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InstDecl GhcRn -> c (InstDecl GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (InstDecl GhcRn)

toConstr :: InstDecl GhcRn -> Constr

dataTypeOf :: InstDecl GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (InstDecl GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> InstDecl GhcRn -> InstDecl GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InstDecl GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InstDecl GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> InstDecl GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> InstDecl GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InstDecl GhcRn -> m (InstDecl GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InstDecl GhcRn -> m (InstDecl GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InstDecl GhcRn -> m (InstDecl GhcRn)

Data (InstDecl GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InstDecl GhcTc -> c (InstDecl GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (InstDecl GhcTc)

toConstr :: InstDecl GhcTc -> Constr

dataTypeOf :: InstDecl GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (InstDecl GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> InstDecl GhcTc -> InstDecl GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InstDecl GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InstDecl GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> InstDecl GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> InstDecl GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InstDecl GhcTc -> m (InstDecl GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InstDecl GhcTc -> m (InstDecl GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InstDecl GhcTc -> m (InstDecl GhcTc)

OutputableBndrId p => Outputable (InstDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: InstDecl (GhcPass p) -> SDoc Source #

type Anno (InstDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

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

Located Instance Declaration

data FamilyInfo pass Source #

Constructors

DataFamily 
OpenTypeFamily 
ClosedTypeFamily (Maybe [LTyFamInstEqn pass])

Nothing if we're in an hs-boot file and the user said "type family Foo x where .."

Instances

Instances details
Data (FamilyInfo GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamilyInfo GhcPs -> c (FamilyInfo GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FamilyInfo GhcPs)

toConstr :: FamilyInfo GhcPs -> Constr

dataTypeOf :: FamilyInfo GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FamilyInfo GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> FamilyInfo GhcPs -> FamilyInfo GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamilyInfo GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamilyInfo GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> FamilyInfo GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> FamilyInfo GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamilyInfo GhcPs -> m (FamilyInfo GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyInfo GhcPs -> m (FamilyInfo GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyInfo GhcPs -> m (FamilyInfo GhcPs)

Data (FamilyInfo GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamilyInfo GhcRn -> c (FamilyInfo GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FamilyInfo GhcRn)

toConstr :: FamilyInfo GhcRn -> Constr

dataTypeOf :: FamilyInfo GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FamilyInfo GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> FamilyInfo GhcRn -> FamilyInfo GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamilyInfo GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamilyInfo GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> FamilyInfo GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> FamilyInfo GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamilyInfo GhcRn -> m (FamilyInfo GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyInfo GhcRn -> m (FamilyInfo GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyInfo GhcRn -> m (FamilyInfo GhcRn)

Data (FamilyInfo GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamilyInfo GhcTc -> c (FamilyInfo GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FamilyInfo GhcTc)

toConstr :: FamilyInfo GhcTc -> Constr

dataTypeOf :: FamilyInfo GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FamilyInfo GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> FamilyInfo GhcTc -> FamilyInfo GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamilyInfo GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamilyInfo GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> FamilyInfo GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> FamilyInfo GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamilyInfo GhcTc -> m (FamilyInfo GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyInfo GhcTc -> m (FamilyInfo GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyInfo GhcTc -> m (FamilyInfo GhcTc)

Outputable (FamilyInfo pass) Source # 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: FamilyInfo pass -> SDoc Source #

familyInfoTyConFlavour Source #

Arguments

:: Maybe tc

Just cls = this is an associated family of class cls

-> FamilyInfo pass 
-> TyConFlavour tc 

data TyFamInstDecl pass Source #

Type Family Instance Declaration

Instances

Instances details
Data (TyFamInstDecl GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyFamInstDecl GhcPs -> c (TyFamInstDecl GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyFamInstDecl GhcPs)

toConstr :: TyFamInstDecl GhcPs -> Constr

dataTypeOf :: TyFamInstDecl GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyFamInstDecl GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> TyFamInstDecl GhcPs -> TyFamInstDecl GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyFamInstDecl GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyFamInstDecl GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> TyFamInstDecl GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyFamInstDecl GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyFamInstDecl GhcPs -> m (TyFamInstDecl GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyFamInstDecl GhcPs -> m (TyFamInstDecl GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyFamInstDecl GhcPs -> m (TyFamInstDecl GhcPs)

Data (TyFamInstDecl GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyFamInstDecl GhcRn -> c (TyFamInstDecl GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyFamInstDecl GhcRn)

toConstr :: TyFamInstDecl GhcRn -> Constr

dataTypeOf :: TyFamInstDecl GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyFamInstDecl GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> TyFamInstDecl GhcRn -> TyFamInstDecl GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyFamInstDecl GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyFamInstDecl GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> TyFamInstDecl GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyFamInstDecl GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyFamInstDecl GhcRn -> m (TyFamInstDecl GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyFamInstDecl GhcRn -> m (TyFamInstDecl GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyFamInstDecl GhcRn -> m (TyFamInstDecl GhcRn)

Data (TyFamInstDecl GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyFamInstDecl GhcTc -> c (TyFamInstDecl GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyFamInstDecl GhcTc)

toConstr :: TyFamInstDecl GhcTc -> Constr

dataTypeOf :: TyFamInstDecl GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyFamInstDecl GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> TyFamInstDecl GhcTc -> TyFamInstDecl GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyFamInstDecl GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyFamInstDecl GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> TyFamInstDecl GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyFamInstDecl GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyFamInstDecl GhcTc -> m (TyFamInstDecl GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyFamInstDecl GhcTc -> m (TyFamInstDecl GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyFamInstDecl GhcTc -> m (TyFamInstDecl GhcTc)

OutputableBndrId p => Outputable (TyFamInstDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

type Anno (TyFamInstDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

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

Located Type Family Instance Declaration

type TyFamDefltDecl = TyFamInstDecl Source #

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

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

Located type family default declarations.

newtype DataFamInstDecl pass Source #

Data Family Instance Declaration

Instances

Instances details
Data (DataFamInstDecl GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataFamInstDecl GhcPs -> c (DataFamInstDecl GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DataFamInstDecl GhcPs)

toConstr :: DataFamInstDecl GhcPs -> Constr

dataTypeOf :: DataFamInstDecl GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DataFamInstDecl GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> DataFamInstDecl GhcPs -> DataFamInstDecl GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataFamInstDecl GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DataFamInstDecl GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> DataFamInstDecl GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DataFamInstDecl GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DataFamInstDecl GhcPs -> m (DataFamInstDecl GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DataFamInstDecl GhcPs -> m (DataFamInstDecl GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DataFamInstDecl GhcPs -> m (DataFamInstDecl GhcPs)

Data (DataFamInstDecl GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataFamInstDecl GhcRn -> c (DataFamInstDecl GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DataFamInstDecl GhcRn)

toConstr :: DataFamInstDecl GhcRn -> Constr

dataTypeOf :: DataFamInstDecl GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DataFamInstDecl GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> DataFamInstDecl GhcRn -> DataFamInstDecl GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataFamInstDecl GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DataFamInstDecl GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> DataFamInstDecl GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DataFamInstDecl GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DataFamInstDecl GhcRn -> m (DataFamInstDecl GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DataFamInstDecl GhcRn -> m (DataFamInstDecl GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DataFamInstDecl GhcRn -> m (DataFamInstDecl GhcRn)

Data (DataFamInstDecl GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataFamInstDecl GhcTc -> c (DataFamInstDecl GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DataFamInstDecl GhcTc)

toConstr :: DataFamInstDecl GhcTc -> Constr

dataTypeOf :: DataFamInstDecl GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DataFamInstDecl GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> DataFamInstDecl GhcTc -> DataFamInstDecl GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataFamInstDecl GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DataFamInstDecl GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> DataFamInstDecl GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DataFamInstDecl GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DataFamInstDecl GhcTc -> m (DataFamInstDecl GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DataFamInstDecl GhcTc -> m (DataFamInstDecl GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DataFamInstDecl GhcTc -> m (DataFamInstDecl GhcTc)

OutputableBndrId p => Outputable (DataFamInstDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

type Anno (DataFamInstDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

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

Located Data Family Instance Declaration

data FamEqn pass rhs Source #

Family Equation

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

Constructors

FamEqn 

Fields

XFamEqn !(XXFamEqn pass rhs) 

Instances

Instances details
Data rhs => Data (FamEqn GhcPs rhs) 
Instance details

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: FamEqn GhcPs rhs -> Constr

dataTypeOf :: FamEqn GhcPs rhs -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> FamEqn GhcPs rhs -> FamEqn GhcPs rhs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamEqn GhcPs rhs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamEqn GhcPs rhs -> r

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> FamEqn GhcPs rhs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamEqn GhcPs rhs -> m (FamEqn GhcPs rhs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamEqn GhcPs rhs -> m (FamEqn GhcPs rhs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamEqn GhcPs rhs -> m (FamEqn GhcPs rhs)

Data rhs => Data (FamEqn GhcRn rhs) 
Instance details

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: FamEqn GhcRn rhs -> Constr

dataTypeOf :: FamEqn GhcRn rhs -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> FamEqn GhcRn rhs -> FamEqn GhcRn rhs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamEqn GhcRn rhs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamEqn GhcRn rhs -> r

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> FamEqn GhcRn rhs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamEqn GhcRn rhs -> m (FamEqn GhcRn rhs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamEqn GhcRn rhs -> m (FamEqn GhcRn rhs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamEqn GhcRn rhs -> m (FamEqn GhcRn rhs)

Data rhs => Data (FamEqn GhcTc rhs) 
Instance details

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: FamEqn GhcTc rhs -> Constr

dataTypeOf :: FamEqn GhcTc rhs -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> FamEqn GhcTc rhs -> FamEqn GhcTc rhs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamEqn GhcTc rhs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamEqn GhcTc rhs -> r

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> FamEqn GhcTc rhs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamEqn GhcTc rhs -> m (FamEqn GhcTc rhs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamEqn GhcTc rhs -> m (FamEqn GhcTc rhs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamEqn GhcTc rhs -> m (FamEqn GhcTc rhs)

type Anno (FamEqn (GhcPass p) _1) Source # 
Instance details

Defined in GHC.Hs.Decls

type Anno (FamEqn (GhcPass p) _1) = SrcSpanAnnA
type Anno (FamEqn (GhcPass p) _1) Source # 
Instance details

Defined in GHC.Hs.Decls

type Anno (FamEqn (GhcPass p) _1) = SrcSpanAnnA
type Anno (FamEqn p (LocatedA (HsType p))) Source # 
Instance details

Defined in GHC.Hs.Decls

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

Type Family Instance Equation

type LTyFamInstEqn pass Source #

Arguments

 = XRec pass (TyFamInstEqn pass)

May have AnnKeywordId : AnnSemi when in a list

Located Type Family Instance Equation

type HsTyPats pass = [LHsTypeArg pass] Source #

Haskell Type Patterns

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

Located Class Instance Declaration

data ClsInstDecl pass Source #

Class Instance Declaration - AnnKeywordId : AnnInstance, AnnWhere, AnnOpen,AnnClose, For details on above see Note [exact print annotations] in GHC.Parser.Annotation

Instances

Instances details
Data (ClsInstDecl GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ClsInstDecl GhcPs -> c (ClsInstDecl GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ClsInstDecl GhcPs)

toConstr :: ClsInstDecl GhcPs -> Constr

dataTypeOf :: ClsInstDecl GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ClsInstDecl GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> ClsInstDecl GhcPs -> ClsInstDecl GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ClsInstDecl GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ClsInstDecl GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> ClsInstDecl GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ClsInstDecl GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ClsInstDecl GhcPs -> m (ClsInstDecl GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ClsInstDecl GhcPs -> m (ClsInstDecl GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ClsInstDecl GhcPs -> m (ClsInstDecl GhcPs)

Data (ClsInstDecl GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ClsInstDecl GhcRn -> c (ClsInstDecl GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ClsInstDecl GhcRn)

toConstr :: ClsInstDecl GhcRn -> Constr

dataTypeOf :: ClsInstDecl GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ClsInstDecl GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> ClsInstDecl GhcRn -> ClsInstDecl GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ClsInstDecl GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ClsInstDecl GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> ClsInstDecl GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ClsInstDecl GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ClsInstDecl GhcRn -> m (ClsInstDecl GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ClsInstDecl GhcRn -> m (ClsInstDecl GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ClsInstDecl GhcRn -> m (ClsInstDecl GhcRn)

Data (ClsInstDecl GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ClsInstDecl GhcTc -> c (ClsInstDecl GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ClsInstDecl GhcTc)

toConstr :: ClsInstDecl GhcTc -> Constr

dataTypeOf :: ClsInstDecl GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ClsInstDecl GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> ClsInstDecl GhcTc -> ClsInstDecl GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ClsInstDecl GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ClsInstDecl GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> ClsInstDecl GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ClsInstDecl GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ClsInstDecl GhcTc -> m (ClsInstDecl GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ClsInstDecl GhcTc -> m (ClsInstDecl GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ClsInstDecl GhcTc -> m (ClsInstDecl GhcTc)

OutputableBndrId p => Outputable (ClsInstDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: ClsInstDecl (GhcPass p) -> SDoc Source #

type Anno (ClsInstDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

Standalone deriving declarations

data DerivDecl pass Source #

Stand-alone 'deriving instance' declaration

Constructors

DerivDecl 

Fields

XDerivDecl !(XXDerivDecl pass) 

Instances

Instances details
Data (DerivDecl GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivDecl GhcPs -> c (DerivDecl GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DerivDecl GhcPs)

toConstr :: DerivDecl GhcPs -> Constr

dataTypeOf :: DerivDecl GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DerivDecl GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> DerivDecl GhcPs -> DerivDecl GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivDecl GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivDecl GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> DerivDecl GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivDecl GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivDecl GhcPs -> m (DerivDecl GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivDecl GhcPs -> m (DerivDecl GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivDecl GhcPs -> m (DerivDecl GhcPs)

Data (DerivDecl GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivDecl GhcRn -> c (DerivDecl GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DerivDecl GhcRn)

toConstr :: DerivDecl GhcRn -> Constr

dataTypeOf :: DerivDecl GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DerivDecl GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> DerivDecl GhcRn -> DerivDecl GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivDecl GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivDecl GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> DerivDecl GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivDecl GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivDecl GhcRn -> m (DerivDecl GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivDecl GhcRn -> m (DerivDecl GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivDecl GhcRn -> m (DerivDecl GhcRn)

Data (DerivDecl GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivDecl GhcTc -> c (DerivDecl GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DerivDecl GhcTc)

toConstr :: DerivDecl GhcTc -> Constr

dataTypeOf :: DerivDecl GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DerivDecl GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> DerivDecl GhcTc -> DerivDecl GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivDecl GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivDecl GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> DerivDecl GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivDecl GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivDecl GhcTc -> m (DerivDecl GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivDecl GhcTc -> m (DerivDecl GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivDecl GhcTc -> m (DerivDecl GhcTc)

OutputableBndrId p => Outputable (DerivDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: DerivDecl (GhcPass p) -> SDoc Source #

type Anno (DerivDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

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

Located stand-alone 'deriving instance' declaration

Deriving strategies

data DerivStrategy pass Source #

Which technique the user explicitly requested when deriving an instance.

Constructors

StockStrategy (XStockStrategy pass)

GHC's "standard" strategy, which is to implement a custom instance for the data type. This only works for certain types that GHC knows about (e.g., Eq, Show, Functor when -XDeriveFunctor is enabled, etc.)

AnyclassStrategy (XAnyClassStrategy pass)
-XDeriveAnyClass
NewtypeStrategy (XNewtypeStrategy pass)
-XGeneralizedNewtypeDeriving
ViaStrategy (XViaStrategy pass)
-XDerivingVia

Instances

Instances details
Data (DerivStrategy GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivStrategy GhcPs -> c (DerivStrategy GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DerivStrategy GhcPs)

toConstr :: DerivStrategy GhcPs -> Constr

dataTypeOf :: DerivStrategy GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DerivStrategy GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> DerivStrategy GhcPs -> DerivStrategy GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> DerivStrategy GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivStrategy GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivStrategy GhcPs -> m (DerivStrategy GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy GhcPs -> m (DerivStrategy GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy GhcPs -> m (DerivStrategy GhcPs)

Data (DerivStrategy GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivStrategy GhcRn -> c (DerivStrategy GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DerivStrategy GhcRn)

toConstr :: DerivStrategy GhcRn -> Constr

dataTypeOf :: DerivStrategy GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DerivStrategy GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> DerivStrategy GhcRn -> DerivStrategy GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> DerivStrategy GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivStrategy GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivStrategy GhcRn -> m (DerivStrategy GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy GhcRn -> m (DerivStrategy GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy GhcRn -> m (DerivStrategy GhcRn)

Data (DerivStrategy GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivStrategy GhcTc -> c (DerivStrategy GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DerivStrategy GhcTc)

toConstr :: DerivStrategy GhcTc -> Constr

dataTypeOf :: DerivStrategy GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DerivStrategy GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> DerivStrategy GhcTc -> DerivStrategy GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> DerivStrategy GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivStrategy GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivStrategy GhcTc -> m (DerivStrategy GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy GhcTc -> m (DerivStrategy GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy GhcTc -> m (DerivStrategy GhcTc)

OutputableBndrId p => Outputable (DerivStrategy (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

type Anno (DerivStrategy (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

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

A Located DerivStrategy.

RULE declarations

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

Located Rule Declarations

data RuleDecls pass Source #

Rule Declarations

Constructors

HsRules 

Fields

XRuleDecls !(XXRuleDecls pass) 

Instances

Instances details
Data (RuleDecls GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleDecls GhcPs -> c (RuleDecls GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RuleDecls GhcPs)

toConstr :: RuleDecls GhcPs -> Constr

dataTypeOf :: RuleDecls GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RuleDecls GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> RuleDecls GhcPs -> RuleDecls GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecls GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecls GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> RuleDecls GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleDecls GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleDecls GhcPs -> m (RuleDecls GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecls GhcPs -> m (RuleDecls GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecls GhcPs -> m (RuleDecls GhcPs)

Data (RuleDecls GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleDecls GhcRn -> c (RuleDecls GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RuleDecls GhcRn)

toConstr :: RuleDecls GhcRn -> Constr

dataTypeOf :: RuleDecls GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RuleDecls GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> RuleDecls GhcRn -> RuleDecls GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecls GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecls GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> RuleDecls GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleDecls GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleDecls GhcRn -> m (RuleDecls GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecls GhcRn -> m (RuleDecls GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecls GhcRn -> m (RuleDecls GhcRn)

Data (RuleDecls GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleDecls GhcTc -> c (RuleDecls GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RuleDecls GhcTc)

toConstr :: RuleDecls GhcTc -> Constr

dataTypeOf :: RuleDecls GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RuleDecls GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> RuleDecls GhcTc -> RuleDecls GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecls GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecls GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> RuleDecls GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleDecls GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleDecls GhcTc -> m (RuleDecls GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecls GhcTc -> m (RuleDecls GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecls GhcTc -> m (RuleDecls GhcTc)

OutputableBndrId p => Outputable (RuleDecls (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: RuleDecls (GhcPass p) -> SDoc Source #

type Anno (RuleDecls (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

data RuleDecl pass Source #

Rule Declaration

Constructors

HsRule 

Fields

XRuleDecl !(XXRuleDecl pass) 

Instances

Instances details
Data (RuleDecl GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleDecl GhcPs -> c (RuleDecl GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RuleDecl GhcPs)

toConstr :: RuleDecl GhcPs -> Constr

dataTypeOf :: RuleDecl GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RuleDecl GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> RuleDecl GhcPs -> RuleDecl GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecl GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecl GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> RuleDecl GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleDecl GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleDecl GhcPs -> m (RuleDecl GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecl GhcPs -> m (RuleDecl GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecl GhcPs -> m (RuleDecl GhcPs)

Data (RuleDecl GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleDecl GhcRn -> c (RuleDecl GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RuleDecl GhcRn)

toConstr :: RuleDecl GhcRn -> Constr

dataTypeOf :: RuleDecl GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RuleDecl GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> RuleDecl GhcRn -> RuleDecl GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecl GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecl GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> RuleDecl GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleDecl GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleDecl GhcRn -> m (RuleDecl GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecl GhcRn -> m (RuleDecl GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecl GhcRn -> m (RuleDecl GhcRn)

Data (RuleDecl GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleDecl GhcTc -> c (RuleDecl GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RuleDecl GhcTc)

toConstr :: RuleDecl GhcTc -> Constr

dataTypeOf :: RuleDecl GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RuleDecl GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> RuleDecl GhcTc -> RuleDecl GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecl GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleDecl GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> RuleDecl GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleDecl GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleDecl GhcTc -> m (RuleDecl GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecl GhcTc -> m (RuleDecl GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleDecl GhcTc -> m (RuleDecl GhcTc)

OutputableBndrId p => Outputable (RuleDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: RuleDecl (GhcPass p) -> SDoc Source #

type Anno (RuleDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

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

Located Rule Declaration

data RuleBndr pass Source #

Rule Binder

Instances

Instances details
Data (RuleBndr GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleBndr GhcPs -> c (RuleBndr GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RuleBndr GhcPs)

toConstr :: RuleBndr GhcPs -> Constr

dataTypeOf :: RuleBndr GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RuleBndr GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> RuleBndr GhcPs -> RuleBndr GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> RuleBndr GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleBndr GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleBndr GhcPs -> m (RuleBndr GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr GhcPs -> m (RuleBndr GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr GhcPs -> m (RuleBndr GhcPs)

Data (RuleBndr GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleBndr GhcRn -> c (RuleBndr GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RuleBndr GhcRn)

toConstr :: RuleBndr GhcRn -> Constr

dataTypeOf :: RuleBndr GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RuleBndr GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> RuleBndr GhcRn -> RuleBndr GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> RuleBndr GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleBndr GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleBndr GhcRn -> m (RuleBndr GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr GhcRn -> m (RuleBndr GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr GhcRn -> m (RuleBndr GhcRn)

Data (RuleBndr GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleBndr GhcTc -> c (RuleBndr GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RuleBndr GhcTc)

toConstr :: RuleBndr GhcTc -> Constr

dataTypeOf :: RuleBndr GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RuleBndr GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> RuleBndr GhcTc -> RuleBndr GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> RuleBndr GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleBndr GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleBndr GhcTc -> m (RuleBndr GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr GhcTc -> m (RuleBndr GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr GhcTc -> m (RuleBndr GhcTc)

OutputableBndrId p => Outputable (RuleBndr (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: RuleBndr (GhcPass p) -> SDoc Source #

type Anno (RuleBndr (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

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

Located Rule Binder

default declarations

data DefaultDecl pass Source #

Default Declaration

Instances

Instances details
Data (DefaultDecl GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DefaultDecl GhcPs -> c (DefaultDecl GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DefaultDecl GhcPs)

toConstr :: DefaultDecl GhcPs -> Constr

dataTypeOf :: DefaultDecl GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DefaultDecl GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> DefaultDecl GhcPs -> DefaultDecl GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DefaultDecl GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DefaultDecl GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> DefaultDecl GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DefaultDecl GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DefaultDecl GhcPs -> m (DefaultDecl GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DefaultDecl GhcPs -> m (DefaultDecl GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DefaultDecl GhcPs -> m (DefaultDecl GhcPs)

Data (DefaultDecl GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DefaultDecl GhcRn -> c (DefaultDecl GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DefaultDecl GhcRn)

toConstr :: DefaultDecl GhcRn -> Constr

dataTypeOf :: DefaultDecl GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DefaultDecl GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> DefaultDecl GhcRn -> DefaultDecl GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DefaultDecl GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DefaultDecl GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> DefaultDecl GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DefaultDecl GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DefaultDecl GhcRn -> m (DefaultDecl GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DefaultDecl GhcRn -> m (DefaultDecl GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DefaultDecl GhcRn -> m (DefaultDecl GhcRn)

Data (DefaultDecl GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DefaultDecl GhcTc -> c (DefaultDecl GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DefaultDecl GhcTc)

toConstr :: DefaultDecl GhcTc -> Constr

dataTypeOf :: DefaultDecl GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DefaultDecl GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> DefaultDecl GhcTc -> DefaultDecl GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DefaultDecl GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DefaultDecl GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> DefaultDecl GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DefaultDecl GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DefaultDecl GhcTc -> m (DefaultDecl GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DefaultDecl GhcTc -> m (DefaultDecl GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DefaultDecl GhcTc -> m (DefaultDecl GhcTc)

OutputableBndrId p => Outputable (DefaultDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: DefaultDecl (GhcPass p) -> SDoc Source #

type Anno (DefaultDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

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

Located Default Declaration

Template haskell declaration splice

data SpliceDecoration Source #

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

Constructors

DollarSplice

$splice

BareSplice

bare splice

Instances

Instances details
Data SpliceDecoration Source # 
Instance details

Defined in Language.Haskell.Syntax.Decls

Methods

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

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

toConstr :: SpliceDecoration -> Constr

dataTypeOf :: SpliceDecoration -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> SpliceDecoration -> SpliceDecoration

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

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

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

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

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

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

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

Show SpliceDecoration Source # 
Instance details

Defined in Language.Haskell.Syntax.Decls

Outputable SpliceDecoration Source # 
Instance details

Defined in GHC.Hs.Decls

Eq SpliceDecoration Source # 
Instance details

Defined in Language.Haskell.Syntax.Decls

data SpliceDecl p Source #

Splice Declaration

Instances

Instances details
Data (SpliceDecl GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpliceDecl GhcPs -> c (SpliceDecl GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SpliceDecl GhcPs)

toConstr :: SpliceDecl GhcPs -> Constr

dataTypeOf :: SpliceDecl GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (SpliceDecl GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> SpliceDecl GhcPs -> SpliceDecl GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpliceDecl GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpliceDecl GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> SpliceDecl GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> SpliceDecl GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpliceDecl GhcPs -> m (SpliceDecl GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceDecl GhcPs -> m (SpliceDecl GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceDecl GhcPs -> m (SpliceDecl GhcPs)

Data (SpliceDecl GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpliceDecl GhcRn -> c (SpliceDecl GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SpliceDecl GhcRn)

toConstr :: SpliceDecl GhcRn -> Constr

dataTypeOf :: SpliceDecl GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (SpliceDecl GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> SpliceDecl GhcRn -> SpliceDecl GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpliceDecl GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpliceDecl GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> SpliceDecl GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> SpliceDecl GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpliceDecl GhcRn -> m (SpliceDecl GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceDecl GhcRn -> m (SpliceDecl GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceDecl GhcRn -> m (SpliceDecl GhcRn)

Data (SpliceDecl GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpliceDecl GhcTc -> c (SpliceDecl GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SpliceDecl GhcTc)

toConstr :: SpliceDecl GhcTc -> Constr

dataTypeOf :: SpliceDecl GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (SpliceDecl GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> SpliceDecl GhcTc -> SpliceDecl GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpliceDecl GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpliceDecl GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> SpliceDecl GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> SpliceDecl GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpliceDecl GhcTc -> m (SpliceDecl GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceDecl GhcTc -> m (SpliceDecl GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceDecl GhcTc -> m (SpliceDecl GhcTc)

OutputableBndrId p => Outputable (SpliceDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: SpliceDecl (GhcPass p) -> SDoc Source #

type Anno (SpliceDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

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

Located Splice Declaration

Foreign function interface declarations

data ForeignDecl pass Source #

Foreign Declaration

Instances

Instances details
Data (ForeignDecl GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForeignDecl GhcPs -> c (ForeignDecl GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ForeignDecl GhcPs)

toConstr :: ForeignDecl GhcPs -> Constr

dataTypeOf :: ForeignDecl GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ForeignDecl GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> ForeignDecl GhcPs -> ForeignDecl GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForeignDecl GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForeignDecl GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> ForeignDecl GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ForeignDecl GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForeignDecl GhcPs -> m (ForeignDecl GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignDecl GhcPs -> m (ForeignDecl GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignDecl GhcPs -> m (ForeignDecl GhcPs)

Data (ForeignDecl GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForeignDecl GhcRn -> c (ForeignDecl GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ForeignDecl GhcRn)

toConstr :: ForeignDecl GhcRn -> Constr

dataTypeOf :: ForeignDecl GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ForeignDecl GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> ForeignDecl GhcRn -> ForeignDecl GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForeignDecl GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForeignDecl GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> ForeignDecl GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ForeignDecl GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForeignDecl GhcRn -> m (ForeignDecl GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignDecl GhcRn -> m (ForeignDecl GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignDecl GhcRn -> m (ForeignDecl GhcRn)

Data (ForeignDecl GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForeignDecl GhcTc -> c (ForeignDecl GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ForeignDecl GhcTc)

toConstr :: ForeignDecl GhcTc -> Constr

dataTypeOf :: ForeignDecl GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ForeignDecl GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> ForeignDecl GhcTc -> ForeignDecl GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForeignDecl GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForeignDecl GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> ForeignDecl GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ForeignDecl GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForeignDecl GhcTc -> m (ForeignDecl GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignDecl GhcTc -> m (ForeignDecl GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignDecl GhcTc -> m (ForeignDecl GhcTc)

OutputableBndrId p => Outputable (ForeignDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: ForeignDecl (GhcPass p) -> SDoc Source #

type Anno (ForeignDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

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

Located Foreign Declaration

data ForeignImport pass Source #

Instances

Instances details
Data (ForeignImport GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForeignImport GhcPs -> c (ForeignImport GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ForeignImport GhcPs)

toConstr :: ForeignImport GhcPs -> Constr

dataTypeOf :: ForeignImport GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ForeignImport GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> ForeignImport GhcPs -> ForeignImport GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForeignImport GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForeignImport GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> ForeignImport GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ForeignImport GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForeignImport GhcPs -> m (ForeignImport GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignImport GhcPs -> m (ForeignImport GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignImport GhcPs -> m (ForeignImport GhcPs)

Data (ForeignImport GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForeignImport GhcRn -> c (ForeignImport GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ForeignImport GhcRn)

toConstr :: ForeignImport GhcRn -> Constr

dataTypeOf :: ForeignImport GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ForeignImport GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> ForeignImport GhcRn -> ForeignImport GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForeignImport GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForeignImport GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> ForeignImport GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ForeignImport GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForeignImport GhcRn -> m (ForeignImport GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignImport GhcRn -> m (ForeignImport GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignImport GhcRn -> m (ForeignImport GhcRn)

Data (ForeignImport GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForeignImport GhcTc -> c (ForeignImport GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ForeignImport GhcTc)

toConstr :: ForeignImport GhcTc -> Constr

dataTypeOf :: ForeignImport GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ForeignImport GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> ForeignImport GhcTc -> ForeignImport GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForeignImport GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForeignImport GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> ForeignImport GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ForeignImport GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForeignImport GhcTc -> m (ForeignImport GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignImport GhcTc -> m (ForeignImport GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignImport GhcTc -> m (ForeignImport GhcTc)

OutputableBndrId p => Outputable (ForeignImport (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

data ForeignExport pass Source #

Constructors

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

Instances

Instances details
Data (ForeignExport GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForeignExport GhcPs -> c (ForeignExport GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ForeignExport GhcPs)

toConstr :: ForeignExport GhcPs -> Constr

dataTypeOf :: ForeignExport GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ForeignExport GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> ForeignExport GhcPs -> ForeignExport GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForeignExport GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForeignExport GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> ForeignExport GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ForeignExport GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForeignExport GhcPs -> m (ForeignExport GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignExport GhcPs -> m (ForeignExport GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignExport GhcPs -> m (ForeignExport GhcPs)

Data (ForeignExport GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForeignExport GhcRn -> c (ForeignExport GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ForeignExport GhcRn)

toConstr :: ForeignExport GhcRn -> Constr

dataTypeOf :: ForeignExport GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ForeignExport GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> ForeignExport GhcRn -> ForeignExport GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForeignExport GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForeignExport GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> ForeignExport GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ForeignExport GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForeignExport GhcRn -> m (ForeignExport GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignExport GhcRn -> m (ForeignExport GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignExport GhcRn -> m (ForeignExport GhcRn)

Data (ForeignExport GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForeignExport GhcTc -> c (ForeignExport GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ForeignExport GhcTc)

toConstr :: ForeignExport GhcTc -> Constr

dataTypeOf :: ForeignExport GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ForeignExport GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> ForeignExport GhcTc -> ForeignExport GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForeignExport GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForeignExport GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> ForeignExport GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ForeignExport GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForeignExport GhcTc -> m (ForeignExport GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignExport GhcTc -> m (ForeignExport GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignExport GhcTc -> m (ForeignExport GhcTc)

OutputableBndrId p => Outputable (ForeignExport (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

data CImportSpec Source #

Instances

Instances details
Data CImportSpec Source # 
Instance details

Defined in Language.Haskell.Syntax.Decls

Methods

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

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

toConstr :: CImportSpec -> Constr

dataTypeOf :: CImportSpec -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> CImportSpec -> CImportSpec

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

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

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

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

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

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

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

Data-constructor declarations

data ConDecl pass 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

XConDecl !(XXConDecl pass) 

Instances

Instances details
Data (ConDecl GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConDecl GhcPs -> c (ConDecl GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ConDecl GhcPs)

toConstr :: ConDecl GhcPs -> Constr

dataTypeOf :: ConDecl GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ConDecl GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> ConDecl GhcPs -> ConDecl GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConDecl GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConDecl GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> ConDecl GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ConDecl GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConDecl GhcPs -> m (ConDecl GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDecl GhcPs -> m (ConDecl GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDecl GhcPs -> m (ConDecl GhcPs)

Data (ConDecl GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConDecl GhcRn -> c (ConDecl GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ConDecl GhcRn)

toConstr :: ConDecl GhcRn -> Constr

dataTypeOf :: ConDecl GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ConDecl GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> ConDecl GhcRn -> ConDecl GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConDecl GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConDecl GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> ConDecl GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ConDecl GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConDecl GhcRn -> m (ConDecl GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDecl GhcRn -> m (ConDecl GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDecl GhcRn -> m (ConDecl GhcRn)

Data (ConDecl GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConDecl GhcTc -> c (ConDecl GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ConDecl GhcTc)

toConstr :: ConDecl GhcTc -> Constr

dataTypeOf :: ConDecl GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ConDecl GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> ConDecl GhcTc -> ConDecl GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConDecl GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConDecl GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> ConDecl GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ConDecl GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConDecl GhcTc -> m (ConDecl GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDecl GhcTc -> m (ConDecl GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDecl GhcTc -> m (ConDecl GhcTc)

OutputableBndrId p => Outputable (ConDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: ConDecl (GhcPass p) -> SDoc Source #

type Anno (ConDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

type LConDecl pass Source #

Arguments

 = XRec pass (ConDecl pass)

May have AnnKeywordId : AnnSemi when in a GADT constructor list

Located data Constructor Declaration

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

The arguments in a Haskell98-style data constructor.

data HsConDeclGADTDetails pass Source #

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

Constructors

PrefixConGADT [HsScaled pass (LBangType pass)] 
RecConGADT (XRec pass [LConDeclField pass]) (LHsUniToken "->" "\8594" pass) 

Instances

Instances details
Data (HsConDeclGADTDetails GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsConDeclGADTDetails GhcPs -> c (HsConDeclGADTDetails GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsConDeclGADTDetails GhcPs)

toConstr :: HsConDeclGADTDetails GhcPs -> Constr

dataTypeOf :: HsConDeclGADTDetails GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsConDeclGADTDetails GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> HsConDeclGADTDetails GhcPs -> HsConDeclGADTDetails GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclGADTDetails GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclGADTDetails GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> HsConDeclGADTDetails GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsConDeclGADTDetails GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsConDeclGADTDetails GhcPs -> m (HsConDeclGADTDetails GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclGADTDetails GhcPs -> m (HsConDeclGADTDetails GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclGADTDetails GhcPs -> m (HsConDeclGADTDetails GhcPs)

Data (HsConDeclGADTDetails GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsConDeclGADTDetails GhcRn -> c (HsConDeclGADTDetails GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsConDeclGADTDetails GhcRn)

toConstr :: HsConDeclGADTDetails GhcRn -> Constr

dataTypeOf :: HsConDeclGADTDetails GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsConDeclGADTDetails GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> HsConDeclGADTDetails GhcRn -> HsConDeclGADTDetails GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclGADTDetails GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclGADTDetails GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> HsConDeclGADTDetails GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsConDeclGADTDetails GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsConDeclGADTDetails GhcRn -> m (HsConDeclGADTDetails GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclGADTDetails GhcRn -> m (HsConDeclGADTDetails GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclGADTDetails GhcRn -> m (HsConDeclGADTDetails GhcRn)

Data (HsConDeclGADTDetails GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsConDeclGADTDetails GhcTc -> c (HsConDeclGADTDetails GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsConDeclGADTDetails GhcTc)

toConstr :: HsConDeclGADTDetails GhcTc -> Constr

dataTypeOf :: HsConDeclGADTDetails GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsConDeclGADTDetails GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> HsConDeclGADTDetails GhcTc -> HsConDeclGADTDetails GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclGADTDetails GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclGADTDetails GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> HsConDeclGADTDetails GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsConDeclGADTDetails GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsConDeclGADTDetails GhcTc -> m (HsConDeclGADTDetails GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclGADTDetails GhcTc -> m (HsConDeclGADTDetails GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclGADTDetails GhcTc -> m (HsConDeclGADTDetails GhcTc)

Document comments

data DocDecl pass Source #

Documentation comment Declaration

Instances

Instances details
(Data pass, Data (IdP pass)) => Data (DocDecl pass) Source # 
Instance details

Defined in Language.Haskell.Syntax.Decls

Methods

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

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

toConstr :: DocDecl pass -> Constr

dataTypeOf :: DocDecl pass -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable (DocDecl name) Source # 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: DocDecl name -> SDoc Source #

type Anno (DocDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

type LDocDecl pass = XRec pass (DocDecl pass) Source #

Located Documentation comment Declaration

docDeclDoc :: DocDecl pass -> LHsDoc pass Source #

Deprecations

data WarnDecl pass Source #

Warning pragma Declaration

Constructors

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

Instances

Instances details
Data (WarnDecl GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WarnDecl GhcPs -> c (WarnDecl GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WarnDecl GhcPs)

toConstr :: WarnDecl GhcPs -> Constr

dataTypeOf :: WarnDecl GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WarnDecl GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> WarnDecl GhcPs -> WarnDecl GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecl GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecl GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> WarnDecl GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> WarnDecl GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> WarnDecl GhcPs -> m (WarnDecl GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecl GhcPs -> m (WarnDecl GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecl GhcPs -> m (WarnDecl GhcPs)

Data (WarnDecl GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WarnDecl GhcRn -> c (WarnDecl GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WarnDecl GhcRn)

toConstr :: WarnDecl GhcRn -> Constr

dataTypeOf :: WarnDecl GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WarnDecl GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> WarnDecl GhcRn -> WarnDecl GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecl GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecl GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> WarnDecl GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> WarnDecl GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> WarnDecl GhcRn -> m (WarnDecl GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecl GhcRn -> m (WarnDecl GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecl GhcRn -> m (WarnDecl GhcRn)

Data (WarnDecl GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WarnDecl GhcTc -> c (WarnDecl GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WarnDecl GhcTc)

toConstr :: WarnDecl GhcTc -> Constr

dataTypeOf :: WarnDecl GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WarnDecl GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> WarnDecl GhcTc -> WarnDecl GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecl GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecl GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> WarnDecl GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> WarnDecl GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> WarnDecl GhcTc -> m (WarnDecl GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecl GhcTc -> m (WarnDecl GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecl GhcTc -> m (WarnDecl GhcTc)

OutputableBndrId p => Outputable (WarnDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: WarnDecl (GhcPass p) -> SDoc Source #

type Anno (WarnDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

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

Located Warning pragma Declaration

data WarnDecls pass Source #

Warning pragma Declarations

Constructors

Warnings 

Fields

XWarnDecls !(XXWarnDecls pass) 

Instances

Instances details
Data (WarnDecls GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WarnDecls GhcPs -> c (WarnDecls GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WarnDecls GhcPs)

toConstr :: WarnDecls GhcPs -> Constr

dataTypeOf :: WarnDecls GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WarnDecls GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> WarnDecls GhcPs -> WarnDecls GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecls GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecls GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> WarnDecls GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> WarnDecls GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> WarnDecls GhcPs -> m (WarnDecls GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecls GhcPs -> m (WarnDecls GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecls GhcPs -> m (WarnDecls GhcPs)

Data (WarnDecls GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WarnDecls GhcRn -> c (WarnDecls GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WarnDecls GhcRn)

toConstr :: WarnDecls GhcRn -> Constr

dataTypeOf :: WarnDecls GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WarnDecls GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> WarnDecls GhcRn -> WarnDecls GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecls GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecls GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> WarnDecls GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> WarnDecls GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> WarnDecls GhcRn -> m (WarnDecls GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecls GhcRn -> m (WarnDecls GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecls GhcRn -> m (WarnDecls GhcRn)

Data (WarnDecls GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WarnDecls GhcTc -> c (WarnDecls GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WarnDecls GhcTc)

toConstr :: WarnDecls GhcTc -> Constr

dataTypeOf :: WarnDecls GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WarnDecls GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> WarnDecls GhcTc -> WarnDecls GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecls GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecls GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> WarnDecls GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> WarnDecls GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> WarnDecls GhcTc -> m (WarnDecls GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecls GhcTc -> m (WarnDecls GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecls GhcTc -> m (WarnDecls GhcTc)

OutputableBndrId p => Outputable (WarnDecls (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: WarnDecls (GhcPass p) -> SDoc Source #

type Anno (WarnDecls (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

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

Located Warning Declarations

Annotations

data AnnDecl pass Source #

Annotation Declaration

Instances

Instances details
Data (AnnDecl GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnDecl GhcPs -> c (AnnDecl GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnDecl GhcPs)

toConstr :: AnnDecl GhcPs -> Constr

dataTypeOf :: AnnDecl GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AnnDecl GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> AnnDecl GhcPs -> AnnDecl GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnDecl GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnDecl GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> AnnDecl GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnDecl GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnDecl GhcPs -> m (AnnDecl GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnDecl GhcPs -> m (AnnDecl GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnDecl GhcPs -> m (AnnDecl GhcPs)

Data (AnnDecl GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnDecl GhcRn -> c (AnnDecl GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnDecl GhcRn)

toConstr :: AnnDecl GhcRn -> Constr

dataTypeOf :: AnnDecl GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AnnDecl GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> AnnDecl GhcRn -> AnnDecl GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnDecl GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnDecl GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> AnnDecl GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnDecl GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnDecl GhcRn -> m (AnnDecl GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnDecl GhcRn -> m (AnnDecl GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnDecl GhcRn -> m (AnnDecl GhcRn)

Data (AnnDecl GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnDecl GhcTc -> c (AnnDecl GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnDecl GhcTc)

toConstr :: AnnDecl GhcTc -> Constr

dataTypeOf :: AnnDecl GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AnnDecl GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> AnnDecl GhcTc -> AnnDecl GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnDecl GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnDecl GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> AnnDecl GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnDecl GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnDecl GhcTc -> m (AnnDecl GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnDecl GhcTc -> m (AnnDecl GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnDecl GhcTc -> m (AnnDecl GhcTc)

OutputableBndrId p => Outputable (AnnDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: AnnDecl (GhcPass p) -> SDoc Source #

type Anno (AnnDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

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

Located Annotation Declaration

data AnnProvenance pass Source #

Annotation Provenance

Instances

Instances details
Data (AnnProvenance GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnProvenance GhcPs -> c (AnnProvenance GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnProvenance GhcPs)

toConstr :: AnnProvenance GhcPs -> Constr

dataTypeOf :: AnnProvenance GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AnnProvenance GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> AnnProvenance GhcPs -> AnnProvenance GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> AnnProvenance GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnProvenance GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnProvenance GhcPs -> m (AnnProvenance GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance GhcPs -> m (AnnProvenance GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance GhcPs -> m (AnnProvenance GhcPs)

Data (AnnProvenance GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnProvenance GhcRn -> c (AnnProvenance GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnProvenance GhcRn)

toConstr :: AnnProvenance GhcRn -> Constr

dataTypeOf :: AnnProvenance GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AnnProvenance GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> AnnProvenance GhcRn -> AnnProvenance GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> AnnProvenance GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnProvenance GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnProvenance GhcRn -> m (AnnProvenance GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance GhcRn -> m (AnnProvenance GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance GhcRn -> m (AnnProvenance GhcRn)

Data (AnnProvenance GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnProvenance GhcTc -> c (AnnProvenance GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnProvenance GhcTc)

toConstr :: AnnProvenance GhcTc -> Constr

dataTypeOf :: AnnProvenance GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AnnProvenance GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> AnnProvenance GhcTc -> AnnProvenance GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> AnnProvenance GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnProvenance GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnProvenance GhcTc -> m (AnnProvenance GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance GhcTc -> m (AnnProvenance GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance GhcTc -> m (AnnProvenance GhcTc)

Role annotations

data RoleAnnotDecl pass Source #

Role Annotation Declaration

Instances

Instances details
Data (RoleAnnotDecl GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RoleAnnotDecl GhcPs -> c (RoleAnnotDecl GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RoleAnnotDecl GhcPs)

toConstr :: RoleAnnotDecl GhcPs -> Constr

dataTypeOf :: RoleAnnotDecl GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RoleAnnotDecl GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> RoleAnnotDecl GhcPs -> RoleAnnotDecl GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RoleAnnotDecl GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RoleAnnotDecl GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> RoleAnnotDecl GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> RoleAnnotDecl GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RoleAnnotDecl GhcPs -> m (RoleAnnotDecl GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RoleAnnotDecl GhcPs -> m (RoleAnnotDecl GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RoleAnnotDecl GhcPs -> m (RoleAnnotDecl GhcPs)

Data (RoleAnnotDecl GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RoleAnnotDecl GhcRn -> c (RoleAnnotDecl GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RoleAnnotDecl GhcRn)

toConstr :: RoleAnnotDecl GhcRn -> Constr

dataTypeOf :: RoleAnnotDecl GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RoleAnnotDecl GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> RoleAnnotDecl GhcRn -> RoleAnnotDecl GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RoleAnnotDecl GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RoleAnnotDecl GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> RoleAnnotDecl GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> RoleAnnotDecl GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RoleAnnotDecl GhcRn -> m (RoleAnnotDecl GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RoleAnnotDecl GhcRn -> m (RoleAnnotDecl GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RoleAnnotDecl GhcRn -> m (RoleAnnotDecl GhcRn)

Data (RoleAnnotDecl GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RoleAnnotDecl GhcTc -> c (RoleAnnotDecl GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RoleAnnotDecl GhcTc)

toConstr :: RoleAnnotDecl GhcTc -> Constr

dataTypeOf :: RoleAnnotDecl GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RoleAnnotDecl GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> RoleAnnotDecl GhcTc -> RoleAnnotDecl GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RoleAnnotDecl GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RoleAnnotDecl GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> RoleAnnotDecl GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> RoleAnnotDecl GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RoleAnnotDecl GhcTc -> m (RoleAnnotDecl GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RoleAnnotDecl GhcTc -> m (RoleAnnotDecl GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RoleAnnotDecl GhcTc -> m (RoleAnnotDecl GhcTc)

OutputableBndr (IdP (GhcPass p)) => Outputable (RoleAnnotDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

type Anno (RoleAnnotDecl (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

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

Located Role Annotation Declaration

Injective type families

data FamilyResultSig pass Source #

type Family Result Signature

Instances

Instances details
Data (FamilyResultSig GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: FamilyResultSig GhcPs -> Constr

dataTypeOf :: FamilyResultSig GhcPs -> DataType

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

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

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

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

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

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

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

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

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

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

Data (FamilyResultSig GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: FamilyResultSig GhcRn -> Constr

dataTypeOf :: FamilyResultSig GhcRn -> DataType

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

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

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

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

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

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

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

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

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

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

Data (FamilyResultSig GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: FamilyResultSig GhcTc -> Constr

dataTypeOf :: FamilyResultSig GhcTc -> DataType

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

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

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

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

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

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

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

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

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

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

type Anno (FamilyResultSig (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

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

Located type Family Result Signature

data InjectivityAnn pass Source #

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

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

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

Instances

Instances details
Data (InjectivityAnn GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: InjectivityAnn GhcPs -> Constr

dataTypeOf :: InjectivityAnn GhcPs -> DataType

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

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

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

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

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

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

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

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

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

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

Data (InjectivityAnn GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: InjectivityAnn GhcRn -> Constr

dataTypeOf :: InjectivityAnn GhcRn -> DataType

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

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

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

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

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

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

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

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

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

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

Data (InjectivityAnn GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: InjectivityAnn GhcTc -> Constr

dataTypeOf :: InjectivityAnn GhcTc -> DataType

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

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

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

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

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

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

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

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

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

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

type Anno (InjectivityAnn (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

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

Located Injectivity Annotation

Grouping

data HsGroup p Source #

Haskell Group

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

Instances

Instances details
Data (HsGroup GhcPs) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsGroup GhcPs -> c (HsGroup GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsGroup GhcPs)

toConstr :: HsGroup GhcPs -> Constr

dataTypeOf :: HsGroup GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsGroup GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> HsGroup GhcPs -> HsGroup GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsGroup GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsGroup GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> HsGroup GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsGroup GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsGroup GhcPs -> m (HsGroup GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGroup GhcPs -> m (HsGroup GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGroup GhcPs -> m (HsGroup GhcPs)

Data (HsGroup GhcRn) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsGroup GhcRn -> c (HsGroup GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsGroup GhcRn)

toConstr :: HsGroup GhcRn -> Constr

dataTypeOf :: HsGroup GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsGroup GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> HsGroup GhcRn -> HsGroup GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsGroup GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsGroup GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> HsGroup GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsGroup GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsGroup GhcRn -> m (HsGroup GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGroup GhcRn -> m (HsGroup GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGroup GhcRn -> m (HsGroup GhcRn)

Data (HsGroup GhcTc) 
Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsGroup GhcTc -> c (HsGroup GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsGroup GhcTc)

toConstr :: HsGroup GhcTc -> Constr

dataTypeOf :: HsGroup GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsGroup GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> HsGroup GhcTc -> HsGroup GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsGroup GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsGroup GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> HsGroup GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsGroup GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsGroup GhcTc -> m (HsGroup GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGroup GhcTc -> m (HsGroup GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGroup GhcTc -> m (HsGroup GhcTc)

OutputableBndrId p => Outputable (HsGroup (GhcPass p)) Source # 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: HsGroup (GhcPass p) -> SDoc Source #