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)

(SourceTextX pass, OutputableBndrId pass) => Outputable (HsDecl pass)

Methods

ppr :: HsDecl pass -> SDoc

pprPrec :: Rational -> HsDecl pass -> SDoc

type LHsDecl id

Arguments

 = Located (HsDecl id)

When in a list this may have

• AnnKeywordId : AnnSemi

data HsDataDefn pass

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 pass

  Context

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

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

  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 pass

  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)

(SourceTextX pass, OutputableBndrId pass) => Outputable (HsDataDefn pass)

Methods

ppr :: HsDataDefn pass -> SDoc

pprPrec :: Rational -> HsDataDefn pass -> SDoc

type HsDeriving pass

Arguments

 = Located [LHsDerivingClause pass]

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

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

Haskell Deriving clause

data HsDerivingClause pass

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

  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)

(SourceTextX pass, OutputableBndrId pass) => Outputable (HsDerivingClause pass)

Methods

ppr :: HsDerivingClause pass -> SDoc

pprPrec :: Rational -> HsDerivingClause pass -> SDoc

type LHsDerivingClause pass = Located (HsDerivingClause pass)

Class or type declarations

data TyClDecl pass

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 pass

SynDecl

type declaration

• AnnKeywordId : AnnType, AnnEqual,

Fields

• tcdLName :: Located (IdP pass)

  Type constructor

• tcdTyVars :: LHsQTyVars pass

  Type variables; for an associated type these include outer binders

• tcdFixity :: LexicalFixity

  Fixity used in the declaration

• tcdRhs :: LHsType pass

  RHS of type declaration

• tcdFVs :: PostRn pass NameSet

DataDecl

data declaration

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

Fields

• tcdLName :: Located (IdP pass)

  Type constructor

• tcdTyVars :: LHsQTyVars pass

  Type variables; for an associated type these include outer binders

• tcdFixity :: LexicalFixity

  Fixity used in the declaration

• tcdDataDefn :: HsDataDefn pass
• tcdDataCusk :: PostRn pass Bool

  does this have a CUSK?

• tcdFVs :: PostRn pass NameSet

ClassDecl

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

Fields

• tcdCtxt :: LHsContext pass

  Context...

• tcdLName :: Located (IdP pass)

  Type constructor

• tcdTyVars :: LHsQTyVars pass

  Type variables; for an associated type these include outer binders

• tcdFixity :: LexicalFixity

  Fixity used in the declaration

• tcdFDs :: [Located (FunDep (Located (IdP pass)))]

  Functional deps

• tcdSigs :: [LSig pass]

  Methods' signatures

• tcdMeths :: LHsBinds pass

  Default methods

• tcdATs :: [LFamilyDecl pass]

  Associated types;

• tcdATDefs :: [LTyFamDefltEqn pass]

  Associated type defaults

• tcdDocs :: [LDocDecl]

  Haddock docs

• tcdFVs :: PostRn pass 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)

(SourceTextX pass, OutputableBndrId pass) => Outputable (TyClDecl pass)

Methods

ppr :: TyClDecl pass -> SDoc

pprPrec :: Rational -> TyClDecl pass -> SDoc

type LTyClDecl pass = Located (TyClDecl pass)

Located Declaration of a Type or Class

data TyClGroup pass

Type or Class Group

Constructors

TyClGroup

Fields

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

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)

(SourceTextX pass, OutputableBndrId pass) => Outputable (TyClGroup pass)

Methods

ppr :: TyClGroup pass -> SDoc

pprPrec :: Rational -> TyClGroup pass -> SDoc

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

emptyTyClGroup :: TyClGroup pass

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

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

tyClGroupRoleDecls :: [TyClGroup pass] -> [LRoleAnnotDecl pass]

isClassDecl :: TyClDecl pass -> Bool

type class

isDataDecl :: TyClDecl pass -> Bool

True = argument is a data/newtype declaration.

isSynDecl :: TyClDecl pass -> Bool

type or type instance declaration

tcdName :: TyClDecl pass -> IdP pass

isFamilyDecl :: TyClDecl pass -> Bool

type/data family declaration

isTypeFamilyDecl :: TyClDecl pass -> Bool

type family declaration

isDataFamilyDecl :: TyClDecl pass -> Bool

data family declaration

isOpenTypeFamilyInfo :: FamilyInfo pass -> Bool

open type family info

isClosedTypeFamilyInfo :: FamilyInfo pass -> Bool

closed type family info

tyFamInstDeclName :: TyFamInstDecl pass -> IdP pass

tyFamInstDeclLName :: TyFamInstDecl pass -> Located (IdP pass)

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

pprTyClDeclFlavour :: TyClDecl a -> SDoc

tyClDeclLName :: TyClDecl pass -> Located (IdP pass)

tyClDeclTyVars :: TyClDecl pass -> LHsQTyVars pass

hsDeclHasCusk :: TyClDecl GhcRn -> 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 pass

-> Bool

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

data FamilyDecl pass

type Family Declaration

Constructors

FamilyDecl

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

Fields

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

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)

(SourceTextX pass, OutputableBndrId pass) => Outputable (FamilyDecl pass)

Methods

ppr :: FamilyDecl pass -> SDoc

pprPrec :: Rational -> FamilyDecl pass -> SDoc

type LFamilyDecl pass = Located (FamilyDecl pass)

Located type Family Declaration

Instance declarations

data InstDecl pass

Instance Declaration

Constructors

ClsInstD

Fields

• cid_inst :: ClsInstDecl pass

DataFamInstD

Fields

• dfid_inst :: DataFamInstDecl pass

TyFamInstD

Fields

• tfid_inst :: TyFamInstDecl pass

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)

(SourceTextX pass, OutputableBndrId pass) => Outputable (InstDecl pass)

Methods

ppr :: InstDecl pass -> SDoc

pprPrec :: Rational -> InstDecl pass -> SDoc

type LInstDecl pass = Located (InstDecl pass)

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 pass

Constructors

DataFamily

OpenTypeFamily

ClosedTypeFamily (Maybe [LTyFamInstEqn pass])

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

Instances

DataId pass => Data (FamilyInfo pass)

Methods

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

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

toConstr :: FamilyInfo pass -> Constr

dataTypeOf :: FamilyInfo pass -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable (FamilyInfo pass)

Methods

ppr :: FamilyInfo pass -> SDoc

pprPrec :: Rational -> FamilyInfo pass -> SDoc

newtype TyFamInstDecl pass

Type Family Instance Declaration

Constructors

TyFamInstDecl

• AnnKeywordId : AnnType, AnnInstance,

Fields

• tfid_eqn :: TyFamInstEqn pass

Instances

DataId pass => Data (TyFamInstDecl pass)

Methods

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

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

toConstr :: TyFamInstDecl pass -> Constr

dataTypeOf :: TyFamInstDecl pass -> DataType

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

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

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

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

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

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

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

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

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

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

(SourceTextX pass, OutputableBndrId pass) => Outputable (TyFamInstDecl pass)

Methods

ppr :: TyFamInstDecl pass -> SDoc

pprPrec :: Rational -> TyFamInstDecl pass -> SDoc

type LTyFamInstDecl pass = Located (TyFamInstDecl pass)

Located Type Family Instance Declaration

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

newtype DataFamInstDecl pass

Data Family Instance Declaration

Constructors

DataFamInstDecl

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

Fields

• dfid_eqn :: FamInstEqn pass (HsDataDefn pass)

Instances

DataId pass => Data (DataFamInstDecl pass)

Methods

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

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

toConstr :: DataFamInstDecl pass -> Constr

dataTypeOf :: DataFamInstDecl pass -> DataType

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

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

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

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

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

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

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

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

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

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

(SourceTextX pass, OutputableBndrId pass) => Outputable (DataFamInstDecl pass)

Methods

ppr :: DataFamInstDecl pass -> SDoc

pprPrec :: Rational -> DataFamInstDecl pass -> SDoc

type LDataFamInstDecl pass = Located (DataFamInstDecl pass)

Located Data Family Instance Declaration

pprDataFamInstFlavour :: DataFamInstDecl pass -> SDoc

pprFamInstLHS :: (SourceTextX pass, OutputableBndrId pass) => Located (IdP pass) -> HsTyPats pass -> LexicalFixity -> HsContext pass -> Maybe (LHsKind pass) -> SDoc

type FamInstEqn pass rhs

Arguments

 = HsImplicitBndrs pass (FamEqn pass (HsTyPats pass) rhs)

Here, the pats are type patterns (with kind and type bndrs). See Note [Family instance declaration binders]

Family Instance Equation

type LFamInstEqn pass rhs = Located (FamInstEqn pass rhs)

Located Family Instance Equation

data FamEqn pass pats rhs

Family Equation

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

Constructors

FamEqn

• AnnKeywordId : AnnEqual

Fields

• feqn_tycon :: Located (IdP pass)
• feqn_pats :: pats
• feqn_fixity :: LexicalFixity

  Fixity used in the declaration

• feqn_rhs :: rhs

Instances

(DataId pass, Data pats, Data rhs) => Data (FamEqn pass pats rhs)

Methods

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

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

toConstr :: FamEqn pass pats rhs -> Constr

dataTypeOf :: FamEqn pass pats rhs -> DataType

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

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

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

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

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

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

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

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

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

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

type TyFamInstEqn pass = FamInstEqn pass (LHsType pass)

Type Family Instance Equation

type LTyFamInstEqn pass

Arguments

 = Located (TyFamInstEqn pass)

May have AnnKeywordId : AnnSemi when in a list

Located Type Family Instance Equation

type TyFamDefltEqn pass = FamEqn pass (LHsQTyVars pass) (LHsType pass)

Type Family Default Equation

type LTyFamDefltEqn pass = Located (TyFamDefltEqn pass)

Located Type Family Default Equation

type HsTyPats pass = [LHsType pass]

Haskell Type Patterns

type LClsInstDecl pass = Located (ClsInstDecl pass)

Located Class Instance Declaration

data ClsInstDecl pass

Class Instance Declaration

Constructors

ClsInstDecl

• AnnKeywordId : AnnInstance, AnnWhere, AnnOpen,AnnClose,

Fields

• cid_poly_ty :: LHsSigType pass
• cid_binds :: LHsBinds pass
• cid_sigs :: [LSig pass]
• cid_tyfam_insts :: [LTyFamInstDecl pass]
• cid_datafam_insts :: [LDataFamInstDecl pass]
• 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)

(SourceTextX pass, OutputableBndrId pass) => Outputable (ClsInstDecl pass)

Methods

ppr :: ClsInstDecl pass -> SDoc

pprPrec :: Rational -> ClsInstDecl pass -> SDoc

Standalone deriving declarations

data DerivDecl pass

Deriving Declaration

Constructors

DerivDecl

Fields

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

Instances

DataId pass => Data (DerivDecl pass)

Methods

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

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

toConstr :: DerivDecl pass -> Constr

dataTypeOf :: DerivDecl pass -> DataType

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

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

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

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

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

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

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

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

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

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

(SourceTextX pass, OutputableBndrId pass) => Outputable (DerivDecl pass)

Methods

ppr :: DerivDecl pass -> SDoc

pprPrec :: Rational -> DerivDecl pass -> SDoc

type LDerivDecl pass = Located (DerivDecl pass)

Located Deriving Declaration

RULE declarations

type LRuleDecls pass = Located (RuleDecls pass)

Located Rule Declarations

data RuleDecls pass

Rule Declarations

Constructors

HsRules

Fields

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

Instances

DataId pass => Data (RuleDecls pass)

Methods

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

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

toConstr :: RuleDecls pass -> Constr

dataTypeOf :: RuleDecls pass -> DataType

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

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

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

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

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

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

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

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

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

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

(SourceTextX pass, OutputableBndrId pass) => Outputable (RuleDecls pass)

Methods

ppr :: RuleDecls pass -> SDoc

pprPrec :: Rational -> RuleDecls pass -> SDoc

data RuleDecl pass

Rule Declaration

Constructors

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

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

Instances

DataId pass => Data (RuleDecl pass)

Methods

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

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

toConstr :: RuleDecl pass -> Constr

dataTypeOf :: RuleDecl pass -> DataType

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

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

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

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

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

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

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

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

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

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

(SourceTextX pass, OutputableBndrId pass) => Outputable (RuleDecl pass)

Methods

ppr :: RuleDecl pass -> SDoc

pprPrec :: Rational -> RuleDecl pass -> SDoc

type LRuleDecl pass = Located (RuleDecl pass)

Located Rule Declaration

data RuleBndr pass

Rule Binder

Constructors

RuleBndr (Located (IdP pass))

RuleBndrSig (Located (IdP pass)) (LHsSigWcType pass)

• AnnKeywordId : AnnOpen, AnnDcolon,AnnClose

Instances

DataId pass => Data (RuleBndr pass)

Methods

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

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

toConstr :: RuleBndr pass -> Constr

dataTypeOf :: RuleBndr pass -> DataType

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

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

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

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

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

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

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

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

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

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

(SourceTextX pass, OutputableBndrId pass) => Outputable (RuleBndr pass)

Methods

ppr :: RuleBndr pass -> SDoc

pprPrec :: Rational -> RuleBndr pass -> SDoc

type LRuleBndr pass = Located (RuleBndr pass)

Located Rule Binder

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

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

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

VECTORISE declarations

data VectDecl pass

Vectorise Declaration

Constructors

HsVect SourceText (Located (IdP pass)) (LHsExpr pass)

• AnnKeywordId : AnnOpen, AnnEqual,AnnClose

HsNoVect SourceText (Located (IdP pass))

• AnnKeywordId : AnnOpen, AnnClose

HsVectTypeIn SourceText Bool (Located (IdP pass)) (Maybe (Located (IdP pass)))

• AnnKeywordId : AnnOpen, AnnType,AnnClose, AnnEqual

HsVectTypeOut Bool TyCon (Maybe TyCon)

HsVectClassIn SourceText (Located (IdP pass))

• AnnKeywordId : AnnOpen, AnnClass,AnnClose,

HsVectClassOut Class

HsVectInstIn (LHsSigType pass)

HsVectInstOut ClsInst

Instances

DataId pass => Data (VectDecl pass)

Methods

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

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

toConstr :: VectDecl pass -> Constr

dataTypeOf :: VectDecl pass -> DataType

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

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

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

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

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

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

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

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

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

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

(SourceTextX pass, OutputableBndrId pass) => Outputable (VectDecl pass)

Methods

ppr :: VectDecl pass -> SDoc

pprPrec :: Rational -> VectDecl pass -> SDoc

type LVectDecl pass = Located (VectDecl pass)

Located Vectorise Declaration

lvectDeclName :: NamedThing (IdP pass) => LVectDecl pass -> Name

lvectInstDecl :: LVectDecl pass -> Bool

default declarations

data DefaultDecl pass

Default Declaration

Constructors

DefaultDecl [LHsType pass]

• AnnKeywordIds : AnnDefault, AnnOpen,AnnClose

Instances

DataId pass => Data (DefaultDecl pass)

Methods

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

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

toConstr :: DefaultDecl pass -> Constr

dataTypeOf :: DefaultDecl pass -> DataType

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

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

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

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

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

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

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

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

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

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

(SourceTextX pass, OutputableBndrId pass) => Outputable (DefaultDecl pass)

Methods

ppr :: DefaultDecl pass -> SDoc

pprPrec :: Rational -> DefaultDecl pass -> SDoc

type LDefaultDecl pass = Located (DefaultDecl pass)

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)

(SourceTextX pass, OutputableBndrId pass) => Outputable (SpliceDecl pass)

Methods

ppr :: SpliceDecl pass -> SDoc

pprPrec :: Rational -> SpliceDecl pass -> SDoc

type LSpliceDecl pass = Located (SpliceDecl pass)

Located Splice Declaration

Foreign function interface declarations

data ForeignDecl pass

Foreign Declaration

Constructors

ForeignImport

Fields

• fd_name :: Located (IdP pass)
• fd_sig_ty :: LHsSigType pass
• fd_co :: PostTc pass Coercion
• fd_fi :: ForeignImport

ForeignExport

• AnnKeywordId : AnnForeign, AnnImport,AnnExport, AnnDcolon

Fields

• fd_name :: Located (IdP pass)
• fd_sig_ty :: LHsSigType pass
• fd_co :: PostTc pass Coercion
• fd_fe :: ForeignExport

Instances

DataId pass => Data (ForeignDecl pass)

Methods

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

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

toConstr :: ForeignDecl pass -> Constr

dataTypeOf :: ForeignDecl pass -> DataType

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

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

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

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

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

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

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

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

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

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

(SourceTextX pass, OutputableBndrId pass) => Outputable (ForeignDecl pass)

Methods

ppr :: ForeignDecl pass -> SDoc

pprPrec :: Rational -> ForeignDecl pass -> SDoc

type LForeignDecl pass = Located (ForeignDecl pass)

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 pass

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 (IdP pass)]
• con_type :: LHsSigType pass

  The type after the ‘::’

• con_doc :: Maybe LHsDocString

  A possible Haddock comment.

ConDeclH98

Fields

• con_name :: Located (IdP pass)
• con_qvars :: Maybe (LHsQTyVars pass)
• con_cxt :: Maybe (LHsContext pass)

  User-written context (if any)

• con_details :: HsConDeclDetails pass

  Arguments

• con_doc :: Maybe LHsDocString

  A possible Haddock comment.

Instances

DataId pass => Data (ConDecl pass)

Methods

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

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

toConstr :: ConDecl pass -> Constr

dataTypeOf :: ConDecl pass -> DataType

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

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

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

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

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

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

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

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

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

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

(SourceTextX pass, OutputableBndrId pass) => Outputable (ConDecl pass)

Methods

ppr :: ConDecl pass -> SDoc

pprPrec :: Rational -> ConDecl pass -> SDoc

type LConDecl pass

Arguments

 = Located (ConDecl pass)

May have AnnKeywordId : AnnSemi when in a GADT constructor list

Located data Constructor Declaration

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

Haskell data Constructor Declaration Details

hsConDeclArgTys :: HsConDeclDetails pass -> [LBangType pass]

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

getConDetails :: ConDecl pass -> HsConDeclDetails pass

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

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 pass

Warning pragma Declaration

Constructors

Warning [Located (IdP pass)] WarningTxt

Instances

DataId pass => Data (WarnDecl pass)

Methods

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

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

toConstr :: WarnDecl pass -> Constr

dataTypeOf :: WarnDecl pass -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndr (IdP pass) => Outputable (WarnDecl pass)

Methods

ppr :: WarnDecl pass -> SDoc

pprPrec :: Rational -> WarnDecl pass -> SDoc

type LWarnDecl pass = Located (WarnDecl pass)

Located Warning pragma Declaration

data WarnDecls pass

Warning pragma Declarations

Constructors

Warnings

Fields

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

Instances

DataId pass => Data (WarnDecls pass)

Methods

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

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

toConstr :: WarnDecls pass -> Constr

dataTypeOf :: WarnDecls pass -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndr (IdP pass) => Outputable (WarnDecls pass)

Methods

ppr :: WarnDecls pass -> SDoc

pprPrec :: Rational -> WarnDecls pass -> SDoc

type LWarnDecls pass = Located (WarnDecls pass)

Located Warning Declarations

Annotations

data AnnDecl pass

Annotation Declaration

Constructors

HsAnnotation SourceText (AnnProvenance (IdP pass)) (Located (HsExpr pass))

• AnnKeywordId : AnnOpen, AnnType AnnModule AnnClose

Instances

DataId pass => Data (AnnDecl pass)

Methods

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

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

toConstr :: AnnDecl pass -> Constr

dataTypeOf :: AnnDecl pass -> DataType

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

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

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

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

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

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

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

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

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

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

(SourceTextX pass, OutputableBndrId pass) => Outputable (AnnDecl pass)

Methods

ppr :: AnnDecl pass -> SDoc

pprPrec :: Rational -> AnnDecl pass -> SDoc

type LAnnDecl pass = Located (AnnDecl pass)

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 pass => Data (AnnProvenance pass)

Methods

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

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

toConstr :: AnnProvenance pass -> Constr

dataTypeOf :: AnnProvenance pass -> DataType

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

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

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

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

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

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

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

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

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

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

annProvenanceName_maybe :: AnnProvenance name -> Maybe name

Role annotations

data RoleAnnotDecl pass

Role Annotation Declaration

Constructors

RoleAnnotDecl (Located (IdP pass)) [Located (Maybe Role)]

• AnnKeywordId : AnnType, AnnRole

Instances

DataId pass => Data (RoleAnnotDecl pass)

Methods

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

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

toConstr :: RoleAnnotDecl pass -> Constr

dataTypeOf :: RoleAnnotDecl pass -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndr (IdP pass) => Outputable (RoleAnnotDecl pass)

Methods

ppr :: RoleAnnotDecl pass -> SDoc

pprPrec :: Rational -> RoleAnnotDecl pass -> SDoc

type LRoleAnnotDecl pass = Located (RoleAnnotDecl pass)

Located Role Annotation Declaration

roleAnnotDeclName :: RoleAnnotDecl pass -> IdP pass

Injective type families

data FamilyResultSig pass

type Family Result Signature

Constructors

NoSig

• AnnKeywordId :

KindSig (LHsKind pass)

• AnnKeywordId : AnnOpenP,AnnDcolon, AnnCloseP

TyVarSig (LHsTyVarBndr pass)

• AnnKeywordId : AnnOpenP,AnnDcolon, AnnCloseP, AnnEqual

Instances

DataId pass => Data (FamilyResultSig pass)

Methods

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

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

toConstr :: FamilyResultSig pass -> Constr

dataTypeOf :: FamilyResultSig pass -> DataType

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

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

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

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

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

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

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

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

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

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

type LFamilyResultSig pass = Located (FamilyResultSig pass)

Located type Family Result Signature

data InjectivityAnn pass

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 (IdP pass)) [Located (IdP pass)]

• AnnKeywordId : AnnRarrow, AnnVbar

Instances

DataId pass => Data (InjectivityAnn pass)

Methods

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

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

toConstr :: InjectivityAnn pass -> Constr

dataTypeOf :: InjectivityAnn pass -> DataType

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

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

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

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

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

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

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

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

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

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

type LInjectivityAnn pass = Located (InjectivityAnn pass)

Located Injectivity Annotation

resultVariableName :: FamilyResultSig a -> Maybe (IdP 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)

(SourceTextX pass, OutputableBndrId pass) => Outputable (HsGroup pass)

Methods

ppr :: HsGroup pass -> SDoc

pprPrec :: Rational -> HsGroup pass -> SDoc

emptyRdrGroup :: HsGroup a

emptyRnGroup :: HsGroup a

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

hsGroupInstDecls :: HsGroup id -> [LInstDecl id]