HsDecls

Abstract syntax of global declarations.

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

Toplevel declarations

data HsDecl id

A Haskell Declaration

Constructors

TyClD (TyClDecl id)

Type or Class Declaration

InstD (InstDecl id)

Instance declaration

DerivD (DerivDecl id)

Deriving declaration

ValD (HsBind id)

Value declaration

SigD (Sig id)

Signature declaration

DefD (DefaultDecl id)

'default' declaration

ForD (ForeignDecl id)

Foreign declaration

WarningD (WarnDecls id)

Warning declaration

AnnD (AnnDecl id)

Annotation declaration

RuleD (RuleDecls id)

Rule declaration

VectD (VectDecl id)

Vectorise declaration

SpliceD (SpliceDecl id)

Splice declaration (Includes quasi-quotes)

DocD DocDecl

Documentation comment declaration

RoleAnnotD (RoleAnnotDecl id)

Role annotation declaration

Instances

DataId id => Data (HsDecl id)

Methods

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

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

toConstr :: HsDecl id -> Constr

dataTypeOf :: HsDecl id -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndrId name => Outputable (HsDecl name)

Methods

ppr :: HsDecl name -> SDoc

pprPrec :: Rational -> HsDecl name -> SDoc

type LHsDecl id

Arguments

 = Located (HsDecl id)

When in a list this may have

• AnnKeywordId : AnnSemi

data HsDataDefn name

Haskell Data type Definition

Constructors

HsDataDefn

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

Fields

• dd_ND :: NewOrData
• dd_ctxt :: LHsContext name

  Context

• dd_cType :: Maybe (Located CType)
• dd_kindSig :: Maybe (LHsKind name)

  Optional kind signature.

  (Just k) for a GADT-style data, or data instance decl, with explicit kind sig

  Always Nothing for H98-syntax decls

• dd_cons :: [LConDecl name]

  Data constructors

  For data T a = T1 | T2 a the LConDecls all have ConDeclH98. For data T a where { T1 :: T a } the LConDecls all have ConDeclGADT.

• dd_derivs :: HsDeriving name

  Optional 'deriving' claues

Instances

DataId id => Data (HsDataDefn id)

Methods

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

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

toConstr :: HsDataDefn id -> Constr

dataTypeOf :: HsDataDefn id -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndrId name => Outputable (HsDataDefn name)

Methods

ppr :: HsDataDefn name -> SDoc

pprPrec :: Rational -> HsDataDefn name -> SDoc

type HsDeriving name

Arguments

 = Located [LHsDerivingClause name]

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

The list of LHsDerivingClauses corresponds to exactly what the user requested to derive, in order. If no deriving clauses were specified, the list is empty.

Haskell Deriving clause

data HsDerivingClause name

A single deriving clause of a data declaration.

• AnnKeywordId : AnnDeriving, AnnStock, AnnAnyClass, AnnNewtype, AnnOpen,AnnClose

Constructors

HsDerivingClause

Fields

• deriv_clause_strategy :: Maybe (Located DerivStrategy)

  The user-specified strategy (if any) to use when deriving deriv_clause_tys.

• deriv_clause_tys :: Located [LHsSigType name]

  The types to derive.

  It uses LHsSigTypes because, with -XGeneralizedNewtypeDeriving, we can mention type variables that aren't bound by the datatype, e.g.

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

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

Instances

DataId id => Data (HsDerivingClause id)

Methods

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

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

toConstr :: HsDerivingClause id -> Constr

dataTypeOf :: HsDerivingClause id -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndrId name => Outputable (HsDerivingClause name)

Methods

ppr :: HsDerivingClause name -> SDoc

pprPrec :: Rational -> HsDerivingClause name -> SDoc

type LHsDerivingClause name = Located (HsDerivingClause name)

Class or type declarations

data TyClDecl name

A type or class declaration.

Constructors

FamDecl

type/data family T :: *->*

• AnnKeywordId : AnnType, AnnData, AnnFamily,AnnDcolon, AnnWhere,AnnOpenP, AnnDcolon,AnnCloseP, AnnEqual,AnnRarrow, AnnVbar

Fields

• tcdFam :: FamilyDecl name

SynDecl

type declaration

• AnnKeywordId : AnnType, AnnEqual,

Fields

• tcdLName :: Located name

  Type constructor

• tcdTyVars :: LHsQTyVars name

  Type variables; for an associated type these include outer binders

• tcdFixity :: LexicalFixity

  Fixity used in the declaration

• tcdRhs :: LHsType name

  RHS of type declaration

• tcdFVs :: PostRn name NameSet

DataDecl

data declaration

• AnnKeywordId : AnnData, AnnFamily, AnnNewType, AnnNewType,AnnDcolon AnnWhere,

Fields

• tcdLName :: Located name

  Type constructor

• tcdTyVars :: LHsQTyVars name

  Type variables; for an associated type these include outer binders

• tcdFixity :: LexicalFixity

  Fixity used in the declaration

• tcdDataDefn :: HsDataDefn name
• tcdDataCusk :: PostRn name Bool

  does this have a CUSK?

• tcdFVs :: PostRn name NameSet

ClassDecl

• AnnKeywordId : AnnClass, AnnWhere,AnnOpen, AnnClose
• The tcdFDs will have AnnVbar, AnnComma AnnRarrow

Fields

• tcdCtxt :: LHsContext name

  Context...

• tcdLName :: Located name

  Type constructor

• tcdTyVars :: LHsQTyVars name

  Type variables; for an associated type these include outer binders

• tcdFixity :: LexicalFixity

  Fixity used in the declaration

• tcdFDs :: [Located (FunDep (Located name))]

  Functional deps

• tcdSigs :: [LSig name]

  Methods' signatures

• tcdMeths :: LHsBinds name

  Default methods

• tcdATs :: [LFamilyDecl name]

  Associated types;

• tcdATDefs :: [LTyFamDefltEqn name]

  Associated type defaults

• tcdDocs :: [LDocDecl]

  Haddock docs

• tcdFVs :: PostRn name NameSet

Instances

DataId id => Data (TyClDecl id)

Methods

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

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

toConstr :: TyClDecl id -> Constr

dataTypeOf :: TyClDecl id -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndrId name => Outputable (TyClDecl name)

Methods

ppr :: TyClDecl name -> SDoc

pprPrec :: Rational -> TyClDecl name -> SDoc

type LTyClDecl name = Located (TyClDecl name)

Located Declaration of a Type or Class

data TyClGroup name

Type or Class Group

Constructors

TyClGroup

Fields

• group_tyclds :: [LTyClDecl name]
• group_roles :: [LRoleAnnotDecl name]
• group_instds :: [LInstDecl name]

Instances

DataId id => Data (TyClGroup id)

Methods

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

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

toConstr :: TyClGroup id -> Constr

dataTypeOf :: TyClGroup id -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndrId name => Outputable (TyClGroup name)

Methods

ppr :: TyClGroup name -> SDoc

pprPrec :: Rational -> TyClGroup name -> SDoc

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

emptyTyClGroup :: TyClGroup name

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

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

tyClGroupRoleDecls :: [TyClGroup name] -> [LRoleAnnotDecl 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

tyFamInstDeclName :: TyFamInstDecl name -> name

tyFamInstDeclLName :: TyFamInstDecl name -> Located name

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

pprTyClDeclFlavour :: TyClDecl a -> SDoc

tyClDeclLName :: TyClDecl name -> Located name

tyClDeclTyVars :: TyClDecl name -> LHsQTyVars name

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

type Family Declaration

Constructors

FamilyDecl

• AnnKeywordId : AnnType, AnnData, AnnFamily, AnnWhere, AnnOpenP, AnnDcolon, AnnCloseP, AnnEqual, AnnRarrow, AnnVbar

Fields

• fdInfo :: FamilyInfo name
• fdLName :: Located name
• fdTyVars :: LHsQTyVars name
• fdFixity :: LexicalFixity
• fdResultSig :: LFamilyResultSig name
• fdInjectivityAnn :: Maybe (LInjectivityAnn name)

Instances

DataId id => Data (FamilyDecl id)

Methods

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

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

toConstr :: FamilyDecl id -> Constr

dataTypeOf :: FamilyDecl id -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndrId name => Outputable (FamilyDecl name)

Methods

ppr :: FamilyDecl name -> SDoc

pprPrec :: Rational -> FamilyDecl name -> SDoc

type LFamilyDecl name = Located (FamilyDecl name)

Located type Family Declaration

Instance declarations

data InstDecl name

Instance Declaration

Constructors

ClsInstD

Fields

• cid_inst :: ClsInstDecl name

DataFamInstD

Fields

• dfid_inst :: DataFamInstDecl name

TyFamInstD

Fields

• tfid_inst :: TyFamInstDecl name

Instances

DataId id => Data (InstDecl id)

Methods

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

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

toConstr :: InstDecl id -> Constr

dataTypeOf :: InstDecl id -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndrId name => Outputable (InstDecl name)

Methods

ppr :: InstDecl name -> SDoc

pprPrec :: Rational -> InstDecl name -> SDoc

type LInstDecl name = Located (InstDecl name)

Located Instance Declaration

data NewOrData

Constructors

NewType

newtype Blah ...

DataType

data Blah ...

Instances

Eq NewOrData

Methods

(==) :: NewOrData -> NewOrData -> Bool

(/=) :: NewOrData -> NewOrData -> Bool

Data NewOrData

Methods

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

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

toConstr :: NewOrData -> Constr

dataTypeOf :: NewOrData -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable NewOrData

Methods

ppr :: NewOrData -> SDoc

pprPrec :: Rational -> NewOrData -> SDoc

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)

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

toConstr :: FamilyInfo name -> Constr

dataTypeOf :: FamilyInfo name -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable (FamilyInfo name)

Methods

ppr :: FamilyInfo name -> SDoc

pprPrec :: Rational -> FamilyInfo name -> SDoc

data TyFamInstDecl name

Type Family Instance Declaration

Constructors

TyFamInstDecl

• AnnKeywordId : AnnType, AnnInstance,

Fields

• tfid_eqn :: LTyFamInstEqn name
• tfid_fvs :: PostRn name NameSet

Instances

DataId name => Data (TyFamInstDecl name)

Methods

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

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

toConstr :: TyFamInstDecl name -> Constr

dataTypeOf :: TyFamInstDecl name -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndrId name => Outputable (TyFamInstDecl name)

Methods

ppr :: TyFamInstDecl name -> SDoc

pprPrec :: Rational -> TyFamInstDecl name -> SDoc

type LTyFamInstDecl name = Located (TyFamInstDecl name)

Located Type Family Instance Declaration

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

data DataFamInstDecl name

Data Family Instance Declaration

Constructors

DataFamInstDecl

• AnnKeywordId : AnnData, AnnNewType,AnnInstance, AnnDcolon AnnWhere,AnnOpen, AnnClose

Fields

• dfid_tycon :: Located name
• dfid_pats :: HsTyPats name
• dfid_fixity :: LexicalFixity

  Fixity used in the declaration

• dfid_defn :: HsDataDefn name
• dfid_fvs :: PostRn name NameSet

Instances

DataId name => Data (DataFamInstDecl name)

Methods

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

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

toConstr :: DataFamInstDecl name -> Constr

dataTypeOf :: DataFamInstDecl name -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndrId name => Outputable (DataFamInstDecl name)

Methods

ppr :: DataFamInstDecl name -> SDoc

pprPrec :: Rational -> DataFamInstDecl name -> SDoc

type LDataFamInstDecl name = Located (DataFamInstDecl name)

Located Data Family Instance Declaration

pprDataFamInstFlavour :: DataFamInstDecl name -> SDoc

data TyFamEqn name pats

Type Family Equation

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

Constructors

TyFamEqn

• AnnKeywordId : AnnEqual

Fields

• tfe_tycon :: Located name
• tfe_pats :: pats
• tfe_fixity :: LexicalFixity

  Fixity used in the declaration

• tfe_rhs :: LHsType name

Instances

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

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)

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

toConstr :: TyFamEqn name pats -> Constr

dataTypeOf :: TyFamEqn name pats -> DataType

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

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

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

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

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

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

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

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

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

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

type TyFamInstEqn name = TyFamEqn name (HsTyPats name)

Type Family Instance Equation

type LTyFamInstEqn name

Arguments

 = Located (TyFamInstEqn name)

May have AnnKeywordId : AnnSemi when in a list

Located Type Family Instance Equation

type TyFamDefltEqn name = TyFamEqn name (LHsQTyVars name)

Type Family Default Equation

type LTyFamDefltEqn name = Located (TyFamDefltEqn name)

Located Type Family Default Equation

type HsTyPats name

Arguments

 = HsImplicitBndrs name [LHsType name]

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

Haskell Type Patterns

type LClsInstDecl name = Located (ClsInstDecl name)

Located Class Instance Declaration

data ClsInstDecl name

Class Instance Declaration

Constructors

ClsInstDecl

• AnnKeywordId : AnnInstance, AnnWhere, AnnOpen,AnnClose,

Fields

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

Instances

DataId id => Data (ClsInstDecl id)

Methods

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

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

toConstr :: ClsInstDecl id -> Constr

dataTypeOf :: ClsInstDecl id -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndrId name => Outputable (ClsInstDecl name)

Methods

ppr :: ClsInstDecl name -> SDoc

pprPrec :: Rational -> ClsInstDecl name -> SDoc

Standalone deriving declarations

data DerivDecl name

Deriving Declaration

Constructors

DerivDecl

Fields

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

Instances

DataId name => Data (DerivDecl name)

Methods

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

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

toConstr :: DerivDecl name -> Constr

dataTypeOf :: DerivDecl name -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndrId name => Outputable (DerivDecl name)

Methods

ppr :: DerivDecl name -> SDoc

pprPrec :: Rational -> DerivDecl name -> SDoc

type LDerivDecl name = Located (DerivDecl name)

Located Deriving Declaration

RULE declarations

type LRuleDecls name = Located (RuleDecls name)

Located Rule Declarations

data RuleDecls name

Rule Declarations

Constructors

HsRules

Fields

• rds_src :: SourceText
• rds_rules :: [LRuleDecl name]

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)

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

toConstr :: RuleDecls name -> Constr

dataTypeOf :: RuleDecls name -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndrId name => Outputable (RuleDecls name)

Methods

ppr :: RuleDecls name -> SDoc

pprPrec :: Rational -> RuleDecls name -> SDoc

data RuleDecl name

Rule Declaration

Constructors

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

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

Instances

DataId name => Data (RuleDecl name)

Methods

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

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

toConstr :: RuleDecl name -> Constr

dataTypeOf :: RuleDecl name -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndrId name => Outputable (RuleDecl name)

Methods

ppr :: RuleDecl name -> SDoc

pprPrec :: Rational -> RuleDecl name -> SDoc

type LRuleDecl name = Located (RuleDecl name)

Located Rule Declaration

data RuleBndr name

Rule Binder

Constructors

RuleBndr (Located name)

RuleBndrSig (Located name) (LHsSigWcType name)

• AnnKeywordId : AnnOpen, AnnDcolon,AnnClose

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)

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

toConstr :: RuleBndr name -> Constr

dataTypeOf :: RuleBndr name -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndrId name => Outputable (RuleBndr name)

Methods

ppr :: RuleBndr name -> SDoc

pprPrec :: Rational -> RuleBndr name -> SDoc

type LRuleBndr name = Located (RuleBndr name)

Located Rule Binder

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

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

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

VECTORISE declarations

data VectDecl name

Vectorise Declaration

Constructors

HsVect SourceText (Located name) (LHsExpr name)

• AnnKeywordId : AnnOpen, AnnEqual,AnnClose

HsNoVect SourceText (Located name)

• AnnKeywordId : AnnOpen, AnnClose

HsVectTypeIn SourceText Bool (Located name) (Maybe (Located name))

• AnnKeywordId : AnnOpen, AnnType,AnnClose, AnnEqual

HsVectTypeOut Bool TyCon (Maybe TyCon)

HsVectClassIn SourceText (Located name)

• AnnKeywordId : AnnOpen, AnnClass,AnnClose,

HsVectClassOut Class

HsVectInstIn (LHsSigType name)

HsVectInstOut ClsInst

Instances

DataId name => Data (VectDecl name)

Methods

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

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

toConstr :: VectDecl name -> Constr

dataTypeOf :: VectDecl name -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndrId name => Outputable (VectDecl name)

Methods

ppr :: VectDecl name -> SDoc

pprPrec :: Rational -> VectDecl name -> SDoc

type LVectDecl name = Located (VectDecl name)

Located Vectorise Declaration

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

lvectInstDecl :: LVectDecl name -> Bool

default declarations

data DefaultDecl name

Default Declaration

Constructors

DefaultDecl [LHsType name]

• AnnKeywordIds : AnnDefault, AnnOpen,AnnClose

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)

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

toConstr :: DefaultDecl name -> Constr

dataTypeOf :: DefaultDecl name -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndrId name => Outputable (DefaultDecl name)

Methods

ppr :: DefaultDecl name -> SDoc

pprPrec :: Rational -> DefaultDecl name -> SDoc

type LDefaultDecl name = Located (DefaultDecl name)

Located Default Declaration

Template haskell declaration splice

data SpliceExplicitFlag

Constructors

ExplicitSplice

= $(f x y)

ImplicitSplice

= f x y, i.e. a naked top level expression

Instances

Data SpliceExplicitFlag

Methods

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

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

toConstr :: SpliceExplicitFlag -> Constr

dataTypeOf :: SpliceExplicitFlag -> DataType

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

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

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

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

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

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

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

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

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

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

data SpliceDecl id

Splice Declaration

Constructors

SpliceDecl (Located (HsSplice id)) SpliceExplicitFlag

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)

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

toConstr :: SpliceDecl id -> Constr

dataTypeOf :: SpliceDecl id -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndrId name => Outputable (SpliceDecl name)

Methods

ppr :: SpliceDecl name -> SDoc

pprPrec :: Rational -> SpliceDecl name -> SDoc

type LSpliceDecl name = Located (SpliceDecl name)

Located Splice Declaration

Foreign function interface declarations

data ForeignDecl name

Foreign Declaration

Constructors

ForeignImport

Fields

• fd_name :: Located name
• fd_sig_ty :: LHsSigType name
• fd_co :: PostTc name Coercion
• fd_fi :: ForeignImport

ForeignExport

• AnnKeywordId : AnnForeign, AnnImport,AnnExport, AnnDcolon

Fields

• fd_name :: Located name
• fd_sig_ty :: LHsSigType name
• fd_co :: PostTc name Coercion
• fd_fe :: ForeignExport

Instances

DataId name => Data (ForeignDecl name)

Methods

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

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

toConstr :: ForeignDecl name -> Constr

dataTypeOf :: ForeignDecl name -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndrId name => Outputable (ForeignDecl name)

Methods

ppr :: ForeignDecl name -> SDoc

pprPrec :: Rational -> ForeignDecl name -> SDoc

type LForeignDecl name = Located (ForeignDecl name)

Located Foreign Declaration

data ForeignImport

Constructors

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

Instances

Data ForeignImport

Methods

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

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

toConstr :: ForeignImport -> Constr

dataTypeOf :: ForeignImport -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable ForeignImport

Methods

ppr :: ForeignImport -> SDoc

pprPrec :: Rational -> ForeignImport -> SDoc

data ForeignExport

Constructors

CExport (Located CExportSpec) (Located SourceText)

Instances

Data ForeignExport

Methods

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

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

toConstr :: ForeignExport -> Constr

dataTypeOf :: ForeignExport -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable ForeignExport

Methods

ppr :: ForeignExport -> SDoc

pprPrec :: Rational -> ForeignExport -> SDoc

noForeignImportCoercionYet :: PlaceHolder

noForeignExportCoercionYet :: PlaceHolder

data CImportSpec

Constructors

CLabel CLabelString

CFunction CCallTarget

CWrapper

Instances

Data CImportSpec

Methods

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

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

toConstr :: CImportSpec -> Constr

dataTypeOf :: CImportSpec -> DataType

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

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

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

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

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

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

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

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

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

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

Data-constructor declarations

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

• AnnKeywordIds : AnnOpen, AnnDotdot,AnnCLose, AnnEqual,AnnVbar, AnnDarrow,AnnDarrow, AnnForall,AnnDot

data Constructor Declaration

Constructors

ConDeclGADT

Fields

• con_names :: [Located name]
• con_type :: LHsSigType name

  The type after the ‘::’

• con_doc :: Maybe LHsDocString

  A possible Haddock comment.

ConDeclH98

Fields

• con_name :: Located name
• con_qvars :: Maybe (LHsQTyVars name)
• con_cxt :: Maybe (LHsContext name)

  User-written context (if any)

• con_details :: HsConDeclDetails name

  Arguments

• con_doc :: Maybe LHsDocString

  A possible Haddock comment.

Instances

DataId name => Data (ConDecl name)

Methods

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

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

toConstr :: ConDecl name -> Constr

dataTypeOf :: ConDecl name -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndrId name => Outputable (ConDecl name)

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

Located data Constructor Declaration

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

Haskell data Constructor Declaration Details

hsConDeclArgTys :: HsConDeclDetails name -> [LBangType name]

getConNames :: ConDecl name -> [Located name]

getConDetails :: ConDecl name -> HsConDeclDetails name

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

Document comments

data DocDecl

Documentation comment Declaration

Constructors

DocCommentNext HsDocString

DocCommentPrev HsDocString

DocCommentNamed String HsDocString

DocGroup Int HsDocString

Instances

Data DocDecl

Methods

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

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

toConstr :: DocDecl -> Constr

dataTypeOf :: DocDecl -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable DocDecl

Methods

ppr :: DocDecl -> SDoc

pprPrec :: Rational -> DocDecl -> SDoc

type LDocDecl = Located DocDecl

Located Documentation comment Declaration

docDeclDoc :: DocDecl -> HsDocString

Deprecations

data WarnDecl name

Warning pragma Declaration

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)

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

toConstr :: WarnDecl name -> Constr

dataTypeOf :: WarnDecl name -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndr name => Outputable (WarnDecl name)

Methods

ppr :: WarnDecl name -> SDoc

pprPrec :: Rational -> WarnDecl name -> SDoc

type LWarnDecl name = Located (WarnDecl name)

Located Warning pragma Declaration

data WarnDecls name

Warning pragma Declarations

Constructors

Warnings

Fields

• wd_src :: SourceText
• wd_warnings :: [LWarnDecl name]

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)

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

toConstr :: WarnDecls name -> Constr

dataTypeOf :: WarnDecls name -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndr name => Outputable (WarnDecls name)

Methods

ppr :: WarnDecls name -> SDoc

pprPrec :: Rational -> WarnDecls name -> SDoc

type LWarnDecls name = Located (WarnDecls name)

Located Warning Declarations

Annotations

data AnnDecl name

Annotation Declaration

Constructors

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

• AnnKeywordId : AnnOpen, AnnType AnnModule AnnClose

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)

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

toConstr :: AnnDecl name -> Constr

dataTypeOf :: AnnDecl name -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndrId name => Outputable (AnnDecl name)

Methods

ppr :: AnnDecl name -> SDoc

pprPrec :: Rational -> AnnDecl name -> SDoc

type LAnnDecl name = Located (AnnDecl name)

Located Annotation Declaration

data AnnProvenance name

Annotation Provenance

Constructors

ValueAnnProvenance (Located name)

TypeAnnProvenance (Located name)

ModuleAnnProvenance

Instances

Functor AnnProvenance

Methods

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

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

Foldable AnnProvenance

Methods

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

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

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

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

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

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

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

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

toList :: AnnProvenance a -> [a]

null :: AnnProvenance a -> Bool

length :: AnnProvenance a -> Int

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

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

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

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

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

Traversable AnnProvenance

Methods

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

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

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

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

Data name => Data (AnnProvenance name)

Methods

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

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

toConstr :: AnnProvenance name -> Constr

dataTypeOf :: AnnProvenance name -> DataType

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

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

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

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

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

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

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

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

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

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

annProvenanceName_maybe :: AnnProvenance name -> Maybe name

Role annotations

data RoleAnnotDecl name

Role Annotation Declaration

Constructors

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

• AnnKeywordId : AnnType, AnnRole

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)

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

toConstr :: RoleAnnotDecl name -> Constr

dataTypeOf :: RoleAnnotDecl name -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndr name => Outputable (RoleAnnotDecl name)

Methods

ppr :: RoleAnnotDecl name -> SDoc

pprPrec :: Rational -> RoleAnnotDecl name -> SDoc

type LRoleAnnotDecl name = Located (RoleAnnotDecl name)

Located Role Annotation Declaration

roleAnnotDeclName :: RoleAnnotDecl name -> name

Injective type families

data FamilyResultSig name

type Family Result Signature

Constructors

NoSig

• AnnKeywordId :

KindSig (LHsKind name)

• AnnKeywordId : AnnOpenP,AnnDcolon, AnnCloseP

TyVarSig (LHsTyVarBndr name)

• AnnKeywordId : AnnOpenP,AnnDcolon, AnnCloseP, AnnEqual

Instances

DataId name => Data (FamilyResultSig name)

Methods

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

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

toConstr :: FamilyResultSig name -> Constr

dataTypeOf :: FamilyResultSig name -> DataType

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

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

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

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

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

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

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

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

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

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

type LFamilyResultSig name = Located (FamilyResultSig name)

Located type Family Result Signature

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

Constructors

InjectivityAnn (Located name) [Located name]

• AnnKeywordId : AnnRarrow, AnnVbar

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)

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

toConstr :: InjectivityAnn name -> Constr

dataTypeOf :: InjectivityAnn name -> DataType

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

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

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

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

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

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

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

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

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

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

type LInjectivityAnn name = Located (InjectivityAnn name)

Located Injectivity Annotation

resultVariableName :: FamilyResultSig a -> Maybe a

Maybe return name of the result type variable

Grouping

data HsGroup id

Haskell Group

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

Constructors

HsGroup

Fields

• hs_valds :: HsValBinds id
• hs_splcds :: [LSpliceDecl id]
• hs_tyclds :: [TyClGroup id]
• hs_derivds :: [LDerivDecl id]
• hs_fixds :: [LFixitySig id]
• hs_defds :: [LDefaultDecl id]
• hs_fords :: [LForeignDecl id]
• hs_warnds :: [LWarnDecls id]
• hs_annds :: [LAnnDecl id]
• hs_ruleds :: [LRuleDecls id]
• hs_vects :: [LVectDecl id]
• hs_docs :: [LDocDecl]

Instances

DataId id => Data (HsGroup id)

Methods

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

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

toConstr :: HsGroup id -> Constr

dataTypeOf :: HsGroup id -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndrId name => Outputable (HsGroup name)

Methods

ppr :: HsGroup name -> SDoc

pprPrec :: Rational -> HsGroup name -> SDoc

emptyRdrGroup :: HsGroup a

emptyRnGroup :: HsGroup a

appendGroups :: HsGroup a -> HsGroup a -> HsGroup a

hsGroupInstDecls :: HsGroup id -> [LInstDecl id]