    {-# LANGUAGE FlexibleInstances #-}
    {-# LANGUAGE PatternGuards #-}

    -- | A type class 'ModSubst' for objects which can have 'ModuleSubst'
    -- applied to them.
    --
    -- See also <https://github.com/ezyang/ghc-proposals/blob/backpack/proposals/0000-backpack.rst>

    module Distribution.Backpack.ModSubst (
        ModSubst(..),
    ) where

    import Prelude ()
    import Distribution.Compat.Prelude hiding (mod)

    import Distribution.Backpack
    import Distribution.ModuleName

    import qualified Data.Map as Map
    import qualified Data.Set as Set

    -- | Applying module substitutions to semantic objects.
    class ModSubst a where
        -- In notation, substitution is postfix, which implies
        -- putting it on the right hand side, but for partial
        -- application it's more convenient to have it on the left
        -- hand side.
        modSubst :: OpenModuleSubst -> a -> a

    instance ModSubst OpenModule where
        modSubst :: OpenModuleSubst -> OpenModule -> OpenModule
    modSubst OpenModuleSubst
    subst (OpenModule OpenUnitId
    cid ModuleName
    mod_name) = OpenUnitId -> ModuleName -> OpenModule
    OpenModule (OpenModuleSubst -> OpenUnitId -> OpenUnitId
    forall a. ModSubst a => OpenModuleSubst -> a -> a
    modSubst OpenModuleSubst
    subst OpenUnitId
    cid) ModuleName
    mod_name
        modSubst OpenModuleSubst
    subst mod :: OpenModule
    mod@(OpenModuleVar ModuleName
    mod_name)
            | Just OpenModule
    mod' <- ModuleName -> OpenModuleSubst -> Maybe OpenModule
    forall k a. Ord k => k -> Map k a -> Maybe a
    Map.lookup ModuleName
    mod_name OpenModuleSubst
    subst = OpenModule
    mod'
            | Bool
    otherwise = OpenModule
    mod

    instance ModSubst OpenUnitId where
        modSubst :: OpenModuleSubst -> OpenUnitId -> OpenUnitId
    modSubst OpenModuleSubst
    subst (IndefFullUnitId ComponentId
    cid OpenModuleSubst
    insts) = ComponentId -> OpenModuleSubst -> OpenUnitId
    IndefFullUnitId ComponentId
    cid (OpenModuleSubst -> OpenModuleSubst -> OpenModuleSubst
    forall a. ModSubst a => OpenModuleSubst -> a -> a
    modSubst OpenModuleSubst
    subst OpenModuleSubst
    insts)
        modSubst OpenModuleSubst
    _subst OpenUnitId
    uid = OpenUnitId
    uid

    instance ModSubst (Set ModuleName) where
        modSubst :: OpenModuleSubst -> Set ModuleName -> Set ModuleName
    modSubst OpenModuleSubst
    subst Set ModuleName
    reqs
            = Set ModuleName -> Set ModuleName -> Set ModuleName
    forall a. Ord a => Set a -> Set a -> Set a
    Set.union (Set ModuleName -> Set ModuleName -> Set ModuleName
    forall a. Ord a => Set a -> Set a -> Set a
    Set.difference Set ModuleName
    reqs (OpenModuleSubst -> Set ModuleName
    forall k a. Map k a -> Set k
    Map.keysSet OpenModuleSubst
    subst))
                        (OpenModuleSubst -> Set ModuleName
    openModuleSubstFreeHoles OpenModuleSubst
    subst)

    -- Substitutions are functorial.  NB: this means that
    -- there is an @instance 'ModSubst' 'ModuleSubst'@!
    instance ModSubst a => ModSubst (Map k a) where
        modSubst :: OpenModuleSubst -> Map k a -> Map k a
    modSubst OpenModuleSubst
    subst = (a -> a) -> Map k a -> Map k a
    forall a b. (a -> b) -> Map k a -> Map k b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (OpenModuleSubst -> a -> a
    forall a. ModSubst a => OpenModuleSubst -> a -> a
    modSubst OpenModuleSubst
    subst)
    instance ModSubst a => ModSubst [a] where
        modSubst :: OpenModuleSubst -> [a] -> [a]
    modSubst OpenModuleSubst
    subst = (a -> a) -> [a] -> [a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (OpenModuleSubst -> a -> a
    forall a. ModSubst a => OpenModuleSubst -> a -> a
    modSubst OpenModuleSubst
    subst)
    instance ModSubst a => ModSubst (k, a) where
        modSubst :: OpenModuleSubst -> (k, a) -> (k, a)
    modSubst OpenModuleSubst
    subst (k
    x,a
    y) = (k
    x, OpenModuleSubst -> a -> a
    forall a. ModSubst a => OpenModuleSubst -> a -> a
    modSubst OpenModuleSubst
    subst a
    y)