Safe Haskell	None
Language	Haskell2010

Distribution.Backpack

Contents

OpenUnitId
DefUnitId
OpenModule
OpenModuleSubst
Conversions to UnitId

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

OpenUnitId

data OpenUnitId Source #

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 `ComponentId` and its `OpenModuleSubst`. TODO: Invariant that `OpenModuleSubst` is non-empty? See also the Text instance.
DefiniteUnitId DefUnitId	Identifies a fully instantiated component, which has been compiled and abbreviated as a hash. The embedded `UnitId` MUST NOT be for an indefinite component; an `OpenUnitId` is guaranteed not to have any holes.

Instances

Eq OpenUnitId Source #
Methods (==) :: OpenUnitId -> OpenUnitId -> Bool # (/=) :: OpenUnitId -> OpenUnitId -> Bool #
Data OpenUnitId Source #
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 Source #
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 Source #
Methods readsPrec :: Int -> ReadS OpenUnitId # readList :: ReadS [OpenUnitId] # readPrec :: ReadPrec OpenUnitId # readListPrec :: ReadPrec [OpenUnitId] #
Show OpenUnitId Source #
Methods showsPrec :: Int -> OpenUnitId -> ShowS # show :: OpenUnitId -> String # showList :: [OpenUnitId] -> ShowS #
Generic OpenUnitId Source #
Associated Types type Rep OpenUnitId :: * -> * # Methods from :: OpenUnitId -> Rep OpenUnitId x # to :: Rep OpenUnitId x -> OpenUnitId #
Binary OpenUnitId Source #
Methods put :: OpenUnitId -> Put # get :: Get OpenUnitId # putList :: [OpenUnitId] -> Put #
NFData OpenUnitId Source #
Methods rnf :: OpenUnitId -> () #
Text OpenUnitId Source #
Methods disp :: OpenUnitId -> Doc Source # parse :: ReadP r OpenUnitId Source #
ModSubst OpenUnitId Source #
Methods modSubst :: OpenModuleSubst -> OpenUnitId -> OpenUnitId Source #
type Rep OpenUnitId Source #
type Rep OpenUnitId = D1 (MetaData "OpenUnitId" "Distribution.Backpack" "Cabal-2.0.0.2-B4YxsRmpeLCDyDZ1N9nEz7" False) ((:+:) (C1 (MetaCons "IndefFullUnitId" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ComponentId)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 OpenModuleSubst)))) (C1 (MetaCons "DefiniteUnitId" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 DefUnitId))))

openUnitIdFreeHoles :: OpenUnitId -> Set ModuleName Source #

Get the set of holes (ModuleVar) embedded in a UnitId.

mkOpenUnitId :: UnitId -> ComponentId -> OpenModuleSubst -> OpenUnitId Source #

Safe constructor from a UnitId. The only way to do this safely is if the instantiation is provided.

DefUnitId

data DefUnitId Source #

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 Source #
Methods (==) :: DefUnitId -> DefUnitId -> Bool # (/=) :: DefUnitId -> DefUnitId -> Bool #
Data DefUnitId Source #
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 Source #
Methods compare :: DefUnitId -> DefUnitId -> Ordering # (<) :: DefUnitId -> DefUnitId -> Bool # (<=) :: DefUnitId -> DefUnitId -> Bool # (>) :: DefUnitId -> DefUnitId -> Bool # (>=) :: DefUnitId -> DefUnitId -> Bool # max :: DefUnitId -> DefUnitId -> DefUnitId # min :: DefUnitId -> DefUnitId -> DefUnitId #
Read DefUnitId Source #
Methods readsPrec :: Int -> ReadS DefUnitId # readList :: ReadS [DefUnitId] # readPrec :: ReadPrec DefUnitId # readListPrec :: ReadPrec [DefUnitId] #
Show DefUnitId Source #
Methods showsPrec :: Int -> DefUnitId -> ShowS # show :: DefUnitId -> String # showList :: [DefUnitId] -> ShowS #
Generic DefUnitId Source #
Associated Types type Rep DefUnitId :: * -> * # Methods from :: DefUnitId -> Rep DefUnitId x # to :: Rep DefUnitId x -> DefUnitId #
Binary DefUnitId Source #
Methods put :: DefUnitId -> Put # get :: Get DefUnitId # putList :: [DefUnitId] -> Put #
NFData DefUnitId Source #
Methods rnf :: DefUnitId -> () #
Text DefUnitId Source #
Methods disp :: DefUnitId -> Doc Source # parse :: ReadP r DefUnitId Source #
type Rep DefUnitId Source #
type Rep DefUnitId = D1 (MetaData "DefUnitId" "Distribution.Types.UnitId" "Cabal-2.0.0.2-B4YxsRmpeLCDyDZ1N9nEz7" True) (C1 (MetaCons "DefUnitId" PrefixI True) (S1 (MetaSel (Just Symbol "unDefUnitId") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 UnitId)))

unDefUnitId :: DefUnitId -> UnitId Source #

mkDefUnitId :: ComponentId -> Map ModuleName Module -> DefUnitId Source #

Create a DefUnitId from a ComponentId and an instantiation with no holes.

OpenModule

data OpenModule Source #

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

Eq OpenModule Source #
Methods (==) :: OpenModule -> OpenModule -> Bool # (/=) :: OpenModule -> OpenModule -> Bool #
Data OpenModule Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OpenModule -> c OpenModule # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OpenModule # toConstr :: OpenModule -> Constr # dataTypeOf :: OpenModule -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c OpenModule) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OpenModule) # gmapT :: (forall b. Data b => b -> b) -> OpenModule -> OpenModule # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OpenModule -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OpenModule -> r # gmapQ :: (forall d. Data d => d -> u) -> OpenModule -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> OpenModule -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OpenModule -> m OpenModule # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OpenModule -> m OpenModule # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OpenModule -> m OpenModule #
Ord OpenModule Source #
Methods compare :: OpenModule -> OpenModule -> Ordering # (<) :: OpenModule -> OpenModule -> Bool # (<=) :: OpenModule -> OpenModule -> Bool # (>) :: OpenModule -> OpenModule -> Bool # (>=) :: OpenModule -> OpenModule -> Bool # max :: OpenModule -> OpenModule -> OpenModule # min :: OpenModule -> OpenModule -> OpenModule #
Read OpenModule Source #
Methods readsPrec :: Int -> ReadS OpenModule # readList :: ReadS [OpenModule] # readPrec :: ReadPrec OpenModule # readListPrec :: ReadPrec [OpenModule] #
Show OpenModule Source #
Methods showsPrec :: Int -> OpenModule -> ShowS # show :: OpenModule -> String # showList :: [OpenModule] -> ShowS #
Generic OpenModule Source #
Associated Types type Rep OpenModule :: * -> * # Methods from :: OpenModule -> Rep OpenModule x # to :: Rep OpenModule x -> OpenModule #
Binary OpenModule Source #
Methods put :: OpenModule -> Put # get :: Get OpenModule # putList :: [OpenModule] -> Put #
NFData OpenModule Source #
Methods rnf :: OpenModule -> () #
Text OpenModule Source #
Methods disp :: OpenModule -> Doc Source # parse :: ReadP r OpenModule Source #
ModSubst OpenModule Source #
Methods modSubst :: OpenModuleSubst -> OpenModule -> OpenModule Source #
type Rep OpenModule Source #
type Rep OpenModule = D1 (MetaData "OpenModule" "Distribution.Backpack" "Cabal-2.0.0.2-B4YxsRmpeLCDyDZ1N9nEz7" False) ((:+:) (C1 (MetaCons "OpenModule" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 OpenUnitId)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ModuleName)))) (C1 (MetaCons "OpenModuleVar" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ModuleName))))

openModuleFreeHoles :: OpenModule -> Set ModuleName Source #

Get the set of holes (ModuleVar) embedded in a Module.

OpenModuleSubst

type OpenModuleSubst = Map ModuleName OpenModule Source #

An explicit substitution on modules.

NB: These substitutions are NOT idempotent, for example, a valid substitution is (A -> B, B -> A).

dispOpenModuleSubst :: OpenModuleSubst -> Doc Source #

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 Source #

Pretty-print a single entry of a module substitution.

parseOpenModuleSubst :: ReadP r OpenModuleSubst Source #

Inverse to dispModSubst.

parseOpenModuleSubstEntry :: ReadP r (ModuleName, OpenModule) Source #

Inverse to dispModSubstEntry.

openModuleSubstFreeHoles :: OpenModuleSubst -> Set ModuleName Source #

Get the set of holes (ModuleVar) embedded in a OpenModuleSubst. This is NOT the domain of the substitution.

Conversions to `UnitId`

abstractUnitId :: OpenUnitId -> UnitId Source #

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 Source #

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.

OpenUnitId

DefUnitId

OpenModule

OpenModuleSubst

Conversions to UnitId

Conversions to `UnitId`