\section[CompManager]{The Compilation Manager}
 
 \begin{code}
-module CompManager ( cmInit, cmLoadModule,
+module CompManager ( cmInit, cmLoadModule, cmUnload,
 #ifdef GHCI
                      cmGetExpr, cmTypeExpr, cmRunExpr,
 #endif
 
 \end{code}
 
+Unload the compilation manager's state: everything it knows about the
+current collection of modules in the Home package.
+
+\begin{code}
+cmUnload :: CmState -> IO CmState
+cmUnload state 
+ = do -- Throw away the old home dir cache
+      emptyHomeDirCache
+      -- Throw away the HIT and the HST
+      return state{ pcms=pcms{ hst=new_hst, hit=new_hit } }
+   where
+     CmState{ pcms=pcms } = state
+     PersistentCMState{ hst=hst, hit=hit } = pcms
+     (new_hst, new_hit) = retainInTopLevelEnvs [] (hst,hit)
+\end{code}
+
 The real business of the compilation manager: given a system state and
 a module name, try and bring the module up to date, probably changing
 the system state at the same time.
         -- then generate version 2's by removing from HIT,HST,UI any
         -- modules in the old MG which are not in the new one.
 
-        -- Throw away the old home dir cache
-        emptyHomeDirCache
-
        dflags <- getDynFlags
         let verb = verbosity dflags
 
 
 -----------------------------------------------------------------------------
--- $Id: InteractiveUI.hs,v 1.12 2000/11/22 11:12:52 simonmar Exp $
+-- $Id: InteractiveUI.hs,v 1.13 2000/11/22 15:51:48 simonmar Exp $
 --
 -- GHC Interactive User Interface
 --
 loadModule :: String -> GHCi ()
 loadModule path = do
   state <- getGHCiState
-  (new_cmstate, ok, mods) <- io (cmLoadModule (cmstate state) path)
+  cmstate1 <- io (cmUnload (cmstate state))
+  (cmstate2, ok, mods) <- io (cmLoadModule cmstate1 path)
 
   let new_state = GHCiState {
-                       cmstate = new_cmstate,
+                       cmstate = cmstate2,
                        modules = mods,
                        current_module = case mods of 
                                           [] -> defaultCurrentModule
   state <- getGHCiState
   case target state of
    Nothing -> io (putStr "no current target\n")
-   Just path -> do (new_cmstate, ok, mod) 
-                       <- io (cmLoadModule (cmstate state) path)
-                  setGHCiState state{cmstate=new_cmstate}  
+   Just path
+      -> do (new_cmstate, ok, mod) <- io (cmLoadModule (cmstate state) path)
+            setGHCiState state{cmstate=new_cmstate}  
 reloadModule _ = noArgs ":reload"
 
 -- set options in the interpreter.  Syntax is exactly the same as the