Language.Haskell.Syntax.ImpExp

Documentation

type LImportDecl pass

Arguments

 = XRec pass (ImportDecl pass)

When in a list this may have

• AnnKeywordId : AnnSemi

Located Import Declaration

data ImportDeclQualifiedStyle

If/how an import is qualified.

Constructors

QualifiedPre

qualified appears in prepositive position.

QualifiedPost

qualified appears in postpositive position.

NotQualified

Not qualified.

Instances

Data ImportDeclQualifiedStyle

Defined in Language.Haskell.Syntax.ImpExp

Methods

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

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

toConstr :: ImportDeclQualifiedStyle -> Constr

dataTypeOf :: ImportDeclQualifiedStyle -> DataType

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

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

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

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

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

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

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

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

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

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

Eq ImportDeclQualifiedStyle

Defined in Language.Haskell.Syntax.ImpExp

Methods

(==) :: ImportDeclQualifiedStyle -> ImportDeclQualifiedStyle -> Bool

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

data IsBootInterface

Indicates whether a module name is referring to a boot interface (hs-boot file) or regular module (hs file). We need to treat boot modules specially when building compilation graphs, since they break cycles. Regular source files and signature files are treated equivalently.

Constructors

NotBoot

IsBoot

Instances

Data IsBootInterface

Defined in Language.Haskell.Syntax.ImpExp

Methods

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

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

toConstr :: IsBootInterface -> Constr

dataTypeOf :: IsBootInterface -> DataType

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

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

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

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

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

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

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

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

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

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

Show IsBootInterface

Defined in Language.Haskell.Syntax.ImpExp

Methods

showsPrec :: Int -> IsBootInterface -> ShowS

show :: IsBootInterface -> String

showList :: [IsBootInterface] -> ShowS

Binary IsBootInterface

Defined in GHC.Unit.Types

Methods

put_ :: BinHandle -> IsBootInterface -> IO ()

put :: BinHandle -> IsBootInterface -> IO (Bin IsBootInterface)

get :: BinHandle -> IO IsBootInterface

Eq IsBootInterface

Defined in Language.Haskell.Syntax.ImpExp

Methods

(==) :: IsBootInterface -> IsBootInterface -> Bool

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

Ord IsBootInterface

Defined in Language.Haskell.Syntax.ImpExp

Methods

compare :: IsBootInterface -> IsBootInterface -> Ordering

(<) :: IsBootInterface -> IsBootInterface -> Bool

(<=) :: IsBootInterface -> IsBootInterface -> Bool

(>) :: IsBootInterface -> IsBootInterface -> Bool

(>=) :: IsBootInterface -> IsBootInterface -> Bool

max :: IsBootInterface -> IsBootInterface -> IsBootInterface

min :: IsBootInterface -> IsBootInterface -> IsBootInterface

data ImportDecl pass

Import Declaration

A single Haskell import declaration.

Constructors

ImportDecl

Fields

• ideclExt :: XCImportDecl pass
• ideclName :: XRec pass ModuleName

  Module name.

• ideclPkgQual :: ImportDeclPkgQual pass

  Package qualifier.

• ideclSource :: IsBootInterface

  IsBoot = {-# SOURCE #-} import

• ideclSafe :: Bool

  True => safe import

• ideclQualified :: ImportDeclQualifiedStyle

  If/how the import is qualified.

• ideclAs :: Maybe (XRec pass ModuleName)

  as Module

• ideclImportList :: Maybe (ImportListInterpretation, XRec pass [LIE pass])

  Explicit import list (EverythingBut => hiding, names)

XImportDecl !(XXImportDecl pass)

AnnKeywordIds

• AnnImport
• AnnOpen, AnnClose for ideclSource
• AnnSafe,AnnQualified, AnnPackageName,AnnAs, AnnVal
• AnnHiding,AnnOpen, AnnClose attached to location in ideclImportList

Instances

Data (ImportDecl GhcPs)

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: ImportDecl GhcPs -> Constr

dataTypeOf :: ImportDecl GhcPs -> DataType

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

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

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

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

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

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

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

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

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

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

Data (ImportDecl GhcRn)

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: ImportDecl GhcRn -> Constr

dataTypeOf :: ImportDecl GhcRn -> DataType

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

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

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

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

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

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

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

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

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

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

Data (ImportDecl GhcTc)

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: ImportDecl GhcTc -> Constr

dataTypeOf :: ImportDecl GhcTc -> DataType

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

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

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

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

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

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

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

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

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

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

(OutputableBndrId p, Outputable (Anno (IE (GhcPass p))), Outputable (ImportDeclPkgQual (GhcPass p))) => Outputable (ImportDecl (GhcPass p))

Defined in GHC.Hs.ImpExp

Methods

ppr :: ImportDecl (GhcPass p) -> SDoc

type Anno (ImportDecl (GhcPass p))

Defined in GHC.Hs.ImpExp

type Anno (ImportDecl (GhcPass p)) = SrcSpanAnnA

data ImportListInterpretation

Whether the import list is exactly what to import, or whether hiding was used, and therefore everything but what was listed should be imported

Constructors

Exactly

EverythingBut

Instances

Data ImportListInterpretation

Defined in Language.Haskell.Syntax.ImpExp

Methods

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

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

toConstr :: ImportListInterpretation -> Constr

dataTypeOf :: ImportListInterpretation -> DataType

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

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

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

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

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

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

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

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

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

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

Eq ImportListInterpretation

Defined in Language.Haskell.Syntax.ImpExp

Methods

(==) :: ImportListInterpretation -> ImportListInterpretation -> Bool

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

type LIE pass

Arguments

 = XRec pass (IE pass)

When in a list this may have

• AnnKeywordId : AnnComma

Located Import or Export

data IE pass

Imported or exported entity.

Constructors

IEVar (XIEVar pass) (LIEWrappedName pass)

Imported or Exported Variable

IEThingAbs (XIEThingAbs pass) (LIEWrappedName pass)

Imported or exported Thing with Absent list

The thing is a Class/Type (can't tell) - AnnKeywordIds : AnnPattern, AnnType,AnnVal

IEThingAll (XIEThingAll pass) (LIEWrappedName pass)

Imported or exported Thing with All imported or exported

The thing is a ClassType and the All refers to methodsconstructors

• AnnKeywordIds : AnnOpen, AnnDotdot,AnnClose, AnnType

IEThingWith (XIEThingWith pass) (LIEWrappedName pass) IEWildcard [LIEWrappedName pass]

Imported or exported Thing With given imported or exported

The thing is a Class/Type and the imported or exported things are its children. - AnnKeywordIds : AnnOpen, AnnClose, AnnComma, AnnType

IEModuleContents (XIEModuleContents pass) (XRec pass ModuleName)

Imported or exported module contents

(Export Only)

• AnnKeywordIds : AnnModule

IEGroup (XIEGroup pass) Int (LHsDoc pass)

Doc section heading

IEDoc (XIEDoc pass) (LHsDoc pass)

Some documentation

IEDocNamed (XIEDocNamed pass) String

Reference to named doc

XIE !(XXIE pass)

Instances

Data (IE GhcPs)

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: IE GhcPs -> Constr

dataTypeOf :: IE GhcPs -> DataType

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

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

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

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

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

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

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

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

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

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

Data (IE GhcRn)

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: IE GhcRn -> Constr

dataTypeOf :: IE GhcRn -> DataType

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

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

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

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

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

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

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

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

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

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

Data (IE GhcTc)

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: IE GhcTc -> Constr

dataTypeOf :: IE GhcTc -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndrId p => Outputable (IE (GhcPass p))

Defined in GHC.Hs.ImpExp

Methods

ppr :: IE (GhcPass p) -> SDoc

Eq (IE GhcPs)

Defined in GHC.Hs.Instances

Methods

(==) :: IE GhcPs -> IE GhcPs -> Bool

(/=) :: IE GhcPs -> IE GhcPs -> Bool

Eq (IE GhcRn)

Defined in GHC.Hs.Instances

Methods

(==) :: IE GhcRn -> IE GhcRn -> Bool

(/=) :: IE GhcRn -> IE GhcRn -> Bool

Eq (IE GhcTc)

Defined in GHC.Hs.Instances

Methods

(==) :: IE GhcTc -> IE GhcTc -> Bool

(/=) :: IE GhcTc -> IE GhcTc -> Bool

type Anno (LocatedA (IE (GhcPass p)))

Defined in GHC.Hs.ImpExp

type Anno (LocatedA (IE (GhcPass p))) = SrcSpanAnnA

type Anno (IE (GhcPass p))

Defined in GHC.Hs.ImpExp

type Anno (IE (GhcPass p)) = SrcSpanAnnA

type Anno [LocatedA (IE (GhcPass p))]

Defined in GHC.Hs.ImpExp

type Anno [LocatedA (IE (GhcPass p))] = SrcSpanAnnL

data IEWildcard

Wildcard in an import or export sublist, like the .. in import Mod ( T(Mk1, Mk2, ..) ).

Constructors

NoIEWildcard

no wildcard in this list

IEWildcard Int

wildcard after the given # of items in this list The Int is in the range [0..n], where n is the length of the list.

Instances

Data IEWildcard

Defined in Language.Haskell.Syntax.ImpExp

Methods

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

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

toConstr :: IEWildcard -> Constr

dataTypeOf :: IEWildcard -> DataType

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

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

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

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

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

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

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

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

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

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

Eq IEWildcard

Defined in Language.Haskell.Syntax.ImpExp

Methods

(==) :: IEWildcard -> IEWildcard -> Bool

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

data IEWrappedName p

A name in an import or export specification which may have adornments. Used primarily for accurate pretty printing of ParsedSource, and API Annotation placement. The Annotation is the location of the adornment in the original source.

Constructors

IEName (XIEName p) (LIdP p)

no extra

IEPattern (XIEPattern p) (LIdP p)

pattern X

IEType (XIEType p) (LIdP p)

type (:+:)

XIEWrappedName !(XXIEWrappedName p)

Instances

Data (IEWrappedName GhcPs)

Defined in GHC.Hs.ImpExp

Methods

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

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

toConstr :: IEWrappedName GhcPs -> Constr

dataTypeOf :: IEWrappedName GhcPs -> DataType

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

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

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

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

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

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

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

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

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

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

Data (IEWrappedName GhcRn)

Defined in GHC.Hs.ImpExp

Methods

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

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

toConstr :: IEWrappedName GhcRn -> Constr

dataTypeOf :: IEWrappedName GhcRn -> DataType

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

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

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

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

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

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

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

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

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

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

Data (IEWrappedName GhcTc)

Defined in GHC.Hs.ImpExp

Methods

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

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

toConstr :: IEWrappedName GhcTc -> Constr

dataTypeOf :: IEWrappedName GhcTc -> DataType

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

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

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

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

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

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

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

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

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

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

(HasOccName (IdP (GhcPass p)), OutputableBndrId p) => HasOccName (IEWrappedName (GhcPass p))

Defined in GHC.Hs.ImpExp

Methods

occName :: IEWrappedName (GhcPass p) -> OccName

OutputableBndrId p => Outputable (IEWrappedName (GhcPass p))

Defined in GHC.Hs.ImpExp

Methods

ppr :: IEWrappedName (GhcPass p) -> SDoc

OutputableBndrId p => OutputableBndr (IEWrappedName (GhcPass p))

Defined in GHC.Hs.ImpExp

Methods

pprBndr :: BindingSite -> IEWrappedName (GhcPass p) -> SDoc

pprPrefixOcc :: IEWrappedName (GhcPass p) -> SDoc

pprInfixOcc :: IEWrappedName (GhcPass p) -> SDoc

bndrIsJoin_maybe :: IEWrappedName (GhcPass p) -> Maybe Int

Eq (IEWrappedName GhcPs)

Defined in GHC.Hs.ImpExp

Methods

(==) :: IEWrappedName GhcPs -> IEWrappedName GhcPs -> Bool

(/=) :: IEWrappedName GhcPs -> IEWrappedName GhcPs -> Bool

Eq (IEWrappedName GhcRn)

Defined in GHC.Hs.ImpExp

Methods

(==) :: IEWrappedName GhcRn -> IEWrappedName GhcRn -> Bool

(/=) :: IEWrappedName GhcRn -> IEWrappedName GhcRn -> Bool

Eq (IEWrappedName GhcTc)

Defined in GHC.Hs.ImpExp

Methods

(==) :: IEWrappedName GhcTc -> IEWrappedName GhcTc -> Bool

(/=) :: IEWrappedName GhcTc -> IEWrappedName GhcTc -> Bool

type Anno (IEWrappedName (GhcPass _1))

Defined in GHC.Hs.ImpExp

type Anno (IEWrappedName (GhcPass _1)) = SrcSpanAnnA

type LIEWrappedName p = XRec p (IEWrappedName p)

Located name with possible adornment - AnnKeywordIds : AnnType, AnnPattern