ghc-8.0.2: 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 #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (HsDecl id)) Source #

dataCast2 :: Typeable (* -> * -> *) 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 #

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

type LHsDecl id #

Arguments

 = Located (HsDecl id)

When in a list this may have

data HsDataDefn name #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (HsDataDefn id)) Source #

dataCast2 :: Typeable (* -> * -> *) 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 #

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

type HsDeriving name #

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 #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (TyClDecl id)) Source #

dataCast2 :: Typeable (* -> * -> *) 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 #

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

type LTyClDecl name = Located (TyClDecl name) #

data TyClGroup name #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (TyClGroup id)) Source #

dataCast2 :: Typeable (* -> * -> *) 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 #

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

tyClGroupConcat :: [TyClGroup name] -> [LTyClDecl name] #

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

isClassDecl :: TyClDecl name -> Bool #

type class

isDataDecl :: TyClDecl name -> Bool #

True = argument is a data/newtype declaration.

isSynDecl :: TyClDecl name -> Bool #

type or type instance declaration

tcdName :: TyClDecl name -> name #

isFamilyDecl :: TyClDecl name -> Bool #

type/data family declaration

isTypeFamilyDecl :: TyClDecl name -> Bool #

type family declaration

isDataFamilyDecl :: TyClDecl name -> Bool #

data family declaration

isOpenTypeFamilyInfo :: FamilyInfo name -> Bool #

open type family info

isClosedTypeFamilyInfo :: FamilyInfo name -> Bool #

closed type family info

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

hsDeclHasCusk :: TyClDecl Name -> Bool #

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

famDeclHasCusk #

Arguments

:: Maybe Bool

if associated, does the enclosing class have a CUSK?

-> FamilyDecl name 
-> Bool 

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

data FamilyDecl name #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (FamilyDecl id)) Source #

dataCast2 :: Typeable (* -> * -> *) 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 #

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

type LFamilyDecl name = Located (FamilyDecl name) #

Instance declarations

data InstDecl name #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (InstDecl id)) Source #

dataCast2 :: Typeable (* -> * -> *) 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 #

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

type LInstDecl name = Located (InstDecl name) #

data NewOrData #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c NewOrData) Source #

dataCast2 :: Typeable (* -> * -> *) 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 #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (FamilyInfo name)) Source #

dataCast2 :: Typeable (* -> * -> *) 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 #

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

data TyFamInstDecl name #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (TyFamInstDecl name)) Source #

dataCast2 :: Typeable (* -> * -> *) 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) # 

Methods

ppr :: TyFamInstDecl name -> SDoc #

pprPrec :: Rational -> TyFamInstDecl name -> SDoc #

data DataFamInstDecl name #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (DataFamInstDecl name)) Source #

dataCast2 :: Typeable (* -> * -> *) 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) # 

Methods

ppr :: DataFamInstDecl name -> SDoc #

pprPrec :: Rational -> DataFamInstDecl name -> SDoc #

data TyFamEqn name pats #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (TyFamEqn name pats)) Source #

dataCast2 :: Typeable (* -> * -> *) 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) #

type LTyFamInstEqn name #

Arguments

 = Located (TyFamInstEqn name)

May have AnnKeywordId : AnnSemi when in a list

type TyFamDefltEqn name = TyFamEqn name (LHsQTyVars name) #

type HsTyPats name #

Arguments

 = HsImplicitBndrs name [LHsType name]

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

type LClsInstDecl name = Located (ClsInstDecl name) #

data ClsInstDecl name #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (ClsInstDecl id)) Source #

dataCast2 :: Typeable (* -> * -> *) 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) # 

Methods

ppr :: ClsInstDecl name -> SDoc #

pprPrec :: Rational -> ClsInstDecl name -> SDoc #

Standalone deriving declarations

data DerivDecl name #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (DerivDecl name)) Source #

dataCast2 :: Typeable (* -> * -> *) 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 #

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

type LDerivDecl name = Located (DerivDecl name) #

RULE declarations

type LRuleDecls name = Located (RuleDecls name) #

data RuleDecls name #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (RuleDecls name)) Source #

dataCast2 :: Typeable (* -> * -> *) 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 #

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

data RuleDecl name #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (RuleDecl name)) Source #

dataCast2 :: Typeable (* -> * -> *) 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 #

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

type LRuleDecl name = Located (RuleDecl name) #

data RuleBndr name #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (RuleBndr name)) Source #

dataCast2 :: Typeable (* -> * -> *) 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 #

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

type LRuleBndr name = Located (RuleBndr name) #

VECTORISE declarations

data VectDecl name #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (VectDecl name)) Source #

dataCast2 :: Typeable (* -> * -> *) 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 #

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

type LVectDecl name = Located (VectDecl name) #

default declarations

data DefaultDecl name #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (DefaultDecl name)) Source #

dataCast2 :: Typeable (* -> * -> *) 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) # 

Methods

ppr :: DefaultDecl name -> SDoc #

pprPrec :: Rational -> DefaultDecl name -> SDoc #

type LDefaultDecl name = Located (DefaultDecl name) #

Template haskell declaration splice

data SpliceExplicitFlag #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SpliceExplicitFlag) Source #

dataCast2 :: Typeable (* -> * -> *) 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 #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (SpliceDecl id)) Source #

dataCast2 :: Typeable (* -> * -> *) 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 #

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

type LSpliceDecl name = Located (SpliceDecl name) #

Foreign function interface declarations

data ForeignDecl name #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (ForeignDecl name)) Source #

dataCast2 :: Typeable (* -> * -> *) 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) # 

Methods

ppr :: ForeignDecl name -> SDoc #

pprPrec :: Rational -> ForeignDecl name -> SDoc #

type LForeignDecl name = Located (ForeignDecl name) #

data ForeignImport #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ForeignImport) Source #

dataCast2 :: Typeable (* -> * -> *) 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 #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ForeignExport) Source #

dataCast2 :: Typeable (* -> * -> *) 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 #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c CImportSpec) Source #

dataCast2 :: Typeable (* -> * -> *) 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 #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (ConDecl name)) Source #

dataCast2 :: Typeable (* -> * -> *) 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 #

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

type LConDecl name #

Arguments

 = Located (ConDecl name)

May have AnnKeywordId : AnnSemi when in a GADT constructor list

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

Document comments

data DocDecl #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c DocDecl) Source #

dataCast2 :: Typeable (* -> * -> *) 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 # 

Methods

ppr :: DocDecl -> SDoc #

pprPrec :: Rational -> DocDecl -> SDoc #

Deprecations

data WarnDecl name #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (WarnDecl name)) Source #

dataCast2 :: Typeable (* -> * -> *) 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 #

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

type LWarnDecl name = Located (WarnDecl name) #

data WarnDecls name #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (WarnDecls name)) Source #

dataCast2 :: Typeable (* -> * -> *) 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 #

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

type LWarnDecls name = Located (WarnDecls name) #

Annotations

data AnnDecl name #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (AnnDecl name)) Source #

dataCast2 :: Typeable (* -> * -> *) 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 #

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

type LAnnDecl name = Located (AnnDecl name) #

data AnnProvenance name #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (AnnProvenance name)) Source #

dataCast2 :: Typeable (* -> * -> *) 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 #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (RoleAnnotDecl name)) Source #

dataCast2 :: Typeable (* -> * -> *) 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) # 

Methods

ppr :: RoleAnnotDecl name -> SDoc #

pprPrec :: Rational -> RoleAnnotDecl name -> SDoc #

Injective type families

data FamilyResultSig name #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (FamilyResultSig name)) Source #

dataCast2 :: Typeable (* -> * -> *) 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 #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (InjectivityAnn name)) Source #

dataCast2 :: Typeable (* -> * -> *) 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 #

Maybe return name of the result type variable

Grouping

data HsGroup id #

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (HsGroup id)) Source #

dataCast2 :: Typeable (* -> * -> *) 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 #

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