GHC.Unit.Types

Unit & Module types

This module is used to resolve the loops between Unit and Module types (Module references a Unit and vice-versa).

Modules

data GenModule unit

A generic module is a pair of a unit identifier and a ModuleName.

Constructors

Module

Fields

• moduleUnit :: !unit

  Unit the module belongs to

• moduleName :: !ModuleName

  Module name (e.g. A.B.C)

Instances

Functor GenModule

Defined in GHC.Unit.Types

Methods

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

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

Outputable Module

Defined in GHC.Unit.Types

Methods

ppr :: Module -> SDoc

Outputable InstantiatedModule

Defined in GHC.Unit.Types

Methods

ppr :: InstantiatedModule -> SDoc

Outputable InstalledModule

Defined in GHC.Unit.Types

Methods

ppr :: InstalledModule -> SDoc

Uniquable Module

Defined in GHC.Unit.Types

Methods

getUnique :: Module -> Unique

Eq unit => Eq (GenModule unit)

Defined in GHC.Unit.Types

Methods

(==) :: GenModule unit -> GenModule unit -> Bool

(/=) :: GenModule unit -> GenModule unit -> Bool

Data unit => Data (GenModule unit)

Defined in GHC.Unit.Types

Methods

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

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

toConstr :: GenModule unit -> Constr

dataTypeOf :: GenModule unit -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> GenModule unit -> GenModule unit

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

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

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

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

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

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

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

Ord unit => Ord (GenModule unit)

Defined in GHC.Unit.Types

Methods

compare :: GenModule unit -> GenModule unit -> Ordering

(<) :: GenModule unit -> GenModule unit -> Bool

(<=) :: GenModule unit -> GenModule unit -> Bool

(>) :: GenModule unit -> GenModule unit -> Bool

(>=) :: GenModule unit -> GenModule unit -> Bool

max :: GenModule unit -> GenModule unit -> GenModule unit

min :: GenModule unit -> GenModule unit -> GenModule unit

NFData (GenModule a)

Defined in GHC.Unit.Types

Methods

rnf :: GenModule a -> ()

Binary a => Binary (GenModule a)

Defined in GHC.Unit.Types

Methods

put_ :: BinHandle -> GenModule a -> IO ()

put :: BinHandle -> GenModule a -> IO (Bin (GenModule a))

get :: BinHandle -> IO (GenModule a)

type Module = GenModule Unit

A Module is a pair of a Unit and a ModuleName.

type InstalledModule = GenModule UnitId

A InstalledModule is a Module whose unit is identified with an UnitId.

type InstantiatedModule = GenModule InstantiatedUnit

An InstantiatedModule is a Module whose unit is identified with an InstantiatedUnit.

mkModule :: u -> ModuleName -> GenModule u

pprModule :: Module -> SDoc

pprInstantiatedModule :: InstantiatedModule -> SDoc

moduleFreeHoles :: GenModule (GenUnit u) -> UniqDSet ModuleName

Calculate the free holes of a Module. If this set is non-empty, this module was defined in an indefinite library that had required signatures.

If a module has free holes, that means that substitutions can operate on it; if it has no free holes, substituting over a module has no effect.

Units

class IsUnitId u

Class for types that are used as unit identifiers (UnitKey, UnitId, Unit)

We need this class because we create new unit ids for virtual units (see VirtUnit) and they have to to be made from units with different kinds of identifiers.

Minimal complete definition

unitFS

Instances

IsUnitId UnitId

Defined in GHC.Unit.Types

Methods

unitFS :: UnitId -> FastString

IsUnitId UnitKey

Defined in GHC.Unit.Types

Methods

unitFS :: UnitKey -> FastString

IsUnitId unit => IsUnitId (Indefinite unit)

Defined in GHC.Unit.Types

Methods

unitFS :: Indefinite unit -> FastString

IsUnitId u => IsUnitId (GenUnit u)

Defined in GHC.Unit.Types

Methods

unitFS :: GenUnit u -> FastString

IsUnitId unit => IsUnitId (Definite unit)

Defined in GHC.Unit.Types

Methods

unitFS :: Definite unit -> FastString

data GenUnit uid

A unit identifier identifies a (possibly partially) instantiated library. It is primarily used as part of Module, which in turn is used in Name, which is used to give names to entities when typechecking.

There are two possible forms for a Unit:

1) It can be a RealUnit, in which case we just have a DefUnitId that uniquely identifies some fully compiled, installed library we have on disk.

2) It can be an VirtUnit. When we are typechecking a library with missing holes, we may need to instantiate a library on the fly (in which case we don't have any on-disk representation.) In that case, you have an InstantiatedUnit, which explicitly records the instantiation, so that we can substitute over it.

Constructors

RealUnit !(Definite uid)

Installed definite unit (either a fully instantiated unit or a closed unit)

VirtUnit !(GenInstantiatedUnit uid)

Virtual unit instantiated on-the-fly. It may be definite if all the holes are instantiated but we don't have code objects for it.

HoleUnit

Fake hole unit

Instances

Data Unit

Defined in GHC.Unit.Types

Methods

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

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

toConstr :: Unit -> Constr

dataTypeOf :: Unit -> DataType

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

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

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

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

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

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

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

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

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

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

Ord Unit

Defined in GHC.Unit.Types

Methods

compare :: Unit -> Unit -> Ordering

(<) :: Unit -> Unit -> Bool

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

(>) :: Unit -> Unit -> Bool

(>=) :: Unit -> Unit -> Bool

max :: Unit -> Unit -> Unit

min :: Unit -> Unit -> Unit

Show Unit

Defined in GHC.Unit.Types

Methods

showsPrec :: Int -> Unit -> ShowS

show :: Unit -> String

showList :: [Unit] -> ShowS

NFData Unit

Defined in GHC.Unit.Types

Methods

rnf :: Unit -> ()

Outputable Unit

Defined in GHC.Unit.Types

Methods

ppr :: Unit -> SDoc

Outputable Module

Defined in GHC.Unit.Types

Methods

ppr :: Module -> SDoc

Uniquable Module

Defined in GHC.Unit.Types

Methods

getUnique :: Module -> Unique

Binary Unit

Defined in GHC.Unit.Types

Methods

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

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

get :: BinHandle -> IO Unit

IsUnitId u => Eq (GenUnit u)

Defined in GHC.Unit.Types

Methods

(==) :: GenUnit u -> GenUnit u -> Bool

(/=) :: GenUnit u -> GenUnit u -> Bool

IsUnitId u => Uniquable (GenUnit u)

Defined in GHC.Unit.Types

Methods

getUnique :: GenUnit u -> Unique

IsUnitId u => IsUnitId (GenUnit u)

Defined in GHC.Unit.Types

Methods

unitFS :: GenUnit u -> FastString

type Unit = GenUnit UnitId

newtype UnitId

A UnitId identifies a built library in a database and is used to generate unique symbols, etc. It's usually of the form:

pkgname-1.2:libname+hash

These UnitId are provided to us via the -this-unit-id flag.

The library in question may be definite or indefinite; if it is indefinite, none of the holes have been filled (we never install partially instantiated libraries as we can cheaply instantiate them on-the-fly, cf VirtUnit). Put another way, an installed unit id is either fully instantiated, or not instantiated at all.

Constructors

UnitId

Fields

• unitIdFS :: FastString

  The full hashed unit identifier, including the component id and the hash.

Instances

Eq UnitId

Defined in GHC.Unit.Types

Methods

(==) :: UnitId -> UnitId -> Bool

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

Data Unit

Defined in GHC.Unit.Types

Methods

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

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

toConstr :: Unit -> Constr

dataTypeOf :: Unit -> DataType

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

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

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

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

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

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

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

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

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

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

Ord Unit

Defined in GHC.Unit.Types

Methods

compare :: Unit -> Unit -> Ordering

(<) :: Unit -> Unit -> Bool

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

(>) :: Unit -> Unit -> Bool

(>=) :: Unit -> Unit -> Bool

max :: Unit -> Unit -> Unit

min :: Unit -> Unit -> Unit

Ord UnitId

Defined in GHC.Unit.Types

Methods

compare :: UnitId -> UnitId -> Ordering

(<) :: UnitId -> UnitId -> Bool

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

(>) :: UnitId -> UnitId -> Bool

(>=) :: UnitId -> UnitId -> Bool

max :: UnitId -> UnitId -> UnitId

min :: UnitId -> UnitId -> UnitId

Show Unit

Defined in GHC.Unit.Types

Methods

showsPrec :: Int -> Unit -> ShowS

show :: Unit -> String

showList :: [Unit] -> ShowS

NFData Unit

Defined in GHC.Unit.Types

Methods

rnf :: Unit -> ()

Outputable Unit

Defined in GHC.Unit.Types

Methods

ppr :: Unit -> SDoc

Outputable Module

Defined in GHC.Unit.Types

Methods

ppr :: Module -> SDoc

Outputable UnitId

Defined in GHC.Unit.Types

Methods

ppr :: UnitId -> SDoc

Outputable InstantiatedUnit

Defined in GHC.Unit.Types

Methods

ppr :: InstantiatedUnit -> SDoc

Outputable InstantiatedModule

Defined in GHC.Unit.Types

Methods

ppr :: InstantiatedModule -> SDoc

Outputable InstalledModule

Defined in GHC.Unit.Types

Methods

ppr :: InstalledModule -> SDoc

Uniquable Module

Defined in GHC.Unit.Types

Methods

getUnique :: Module -> Unique

Uniquable UnitId

Defined in GHC.Unit.Types

Methods

getUnique :: UnitId -> Unique

Binary Unit

Defined in GHC.Unit.Types

Methods

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

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

get :: BinHandle -> IO Unit

Binary UnitId

Defined in GHC.Unit.Types

Methods

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

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

get :: BinHandle -> IO UnitId

Binary InstantiatedUnit

Defined in GHC.Unit.Types

Methods

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

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

get :: BinHandle -> IO InstantiatedUnit

IsUnitId UnitId

Defined in GHC.Unit.Types

Methods

unitFS :: UnitId -> FastString

newtype UnitKey

A unit key in the database

Constructors

UnitKey FastString

Instances

IsUnitId UnitKey

Defined in GHC.Unit.Types

Methods

unitFS :: UnitKey -> FastString

data GenInstantiatedUnit unit

An instantiated unit.

It identifies an indefinite library (with holes) that has been instantiated.

This unit may be indefinite or not (i.e. with remaining holes or not). If it is definite, we don't know if it has already been compiled and installed in a database. Nevertheless, we have a mechanism called "improvement" to try to match a fully instantiated unit with existing compiled and installed units: see Note [VirtUnit to RealUnit improvement].

An indefinite unit identifier pretty-prints to something like p[H=H,A=aimpl:A>] (p is the IndefUnitId, and the brackets enclose the module substitution).

Constructors

InstantiatedUnit

Fields

• instUnitFS :: !FastString

  A private, uniquely identifying representation of an InstantiatedUnit. This string is completely private to GHC and is just used to get a unique.

• instUnitKey :: !Unique

  Cached unique of unitFS.

• instUnitInstanceOf :: !(Indefinite unit)

  The indefinite unit being instantiated.

• instUnitInsts :: !(GenInstantiations unit)

  The sorted (by ModuleName) instantiations of this unit.

• instUnitHoles :: UniqDSet ModuleName

  A cache of the free module holes of instUnitInsts. This lets us efficiently tell if a InstantiatedUnit has been fully instantiated (empty set of free module holes) and whether or not a substitution can have any effect.

Instances

Outputable InstantiatedUnit

Defined in GHC.Unit.Types

Methods

ppr :: InstantiatedUnit -> SDoc

Outputable InstantiatedModule

Defined in GHC.Unit.Types

Methods

ppr :: InstantiatedModule -> SDoc

Binary InstantiatedUnit

Defined in GHC.Unit.Types

Methods

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

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

get :: BinHandle -> IO InstantiatedUnit

Eq (GenInstantiatedUnit unit)

Defined in GHC.Unit.Types

Methods

(==) :: GenInstantiatedUnit unit -> GenInstantiatedUnit unit -> Bool

(/=) :: GenInstantiatedUnit unit -> GenInstantiatedUnit unit -> Bool

Ord (GenInstantiatedUnit unit)

Defined in GHC.Unit.Types

Methods

compare :: GenInstantiatedUnit unit -> GenInstantiatedUnit unit -> Ordering

(<) :: GenInstantiatedUnit unit -> GenInstantiatedUnit unit -> Bool

(<=) :: GenInstantiatedUnit unit -> GenInstantiatedUnit unit -> Bool

(>) :: GenInstantiatedUnit unit -> GenInstantiatedUnit unit -> Bool

(>=) :: GenInstantiatedUnit unit -> GenInstantiatedUnit unit -> Bool

max :: GenInstantiatedUnit unit -> GenInstantiatedUnit unit -> GenInstantiatedUnit unit

min :: GenInstantiatedUnit unit -> GenInstantiatedUnit unit -> GenInstantiatedUnit unit

type InstantiatedUnit = GenInstantiatedUnit UnitId

type IndefUnitId = Indefinite UnitId

An IndefUnitId is an UnitId with the invariant that it only refers to an indefinite library; i.e., one that can be instantiated.

type DefUnitId = Definite UnitId

A DefUnitId is an UnitId with the invariant that it only refers to a definite library; i.e., one we have generated code for.

type Instantiations = GenInstantiations UnitId

type GenInstantiations unit = [(ModuleName, GenModule (GenUnit unit))]

mkInstantiatedUnit :: IsUnitId u => Indefinite u -> GenInstantiations u -> GenInstantiatedUnit u

Create a new GenInstantiatedUnit given an explicit module substitution.

mkInstantiatedUnitHash :: IsUnitId u => Indefinite u -> [(ModuleName, GenModule (GenUnit u))] -> FastString

Generate a uniquely identifying hash (internal unit-id) for an instantiated unit.

This is a one-way function. If the indefinite unit has not been instantiated at all, we return its unit-id.

This hash is completely internal to GHC and is not used for symbol names or file paths. It is different from the hash Cabal would produce for the same instantiated unit.

mkVirtUnit :: IsUnitId u => Indefinite u -> [(ModuleName, GenModule (GenUnit u))] -> GenUnit u

Smart constructor for instantiated GenUnit

mapGenUnit :: IsUnitId v => (u -> v) -> GenUnit u -> GenUnit v

Map over the unit type of a GenUnit

mapInstantiations :: IsUnitId v => (u -> v) -> GenInstantiations u -> GenInstantiations v

Map over the unit identifier of unit instantiations.

unitFreeModuleHoles :: GenUnit u -> UniqDSet ModuleName

Retrieve the set of free module holes of a Unit.

fsToUnit :: FastString -> Unit

Create a new simple unit identifier from a FastString. Internally, this is primarily used to specify wired-in unit identifiers.

unitFS :: IsUnitId u => u -> FastString

unitString :: IsUnitId u => u -> String

toUnitId :: Unit -> UnitId

Return the UnitId of the Unit. For on-the-fly instantiated units, return the UnitId of the indefinite unit this unit is an instance of.

virtualUnitId :: InstantiatedUnit -> UnitId

Return the virtual UnitId of an on-the-fly instantiated unit.

stringToUnit :: String -> Unit

stableUnitCmp :: Unit -> Unit -> Ordering

Compares unit ids lexically, rather than by their Uniques

unitIsDefinite :: Unit -> Bool

A Unit is definite if it has no free holes.

isHoleUnit :: GenUnit u -> Bool

Unit Ids

unitIdString :: UnitId -> String

stringToUnitId :: String -> UnitId

Utils

newtype Definite unit

A definite unit (i.e. without any free module hole)

Constructors

Definite

Fields

• unDefinite :: unit

Instances

Functor Definite

Defined in GHC.Unit.Types

Methods

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

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

Eq unit => Eq (Definite unit)

Defined in GHC.Unit.Types

Methods

(==) :: Definite unit -> Definite unit -> Bool

(/=) :: Definite unit -> Definite unit -> Bool

Ord unit => Ord (Definite unit)

Defined in GHC.Unit.Types

Methods

compare :: Definite unit -> Definite unit -> Ordering

(<) :: Definite unit -> Definite unit -> Bool

(<=) :: Definite unit -> Definite unit -> Bool

(>) :: Definite unit -> Definite unit -> Bool

(>=) :: Definite unit -> Definite unit -> Bool

max :: Definite unit -> Definite unit -> Definite unit

min :: Definite unit -> Definite unit -> Definite unit

Outputable unit => Outputable (Definite unit)

Defined in GHC.Unit.Types

Methods

ppr :: Definite unit -> SDoc

Uniquable unit => Uniquable (Definite unit)

Defined in GHC.Unit.Types

Methods

getUnique :: Definite unit -> Unique

Binary unit => Binary (Definite unit)

Defined in GHC.Unit.Types

Methods

put_ :: BinHandle -> Definite unit -> IO ()

put :: BinHandle -> Definite unit -> IO (Bin (Definite unit))

get :: BinHandle -> IO (Definite unit)

IsUnitId unit => IsUnitId (Definite unit)

Defined in GHC.Unit.Types

Methods

unitFS :: Definite unit -> FastString

newtype Indefinite unit

Constructors

Indefinite

Fields

• indefUnit :: unit

Instances

Functor Indefinite

Defined in GHC.Unit.Types

Methods

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

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

Eq unit => Eq (Indefinite unit)

Defined in GHC.Unit.Types

Methods

(==) :: Indefinite unit -> Indefinite unit -> Bool

(/=) :: Indefinite unit -> Indefinite unit -> Bool

Ord unit => Ord (Indefinite unit)

Defined in GHC.Unit.Types

Methods

compare :: Indefinite unit -> Indefinite unit -> Ordering

(<) :: Indefinite unit -> Indefinite unit -> Bool

(<=) :: Indefinite unit -> Indefinite unit -> Bool

(>) :: Indefinite unit -> Indefinite unit -> Bool

(>=) :: Indefinite unit -> Indefinite unit -> Bool

max :: Indefinite unit -> Indefinite unit -> Indefinite unit

min :: Indefinite unit -> Indefinite unit -> Indefinite unit

Outputable unit => Outputable (Indefinite unit)

Defined in GHC.Unit.Types

Methods

ppr :: Indefinite unit -> SDoc

Uniquable unit => Uniquable (Indefinite unit)

Defined in GHC.Unit.Types

Methods

getUnique :: Indefinite unit -> Unique

Binary unit => Binary (Indefinite unit)

Defined in GHC.Unit.Types

Methods

put_ :: BinHandle -> Indefinite unit -> IO ()

put :: BinHandle -> Indefinite unit -> IO (Bin (Indefinite unit))

get :: BinHandle -> IO (Indefinite unit)

IsUnitId unit => IsUnitId (Indefinite unit)

Defined in GHC.Unit.Types

Methods

unitFS :: Indefinite unit -> FastString

Wired-in units

primUnitId :: UnitId

bignumUnitId :: UnitId

baseUnitId :: UnitId

rtsUnitId :: UnitId

thUnitId :: UnitId

mainUnitId :: UnitId

This is the package Id for the current program. It is the default package Id if you don't specify a package name. We don't add this prefix to symbol names, since there can be only one main package per program.

thisGhcUnitId :: UnitId

interactiveUnitId :: UnitId

primUnit :: Unit

bignumUnit :: Unit

baseUnit :: Unit

rtsUnit :: Unit

thUnit :: Unit

mainUnit :: Unit

thisGhcUnit :: Unit

interactiveUnit :: Unit

isInteractiveModule :: Module -> Bool

wiredInUnitIds :: [UnitId]

Boot modules

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

Eq IsBootInterface

Defined in GHC.Unit.Types

Methods

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

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

Data IsBootInterface

Defined in GHC.Unit.Types

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

Ord IsBootInterface

Defined in GHC.Unit.Types

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

Show IsBootInterface

Defined in GHC.Unit.Types

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

data GenWithIsBoot mod

This data type just pairs a value mod with an IsBootInterface flag. In practice, mod is usually a Module or ModuleName'.

Constructors

GWIB

Fields

• gwib_mod :: mod
• gwib_isBoot :: IsBootInterface

Instances

Functor GenWithIsBoot

Defined in GHC.Unit.Types

Methods

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

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

Foldable GenWithIsBoot

Defined in GHC.Unit.Types

Methods

fold :: Monoid m => GenWithIsBoot m -> m

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

foldMap' :: Monoid m => (a -> m) -> GenWithIsBoot a -> m

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

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

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

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

foldr1 :: (a -> a -> a) -> GenWithIsBoot a -> a

foldl1 :: (a -> a -> a) -> GenWithIsBoot a -> a

toList :: GenWithIsBoot a -> [a]

null :: GenWithIsBoot a -> Bool

length :: GenWithIsBoot a -> Int

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

maximum :: Ord a => GenWithIsBoot a -> a

minimum :: Ord a => GenWithIsBoot a -> a

sum :: Num a => GenWithIsBoot a -> a

product :: Num a => GenWithIsBoot a -> a

Traversable GenWithIsBoot

Defined in GHC.Unit.Types

Methods

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

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

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

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

Eq mod => Eq (GenWithIsBoot mod)

Defined in GHC.Unit.Types

Methods

(==) :: GenWithIsBoot mod -> GenWithIsBoot mod -> Bool

(/=) :: GenWithIsBoot mod -> GenWithIsBoot mod -> Bool

Ord mod => Ord (GenWithIsBoot mod)

Defined in GHC.Unit.Types

Methods

compare :: GenWithIsBoot mod -> GenWithIsBoot mod -> Ordering

(<) :: GenWithIsBoot mod -> GenWithIsBoot mod -> Bool

(<=) :: GenWithIsBoot mod -> GenWithIsBoot mod -> Bool

(>) :: GenWithIsBoot mod -> GenWithIsBoot mod -> Bool

(>=) :: GenWithIsBoot mod -> GenWithIsBoot mod -> Bool

max :: GenWithIsBoot mod -> GenWithIsBoot mod -> GenWithIsBoot mod

min :: GenWithIsBoot mod -> GenWithIsBoot mod -> GenWithIsBoot mod

Show mod => Show (GenWithIsBoot mod)

Defined in GHC.Unit.Types

Methods

showsPrec :: Int -> GenWithIsBoot mod -> ShowS

show :: GenWithIsBoot mod -> String

showList :: [GenWithIsBoot mod] -> ShowS

Outputable a => Outputable (GenWithIsBoot a)

Defined in GHC.Unit.Types

Methods

ppr :: GenWithIsBoot a -> SDoc

Binary a => Binary (GenWithIsBoot a)

Defined in GHC.Unit.Types

Methods

put_ :: BinHandle -> GenWithIsBoot a -> IO ()

put :: BinHandle -> GenWithIsBoot a -> IO (Bin (GenWithIsBoot a))

get :: BinHandle -> IO (GenWithIsBoot a)

type ModuleNameWithIsBoot = GenWithIsBoot ModuleName

type ModuleWithIsBoot = GenWithIsBoot Module