| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Distribution.Backpack
Description
This module defines the core data types for Backpack. For more details, see:
https://github.com/ezyang/ghc-proposals/blob/backpack/proposals/0000-backpack.rst
Synopsis
- data OpenUnitId
- openUnitIdFreeHoles :: OpenUnitId -> Set ModuleName
- mkOpenUnitId :: UnitId -> ComponentId -> OpenModuleSubst -> OpenUnitId
- data DefUnitId
- unDefUnitId :: DefUnitId -> UnitId
- mkDefUnitId :: ComponentId -> Map ModuleName Module -> DefUnitId
- data OpenModule
- openModuleFreeHoles :: OpenModule -> Set ModuleName
- type OpenModuleSubst = Map ModuleName OpenModule
- dispOpenModuleSubst :: OpenModuleSubst -> Doc
- dispOpenModuleSubstEntry :: (ModuleName, OpenModule) -> Doc
- parseOpenModuleSubst :: ReadP r OpenModuleSubst
- parseOpenModuleSubstEntry :: ReadP r (ModuleName, OpenModule)
- parsecOpenModuleSubst :: CabalParsing m => m OpenModuleSubst
- parsecOpenModuleSubstEntry :: CabalParsing m => m (ModuleName, OpenModule)
- openModuleSubstFreeHoles :: OpenModuleSubst -> Set ModuleName
- abstractUnitId :: OpenUnitId -> UnitId
- hashModuleSubst :: Map ModuleName Module -> Maybe String
OpenUnitId
data OpenUnitId #
An OpenUnitId describes a (possibly partially) instantiated
Backpack component, with a description of how the holes are filled
in. Unlike OpenUnitId, the ModuleSubst is kept in a structured
form that allows for substitution (which fills in holes.) This form
of unit cannot be installed. It must first be converted to a
UnitId.
In the absence of Backpack, there are no holes to fill, so any such component always has an empty module substitution; thus we can lossly represent it as an 'OpenUnitId uid'.
For a source component using Backpack, however, there is more structure as components may be parametrized over some signatures, and these "holes" may be partially or wholly filled.
OpenUnitId plays an important role when we are mix-in linking,
and is recorded to the installed packaged database for indefinite
packages; however, for compiled packages that are fully instantiated,
we instantiate OpenUnitId into UnitId.
For more details see the Backpack spec https://github.com/ezyang/ghc-proposals/blob/backpack/proposals/0000-backpack.rst
Constructors
| IndefFullUnitId ComponentId OpenModuleSubst | Identifies a component which may have some unfilled holes;
specifying its |
| DefiniteUnitId DefUnitId | Identifies a fully instantiated component, which has
been compiled and abbreviated as a hash. The embedded |
Instances
| Eq OpenUnitId # | |
| Data OpenUnitId # | |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OpenUnitId -> c OpenUnitId # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OpenUnitId # toConstr :: OpenUnitId -> Constr # dataTypeOf :: OpenUnitId -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OpenUnitId) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OpenUnitId) # gmapT :: (forall b. Data b => b -> b) -> OpenUnitId -> OpenUnitId # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OpenUnitId -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OpenUnitId -> r # gmapQ :: (forall d. Data d => d -> u) -> OpenUnitId -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> OpenUnitId -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OpenUnitId -> m OpenUnitId # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OpenUnitId -> m OpenUnitId # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OpenUnitId -> m OpenUnitId # | |
| Ord OpenUnitId # | |
Methods compare :: OpenUnitId -> OpenUnitId -> Ordering # (<) :: OpenUnitId -> OpenUnitId -> Bool # (<=) :: OpenUnitId -> OpenUnitId -> Bool # (>) :: OpenUnitId -> OpenUnitId -> Bool # (>=) :: OpenUnitId -> OpenUnitId -> Bool # max :: OpenUnitId -> OpenUnitId -> OpenUnitId # min :: OpenUnitId -> OpenUnitId -> OpenUnitId # | |
| Read OpenUnitId # | |
Methods readsPrec :: Int -> ReadS OpenUnitId # readList :: ReadS [OpenUnitId] # readPrec :: ReadPrec OpenUnitId # readListPrec :: ReadPrec [OpenUnitId] # | |
| Show OpenUnitId # | |
Methods showsPrec :: Int -> OpenUnitId -> ShowS # show :: OpenUnitId -> String # showList :: [OpenUnitId] -> ShowS # | |
| Generic OpenUnitId # | |
Associated Types type Rep OpenUnitId :: * -> * # | |
| Binary OpenUnitId # | |
| NFData OpenUnitId # | |
Methods rnf :: OpenUnitId -> () # | |
| Pretty OpenUnitId # | |
Methods pretty :: OpenUnitId -> Doc # | |
| Parsec OpenUnitId # |
|
Methods parsec :: CabalParsing m => m OpenUnitId # | |
| Text OpenUnitId # | |
| ModSubst OpenUnitId # | |
Methods modSubst :: OpenModuleSubst -> OpenUnitId -> OpenUnitId # | |
| type Rep OpenUnitId # | |
type Rep OpenUnitId = D1 (MetaData "OpenUnitId" "Distribution.Backpack" "Cabal-2.2.0.1-JS0vobxWxH7sbYKd0omMO" False) (C1 (MetaCons "IndefFullUnitId" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ComponentId) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 OpenModuleSubst)) :+: C1 (MetaCons "DefiniteUnitId" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 DefUnitId))) | |
openUnitIdFreeHoles :: OpenUnitId -> Set ModuleName #
Get the set of holes (ModuleVar) embedded in a UnitId.
mkOpenUnitId :: UnitId -> ComponentId -> OpenModuleSubst -> OpenUnitId #
Safe constructor from a UnitId. The only way to do this safely is if the instantiation is provided.
DefUnitId
A UnitId for a definite package. The DefUnitId invariant says
that a UnitId identified this way is definite; i.e., it has no
unfilled holes.
Instances
| Eq DefUnitId # | |
| Data DefUnitId # | |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DefUnitId -> c DefUnitId # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DefUnitId # toConstr :: DefUnitId -> Constr # dataTypeOf :: DefUnitId -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DefUnitId) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DefUnitId) # gmapT :: (forall b. Data b => b -> b) -> DefUnitId -> DefUnitId # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DefUnitId -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DefUnitId -> r # gmapQ :: (forall d. Data d => d -> u) -> DefUnitId -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DefUnitId -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DefUnitId -> m DefUnitId # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DefUnitId -> m DefUnitId # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DefUnitId -> m DefUnitId # | |
| Ord DefUnitId # | |
| Read DefUnitId # | |
| Show DefUnitId # | |
| Generic DefUnitId # | |
| Binary DefUnitId # | |
| NFData DefUnitId # | |
| Pretty DefUnitId # | |
| Parsec DefUnitId # | |
Methods parsec :: CabalParsing m => m DefUnitId # | |
| Text DefUnitId # | |
| type Rep DefUnitId # | |
unDefUnitId :: DefUnitId -> UnitId #
mkDefUnitId :: ComponentId -> Map ModuleName Module -> DefUnitId #
Create a DefUnitId from a ComponentId and an instantiation
with no holes.
OpenModule
data OpenModule #
Unlike a Module, an OpenModule is either an ordinary
module from some unit, OR an OpenModuleVar, representing a
hole that needs to be filled in. Substitutions are over
module variables.
Constructors
| OpenModule OpenUnitId ModuleName | |
| OpenModuleVar ModuleName |
Instances
openModuleFreeHoles :: OpenModule -> Set ModuleName #
Get the set of holes (ModuleVar) embedded in a Module.
OpenModuleSubst
type OpenModuleSubst = Map ModuleName OpenModule #
An explicit substitution on modules.
NB: These substitutions are NOT idempotent, for example, a valid substitution is (A -> B, B -> A).
dispOpenModuleSubst :: OpenModuleSubst -> Doc #
Pretty-print the entries of a module substitution, suitable
for embedding into a OpenUnitId or passing to GHC via --instantiate-with.
dispOpenModuleSubstEntry :: (ModuleName, OpenModule) -> Doc #
Pretty-print a single entry of a module substitution.
parseOpenModuleSubst :: ReadP r OpenModuleSubst #
Inverse to dispModSubst.
parseOpenModuleSubstEntry :: ReadP r (ModuleName, OpenModule) #
Inverse to dispModSubstEntry.
parsecOpenModuleSubst :: CabalParsing m => m OpenModuleSubst #
Inverse to dispModSubst.
Since: 2.2
parsecOpenModuleSubstEntry :: CabalParsing m => m (ModuleName, OpenModule) #
Inverse to dispModSubstEntry.
Since: 2.2
openModuleSubstFreeHoles :: OpenModuleSubst -> Set ModuleName #
Get the set of holes (ModuleVar) embedded in a OpenModuleSubst.
This is NOT the domain of the substitution.
Conversions to UnitId
abstractUnitId :: OpenUnitId -> UnitId #
When typechecking, we don't demand that a freshly instantiated
IndefFullUnitId be compiled; instead, we just depend on the
installed indefinite unit installed at the ComponentId.
hashModuleSubst :: Map ModuleName Module -> Maybe String #
Take a module substitution and hash it into a string suitable for
UnitId. Note that since this takes Module, not OpenModule,
you are responsible for recursively converting OpenModule
into Module. See also Distribution.Backpack.ReadyComponent.