ghc-8.0.0.20160204: The GHC API

Safe HaskellNone
LanguageHaskell2010

HsDecls

Contents

Description

Abstract syntax of global declarations.

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

Synopsis

Toplevel declarations

data HsDecl id Source

A Haskell Declaration

Constructors

TyClD (TyClDecl id)

A type or class declaration.

InstD (InstDecl id)

An instance declaration.

DerivD (DerivDecl id) 
ValD (HsBind id) 
SigD (Sig id) 
DefD (DefaultDecl id) 
ForD (ForeignDecl id) 
WarningD (WarnDecls id) 
AnnD (AnnDecl id) 
RuleD (RuleDecls id) 
VectD (VectDecl id) 
SpliceD (SpliceDecl id) 
DocD DocDecl 
RoleAnnotD (RoleAnnotDecl id) 

Instances

DataId id => Data (HsDecl id) 

Methods

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

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

toConstr :: HsDecl id -> Constr Source

dataTypeOf :: HsDecl id -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (HsDecl id)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsDecl id)) Source

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

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

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

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

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

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

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

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

OutputableBndr name => Outputable (HsDecl name) 

Methods

ppr :: HsDecl name -> SDoc Source

pprPrec :: Rational -> HsDecl name -> SDoc Source

type LHsDecl id Source

Arguments

 = Located (HsDecl id)

When in a list this may have

data HsDataDefn name Source

Constructors

HsDataDefn

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

Fields

Instances

DataId id => Data (HsDataDefn id) 

Methods

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

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

toConstr :: HsDataDefn id -> Constr Source

dataTypeOf :: HsDataDefn id -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (HsDataDefn id)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsDataDefn id)) Source

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

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

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

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

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

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

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

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

OutputableBndr name => Outputable (HsDataDefn name) 

Methods

ppr :: HsDataDefn name -> SDoc Source

pprPrec :: Rational -> HsDataDefn name -> SDoc Source

type HsDeriving name Source

Arguments

 = Maybe (Located [LHsSigType name])

The optional 'deriving' clause of a data declaration

Nothing => not specified, Just [] => derive exactly what is asked

It's a LHsSigType because, with Generalised Newtype Deriving, we can mention type variables that aren't bound by the date type. e.g. data T b = ... deriving( C [a] ) should producd a derived instance for (C [a] (T b))

The payload of the Maybe is Located so that we have a place to hang the API annotations: - AnnKeywordId : AnnDeriving, AnnOpen,AnnClose

Class or type declarations

data TyClDecl name Source

A type or class declaration.

Constructors

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

Fields

SynDecl

type declaration

Fields

DataDecl

data declaration

Fields

ClassDecl

Fields

Instances

DataId id => Data (TyClDecl id) 

Methods

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

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

toConstr :: TyClDecl id -> Constr Source

dataTypeOf :: TyClDecl id -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (TyClDecl id)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TyClDecl id)) Source

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

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

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

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

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

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

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

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

OutputableBndr name => Outputable (TyClDecl name) 

Methods

ppr :: TyClDecl name -> SDoc Source

pprPrec :: Rational -> TyClDecl name -> SDoc Source

type LTyClDecl name = Located (TyClDecl name) Source

data TyClGroup name Source

Constructors

TyClGroup 

Fields

Instances

DataId id => Data (TyClGroup id) 

Methods

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

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

toConstr :: TyClGroup id -> Constr Source

dataTypeOf :: TyClGroup id -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (TyClGroup id)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TyClGroup id)) Source

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

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

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

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

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

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

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

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

OutputableBndr name => Outputable (TyClGroup name) 

Methods

ppr :: TyClGroup name -> SDoc Source

pprPrec :: Rational -> TyClGroup name -> SDoc Source

isClassDecl :: TyClDecl name -> Bool Source

type class

isDataDecl :: TyClDecl name -> Bool Source

True = argument is a data/newtype declaration.

isSynDecl :: TyClDecl name -> Bool Source

type or type instance declaration

tcdName :: TyClDecl name -> name Source

isFamilyDecl :: TyClDecl name -> Bool Source

type/data family declaration

isTypeFamilyDecl :: TyClDecl name -> Bool Source

type family declaration

isDataFamilyDecl :: TyClDecl name -> Bool Source

data family declaration

isOpenTypeFamilyInfo :: FamilyInfo name -> Bool Source

open type family info

isClosedTypeFamilyInfo :: FamilyInfo name -> Bool Source

closed type family info

hsDeclHasCusk :: TyClDecl Name -> Bool Source

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

famDeclHasCusk :: FamilyDecl name -> Bool Source

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

data FamilyDecl name Source

Instances

DataId id => Data (FamilyDecl id) 

Methods

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

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

toConstr :: FamilyDecl id -> Constr Source

dataTypeOf :: FamilyDecl id -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (FamilyDecl id)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FamilyDecl id)) Source

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

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

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

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

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

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

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

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

OutputableBndr name => Outputable (FamilyDecl name) 

Methods

ppr :: FamilyDecl name -> SDoc Source

pprPrec :: Rational -> FamilyDecl name -> SDoc Source

Instance declarations

data InstDecl name Source

Constructors

ClsInstD 

Fields

DataFamInstD 

Fields

TyFamInstD 

Fields

Instances

DataId id => Data (InstDecl id) 

Methods

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

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

toConstr :: InstDecl id -> Constr Source

dataTypeOf :: InstDecl id -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (InstDecl id)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (InstDecl id)) Source

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

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

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

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

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

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

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

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

OutputableBndr name => Outputable (InstDecl name) 

Methods

ppr :: InstDecl name -> SDoc Source

pprPrec :: Rational -> InstDecl name -> SDoc Source

type LInstDecl name = Located (InstDecl name) Source

data NewOrData Source

Constructors

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

Instances

Eq NewOrData 
Data NewOrData 

Methods

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

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

toConstr :: NewOrData -> Constr Source

dataTypeOf :: NewOrData -> DataType Source

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

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

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

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

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

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

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

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

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

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

Outputable NewOrData 

data FamilyInfo name Source

Constructors

DataFamily 
OpenTypeFamily 
ClosedTypeFamily (Maybe [LTyFamInstEqn name])

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

Instances

DataId name => Data (FamilyInfo name) 

Methods

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

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

toConstr :: FamilyInfo name -> Constr Source

dataTypeOf :: FamilyInfo name -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (FamilyInfo name)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FamilyInfo name)) Source

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

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

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

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

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

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

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

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

Outputable (FamilyInfo name) 

Methods

ppr :: FamilyInfo name -> SDoc Source

pprPrec :: Rational -> FamilyInfo name -> SDoc Source

data TyFamInstDecl name Source

Instances

DataId name => Data (TyFamInstDecl name) 

Methods

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

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

toConstr :: TyFamInstDecl name -> Constr Source

dataTypeOf :: TyFamInstDecl name -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (TyFamInstDecl name)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TyFamInstDecl name)) Source

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

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

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

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

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

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

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

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

OutputableBndr name => Outputable (TyFamInstDecl name) 

data DataFamInstDecl name Source

Instances

DataId name => Data (DataFamInstDecl name) 

Methods

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

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

toConstr :: DataFamInstDecl name -> Constr Source

dataTypeOf :: DataFamInstDecl name -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (DataFamInstDecl name)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DataFamInstDecl name)) Source

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

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

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

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

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

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

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

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

OutputableBndr name => Outputable (DataFamInstDecl name) 

data TyFamEqn name pats Source

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

Constructors

TyFamEqn

Fields

Instances

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

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyFamEqn name pats -> c (TyFamEqn name pats) Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyFamEqn name pats) Source

toConstr :: TyFamEqn name pats -> Constr Source

dataTypeOf :: TyFamEqn name pats -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (TyFamEqn name pats)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TyFamEqn name pats)) Source

gmapT :: (forall b. Data b => b -> b) -> TyFamEqn name pats -> TyFamEqn name pats Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyFamEqn name pats -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyFamEqn name pats -> r Source

gmapQ :: (forall d. Data d => d -> u) -> TyFamEqn name pats -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyFamEqn name pats -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyFamEqn name pats -> m (TyFamEqn name pats) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyFamEqn name pats -> m (TyFamEqn name pats) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyFamEqn name pats -> m (TyFamEqn name pats) Source

type TyFamInstEqn name = TyFamEqn name (HsTyPats name) Source

type LTyFamInstEqn name Source

Arguments

 = Located (TyFamInstEqn name)

May have AnnKeywordId : AnnSemi when in a list

type TyFamDefltEqn name = TyFamEqn name (LHsQTyVars name) Source

type HsTyPats name Source

Arguments

 = HsImplicitBndrs name [LHsType name]

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

data ClsInstDecl name Source

Instances

DataId id => Data (ClsInstDecl id) 

Methods

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

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

toConstr :: ClsInstDecl id -> Constr Source

dataTypeOf :: ClsInstDecl id -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (ClsInstDecl id)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ClsInstDecl id)) Source

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

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

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

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

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

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

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

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

OutputableBndr name => Outputable (ClsInstDecl name) 

Standalone deriving declarations

data DerivDecl name Source

Instances

DataId name => Data (DerivDecl name) 

Methods

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

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

toConstr :: DerivDecl name -> Constr Source

dataTypeOf :: DerivDecl name -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (DerivDecl name)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DerivDecl name)) Source

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

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

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

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

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

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

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

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

OutputableBndr name => Outputable (DerivDecl name) 

Methods

ppr :: DerivDecl name -> SDoc Source

pprPrec :: Rational -> DerivDecl name -> SDoc Source

type LDerivDecl name = Located (DerivDecl name) Source

RULE declarations

type LRuleDecls name = Located (RuleDecls name) Source

data RuleDecls name Source

Constructors

HsRules 

Fields

Instances

DataId name => Data (RuleDecls name) 

Methods

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

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

toConstr :: RuleDecls name -> Constr Source

dataTypeOf :: RuleDecls name -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (RuleDecls name)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RuleDecls name)) Source

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

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

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

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

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

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

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

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

OutputableBndr name => Outputable (RuleDecls name) 

Methods

ppr :: RuleDecls name -> SDoc Source

pprPrec :: Rational -> RuleDecls name -> SDoc Source

data RuleDecl name Source

Instances

DataId name => Data (RuleDecl name) 

Methods

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

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

toConstr :: RuleDecl name -> Constr Source

dataTypeOf :: RuleDecl name -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (RuleDecl name)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RuleDecl name)) Source

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

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

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

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

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

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

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

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

OutputableBndr name => Outputable (RuleDecl name) 

Methods

ppr :: RuleDecl name -> SDoc Source

pprPrec :: Rational -> RuleDecl name -> SDoc Source

type LRuleDecl name = Located (RuleDecl name) Source

data RuleBndr name Source

Instances

DataId name => Data (RuleBndr name) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleBndr name -> c (RuleBndr name) Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RuleBndr name) Source

toConstr :: RuleBndr name -> Constr Source

dataTypeOf :: RuleBndr name -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (RuleBndr name)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RuleBndr name)) Source

gmapT :: (forall b. Data b => b -> b) -> RuleBndr name -> RuleBndr name Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr name -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr name -> r Source

gmapQ :: (forall d. Data d => d -> u) -> RuleBndr name -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleBndr name -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleBndr name -> m (RuleBndr name) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr name -> m (RuleBndr name) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr name -> m (RuleBndr name) Source

OutputableBndr name => Outputable (RuleBndr name) 

Methods

ppr :: RuleBndr name -> SDoc Source

pprPrec :: Rational -> RuleBndr name -> SDoc Source

type LRuleBndr name = Located (RuleBndr name) Source

VECTORISE declarations

data VectDecl name Source

Instances

DataId name => Data (VectDecl name) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VectDecl name -> c (VectDecl name) Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (VectDecl name) Source

toConstr :: VectDecl name -> Constr Source

dataTypeOf :: VectDecl name -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (VectDecl name)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (VectDecl name)) Source

gmapT :: (forall b. Data b => b -> b) -> VectDecl name -> VectDecl name Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VectDecl name -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VectDecl name -> r Source

gmapQ :: (forall d. Data d => d -> u) -> VectDecl name -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> VectDecl name -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> VectDecl name -> m (VectDecl name) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VectDecl name -> m (VectDecl name) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VectDecl name -> m (VectDecl name) Source

OutputableBndr name => Outputable (VectDecl name) 

Methods

ppr :: VectDecl name -> SDoc Source

pprPrec :: Rational -> VectDecl name -> SDoc Source

type LVectDecl name = Located (VectDecl name) Source

default declarations

data DefaultDecl name Source

Instances

DataId name => Data (DefaultDecl name) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DefaultDecl name -> c (DefaultDecl name) Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DefaultDecl name) Source

toConstr :: DefaultDecl name -> Constr Source

dataTypeOf :: DefaultDecl name -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (DefaultDecl name)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DefaultDecl name)) Source

gmapT :: (forall b. Data b => b -> b) -> DefaultDecl name -> DefaultDecl name Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DefaultDecl name -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DefaultDecl name -> r Source

gmapQ :: (forall d. Data d => d -> u) -> DefaultDecl name -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> DefaultDecl name -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DefaultDecl name -> m (DefaultDecl name) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DefaultDecl name -> m (DefaultDecl name) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DefaultDecl name -> m (DefaultDecl name) Source

OutputableBndr name => Outputable (DefaultDecl name) 

Template haskell declaration splice

data SpliceExplicitFlag Source

Instances

Data SpliceExplicitFlag 

Methods

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

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

toConstr :: SpliceExplicitFlag -> Constr Source

dataTypeOf :: SpliceExplicitFlag -> DataType Source

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

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

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

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

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

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

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

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

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

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

data SpliceDecl id Source

Instances

DataId id => Data (SpliceDecl id) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpliceDecl id -> c (SpliceDecl id) Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SpliceDecl id) Source

toConstr :: SpliceDecl id -> Constr Source

dataTypeOf :: SpliceDecl id -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (SpliceDecl id)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SpliceDecl id)) Source

gmapT :: (forall b. Data b => b -> b) -> SpliceDecl id -> SpliceDecl id Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpliceDecl id -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpliceDecl id -> r Source

gmapQ :: (forall d. Data d => d -> u) -> SpliceDecl id -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> SpliceDecl id -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpliceDecl id -> m (SpliceDecl id) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceDecl id -> m (SpliceDecl id) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceDecl id -> m (SpliceDecl id) Source

OutputableBndr name => Outputable (SpliceDecl name) 

Methods

ppr :: SpliceDecl name -> SDoc Source

pprPrec :: Rational -> SpliceDecl name -> SDoc Source

Foreign function interface declarations

data ForeignDecl name Source

Instances

DataId name => Data (ForeignDecl name) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForeignDecl name -> c (ForeignDecl name) Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ForeignDecl name) Source

toConstr :: ForeignDecl name -> Constr Source

dataTypeOf :: ForeignDecl name -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (ForeignDecl name)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ForeignDecl name)) Source

gmapT :: (forall b. Data b => b -> b) -> ForeignDecl name -> ForeignDecl name Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForeignDecl name -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForeignDecl name -> r Source

gmapQ :: (forall d. Data d => d -> u) -> ForeignDecl name -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> ForeignDecl name -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForeignDecl name -> m (ForeignDecl name) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignDecl name -> m (ForeignDecl name) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignDecl name -> m (ForeignDecl name) Source

OutputableBndr name => Outputable (ForeignDecl name) 

data ForeignImport Source

Instances

Data ForeignImport 

Methods

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

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

toConstr :: ForeignImport -> Constr Source

dataTypeOf :: ForeignImport -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c ForeignImport) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ForeignImport) Source

gmapT :: (forall b. Data b => b -> b) -> ForeignImport -> ForeignImport Source

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

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

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

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

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

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

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

Outputable ForeignImport 

data ForeignExport Source

Instances

Data ForeignExport 

Methods

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

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

toConstr :: ForeignExport -> Constr Source

dataTypeOf :: ForeignExport -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c ForeignExport) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ForeignExport) Source

gmapT :: (forall b. Data b => b -> b) -> ForeignExport -> ForeignExport Source

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

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

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

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

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

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

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

Outputable ForeignExport 

data CImportSpec Source

Instances

Data CImportSpec 

Methods

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

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

toConstr :: CImportSpec -> Constr Source

dataTypeOf :: CImportSpec -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c CImportSpec) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CImportSpec) Source

gmapT :: (forall b. Data b => b -> b) -> CImportSpec -> CImportSpec Source

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

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

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

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

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

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

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

Data-constructor declarations

data ConDecl name Source

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

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

data T = Int MkT Int
       | MkT2

data T a where
     Int MkT Int :: T Int

Constructors

ConDeclGADT 

Fields

ConDeclH98 

Fields

Instances

DataId name => Data (ConDecl name) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConDecl name -> c (ConDecl name) Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ConDecl name) Source

toConstr :: ConDecl name -> Constr Source

dataTypeOf :: ConDecl name -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (ConDecl name)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ConDecl name)) Source

gmapT :: (forall b. Data b => b -> b) -> ConDecl name -> ConDecl name Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConDecl name -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConDecl name -> r Source

gmapQ :: (forall d. Data d => d -> u) -> ConDecl name -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> ConDecl name -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConDecl name -> m (ConDecl name) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDecl name -> m (ConDecl name) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDecl name -> m (ConDecl name) Source

OutputableBndr name => Outputable (ConDecl name) 

Methods

ppr :: ConDecl name -> SDoc Source

pprPrec :: Rational -> ConDecl name -> SDoc Source

type LConDecl name Source

Arguments

 = Located (ConDecl name)

May have AnnKeywordId : AnnSemi when in a GADT constructor list

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

Document comments

data DocDecl Source

Instances

Data DocDecl 

Methods

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

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

toConstr :: DocDecl -> Constr Source

dataTypeOf :: DocDecl -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c DocDecl) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DocDecl) Source

gmapT :: (forall b. Data b => b -> b) -> DocDecl -> DocDecl Source

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

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

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

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

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

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

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

Outputable DocDecl 

Deprecations

data WarnDecl name Source

Constructors

Warning [Located name] WarningTxt 

Instances

Data name => Data (WarnDecl name) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WarnDecl name -> c (WarnDecl name) Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WarnDecl name) Source

toConstr :: WarnDecl name -> Constr Source

dataTypeOf :: WarnDecl name -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (WarnDecl name)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WarnDecl name)) Source

gmapT :: (forall b. Data b => b -> b) -> WarnDecl name -> WarnDecl name Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecl name -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecl name -> r Source

gmapQ :: (forall d. Data d => d -> u) -> WarnDecl name -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> WarnDecl name -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> WarnDecl name -> m (WarnDecl name) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecl name -> m (WarnDecl name) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecl name -> m (WarnDecl name) Source

OutputableBndr name => Outputable (WarnDecl name) 

Methods

ppr :: WarnDecl name -> SDoc Source

pprPrec :: Rational -> WarnDecl name -> SDoc Source

type LWarnDecl name = Located (WarnDecl name) Source

data WarnDecls name Source

Constructors

Warnings 

Fields

Instances

Data name => Data (WarnDecls name) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WarnDecls name -> c (WarnDecls name) Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WarnDecls name) Source

toConstr :: WarnDecls name -> Constr Source

dataTypeOf :: WarnDecls name -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (WarnDecls name)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WarnDecls name)) Source

gmapT :: (forall b. Data b => b -> b) -> WarnDecls name -> WarnDecls name Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecls name -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WarnDecls name -> r Source

gmapQ :: (forall d. Data d => d -> u) -> WarnDecls name -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> WarnDecls name -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> WarnDecls name -> m (WarnDecls name) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecls name -> m (WarnDecls name) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WarnDecls name -> m (WarnDecls name) Source

OutputableBndr name => Outputable (WarnDecls name) 

Methods

ppr :: WarnDecls name -> SDoc Source

pprPrec :: Rational -> WarnDecls name -> SDoc Source

type LWarnDecls name = Located (WarnDecls name) Source

Annotations

data AnnDecl name Source

Instances

DataId name => Data (AnnDecl name) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnDecl name -> c (AnnDecl name) Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnDecl name) Source

toConstr :: AnnDecl name -> Constr Source

dataTypeOf :: AnnDecl name -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (AnnDecl name)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AnnDecl name)) Source

gmapT :: (forall b. Data b => b -> b) -> AnnDecl name -> AnnDecl name Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnDecl name -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnDecl name -> r Source

gmapQ :: (forall d. Data d => d -> u) -> AnnDecl name -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnDecl name -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnDecl name -> m (AnnDecl name) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnDecl name -> m (AnnDecl name) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnDecl name -> m (AnnDecl name) Source

OutputableBndr name => Outputable (AnnDecl name) 

Methods

ppr :: AnnDecl name -> SDoc Source

pprPrec :: Rational -> AnnDecl name -> SDoc Source

type LAnnDecl name = Located (AnnDecl name) Source

data AnnProvenance name Source

Instances

Functor AnnProvenance 

Methods

fmap :: (a -> b) -> AnnProvenance a -> AnnProvenance b Source

(<$) :: a -> AnnProvenance b -> AnnProvenance a Source

Foldable AnnProvenance 

Methods

fold :: Monoid m => AnnProvenance m -> m Source

foldMap :: Monoid m => (a -> m) -> AnnProvenance a -> m Source

foldr :: (a -> b -> b) -> b -> AnnProvenance a -> b Source

foldr' :: (a -> b -> b) -> b -> AnnProvenance a -> b Source

foldl :: (b -> a -> b) -> b -> AnnProvenance a -> b Source

foldl' :: (b -> a -> b) -> b -> AnnProvenance a -> b Source

foldr1 :: (a -> a -> a) -> AnnProvenance a -> a Source

foldl1 :: (a -> a -> a) -> AnnProvenance a -> a Source

toList :: AnnProvenance a -> [a] Source

null :: AnnProvenance a -> Bool Source

length :: AnnProvenance a -> Int Source

elem :: Eq a => a -> AnnProvenance a -> Bool Source

maximum :: Ord a => AnnProvenance a -> a Source

minimum :: Ord a => AnnProvenance a -> a Source

sum :: Num a => AnnProvenance a -> a Source

product :: Num a => AnnProvenance a -> a Source

Traversable AnnProvenance 

Methods

traverse :: Applicative f => (a -> f b) -> AnnProvenance a -> f (AnnProvenance b) Source

sequenceA :: Applicative f => AnnProvenance (f a) -> f (AnnProvenance a) Source

mapM :: Monad m => (a -> m b) -> AnnProvenance a -> m (AnnProvenance b) Source

sequence :: Monad m => AnnProvenance (m a) -> m (AnnProvenance a) Source

Data name => Data (AnnProvenance name) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnProvenance name -> c (AnnProvenance name) Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnProvenance name) Source

toConstr :: AnnProvenance name -> Constr Source

dataTypeOf :: AnnProvenance name -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (AnnProvenance name)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AnnProvenance name)) Source

gmapT :: (forall b. Data b => b -> b) -> AnnProvenance name -> AnnProvenance name Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance name -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance name -> r Source

gmapQ :: (forall d. Data d => d -> u) -> AnnProvenance name -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnProvenance name -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnProvenance name -> m (AnnProvenance name) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance name -> m (AnnProvenance name) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance name -> m (AnnProvenance name) Source

Role annotations

data RoleAnnotDecl name Source

Instances

Data name => Data (RoleAnnotDecl name) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RoleAnnotDecl name -> c (RoleAnnotDecl name) Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RoleAnnotDecl name) Source

toConstr :: RoleAnnotDecl name -> Constr Source

dataTypeOf :: RoleAnnotDecl name -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (RoleAnnotDecl name)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RoleAnnotDecl name)) Source

gmapT :: (forall b. Data b => b -> b) -> RoleAnnotDecl name -> RoleAnnotDecl name Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RoleAnnotDecl name -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RoleAnnotDecl name -> r Source

gmapQ :: (forall d. Data d => d -> u) -> RoleAnnotDecl name -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> RoleAnnotDecl name -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RoleAnnotDecl name -> m (RoleAnnotDecl name) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RoleAnnotDecl name -> m (RoleAnnotDecl name) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RoleAnnotDecl name -> m (RoleAnnotDecl name) Source

OutputableBndr name => Outputable (RoleAnnotDecl name) 

Injective type families

data FamilyResultSig name Source

Instances

DataId name => Data (FamilyResultSig name) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamilyResultSig name -> c (FamilyResultSig name) Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FamilyResultSig name) Source

toConstr :: FamilyResultSig name -> Constr Source

dataTypeOf :: FamilyResultSig name -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (FamilyResultSig name)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FamilyResultSig name)) Source

gmapT :: (forall b. Data b => b -> b) -> FamilyResultSig name -> FamilyResultSig name Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamilyResultSig name -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamilyResultSig name -> r Source

gmapQ :: (forall d. Data d => d -> u) -> FamilyResultSig name -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> FamilyResultSig name -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamilyResultSig name -> m (FamilyResultSig name) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyResultSig name -> m (FamilyResultSig name) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyResultSig name -> m (FamilyResultSig name) Source

data InjectivityAnn name Source

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

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

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

Instances

Data name => Data (InjectivityAnn name) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InjectivityAnn name -> c (InjectivityAnn name) Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (InjectivityAnn name) Source

toConstr :: InjectivityAnn name -> Constr Source

dataTypeOf :: InjectivityAnn name -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (InjectivityAnn name)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (InjectivityAnn name)) Source

gmapT :: (forall b. Data b => b -> b) -> InjectivityAnn name -> InjectivityAnn name Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityAnn name -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityAnn name -> r Source

gmapQ :: (forall d. Data d => d -> u) -> InjectivityAnn name -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> InjectivityAnn name -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InjectivityAnn name -> m (InjectivityAnn name) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityAnn name -> m (InjectivityAnn name) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityAnn name -> m (InjectivityAnn name) Source

resultVariableName :: FamilyResultSig a -> Maybe a Source

Maybe return name of the result type variable

Grouping

data HsGroup id Source

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

Instances

DataId id => Data (HsGroup id) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsGroup id -> c (HsGroup id) Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsGroup id) Source

toConstr :: HsGroup id -> Constr Source

dataTypeOf :: HsGroup id -> DataType Source

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (HsGroup id)) Source

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsGroup id)) Source

gmapT :: (forall b. Data b => b -> b) -> HsGroup id -> HsGroup id Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsGroup id -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsGroup id -> r Source

gmapQ :: (forall d. Data d => d -> u) -> HsGroup id -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsGroup id -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsGroup id -> m (HsGroup id) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGroup id -> m (HsGroup id) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGroup id -> m (HsGroup id) Source

OutputableBndr name => Outputable (HsGroup name) 

Methods

ppr :: HsGroup name -> SDoc Source

pprPrec :: Rational -> HsGroup name -> SDoc Source