Introducing a datatype for WorkLists that properly prioritizes equalities.
[ghc.git] / compiler / typecheck / TcInteract.lhs
index 9f89f64..4a049aa 100644 (file)
@@ -1,12 +1,13 @@
 \begin{code}
 module TcInteract ( 
-     solveInteract, AtomicInert, 
-     InertSet, emptyInert, extendInertSet, extractUnsolved, solveOne,
-     listToWorkList
+     solveInteract, solveInteractGiven, solveInteractWanted,
+     AtomicInert, tyVarsOfInert, 
+     InertSet, emptyInert, updInertSet, extractUnsolved, solveOne,
   ) where  
 
 #include "HsVersions.h"
 
+
 import BasicTypes 
 import TcCanonical
 import VarSet
@@ -16,32 +17,32 @@ import Id
 import Var
 
 import TcType
-import HsBinds 
+import HsBinds
 
-import InstEnv 
-import Class 
-import TyCon 
+import Inst( tyVarsOfEvVar )
+import Class
+import TyCon
 import Name
 
 import FunDeps
 
-import Control.Monad ( when ) 
-
 import Coercion
 import Outputable
 
-import TcRnTypes 
+import TcRnTypes
 import TcErrors
-import TcSMonad 
-import qualified Bag as Bag
-import Control.Monad( zipWithM, unless )
+import TcSMonad
+import Bag
+import qualified Data.Map as Map
+
+import Control.Monad( when )
+
 import FastString ( sLit ) 
 import DynFlags
 \end{code}
 
-Note [InsertSet invariants]
+Note [InertSet invariants]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 An InertSet is a bag of canonical constraints, with the following invariants:
 
   1 No two constraints react with each other. 
@@ -55,15 +56,20 @@ An InertSet is a bag of canonical constraints, with the following invariants:
     given LHS's occur in any of the given RHS's or reactant parts]
 
   3 Wanted equalities also form an idempotent substitution
+
   4 The entire set of equalities is acyclic.
 
   5 Wanted dictionaries are inert with the top-level axiom set 
 
   6 Equalities of the form tv1 ~ tv2 always have a touchable variable
     on the left (if possible).
-  7 No wanted constraints tv1 ~ tv2 with tv1 touchable. Such constraints 
+
+  7 No wanted constraints tv1 ~ tv2 with tv1 touchable. Such constraints
     will be marked as solved right before being pushed into the inert set. 
     See note [Touchables and givens].
+
+  8 No Given constraint mentions a touchable unification variable,
+    except if the
  
 Note that 6 and 7 are /not/ enforced by canonicalization but rather by 
 insertion in the inert list, ie by TcInteract. 
@@ -78,80 +84,123 @@ implication constraint (when in top-level inference mode).
 
 \begin{code}
 
--- See Note [InertSet invariants]
+data CCanMap a = CCanMap { cts_given   :: Map.Map a CanonicalCts
+                                          -- Invariant: all Given
+                         , cts_derived :: Map.Map a CanonicalCts 
+                                          -- Invariant: all Derived
+                         , cts_wanted  :: Map.Map a CanonicalCts } 
+                                          -- Invariant: all Wanted
+
+cCanMapToBag :: Ord a => CCanMap a -> CanonicalCts 
+cCanMapToBag cmap = Map.fold unionBags rest_wder (cts_given cmap)
+  where rest_wder = Map.fold unionBags rest_der  (cts_wanted cmap) 
+        rest_der  = Map.fold unionBags emptyCCan (cts_derived cmap)
+
+emptyCCanMap :: CCanMap a 
+emptyCCanMap = CCanMap { cts_given = Map.empty
+                       , cts_derived = Map.empty, cts_wanted = Map.empty } 
+
+updCCanMap:: Ord a => (a,CanonicalCt) -> CCanMap a -> CCanMap a 
+updCCanMap (a,ct) cmap 
+  = case cc_flavor ct of 
+      Wanted {} 
+          -> cmap { cts_wanted = Map.insertWith unionBags a this_ct (cts_wanted cmap) } 
+      Given {} 
+          -> cmap { cts_given = Map.insertWith unionBags a this_ct (cts_given cmap) }
+      Derived {}
+          -> cmap { cts_derived = Map.insertWith unionBags a this_ct (cts_derived cmap) }
+  where this_ct = singleCCan ct 
+
+getRelevantCts :: Ord a => a -> CCanMap a -> (CanonicalCts, CCanMap a) 
+-- Gets the relevant constraints and returns the rest of the CCanMap
+getRelevantCts a cmap 
+    = let relevant = unionManyBags [ Map.findWithDefault emptyCCan a (cts_wanted cmap)
+                                   , Map.findWithDefault emptyCCan a (cts_given cmap)
+                                   , Map.findWithDefault emptyCCan a (cts_derived cmap) ]
+          residual_map = cmap { cts_wanted = Map.delete a (cts_wanted cmap) 
+                              , cts_given = Map.delete a (cts_given cmap) 
+                              , cts_derived = Map.delete a (cts_derived cmap) }
+      in (relevant, residual_map) 
+
+extractUnsolvedCMap :: Ord a => CCanMap a -> (CanonicalCts, CCanMap a)
+-- Gets the wanted or derived constraints and returns a residual
+-- CCanMap with only givens.
+extractUnsolvedCMap cmap =
+  let wntd = Map.fold unionBags emptyCCan (cts_wanted cmap)
+      derd = Map.fold unionBags emptyCCan (cts_derived cmap)
+  in (wntd `unionBags` derd, 
+           cmap { cts_wanted = Map.empty, cts_derived = Map.empty })
 
-newtype InertSet = IS (Bag.Bag CanonicalCt)
-instance Outputable InertSet where
-  ppr (IS cts) = vcat (map ppr (Bag.bagToList cts))
 
-{- TODO: Later ...
-data Inert = IS { class_inerts :: FiniteMap Class Atomics
-                 ip_inerts    :: FiniteMap Class Atomics
-                 tyfun_inerts :: FiniteMap TyCon Atomics
-                 tyvar_inerts :: FiniteMap TyVar Atomics
-                }
+-- See Note [InertSet invariants]
+data InertSet 
+  = IS { inert_eqs          :: CanonicalCts               -- Equalities only (CTyEqCan)
+       , inert_dicts        :: CCanMap Class              -- Dictionaries only
+       , inert_ips          :: CCanMap (IPName Name)      -- Implicit parameters 
+       , inert_frozen       :: CanonicalCts
+       , inert_funeqs       :: CCanMap TyCon              -- Type family equalities only
+               -- This representation allows us to quickly get to the relevant 
+               -- inert constraints when interacting a work item with the inert set.
+       }
 
-Later should we also separate out givens and wanteds?
--}
+tyVarsOfInert :: InertSet -> TcTyVarSet 
+tyVarsOfInert (IS { inert_eqs    = eqs
+                  , inert_dicts  = dictmap
+                  , inert_ips    = ipmap
+                  , inert_frozen = frozen
+                  , inert_funeqs = funeqmap }) = tyVarsOfCanonicals cts
+  where
+    cts = eqs `andCCan` frozen `andCCan` cCanMapToBag dictmap
+              `andCCan` cCanMapToBag ipmap `andCCan` cCanMapToBag funeqmap
 
+instance Outputable InertSet where
+  ppr is = vcat [ vcat (map ppr (Bag.bagToList $ inert_eqs is))
+                , vcat (map ppr (Bag.bagToList $ cCanMapToBag (inert_dicts is)))
+                , vcat (map ppr (Bag.bagToList $ cCanMapToBag (inert_ips is))) 
+                , vcat (map ppr (Bag.bagToList $ cCanMapToBag (inert_funeqs is)))
+                , vcat (map ppr (Bag.bagToList $ inert_frozen is))
+                ]
+                       
 emptyInert :: InertSet
-emptyInert = IS Bag.emptyBag
-
-extendInertSet :: InertSet -> AtomicInert -> InertSet
-extendInertSet (IS cts) item = IS (cts `Bag.snocBag` item)
-
-foldlInertSetM :: (Monad m) => (a -> AtomicInert -> m a) -> a -> InertSet -> m a 
-foldlInertSetM k z (IS cts) = Bag.foldlBagM k z cts
+emptyInert = IS { inert_eqs    = Bag.emptyBag
+                , inert_frozen = Bag.emptyBag
+                , inert_dicts  = emptyCCanMap
+                , inert_ips    = emptyCCanMap
+                , inert_funeqs = emptyCCanMap }
+
+updInertSet :: InertSet -> AtomicInert -> InertSet 
+updInertSet is item 
+  | isCTyEqCan item                     -- Other equality 
+  = let eqs' = inert_eqs is `Bag.snocBag` item 
+    in is { inert_eqs = eqs' } 
+  | Just cls <- isCDictCan_Maybe item   -- Dictionary 
+  = is { inert_dicts = updCCanMap (cls,item) (inert_dicts is) } 
+  | Just x  <- isCIPCan_Maybe item      -- IP 
+  = is { inert_ips   = updCCanMap (x,item) (inert_ips is) }  
+  | Just tc <- isCFunEqCan_Maybe item   -- Function equality 
+  = is { inert_funeqs = updCCanMap (tc,item) (inert_funeqs is) }
+  | otherwise 
+  = is { inert_frozen = inert_frozen is `Bag.snocBag` item }
 
 extractUnsolved :: InertSet -> (InertSet, CanonicalCts)
-extractUnsolved (IS cts)
-  = (IS cts', unsolved)
-  where (unsolved, cts') = Bag.partitionBag isWantedCt cts
-
-isWantedCt :: CanonicalCt -> Bool 
-isWantedCt ct = isWanted (cc_flavor ct)
+-- Postcondition: the returned canonical cts are either Derived, or Wanted.
+extractUnsolved is@(IS {inert_eqs = eqs}) 
+  = let is_solved  = is { inert_eqs    = solved_eqs
+                        , inert_dicts  = solved_dicts
+                        , inert_ips    = solved_ips
+                        , inert_frozen = emptyCCan
+                        , inert_funeqs = solved_funeqs }
+    in (is_solved, unsolved)
+
+  where (unsolved_eqs, solved_eqs)       = Bag.partitionBag (not.isGivenCt) eqs
+        (unsolved_ips, solved_ips)       = extractUnsolvedCMap (inert_ips is) 
+        (unsolved_dicts, solved_dicts)   = extractUnsolvedCMap (inert_dicts is) 
+        (unsolved_funeqs, solved_funeqs) = extractUnsolvedCMap (inert_funeqs is) 
+
+        unsolved = unsolved_eqs `unionBags` inert_frozen is `unionBags`
+                   unsolved_ips `unionBags` unsolved_dicts `unionBags` unsolved_funeqs
 \end{code}
 
-Note [Touchables and givens]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Touchable variables will never show up in givens which are inputs to
-the solver.  However, touchables may show up in givens generated by the flattener.  
-For example,
-
-  axioms:
-    G Int ~ Char
-    F Char ~ Int
-
-  wanted:
-    F (G alpha) ~w Int
-  
-canonicalises to
-
-  G alpha ~g b
-  F b ~w Int
-
-which can be put in the inert set.  Suppose we also have a wanted
-
-  alpha ~w Int
-
-We cannot rewrite the given G alpha ~g b using the wanted alpha ~w
-Int.  Instead, after reacting alpha ~w Int with the whole inert set,
-we observe that we can solve it by unifying alpha with Int, so we mark
-it as solved and put it back in the *work list*. [We also immediately unify
-alpha := Int, without telling anyone, see trySpontaneousSolve function, to 
-avoid doing this in the end.]
-
-Later, because it is solved (given, in effect), we can use it to rewrite 
-G alpha ~g b to G Int ~g b, which gets put back in the work list. Eventually, 
-we will dispatch the remaining wanted constraints using the top-level axioms.
-
-Finally, note that after reacting a wanted equality with the entire inert set
-we may end up with something like
-
-  b ~w alpha
-
-which we should flip around to generate the solved constraint alpha ~s b.
-
 %*********************************************************************
 %*                                                                   * 
 *                      Main Interaction Solver                       *
@@ -164,34 +213,19 @@ Note [Basic plan]
 2. Pairwise interaction (binary)
     * Take one from work list 
     * Try all pair-wise interactions with each constraint in inert
+   
+   As an optimisation, we prioritize the equalities both in the 
+   worklist and in the inerts. 
+
 3. Try to solve spontaneously for equalities involving touchables 
 4. Top-level interaction (binary wrt top-level)
    Superclass decomposition belongs in (4), see note [Superclasses]
 
 \begin{code}
-
 type AtomicInert = CanonicalCt     -- constraint pulled from InertSet
 type WorkItem    = CanonicalCt     -- constraint pulled from WorkList
-type SWorkItem   = WorkItem        -- a work item we know is solved
-
-type WorkList    = CanonicalCts    -- A mixture of Given, Wanted, and Solved
-                   
-
-listToWorkList :: [WorkItem] -> WorkList
-listToWorkList = Bag.listToBag
-
-unionWorkLists :: WorkList -> WorkList -> WorkList 
-unionWorkLists = Bag.unionBags 
-
-foldlWorkListM :: (Monad m) => (a -> WorkItem -> m a) -> a -> WorkList -> m a 
-foldlWorkListM = Bag.foldlBagM 
-
-isEmptyWorkList :: WorkList -> Bool 
-isEmptyWorkList = Bag.isEmptyBag
-
-emptyWorkList :: WorkList
-emptyWorkList = Bag.emptyBag
 
+------------------------
 data StopOrContinue 
   = Stop                       -- Work item is consumed
   | ContinueWith WorkItem      -- Not consumed
@@ -219,26 +253,29 @@ instance Outputable StageResult where
                  , ptext (sLit "new work =") <+> ppr work <> comma
                  , ptext (sLit "stop =") <+> ppr stop])
 
-type SimplifierStage = WorkItem -> InertSet -> TcS StageResult 
+type SubGoalDepth = Int          -- Starts at zero; used to limit infinite
+                         -- recursion of sub-goals
+type SimplifierStage = SubGoalDepth -> WorkItem -> InertSet -> TcS StageResult 
 
 -- Combine a sequence of simplifier 'stages' to create a pipeline 
-runSolverPipeline :: [(String, SimplifierStage)]
-                  -> InertSet -> WorkItem 
+runSolverPipeline :: SubGoalDepth
+                  -> [(String, SimplifierStage)]
+                 -> InertSet -> WorkItem 
                   -> TcS (InertSet, WorkList)
 -- Precondition: non-empty list of stages 
-runSolverPipeline pipeline inerts workItem
+runSolverPipeline depth pipeline inerts workItem
   = do { traceTcS "Start solver pipeline" $ 
             vcat [ ptext (sLit "work item =") <+> ppr workItem
                  , ptext (sLit "inerts    =") <+> ppr inerts]
 
        ; let itr_in = SR { sr_inerts = inerts
-                        , sr_new_work = emptyWorkList
-                        , sr_stop = ContinueWith workItem }
+                         , sr_new_work = emptyWorkList
+                         , sr_stop = ContinueWith workItem }
        ; itr_out <- run_pipeline pipeline itr_in
        ; let new_inert 
               = case sr_stop itr_out of 
                          Stop              -> sr_inerts itr_out
-                  ContinueWith item -> sr_inerts itr_out `extendInertSet` item
+                  ContinueWith item -> sr_inerts itr_out `updInertSet` item
        ; return (new_inert, sr_new_work itr_out) }
   where 
     run_pipeline :: [(String, SimplifierStage)]
@@ -250,10 +287,9 @@ runSolverPipeline pipeline inerts workItem
                  (SR { sr_new_work = accum_work
                      , sr_inerts   = inerts
                      , sr_stop     = ContinueWith work_item })
-      = do { itr <- stage work_item inerts 
+      = do { itr <- stage depth work_item inerts 
            ; traceTcS ("Stage result (" ++ name ++ ")") (ppr itr)
-           ; let itr' = itr { sr_new_work = sr_new_work itr 
-                                            `unionWorkLists` accum_work }
+           ; let itr' = itr { sr_new_work = accum_work `unionWorkList` sr_new_work itr }
            ; run_pipeline stages itr' }
 \end{code}
 
@@ -285,21 +321,133 @@ React with (F Int ~ b) ==> IR Stop True []    -- after substituting we re-canoni
 -- returning an extended inert set.
 --
 -- See Note [Touchables and givens].
-solveInteract :: InertSet -> WorkList -> TcS InertSet
+solveInteractGiven :: InertSet -> GivenLoc -> [EvVar] -> TcS InertSet
+solveInteractGiven inert gloc evs
+  = do { (_, inert_ret) <- solveInteract inert $ listToBag $
+                           map mk_given evs
+       ; return inert_ret }
+  where
+    flav = Given gloc
+    mk_given ev = mkEvVarX ev flav
+
+solveInteractWanted :: InertSet -> [WantedEvVar] -> TcS InertSet
+solveInteractWanted inert wvs
+  = do { (_,inert_ret) <- solveInteract inert $ listToBag $
+                          map wantedToFlavored wvs
+       ; return inert_ret }
+
+solveInteract :: InertSet -> Bag FlavoredEvVar -> TcS (Bool, InertSet)
+-- Post: (True,  inert_set) means we managed to discharge all constraints
+--                          without actually doing any interactions!
+--       (False, inert_set) means some interactions occurred
 solveInteract inert ws 
   = do { dyn_flags <- getDynFlags
-       ; solveInteractWithDepth (ctxtStkDepth dyn_flags,0,[]) inert ws 
-       }
-solveOne :: InertSet -> WorkItem -> TcS InertSet 
-solveOne inerts workItem 
+       ; sctx <- getTcSContext
+
+       ; traceTcS "solveInteract, before clever canonicalization:" $
+         vcat [ text "ws = " <+>  ppr (mapBag (\(EvVarX ev ct)
+                                                   -> (ct,evVarPred ev)) ws)
+              , text "inert = " <+> ppr inert ]
+
+       ; can_ws <- mkCanonicalFEVs ws
+
+       ; (flag, inert_ret)
+           <- foldrWorkListM (tryPreSolveAndInteract sctx dyn_flags) (True,inert) can_ws
+
+       ; traceTcS "solveInteract, after clever canonicalization (and interaction):" $
+         vcat [ text "No interaction happened = " <+> ppr flag
+              , text "inert_ret = " <+> ppr inert_ret ]
+
+       ; return (flag, inert_ret) }
+
+tryPreSolveAndInteract :: SimplContext
+                       -> DynFlags
+                       -> CanonicalCt
+                       -> (Bool, InertSet)
+                       -> TcS (Bool, InertSet)
+-- Returns: True if it was able to discharge this constraint AND all previous ones
+tryPreSolveAndInteract sctx dyn_flags ct (all_previous_discharged, inert)
+  = do { let inert_cts = get_inert_cts (evVarPred ev_var)
+
+       ; this_one_discharged <- 
+           if isCFrozenErr ct then 
+               return False
+           else
+               dischargeFromCCans inert_cts ev_var fl
+
+       ; if this_one_discharged
+         then return (all_previous_discharged, inert)
+
+         else do
+       { inert_ret <- solveOneWithDepth (ctxtStkDepth dyn_flags,0,[]) ct inert
+       ; return (False, inert_ret) } }
+
+  where
+    ev_var = cc_id ct
+    fl = cc_flavor ct 
+
+    get_inert_cts (ClassP clas _)
+      | simplEqsOnly sctx = emptyCCan
+      | otherwise         = fst (getRelevantCts clas (inert_dicts inert))
+    get_inert_cts (IParam {})
+      = emptyCCan -- We must not do the same thing for IParams, because (contrary
+                  -- to dictionaries), work items /must/ override inert items.
+                 -- See Note [Overriding implicit parameters] in TcInteract.
+    get_inert_cts (EqPred {})
+      = inert_eqs inert `unionBags` cCanMapToBag (inert_funeqs inert)
+
+dischargeFromCCans :: CanonicalCts -> EvVar -> CtFlavor -> TcS Bool
+-- See if this (pre-canonicalised) work-item is identical to a 
+-- one already in the inert set. Reasons:
+--    a) Avoid creating superclass constraints for millions of incoming (Num a) constraints
+--    b) Termination for improve_eqs in TcSimplify.simpl_loop
+dischargeFromCCans cans ev fl
+  = Bag.foldrBag discharge_ct (return False) cans
+  where 
+    the_pred = evVarPred ev
+
+    discharge_ct :: CanonicalCt -> TcS Bool -> TcS Bool
+    discharge_ct ct _rest
+      | evVarPred (cc_id ct) `tcEqPred` the_pred
+      , cc_flavor ct `canSolve` fl
+      = do { when (isWanted fl) $ set_ev_bind ev (cc_id ct) 
+                -- Deriveds need no evidence
+                -- For Givens, we already have evidence, and we don't need it twice 
+           ; return True }
+      where 
+         set_ev_bind x y
+            | EqPred {} <- evVarPred y = setEvBind x (EvCoercion (mkCoVarCoercion y))
+            | otherwise                = setEvBind x (EvId y)
+
+    discharge_ct _ct rest = rest
+\end{code}
+
+Note [Avoiding the superclass explosion] 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
+This note now is not as significant as it used to be because we no
+longer add the superclasses of Wanted as Derived, except only if they
+have equality superclasses or superclasses with functional
+dependencies. The fear was that hundreds of identical wanteds would
+give rise each to the same superclass or equality Derived's which
+would lead to a blo-up in the number of interactions.
+
+Instead, what we do with tryPreSolveAndCanon, is when we encounter a
+new constraint, we very quickly see if it can be immediately
+discharged by a class constraint in our inert set or the previous
+canonicals. If so, we add nothing to the returned canonical
+constraints.
+
+\begin{code}
+solveOne :: WorkItem -> InertSet -> TcS InertSet 
+solveOne workItem inerts 
   = do { dyn_flags <- getDynFlags
-       ; solveOneWithDepth (ctxtStkDepth dyn_flags,0,[]) inerts workItem
+       ; solveOneWithDepth (ctxtStkDepth dyn_flags,0,[]) workItem inerts
        }
 
 -----------------
 solveInteractWithDepth :: (Int, Int, [WorkItem])
-                       -> InertSet -> WorkList -> TcS InertSet
-solveInteractWithDepth ctxt@(max_depth,n,stack) inert ws 
+                       -> WorkList -> InertSet -> TcS InertSet
+solveInteractWithDepth ctxt@(max_depth,n,stack) ws inert
   | isEmptyWorkList ws
   = return inert
 
@@ -308,36 +456,36 @@ solveInteractWithDepth ctxt@(max_depth,n,stack) inert ws
 
   | otherwise 
   = do { traceTcS "solveInteractWithDepth" $ 
-         vcat [ text "Current depth =" <+> ppr n
-              , text "Max depth =" <+> ppr max_depth
-              ]
-       ; foldlWorkListM (solveOneWithDepth ctxt) inert ws }
+              vcat [ text "Current depth =" <+> ppr n
+                   , text "Max depth =" <+> ppr max_depth
+                   , text "ws =" <+> ppr ws ]
+
+
+       ; foldrWorkListM (solveOneWithDepth ctxt) inert ws }
+              -- use foldr to preserve the order
 
 ------------------
 -- Fully interact the given work item with an inert set, and return a
 -- new inert set which has assimilated the new information.
 solveOneWithDepth :: (Int, Int, [WorkItem])
-                  -> InertSet -> WorkItem -> TcS InertSet
-solveOneWithDepth (max_depth, n, stack) inert work
-  = do { traceTcS0 (indent ++ "Solving {") (ppr work)
-       ; (new_inert, new_work) <- runSolverPipeline thePipeline inert work
+                  -> WorkItem -> InertSet -> TcS InertSet
+solveOneWithDepth (max_depth, depth, stack) work inert
+  = do { traceFireTcS depth (text "Solving {" <+> ppr work)
+       ; (new_inert, new_work) <- runSolverPipeline depth thePipeline inert work
          
-       ; traceTcS0 (indent ++ "Subgoals:") (ppr new_work)
-
         -- Recursively solve the new work generated 
          -- from workItem, with a greater depth
-       ; res_inert <- solveInteractWithDepth (max_depth, n+1, work:stack)
-                                new_inert new_work 
+       ; res_inert <- solveInteractWithDepth (max_depth, depth+1, work:stack) new_work new_inert 
+
+       ; traceFireTcS depth (text "Done }" <+> ppr work) 
 
-       ; traceTcS0 (indent ++ "Done }") (ppr work) 
        ; return res_inert }
-  where
-    indent = replicate (2*n) ' '
 
 thePipeline :: [(String,SimplifierStage)]
-thePipeline = [ ("interact with inerts", interactWithInertsStage)
-              , ("spontaneous solve",    spontaneousSolveStage)
-              , ("top-level reactions",  topReactionsStage) ]
+thePipeline = [ ("interact with inert eqs", interactWithInertEqsStage)
+              , ("interact with inerts",    interactWithInertsStage)
+              , ("spontaneous solve",       spontaneousSolveStage)
+              , ("top-level reactions",     topReactionsStage) ]
 \end{code}
 
 *********************************************************************************
@@ -346,111 +494,198 @@ thePipeline = [ ("interact with inerts", interactWithInertsStage)
 *                                                                               *
 *********************************************************************************
 
+Note [Efficient Orientation] 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+There are two cases where we have to be careful about 
+orienting equalities to get better efficiency. 
+
+Case 1: In Rewriting Equalities (function rewriteEqLHS) 
+
+    When rewriting two equalities with the same LHS:
+          (a)  (tv ~ xi1) 
+          (b)  (tv ~ xi2) 
+    We have a choice of producing work (xi1 ~ xi2) (up-to the
+    canonicalization invariants) However, to prevent the inert items
+    from getting kicked out of the inerts first, we prefer to
+    canonicalize (xi1 ~ xi2) if (b) comes from the inert set, or (xi2
+    ~ xi1) if (a) comes from the inert set.
+    
+    This choice is implemented using the WhichComesFromInert flag. 
+
+Case 2: Functional Dependencies 
+    Again, we should prefer, if possible, the inert variables on the RHS
+
+Case 3: IP improvement work
+    We must always rewrite so that the inert type is on the right. 
+
 \begin{code}
 spontaneousSolveStage :: SimplifierStage 
-spontaneousSolveStage workItem inerts 
-  = do { mSolve <- trySpontaneousSolve workItem 
+spontaneousSolveStage depth workItem inerts 
+  = do { mSolve <- trySpontaneousSolve workItem
+
        ; case mSolve of 
-           Nothing -> -- no spontaneous solution for him, keep going
-               return $ SR { sr_new_work   = emptyWorkList 
-                           , sr_inerts     = inerts 
+           SPCantSolve -> -- No spontaneous solution for him, keep going
+               return $ SR { sr_new_work   = emptyWorkList
+                           , sr_inerts     = inerts
                            , sr_stop       = ContinueWith workItem }
 
-           Just workItem' -- He has been solved; workItem' is a Given
-               | isWantedCt workItem 
-                           -- Original was wanted we have now made him given so 
-                           -- we have to ineract him with the inerts again because 
-                           -- of the change in his status. This may produce some work. 
-                   -> do { traceTcS "recursive interact with inerts {" $ vcat
-                               [ text "work = " <+> ppr workItem'
-                               , text "inerts = " <+> ppr inerts ]
-                         ; itr_again <- interactWithInertsStage workItem' inerts 
-                         ; case sr_stop itr_again of 
-                            Stop -> pprPanic "BUG: Impossible to happen" $ 
-                                    vcat [ text "Original workitem:" <+> ppr workItem
-                                         , text "Spontaneously solved:" <+> ppr workItem'
-                                         , text "Solved was consumed, when reacting with inerts:"
-                                         , nest 2 (ppr inerts) ]
-                            ContinueWith workItem'' -- Now *this* guy is inert wrt to inerts
-                                ->  do { traceTcS "end recursive interact }" $ ppr workItem''
-                                       ; return $ SR { sr_new_work = sr_new_work itr_again
-                                                     , sr_inerts   = sr_inerts itr_again 
-                                                                     `extendInertSet` workItem'' 
-                                                     , sr_stop     = Stop } }
-                         }
-               | otherwise
-                   -> return $ SR { sr_new_work   = emptyWorkList 
-                                  , sr_inerts     = inerts `extendInertSet` workItem' 
-                                  , sr_stop       = Stop } }
+           SPSolved workItem'
+               | not (isGivenCt workItem) 
+                -- Original was wanted or derived but we have now made him 
+                 -- given so we have to interact him with the inerts due to
+                 -- its status change. This in turn may produce more work.
+                -- We do this *right now* (rather than just putting workItem'
+                -- back into the work-list) because we've solved 
+               -> do { bumpStepCountTcS
+                    ; traceFireTcS depth (ptext (sLit "Spontaneous (w/d)") <+> ppr workItem)
+                     ; (new_inert, new_work) <- runSolverPipeline depth
+                             [ ("recursive interact with inert eqs", interactWithInertEqsStage)
+                             , ("recursive interact with inerts", interactWithInertsStage)
+                             ] inerts workItem'
+                     ; return $ SR { sr_new_work = new_work 
+                                   , sr_inerts   = new_inert -- will include workItem' 
+                                   , sr_stop     = Stop }
+                     }
+               | otherwise 
+                   -> -- Original was given; he must then be inert all right, and
+                      -- workList' are all givens from flattening
+                      do { bumpStepCountTcS
+                        ; traceFireTcS depth (ptext (sLit "Spontaneous (g)") <+> ppr workItem)
+                         ; return $ SR { sr_new_work = emptyWorkList
+                                       , sr_inerts   = inerts `updInertSet` workItem' 
+                                       , sr_stop     = Stop } }
+           SPError -> -- Return with no new work
+               return $ SR { sr_new_work = emptyWorkList
+                           , sr_inerts   = inerts
+                           , sr_stop     = Stop }
+       }
+
+data SPSolveResult = SPCantSolve | SPSolved WorkItem | SPError
+-- SPCantSolve means that we can't do the unification because e.g. the variable is untouchable
+-- SPSolved workItem' gives us a new *given* to go on 
+-- SPError means that it's completely impossible to solve this equality, eg due to a kind error
+
 
 -- @trySpontaneousSolve wi@ solves equalities where one side is a
--- touchable unification variable. Returns:
---   * Nothing if we were not able to solve it
---   * Just wi' if we solved it, wi' (now a "given") should be put in the work list.
+-- touchable unification variable.
 --                 See Note [Touchables and givens] 
-trySpontaneousSolve :: WorkItem -> TcS (Maybe SWorkItem)
-trySpontaneousSolve (CTyEqCan { cc_id = cv, cc_flavor = gw, cc_tyvar = tv1, cc_rhs = xi }) 
+trySpontaneousSolve :: WorkItem -> TcS SPSolveResult
+trySpontaneousSolve workItem@(CTyEqCan { cc_id = cv, cc_flavor = gw, cc_tyvar = tv1, cc_rhs = xi })
+  | isGiven gw
+  = return SPCantSolve
   | Just tv2 <- tcGetTyVar_maybe xi
   = do { tch1 <- isTouchableMetaTyVar tv1
        ; tch2 <- isTouchableMetaTyVar tv2
        ; case (tch1, tch2) of
            (True,  True)  -> trySpontaneousEqTwoWay cv gw tv1 tv2
            (True,  False) -> trySpontaneousEqOneWay cv gw tv1 xi
-           (False, True)  | tyVarKind tv1 `isSubKind` tyVarKind tv2
-                          -> trySpontaneousEqOneWay cv gw tv2 (mkTyVarTy tv1)
-          _ -> return Nothing }
+           (False, True)  -> trySpontaneousEqOneWay cv gw tv2 (mkTyVarTy tv1)
+          _ -> return SPCantSolve }
   | otherwise
   = do { tch1 <- isTouchableMetaTyVar tv1
        ; if tch1 then trySpontaneousEqOneWay cv gw tv1 xi
-                 else return Nothing }
+                 else do { traceTcS "Untouchable LHS, can't spontaneously solve workitem:" 
+                                    (ppr workItem) 
+                         ; return SPCantSolve }
+       }
 
   -- No need for 
   --      trySpontaneousSolve (CFunEqCan ...) = ...
   -- See Note [No touchables as FunEq RHS] in TcSMonad
-trySpontaneousSolve _ = return Nothing 
+trySpontaneousSolve _ = return SPCantSolve
 
 ----------------
-trySpontaneousEqOneWay :: CoVar -> CtFlavor -> TcTyVar -> Xi
-                       -> TcS (Maybe SWorkItem)
+trySpontaneousEqOneWay :: CoVar -> CtFlavor -> TcTyVar -> Xi -> TcS SPSolveResult
 -- tv is a MetaTyVar, not untouchable
--- Precondition: kind(xi) is a sub-kind of kind(tv)
 trySpontaneousEqOneWay cv gw tv xi     
-  | not (isSigTyVar tv) || isTyVarTy xi
-  = solveWithIdentity cv gw tv xi
-  | otherwise
-  = return Nothing
+  | not (isSigTyVar tv) || isTyVarTy xi 
+  = do { let kxi = typeKind xi -- NB: 'xi' is fully rewritten according to the inerts 
+                               -- so we have its more specific kind in our hands
+       ; if kxi `isSubKind` tyVarKind tv then
+             solveWithIdentity cv gw tv xi
+         else return SPCantSolve
+{-
+         else if tyVarKind tv `isSubKind` kxi then
+             return SPCantSolve -- kinds are compatible but we can't solveWithIdentity this way
+                                -- This case covers the  a_touchable :: * ~ b_untouchable :: ?? 
+                                -- which has to be deferred or floated out for someone else to solve 
+                                -- it in a scope where 'b' is no longer untouchable.
+         else do { addErrorTcS KindError gw (mkTyVarTy tv) xi -- See Note [Kind errors]
+                 ; return SPError }
+-}
+       }
+  | otherwise -- Still can't solve, sig tyvar and non-variable rhs
+  = return SPCantSolve
 
 ----------------
-trySpontaneousEqTwoWay :: CoVar -> CtFlavor -> TcTyVar -> TcTyVar
-                       -> TcS (Maybe SWorkItem)
--- Both tyvars are *touchable* MetaTyvars
--- By the CTyEqCan invariant, k2 `isSubKind` k1
+trySpontaneousEqTwoWay :: CoVar -> CtFlavor -> TcTyVar -> TcTyVar -> TcS SPSolveResult
+-- Both tyvars are *touchable* MetaTyvars so there is only a chance for kind error here
 trySpontaneousEqTwoWay cv gw tv1 tv2
-  | k1 `eqKind` k2
+  | k1 `isSubKind` k2
   , nicer_to_update_tv2 = solveWithIdentity cv gw tv2 (mkTyVarTy tv1)
-  | otherwise           = ASSERT( k2 `isSubKind` k1 )
-                          solveWithIdentity cv gw tv1 (mkTyVarTy tv2)
+  | k2 `isSubKind` k1 
+  = solveWithIdentity cv gw tv1 (mkTyVarTy tv2)
+  | otherwise -- None is a subkind of the other, but they are both touchable! 
+  = return SPCantSolve
+    -- do { addErrorTcS KindError gw (mkTyVarTy tv1) (mkTyVarTy tv2)
+    --   ; return SPError }
   where
     k1 = tyVarKind tv1
     k2 = tyVarKind tv2
     nicer_to_update_tv2 = isSigTyVar tv1 || isSystemName (Var.varName tv2)
 \end{code}
 
-Note [Loopy spontaneous solving] 
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Consider the original wanted: 
-   wanted :  Maybe (E alpha) ~ alpha 
-where E is a type family, such that E (T x) = x. After canonicalization, 
-as a result of flattening, we will get: 
-   given  : E alpha ~ fsk 
-   wanted : alpha ~ Maybe fsk
-where (fsk := E alpha, on the side). Now, if we spontaneously *solve* 
-(alpha := Maybe fsk) we are in trouble! Instead, we should refrain from solving 
-it and keep it as wanted.  In inference mode we'll end up quantifying over
-   (alpha ~ Maybe (E alpha))
-Hence, 'solveWithIdentity' performs a small occurs check before
-actually solving. But this occurs check *must look through* flatten
-skolems.
+Note [Kind errors] 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Consider the wanted problem: 
+      alpha ~ (# Int, Int #) 
+where alpha :: ?? and (# Int, Int #) :: (#). We can't spontaneously solve this constraint, 
+but we should rather reject the program that give rise to it. If 'trySpontaneousEqTwoWay' 
+simply returns @CantSolve@ then that wanted constraint is going to propagate all the way and 
+get quantified over in inference mode. That's bad because we do know at this point that the 
+constraint is insoluble. Instead, we call 'recKindErrorTcS' here, which will fail later on.
+
+The same applies in canonicalization code in case of kind errors in the givens. 
+
+However, when we canonicalize givens we only check for compatibility (@compatKind@). 
+If there were a kind error in the givens, this means some form of inconsistency or dead code.
+
+You may think that when we spontaneously solve wanteds we may have to look through the 
+bindings to determine the right kind of the RHS type. E.g one may be worried that xi is 
+@alpha@ where alpha :: ? and a previous spontaneous solving has set (alpha := f) with (f :: *).
+But we orient our constraints so that spontaneously solved ones can rewrite all other constraint
+so this situation can't happen. 
+
+Note [Spontaneous solving and kind compatibility] 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Note that our canonical constraints insist that *all* equalities (tv ~
+xi) or (F xis ~ rhs) require the LHS and the RHS to have *compatible*
+the same kinds.  ("compatible" means one is a subKind of the other.)
+
+  - It can't be *equal* kinds, because
+     b) wanted constraints don't necessarily have identical kinds
+               eg   alpha::? ~ Int
+     b) a solved wanted constraint becomes a given
+
+  - SPJ thinks that *given* constraints (tv ~ tau) always have that
+    tau has a sub-kind of tv; and when solving wanted constraints
+    in trySpontaneousEqTwoWay we re-orient to achieve this.
+
+  - Note that the kind invariant is maintained by rewriting.
+    Eg wanted1 rewrites wanted2; if both were compatible kinds before,
+       wanted2 will be afterwards.  Similarly givens.
+
+Caveat:
+  - Givens from higher-rank, such as: 
+          type family T b :: * -> * -> * 
+          type instance T Bool = (->) 
+
+          f :: forall a. ((T a ~ (->)) => ...) -> a -> ... 
+          flop = f (...) True 
+     Whereas we would be able to apply the type instance, we would not be able to 
+     use the given (T Bool ~ (->)) in the body of 'flop' 
+
 
 Note [Avoid double unifications] 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -458,73 +693,46 @@ The spontaneous solver has to return a given which mentions the unified unificat
 variable *on the left* of the equality. Here is what happens if not: 
   Original wanted:  (a ~ alpha),  (alpha ~ Int) 
 We spontaneously solve the first wanted, without changing the order! 
-      given : a ~ alpha      [having unifice alpha := a] 
+      given : a ~ alpha      [having unified alpha := a] 
 Now the second wanted comes along, but he cannot rewrite the given, so we simply continue.
 At the end we spontaneously solve that guy, *reunifying*  [alpha := Int] 
 
-We avoid this problem by orienting the given so that the unification variable is on the left. 
-[Note that alternatively we could attempt to enforce this at canonicalization] 
+We avoid this problem by orienting the resulting given so that the unification
+variable is on the left.  [Note that alternatively we could attempt to
+enforce this at canonicalization]
 
-Avoiding double unifications is yet another reason to disallow touchable unification variables
-as RHS of type family equations: F xis ~ alpha. Consider having already spontaneously solved 
-a wanted (alpha ~ [b]) by setting alpha := [b]. So the inert set looks like: 
-         given : alpha ~ [b]
-And now a new wanted (F tau ~ alpha) comes along. Since it does not react with anything 
-we will be left with a constraint (F tau ~ alpha) that must cause a unification of 
-(alpha := F tau) at some point (either in spontaneous solving, or at the end). But alpha 
-is *already* unified so we must not do anything to it. By disallowing naked touchables in 
-the RHS of constraints (in favor of introduced flatten skolems) we do not have to worry at 
-all about unifying or spontaneously solving (F xis ~ alpha) by unification. 
+See also Note [No touchables as FunEq RHS] in TcSMonad; avoiding
+double unifications is the main reason we disallow touchable
+unification variables as RHS of type family equations: F xis ~ alpha.
 
 \begin{code}
 ----------------
-solveWithIdentity :: CoVar -> CtFlavor -> TcTyVar -> Xi -> TcS (Maybe SWorkItem)
+
+solveWithIdentity :: CoVar -> CtFlavor -> TcTyVar -> Xi -> TcS SPSolveResult
 -- Solve with the identity coercion 
 -- Precondition: kind(xi) is a sub-kind of kind(tv)
--- See [New Wanted Superclass Work] to see why we do this for *given* as well
-solveWithIdentity cv gw tv xi 
-  | tv `elemVarSet` tyVarsOfUnflattenedType xi 
-                           -- Beware of Note [Loopy spontaneous solving] 
-                    -- Can't spontaneously solve loopy equalities
-                    -- though they are not a type error 
-  = return Nothing 
-  | not (isGiven gw) -- Wanted or Derived 
+-- Precondition: CtFlavor is Wanted or Derived
+-- See [New Wanted Superclass Work] to see why solveWithIdentity 
+--     must work for Derived as well as Wanted
+-- Returns: workItem where 
+--        workItem = the new Given constraint
+solveWithIdentity cv wd tv xi 
   = do { traceTcS "Sneaky unification:" $ 
-         vcat [text "Coercion variable:  " <+> ppr gw, 
-               text "Coercion:           " <+> pprEq (mkTyVarTy tv) xi,
-               text "Left  Kind is     : " <+> ppr (typeKind (mkTyVarTy tv)),
-               text "Right Kind is     : " <+> ppr (typeKind xi)
-              ]
-       ; setWantedTyBind tv xi                  -- Set tv := xi
-       ; cv_given <- newGivOrDerCoVar (mkTyVarTy tv) xi xi  
-                                                -- Create new given with identity evidence
+                       vcat [text "Coercion variable:  " <+> ppr wd, 
+                             text "Coercion:           " <+> pprEq (mkTyVarTy tv) xi,
+                             text "Left  Kind is     : " <+> ppr (typeKind (mkTyVarTy tv)),
+                             text "Right Kind is     : " <+> ppr (typeKind xi)
+                  ]
 
-       ; case gw of 
-           Wanted  {} -> setWantedCoBind  cv xi 
-           Derived {} -> setDerivedCoBind cv xi 
-           _          -> pprPanic "Can't spontaneously solve *given*" empty 
-
-       ; let solved = CTyEqCan { cc_id = cv_given
-                               , cc_flavor = mkGivenFlavor gw UnkSkol
-                               , cc_tyvar = tv, cc_rhs = xi }
-       -- See Note [Avoid double unifications] 
-
-       -- The reason that we create a new given variable (cv_given) instead of reusing cv
-       -- is because we do not want to end up with coercion unification variables in the givens.
-       ; return (Just solved) }
-  | otherwise        -- Given 
-  = return Nothing 
-
-tyVarsOfUnflattenedType :: TcType -> TcTyVarSet
--- A version of tyVarsOfType which looks through flatSkols
-tyVarsOfUnflattenedType ty
-  = foldVarSet (unionVarSet . do_tv) emptyVarSet (tyVarsOfType ty)
-  where
-    do_tv :: TyVar -> TcTyVarSet
-    do_tv tv = ASSERT( isTcTyVar tv)
-               case tcTyVarDetails tv of 
-                  FlatSkol ty -> tyVarsOfUnflattenedType ty
-                  _           -> unitVarSet tv 
+       ; setWantedTyBind tv xi
+       ; cv_given <- newGivenCoVar (mkTyVarTy tv) xi xi
+
+       ; when (isWanted wd) (setCoBind cv xi)
+           -- We don't want to do this for Derived, that's why we use 'when (isWanted wd)'
+
+       ; return $ SPSolved (CTyEqCan { cc_id = cv_given
+                                     , cc_flavor = mkGivenFlavor wd UnkSkol
+                                     , cc_tyvar  = tv, cc_rhs = xi }) }
 \end{code}
 
 
@@ -534,6 +742,31 @@ tyVarsOfUnflattenedType ty
 *                                                                               *
 *********************************************************************************
 
+Note [The Solver Invariant]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+We always add Givens first.  So you might think that the solver has
+the invariant
+
+   If the work-item is Given, 
+   then the inert item must Given
+
+But this isn't quite true.  Suppose we have, 
+    c1: [W] beta ~ [alpha], c2 : [W] blah, c3 :[W] alpha ~ Int
+After processing the first two, we get
+     c1: [G] beta ~ [alpha], c2 : [W] blah
+Now, c3 does not interact with the the given c1, so when we spontaneously
+solve c3, we must re-react it with the inert set.  So we can attempt a 
+reaction between inert c2 [W] and work-item c3 [G].
+
+It *is* true that [Solver Invariant]
+   If the work-item is Given, 
+   AND there is a reaction
+   then the inert item must Given
+or, equivalently,
+   If the work-item is Given, 
+   and the inert item is Wanted/Derived
+   then there is no reaction
+
 \begin{code}
 -- Interaction result of  WorkItem <~> AtomicInert
 data InteractResult
@@ -550,81 +783,137 @@ data InteractResult
 
         , ir_new_work     :: WorkList
             -- new work items to add to the WorkList
+
+        , ir_fire :: Maybe String    -- Tells whether a rule fired, and if so what
         }
 
 -- What to do with the inert reactant.
-data InertAction = KeepInert | DropInert
-  deriving Eq
+data InertAction = KeepInert | DropInert 
 
-mkIRContinue :: Monad m => WorkItem -> InertAction -> WorkList -> m InteractResult
-mkIRContinue wi keep newWork = return $ IR (ContinueWith wi) keep newWork
+mkIRContinue :: String -> WorkItem -> InertAction -> WorkList -> TcS InteractResult
+mkIRContinue rule wi keep newWork 
+  = return $ IR { ir_stop = ContinueWith wi, ir_inert_action = keep
+                , ir_new_work = newWork, ir_fire = Just rule }
 
-mkIRStop :: Monad m => InertAction -> WorkList -> m InteractResult
-mkIRStop keep newWork = return $ IR Stop keep newWork
+mkIRStopK :: String -> WorkList -> TcS InteractResult
+mkIRStopK rule newWork
+  = return $ IR { ir_stop = Stop, ir_inert_action = KeepInert
+                , ir_new_work = newWork, ir_fire = Just rule }
 
-dischargeWorkItem :: Monad m => m InteractResult
-dischargeWorkItem = mkIRStop KeepInert emptyCCan
+mkIRStopD :: String -> WorkList -> TcS InteractResult
+mkIRStopD rule newWork
+  = return $ IR { ir_stop = Stop, ir_inert_action = DropInert
+                , ir_new_work = newWork, ir_fire = Just rule }
 
 noInteraction :: Monad m => WorkItem -> m InteractResult
-noInteraction workItem = mkIRContinue workItem KeepInert emptyCCan
+noInteraction wi
+  = return $ IR { ir_stop = ContinueWith wi, ir_inert_action = KeepInert
+                , ir_new_work = emptyWorkList, ir_fire = Nothing }
+
+data WhichComesFromInert = LeftComesFromInert | RightComesFromInert 
+     -- See Note [Efficient Orientation] 
 
 
 ---------------------------------------------------
--- Interact a single WorkItem with an InertSet as far as possible, i.e. until we get a Stop 
--- result from an individual interaction (i.e. when the WorkItem is consumed), or until we've 
--- interacted the WorkItem with the entire InertSet.
---
--- Postcondition: the new InertSet in the resulting StageResult is subset 
--- of the input InertSet.
+-- Interact a single WorkItem with the equalities of an inert set as
+-- far as possible, i.e. until we get a Stop result from an individual
+-- reaction (i.e. when the WorkItem is consumed), or until we've
+-- interact the WorkItem with the entire equalities of the InertSet
+
+interactWithInertEqsStage :: SimplifierStage 
+interactWithInertEqsStage depth workItem inert
+  = Bag.foldrBagM (interactNext depth) initITR (inert_eqs inert)
+                        -- use foldr to preserve the order          
+  where
+    initITR = SR { sr_inerts   = inert { inert_eqs = emptyCCan }
+                 , sr_new_work = emptyWorkList
+                 , sr_stop     = ContinueWith workItem }
+
+---------------------------------------------------
+-- Interact a single WorkItem with *non-equality* constraints in the inert set. 
+-- Precondition: equality interactions must have already happened, hence we have 
+-- to pick up some information from the incoming inert, before folding over the 
+-- "Other" constraints it contains!
 
 interactWithInertsStage :: SimplifierStage
-interactWithInertsStage workItem inert
-  = foldlInertSetM interactNext initITR inert
+interactWithInertsStage depth workItem inert
+  = let (relevant, inert_residual) = getISRelevant workItem inert 
+        initITR = SR { sr_inerts   = inert_residual
+                     , sr_new_work = emptyWorkList
+                     , sr_stop     = ContinueWith workItem } 
+    in Bag.foldrBagM (interactNext depth) initITR relevant 
+                        -- use foldr to preserve the order
   where 
-    initITR = SR { sr_inerts   = emptyInert
-                 , sr_new_work = emptyCCan
-                 , sr_stop     = ContinueWith workItem }
-
-    interactNext :: StageResult -> AtomicInert -> TcS StageResult 
-    interactNext it inert  
-      | ContinueWith workItem <- sr_stop it
-        = do { ir <- interactWithInert inert workItem 
-             ; let inerts = sr_inerts it 
-             ; return $ SR { sr_inerts   = if ir_inert_action ir == KeepInert
-                                           then inerts `extendInertSet` inert
-                                           else inerts
-                           , sr_new_work = sr_new_work it `unionWorkLists` ir_new_work ir
-                           , sr_stop     = ir_stop ir } }
-      | otherwise = return $ itrAddInert inert it
-    
-                             
-    itrAddInert :: AtomicInert -> StageResult -> StageResult
-    itrAddInert inert itr = itr { sr_inerts = (sr_inerts itr) `extendInertSet` inert }
+    getISRelevant :: CanonicalCt -> InertSet -> (CanonicalCts, InertSet) 
+    getISRelevant (CFrozenErr {}) is = (emptyCCan, is)
+                  -- Nothing s relevant; we have alread interacted
+                  -- it with the equalities in the inert set
+
+    getISRelevant (CDictCan { cc_class = cls } ) is
+      = let (relevant, residual_map) = getRelevantCts cls (inert_dicts is)
+        in (relevant, is { inert_dicts = residual_map }) 
+    getISRelevant (CFunEqCan { cc_fun = tc } ) is 
+      = let (relevant, residual_map) = getRelevantCts tc (inert_funeqs is) 
+        in (relevant, is { inert_funeqs = residual_map })
+    getISRelevant (CIPCan { cc_ip_nm = nm }) is 
+      = let (relevant, residual_map) = getRelevantCts nm (inert_ips is)
+        in (relevant, is { inert_ips = residual_map }) 
+    -- An equality, finally, may kick everything except equalities out 
+    -- because we have already interacted the equalities in interactWithInertEqsStage
+    getISRelevant _eq_ct is  -- Equality, everything is relevant for this one 
+                             -- TODO: if we were caching variables, we'd know that only 
+                             --       some are relevant. Experiment with this for now. 
+      = let cts = cCanMapToBag (inert_ips is) `unionBags` 
+                    cCanMapToBag (inert_dicts is) `unionBags` cCanMapToBag (inert_funeqs is)
+        in (cts, is { inert_dicts  = emptyCCanMap
+                    , inert_ips    = emptyCCanMap
+                    , inert_funeqs = emptyCCanMap })
+
+interactNext :: SubGoalDepth -> AtomicInert -> StageResult -> TcS StageResult 
+interactNext depth inert it
+  | ContinueWith work_item <- sr_stop it
+  = do { let inerts = sr_inerts it 
+
+       ; IR { ir_new_work = new_work, ir_inert_action = inert_action
+            , ir_fire = fire_info, ir_stop = stop } 
+            <- interactWithInert inert work_item
+
+       ; let mk_msg rule 
+              = text rule <+> keep_doc
+                <+> vcat [ ptext (sLit "Inert =") <+> ppr inert
+                         , ptext (sLit "Work =")  <+> ppr work_item
+                         , ppUnless (isEmptyWorkList new_work) $
+                            ptext (sLit "New =") <+> ppr new_work ]
+             keep_doc = case inert_action of
+                         KeepInert -> ptext (sLit "[keep]")
+                         DropInert -> ptext (sLit "[drop]")
+       ; case fire_info of
+           Just rule -> do { bumpStepCountTcS
+                           ; traceFireTcS depth (mk_msg rule) }
+           Nothing  -> return ()
+
+       -- New inerts depend on whether we KeepInert or not 
+       ; let inerts_new = case inert_action of
+                            KeepInert -> inerts `updInertSet` inert
+                            DropInert -> inerts
+
+       ; return $ SR { sr_inerts   = inerts_new
+                     , sr_new_work = sr_new_work it `unionWorkList` new_work
+                     , sr_stop     = stop } }
+  | otherwise 
+  = return $ it { sr_inerts = (sr_inerts it) `updInertSet` inert }
 
 -- Do a single interaction of two constraints.
 interactWithInert :: AtomicInert -> WorkItem -> TcS InteractResult
-interactWithInert inert workitem 
-  =  do { ctxt <- getTcSContext
-        ; let is_allowed  = allowedInteraction (simplEqsOnly ctxt) inert workitem 
-              inert_ev    = cc_id inert 
-              work_ev     = cc_id workitem 
-
-        -- Never interact a wanted and a derived where the derived's evidence 
-        -- mentions the wanted evidence in an unguarded way. 
-        -- See Note [Superclasses and recursive dictionaries] 
-        -- and Note [New Wanted Superclass Work] 
-        -- We don't have to do this for givens, as we fully know the evidence for them. 
-        ; rec_ev_ok <- 
-            case (cc_flavor inert, cc_flavor workitem) of 
-              (Wanted loc, Derived _) -> isGoodRecEv work_ev  (WantedEvVar inert_ev loc)
-              (Derived _, Wanted loc) -> isGoodRecEv inert_ev (WantedEvVar work_ev loc)
-              _                       -> return True 
-
-        ; if is_allowed && rec_ev_ok then 
-              doInteractWithInert inert workitem 
+interactWithInert inert workItem 
+  = do { ctxt <- getTcSContext
+       ; let is_allowed  = allowedInteraction (simplEqsOnly ctxt) inert workItem 
+
+       ; if is_allowed then 
+              doInteractWithInert inert workItem 
           else 
-              noInteraction workitem 
-        }
+              noInteraction workItem 
+       }
 
 allowedInteraction :: Bool -> AtomicInert -> WorkItem -> Bool 
 -- Allowed interactions 
@@ -636,25 +925,74 @@ allowedInteraction _ _ _ = True
 doInteractWithInert :: CanonicalCt -> CanonicalCt -> TcS InteractResult
 -- Identical class constraints.
 
-doInteractWithInert 
-           (CDictCan { cc_id = d1, cc_flavor = fl1, cc_class = cls1, cc_tyargs = tys1 }) 
-  workItem@(CDictCan { cc_id = d2, cc_flavor = fl2, cc_class = cls2, cc_tyargs = tys2 })
+doInteractWithInert
+  inertItem@(CDictCan { cc_id = d1, cc_flavor = fl1, cc_class = cls1, cc_tyargs = tys1 }) 
+   workItem@(CDictCan { cc_id = d2, cc_flavor = fl2, cc_class = cls2, cc_tyargs = tys2 })
   | cls1 == cls2 && (and $ zipWith tcEqType tys1 tys2)
-  = solveOneFromTheOther (d1,fl1) workItem 
+  = solveOneFromTheOther "Cls/Cls" (EvId d1,fl1) workItem 
 
   | cls1 == cls2 && (not (isGiven fl1 && isGiven fl2))
   =     -- See Note [When improvement happens]
-    do { let work_item_pred_loc = (ClassP cls2 tys2, ppr d2)
-             inert_pred_loc     = (ClassP cls1 tys1, ppr d1)
-            loc                = combineCtLoc fl1 fl2
-             eqn_pred_locs = improveFromAnother work_item_pred_loc inert_pred_loc         
-       ; wevvars <- mkWantedFunDepEqns loc eqn_pred_locs 
-                -- See Note [Generating extra equalities]
-       ; workList <- canWanteds wevvars 
-       ; mkIRContinue workItem KeepInert workList -- Keep the inert there so we avoid 
-                                                  -- re-introducing the fundep equalities
-         -- See Note [FunDep Reactions] 
-       }
+    do { let pty1 = ClassP cls1 tys1
+             pty2 = ClassP cls2 tys2
+             inert_pred_loc     = (pty1, pprFlavorArising fl1)
+             work_item_pred_loc = (pty2, pprFlavorArising fl2)
+             fd_eqns = improveFromAnother 
+                                  inert_pred_loc     -- the template
+                                  work_item_pred_loc -- the one we aim to rewrite
+                                  -- See Note [Efficient Orientation]
+
+       ; m <- rewriteWithFunDeps fd_eqns tys2 fl2
+       ; case m of 
+           Nothing -> noInteraction workItem
+           Just (rewritten_tys2, cos2, fd_work)
+             | tcEqTypes tys1 rewritten_tys2
+             -> -- Solve him on the spot in this case
+               case fl2 of
+                 Given   {} -> pprPanic "Unexpected given" (ppr inertItem $$ ppr workItem)
+                  Derived {} -> mkIRStopK "Cls/Cls fundep (solved)" fd_work
+                 Wanted  {} 
+                   | isDerived fl1 
+                   -> do { setDictBind d2 (EvCast d1 dict_co)
+                        ; let inert_w = inertItem { cc_flavor = fl2 }
+                          -- A bit naughty: we take the inert Derived, 
+                          -- turn it into a Wanted, use it to solve the work-item
+                          -- and put it back into the work-list
+                          -- Maybe rather than starting again, we could *replace* the
+                          -- inert item, but its safe and simple to restart
+                         ; mkIRStopD "Cls/Cls fundep (solved)" $ 
+                           workListFromNonEq inert_w `unionWorkList` fd_work }
+                   | otherwise 
+                    -> do { setDictBind d2 (EvCast d1 dict_co)
+                          ; mkIRStopK "Cls/Cls fundep (solved)" fd_work }
+
+             | otherwise
+             -> -- We could not quite solve him, but we still rewrite him
+               -- Example: class C a b c | a -> b
+               --          Given: C Int Bool x, Wanted: C Int beta y
+               --          Then rewrite the wanted to C Int Bool y
+               --          but note that is still not identical to the given
+               -- The important thing is that the rewritten constraint is
+               -- inert wrt the given.
+               -- However it is not necessarily inert wrt previous inert-set items.
+                --      class C a b c d |  a -> b, b c -> d
+               --      Inert: c1: C b Q R S, c2: C P Q a b
+               --      Work: C P alpha R beta
+               --      Does not react with c1; reacts with c2, with alpha:=Q
+               --      NOW it reacts with c1!
+               -- So we must stop, and put the rewritten constraint back in the work list
+                do { d2' <- newDictVar cls1 rewritten_tys2
+                   ; case fl2 of
+                       Given {}   -> pprPanic "Unexpected given" (ppr inertItem $$ ppr workItem)
+                       Wanted {}  -> setDictBind d2 (EvCast d2' dict_co)
+                       Derived {} -> return ()
+                   ; let workItem' = workItem { cc_id = d2', cc_tyargs = rewritten_tys2 }
+                   ; mkIRStopK "Cls/Cls fundep (partial)" $ 
+                     workListFromNonEq workItem' `unionWorkList` fd_work } 
+
+             where
+               dict_co = mkTyConCoercion (classTyCon cls1) cos2
+  }
 
 -- Class constraint and given equality: use the equality to rewrite
 -- the class constraint. 
@@ -662,29 +1000,17 @@ doInteractWithInert (CTyEqCan { cc_id = cv, cc_flavor = ifl, cc_tyvar = tv, cc_r
                     (CDictCan { cc_id = dv, cc_flavor = wfl, cc_class = cl, cc_tyargs = xis }) 
   | ifl `canRewrite` wfl 
   , tv `elemVarSet` tyVarsOfTypes xis
-    -- substitute for tv in xis.  Note that the resulting class
-    -- constraint is still canonical, since substituting xi-types in
-    -- xi-types generates xi-types.  However, it may no longer be
-    -- inert with respect to the inert set items we've already seen.
-    -- For example, consider the inert set
-    --
-    --   D Int (g)
-    --   a ~g Int
-    --
-    -- and the work item D a (w). D a does not interact with D Int.
-    -- Next, it does interact with a ~g Int, getting rewritten to D
-    -- Int (w).  But now we must go back through the rest of the inert
-    -- set again, to find that it can now be discharged by the given D
-    -- Int instance.
   = do { rewritten_dict <- rewriteDict (cv,tv,xi) (dv,wfl,cl,xis)
-       ; mkIRStop KeepInert (singleCCan rewritten_dict) }
+            -- Continue with rewritten Dictionary because we can only be in the 
+            -- interactWithEqsStage, so the dictionary is inert. 
+       ; mkIRContinue "Eq/Cls" rewritten_dict KeepInert emptyWorkList }
     
 doInteractWithInert (CDictCan { cc_id = dv, cc_flavor = ifl, cc_class = cl, cc_tyargs = xis }) 
            workItem@(CTyEqCan { cc_id = cv, cc_flavor = wfl, cc_tyvar = tv, cc_rhs = xi })
   | wfl `canRewrite` ifl
   , tv `elemVarSet` tyVarsOfTypes xis
-  = do { rewritten_dict <- rewriteDict (cv,tv,xi) (dv,ifl,cl,xis) 
-       ; mkIRContinue workItem DropInert (singleCCan rewritten_dict) }
+  = do { rewritten_dict <- rewriteDict (cv,tv,xi) (dv,ifl,cl,xis)
+       ; mkIRContinue "Cls/Eq" workItem DropInert (workListFromNonEq rewritten_dict) }
 
 -- Class constraint and given equality: use the equality to rewrite
 -- the class constraint.
@@ -693,14 +1019,14 @@ doInteractWithInert (CTyEqCan { cc_id = cv, cc_flavor = ifl, cc_tyvar = tv, cc_r
   | ifl `canRewrite` wfl
   , tv `elemVarSet` tyVarsOfType ty 
   = do { rewritten_ip <- rewriteIP (cv,tv,xi) (ipid,wfl,nm,ty) 
-       ; mkIRStop KeepInert (singleCCan rewritten_ip) }
+       ; mkIRContinue "Eq/IP" rewritten_ip KeepInert emptyWorkList } 
 
 doInteractWithInert (CIPCan { cc_id = ipid, cc_flavor = ifl, cc_ip_nm = nm, cc_ip_ty = ty }) 
            workItem@(CTyEqCan { cc_id = cv, cc_flavor = wfl, cc_tyvar = tv, cc_rhs = xi })
   | wfl `canRewrite` ifl
   , tv `elemVarSet` tyVarsOfType ty
   = do { rewritten_ip <- rewriteIP (cv,tv,xi) (ipid,ifl,nm,ty) 
-       ; mkIRContinue workItem DropInert (singleCCan rewritten_ip) } 
+       ; mkIRContinue "IP/Eq" workItem DropInert (workListFromNonEq rewritten_ip) }
 
 -- Two implicit parameter constraints.  If the names are the same,
 -- but their types are not, we generate a wanted type equality 
@@ -709,95 +1035,105 @@ doInteractWithInert (CIPCan { cc_id = ipid, cc_flavor = ifl, cc_ip_nm = nm, cc_i
 -- so we just generate a fresh coercion variable that isn't used anywhere.
 doInteractWithInert (CIPCan { cc_id = id1, cc_flavor = ifl, cc_ip_nm = nm1, cc_ip_ty = ty1 }) 
            workItem@(CIPCan { cc_flavor = wfl, cc_ip_nm = nm2, cc_ip_ty = ty2 })
+  | nm1 == nm2 && isGiven wfl && isGiven ifl
+  =    -- See Note [Overriding implicit parameters]
+        -- Dump the inert item, override totally with the new one
+       -- Do not require type equality
+       -- For example, given let ?x::Int = 3 in let ?x::Bool = True in ...
+       --              we must *override* the outer one with the inner one
+    mkIRContinue "IP/IP override" workItem DropInert emptyWorkList
+
   | nm1 == nm2 && ty1 `tcEqType` ty2 
-  = solveOneFromTheOther (id1,ifl) workItem 
+  = solveOneFromTheOther "IP/IP" (EvId id1,ifl) workItem 
 
-  | nm1 == nm2 && (not (isGiven ifl && isGiven wfl))
+  | nm1 == nm2
   =    -- See Note [When improvement happens]
-    do { co_var <- newWantedCoVar ty1 ty2 
+    do { co_var <- newCoVar ty2 ty1 -- See Note [Efficient Orientation]
        ; let flav = Wanted (combineCtLoc ifl wfl) 
-       ; mkCanonical flav co_var >>= mkIRContinue workItem KeepInert } 
-
-
--- Inert: equality, work item: function equality
+       ; cans <- mkCanonical flav co_var 
+       ; mkIRContinue "IP/IP fundep" workItem KeepInert cans }
 
 -- Never rewrite a given with a wanted equality, and a type function
--- equality can never rewrite an equality.  Note also that if we have
--- F x1 ~ x2 and a ~ x3, and a occurs in x2, we don't rewrite it.  We
--- can wait until F x1 ~ x2 matches another F x1 ~ x4, and only then
--- we will ``expose'' x2 and x4 to rewriting.
+-- equality can never rewrite an equality. We rewrite LHS *and* RHS 
+-- of function equalities so that our inert set exposes everything that 
+-- we know about equalities.
 
--- Otherwise, we can try rewriting the type function equality with the equality.
+-- Inert: equality, work item: function equality
 doInteractWithInert (CTyEqCan { cc_id = cv1, cc_flavor = ifl, cc_tyvar = tv, cc_rhs = xi1 }) 
                     (CFunEqCan { cc_id = cv2, cc_flavor = wfl, cc_fun = tc
                                , cc_tyargs = args, cc_rhs = xi2 })
   | ifl `canRewrite` wfl 
-  , tv `elemVarSet` tyVarsOfTypes args
+  , tv `elemVarSet` tyVarsOfTypes (xi2:args) -- Rewrite RHS as well
   = do { rewritten_funeq <- rewriteFunEq (cv1,tv,xi1) (cv2,wfl,tc,args,xi2) 
-       ; mkIRStop KeepInert (singleCCan rewritten_funeq) }
+       ; mkIRStopK "Eq/FunEq" (workListFromEq rewritten_funeq) } 
+         -- Must Stop here, because we may no longer be inert after the rewritting.
 
 -- Inert: function equality, work item: equality
-
 doInteractWithInert (CFunEqCan {cc_id = cv1, cc_flavor = ifl, cc_fun = tc
                               , cc_tyargs = args, cc_rhs = xi1 }) 
            workItem@(CTyEqCan { cc_id = cv2, cc_flavor = wfl, cc_tyvar = tv, cc_rhs = xi2 })
   | wfl `canRewrite` ifl
-  , tv `elemVarSet` tyVarsOfTypes args
+  , tv `elemVarSet` tyVarsOfTypes (xi1:args) -- Rewrite RHS as well
   = do { rewritten_funeq <- rewriteFunEq (cv2,tv,xi2) (cv1,ifl,tc,args,xi1) 
-       ; mkIRContinue workItem DropInert (singleCCan rewritten_funeq) } 
+       ; mkIRContinue "FunEq/Eq" workItem DropInert (workListFromEq rewritten_funeq) } 
+         -- One may think that we could (KeepTransformedInert rewritten_funeq) 
+         -- but that is wrong, because it may end up not being inert with respect 
+         -- to future inerts. Example: 
+         -- Original inert = {    F xis ~  [a], b ~ Maybe Int } 
+         -- Work item comes along = a ~ [b] 
+         -- If we keep { F xis ~ [b] } in the inert set we will end up with: 
+         --      { F xis ~ [b], b ~ Maybe Int, a ~ [Maybe Int] } 
+         -- At the end, which is *not* inert. So we should unfortunately DropInert here.
 
 doInteractWithInert (CFunEqCan { cc_id = cv1, cc_flavor = fl1, cc_fun = tc1
                                , cc_tyargs = args1, cc_rhs = xi1 }) 
            workItem@(CFunEqCan { cc_id = cv2, cc_flavor = fl2, cc_fun = tc2
                                , cc_tyargs = args2, cc_rhs = xi2 })
-  | fl1 `canRewrite` fl2 && lhss_match
-  = do { cans <- rewriteEqLHS (mkCoVarCoercion cv1,xi1) (cv2,fl2,xi2) 
-       ; mkIRStop KeepInert cans } 
-  | fl2 `canRewrite` fl1 && lhss_match
-  = do { cans <- rewriteEqLHS (mkCoVarCoercion cv2,xi2) (cv1,fl1,xi1) 
-       ; mkIRContinue workItem DropInert cans }
+  | fl1 `canSolve` fl2 && lhss_match
+  = do { cans <- rewriteEqLHS LeftComesFromInert  (mkCoVarCoercion cv1,xi1) (cv2,fl2,xi2) 
+       ; mkIRStopK "FunEq/FunEq" cans } 
+  | fl2 `canSolve` fl1 && lhss_match
+  = do { cans <- rewriteEqLHS RightComesFromInert (mkCoVarCoercion cv2,xi2) (cv1,fl1,xi1) 
+       ; mkIRContinue "FunEq/FunEq" workItem DropInert cans }
   where
     lhss_match = tc1 == tc2 && and (zipWith tcEqType args1 args2) 
 
 doInteractWithInert (CTyEqCan { cc_id = cv1, cc_flavor = fl1, cc_tyvar = tv1, cc_rhs = xi1 }) 
            workItem@(CTyEqCan { cc_id = cv2, cc_flavor = fl2, cc_tyvar = tv2, cc_rhs = xi2 })
 -- Check for matching LHS 
-  | fl1 `canRewrite` fl2 && tv1 == tv2 
-  = do { cans <- rewriteEqLHS (mkCoVarCoercion cv1,xi1) (cv2,fl2,xi2) 
-       ; mkIRStop KeepInert cans } 
+  | fl1 `canSolve` fl2 && tv1 == tv2 
+  = do { cans <- rewriteEqLHS LeftComesFromInert (mkCoVarCoercion cv1,xi1) (cv2,fl2,xi2) 
+       ; mkIRStopK "Eq/Eq lhs" cans } 
 
-{-
-  | fl1 `canRewrite` fl2                       -- If at all possible, keep the inert, 
-  , Just tv1_rhs <- tcGetTyVar_maybe xi1       -- special case of inert a~b
-  , tv1_rhs == tv2
-  = do { cans <- rewriteEqLHS (mkSymCoercion (mkCoVarCoercion cv1), mkTyVarTy tv1) 
-                              (cv2,fl2,xi2) 
-       ; mkIRStop KeepInert cans } 
--}
-  | fl2 `canRewrite` fl1 && tv1 == tv2 
-  = do { cans <- rewriteEqLHS (mkCoVarCoercion cv2,xi2) (cv1,fl1,xi1) 
-       ; mkIRContinue workItem DropInert cans } 
+  | fl2 `canSolve` fl1 && tv1 == tv2 
+  = do { cans <- rewriteEqLHS RightComesFromInert (mkCoVarCoercion cv2,xi2) (cv1,fl1,xi1) 
+       ; mkIRContinue "Eq/Eq lhs" workItem DropInert cans }
 
 -- Check for rewriting RHS 
   | fl1 `canRewrite` fl2 && tv1 `elemVarSet` tyVarsOfType xi2 
   = do { rewritten_eq <- rewriteEqRHS (cv1,tv1,xi1) (cv2,fl2,tv2,xi2) 
-       ; mkIRStop KeepInert rewritten_eq }
+       ; mkIRStopK "Eq/Eq rhs" rewritten_eq }
+
   | fl2 `canRewrite` fl1 && tv2 `elemVarSet` tyVarsOfType xi1
   = do { rewritten_eq <- rewriteEqRHS (cv2,tv2,xi2) (cv1,fl1,tv1,xi1) 
-       ; mkIRContinue workItem DropInert rewritten_eq } 
-
+       ; mkIRContinue "Eq/Eq rhs" workItem DropInert rewritten_eq } 
 
--- Fall-through case for all other cases
-doInteractWithInert _ workItem = noInteraction workItem
+doInteractWithInert (CTyEqCan   { cc_id = cv1, cc_flavor = fl1, cc_tyvar = tv1, cc_rhs = xi1 })
+                    (CFrozenErr { cc_id = cv2, cc_flavor = fl2 })
+  | fl1 `canRewrite` fl2 && tv1 `elemVarSet` tyVarsOfEvVar cv2
+  = do { rewritten_frozen <- rewriteFrozen (cv1, tv1, xi1) (cv2, fl2)
+       ; mkIRStopK "Frozen/Eq" rewritten_frozen }
 
---------------------------------------------
-combineCtLoc :: CtFlavor -> CtFlavor -> WantedLoc
--- Precondition: At least one of them should be wanted 
-combineCtLoc (Wanted loc) _ = loc 
-combineCtLoc _ (Wanted loc) = loc 
-combineCtLoc _ _ = panic "Expected one of wanted constraints (BUG)" 
+doInteractWithInert (CFrozenErr { cc_id = cv2, cc_flavor = fl2 })
+           workItem@(CTyEqCan   { cc_id = cv1, cc_flavor = fl1, cc_tyvar = tv1, cc_rhs = xi1 })
+  | fl1 `canRewrite` fl2 && tv1 `elemVarSet` tyVarsOfEvVar cv2
+  = do { rewritten_frozen <- rewriteFrozen (cv1, tv1, xi1) (cv2, fl2)
+       ; mkIRContinue "Frozen/Eq" workItem DropInert rewritten_frozen }
 
+-- Fall-through case for all other situations
+doInteractWithInert _ workItem = noInteraction workItem
 
+-------------------------
 -- Equational Rewriting 
 rewriteDict  :: (CoVar, TcTyVar, Xi) -> (DictId, CtFlavor, Class, [Xi]) -> TcS CanonicalCt
 rewriteDict (cv,tv,xi) (dv,gw,cl,xis) 
@@ -808,7 +1144,9 @@ rewriteDict (cv,tv,xi) (dv,gw,cl,xis)
        ; dv' <- newDictVar cl args 
        ; case gw of 
            Wanted {}         -> setDictBind dv (EvCast dv' (mkSymCoercion dict_co))
-           _given_or_derived -> setDictBind dv' (EvCast dv dict_co) 
+           Given {}          -> setDictBind dv' (EvCast dv dict_co) 
+           Derived {}        -> return () -- Derived dicts we don't set any evidence
+
        ; return (CDictCan { cc_id = dv'
                           , cc_flavor = gw 
                           , cc_class = cl 
@@ -821,32 +1159,41 @@ rewriteIP (cv,tv,xi) (ipid,gw,nm,ty)
        ; ipid' <- newIPVar nm ty' 
        ; case gw of 
            Wanted {}         -> setIPBind ipid  (EvCast ipid' (mkSymCoercion ip_co))
-           _given_or_derived -> setIPBind ipid' (EvCast ipid ip_co) 
+           Given {}          -> setIPBind ipid' (EvCast ipid ip_co) 
+           Derived {}        -> return () -- Derived ips: we don't set any evidence
+
        ; return (CIPCan { cc_id = ipid'
                         , cc_flavor = gw
                         , cc_ip_nm = nm
                         , cc_ip_ty = ty' }) }
    
 rewriteFunEq :: (CoVar,TcTyVar,Xi) -> (CoVar,CtFlavor,TyCon, [Xi], Xi) -> TcS CanonicalCt
-rewriteFunEq (cv1,tv,xi1) (cv2,gw, tc,args,xi2) 
+rewriteFunEq (cv1,tv,xi1) (cv2,gw, tc,args,xi2)                   -- cv2 :: F args ~ xi2
   = do { let arg_cos = substTysWith [tv] [mkCoVarCoercion cv1] args 
              args'   = substTysWith [tv] [xi1] args 
-             fun_co  = mkTyConCoercion tc arg_cos 
-       ; cv2' <- case gw of 
-                   Wanted {} -> do { cv2' <- newWantedCoVar (mkTyConApp tc args') xi2 
-                                   ; setWantedCoBind cv2 $ 
-                                     mkTransCoercion fun_co (mkCoVarCoercion cv2') 
-                                   ; return cv2' } 
-                   _giv_or_der -> newGivOrDerCoVar (mkTyConApp tc args') xi2 $
-                                  mkTransCoercion (mkSymCoercion fun_co) (mkCoVarCoercion cv2) 
+             fun_co  = mkTyConCoercion tc arg_cos                 -- fun_co :: F args ~ F args'
+
+             xi2'    = substTyWith [tv] [xi1] xi2
+             xi2_co  = substTyWith [tv] [mkCoVarCoercion cv1] xi2 -- xi2_co :: xi2 ~ xi2' 
+
+       ; cv2' <- newCoVar (mkTyConApp tc args') xi2'
+       ; case gw of 
+           Wanted {} -> setCoBind cv2  (fun_co               `mkTransCoercion` 
+                                        mkCoVarCoercion cv2' `mkTransCoercion` 
+                                        mkSymCoercion xi2_co)
+           Given {}  -> setCoBind cv2' (mkSymCoercion fun_co `mkTransCoercion` 
+                                        mkCoVarCoercion cv2  `mkTransCoercion` 
+                                        xi2_co)
+           Derived {} -> return () 
+
        ; return (CFunEqCan { cc_id = cv2'
                            , cc_flavor = gw
                            , cc_tyargs = args'
                            , cc_fun = tc 
-                           , cc_rhs = xi2 }) }
+                           , cc_rhs = xi2' }) }
 
 
-rewriteEqRHS :: (CoVar,TcTyVar,Xi) -> (CoVar,CtFlavor,TcTyVar,Xi) -> TcS CanonicalCts
+rewriteEqRHS :: (CoVar,TcTyVar,Xi) -> (CoVar,CtFlavor,TcTyVar,Xi) -> TcS WorkList
 -- Use the first equality to rewrite the second, flavors already checked. 
 -- E.g.          c1 : tv1 ~ xi1   c2 : tv2 ~ xi2
 -- rewrites c2 to give
@@ -856,75 +1203,94 @@ rewriteEqRHS :: (CoVar,TcTyVar,Xi) -> (CoVar,CtFlavor,TcTyVar,Xi) -> TcS Canonic
 rewriteEqRHS (cv1,tv1,xi1) (cv2,gw,tv2,xi2) 
   | Just tv2' <- tcGetTyVar_maybe xi2'
   , tv2 == tv2'         -- In this case xi2[xi1/tv1] = tv2, so we have tv2~tv2
-  = do { when (isWanted gw) (setWantedCoBind cv2 (mkSymCoercion co2')) 
-       ; return emptyCCan } 
-  | otherwise 
-  = do { cv2' <- 
-           case gw of 
-             Wanted {} 
-                 -> do { cv2' <- newWantedCoVar (mkTyVarTy tv2) xi2' 
-                       ; setWantedCoBind cv2 $ 
-                         mkCoVarCoercion cv2' `mkTransCoercion` mkSymCoercion co2'
-                       ; return cv2' } 
-             _giv_or_der 
-                 -> newGivOrDerCoVar (mkTyVarTy tv2) xi2' $ 
-                    mkCoVarCoercion cv2 `mkTransCoercion` co2'
-
-       ; xi2'' <- canOccursCheck gw tv2 xi2' -- we know xi2' is *not* tv2 
-       ; return (singleCCan $ CTyEqCan { cc_id = cv2' 
-                                       , cc_flavor = gw 
-                                       , cc_tyvar = tv2 
-                                       , cc_rhs   = xi2'' }) 
-       }
+  = do { when (isWanted gw) (setCoBind cv2 (mkSymCoercion co2')) 
+       ; return emptyWorkList } 
+  | otherwise
+  = do { cv2' <- newCoVar (mkTyVarTy tv2) xi2'
+       ; case gw of
+             Wanted {} -> setCoBind cv2 $ mkCoVarCoercion cv2' `mkTransCoercion` 
+                                          mkSymCoercion co2'
+             Given {}  -> setCoBind cv2' $ mkCoVarCoercion cv2 `mkTransCoercion` 
+                                           co2'
+             Derived {} -> return ()
+       ; canEqToWorkList gw cv2' (mkTyVarTy tv2) xi2' }
   where 
     xi2' = substTyWith [tv1] [xi1] xi2 
     co2' = substTyWith [tv1] [mkCoVarCoercion cv1] xi2  -- xi2 ~ xi2[xi1/tv1]
 
-rewriteEqLHS :: (Coercion,Xi) -> (CoVar,CtFlavor,Xi) -> TcS CanonicalCts
--- Used to ineratct two equalities of the following form: 
+rewriteEqLHS :: WhichComesFromInert -> (Coercion,Xi) -> (CoVar,CtFlavor,Xi) -> TcS WorkList
+-- Used to ineract two equalities of the following form: 
 -- First Equality:   co1: (XXX ~ xi1)  
 -- Second Equality:  cv2: (XXX ~ xi2) 
 -- Where the cv1 `canRewrite` cv2 equality 
-rewriteEqLHS (co1,xi1) (cv2,gw,xi2) 
-  = do { cv2' <- if isWanted gw then 
-                     do { cv2' <- newWantedCoVar xi1 xi2 
-                        ; setWantedCoBind cv2 $ 
-                          co1 `mkTransCoercion` mkCoVarCoercion cv2'
-                        ; return cv2' } 
-                 else newGivOrDerCoVar xi1 xi2 $ 
-                      mkSymCoercion co1 `mkTransCoercion` mkCoVarCoercion cv2 
+-- We have an option of creating new work (xi1 ~ xi2) OR (xi2 ~ xi1), 
+--    See Note [Efficient Orientation] for that 
+rewriteEqLHS LeftComesFromInert (co1,xi1) (cv2,gw,xi2) 
+  = do { cv2' <- newCoVar xi2 xi1 
+       ; case gw of 
+           Wanted {} -> setCoBind cv2 $ 
+                        co1 `mkTransCoercion` mkSymCoercion (mkCoVarCoercion cv2')
+           Given {}  -> setCoBind cv2' $ 
+                        mkSymCoercion (mkCoVarCoercion cv2) `mkTransCoercion` co1 
+           Derived {} -> return ()
+       ; mkCanonical gw cv2' }
+
+rewriteEqLHS RightComesFromInert (co1,xi1) (cv2,gw,xi2) 
+  = do { cv2' <- newCoVar xi1 xi2
+       ; case gw of
+           Wanted {} -> setCoBind cv2 $
+                        co1 `mkTransCoercion` mkCoVarCoercion cv2'
+           Given {}  -> setCoBind cv2' $
+                        mkSymCoercion co1 `mkTransCoercion` mkCoVarCoercion cv2
+           Derived {} -> return ()
        ; mkCanonical gw cv2' }
 
+rewriteFrozen :: (CoVar,TcTyVar,Xi) -> (CoVar,CtFlavor) -> TcS WorkList
+rewriteFrozen (cv1, tv1, xi1) (cv2, fl2)
+  = do { cv2' <- newCoVar ty2a' ty2b'  -- ty2a[xi1/tv1] ~ ty2b[xi1/tv1]
+       ; case fl2 of
+             Wanted {} -> setCoBind cv2 $ co2a'                `mkTransCoercion`
+                                                 mkCoVarCoercion cv2' `mkTransCoercion`
+                                                 mkSymCoercion co2b'
+
+             Given {} -> setCoBind cv2' $ mkSymCoercion co2a'  `mkTransCoercion`
+                                         mkCoVarCoercion cv2  `mkTransCoercion`
+                                         co2b'
+
+             Derived {} -> return ()
+
+      ; return (workListFromNonEq $ CFrozenErr { cc_id = cv2', cc_flavor = fl2 }) }
+  where
+    (ty2a, ty2b) = coVarKind cv2          -- cv2 : ty2a ~ ty2b
+    ty2a' = substTyWith [tv1] [xi1] ty2a
+    ty2b' = substTyWith [tv1] [xi1] ty2b
+
+    co2a' = substTyWith [tv1] [mkCoVarCoercion cv1] ty2a  -- ty2a ~ ty2a[xi1/tv1]
+    co2b' = substTyWith [tv1] [mkCoVarCoercion cv1] ty2b  -- ty2b ~ ty2b[xi1/tv1]
 
-solveOneFromTheOther :: (EvVar, CtFlavor) -> CanonicalCt -> TcS InteractResult 
--- First argument inert, second argument workitem. They both represent 
--- wanted/given/derived evidence for the *same* predicate so we try here to 
--- discharge one directly from the other. 
+solveOneFromTheOther :: String -> (EvTerm, CtFlavor) -> CanonicalCt -> TcS InteractResult
+-- First argument inert, second argument work-item. They both represent 
+-- wanted/given/derived evidence for the *same* predicate so 
+-- we can discharge one directly from the other. 
 --
 -- Precondition: value evidence only (implicit parameters, classes) 
 --               not coercion
-solveOneFromTheOther (iid,ifl) workItem 
-      -- Both derived needs a special case. You might think that we do not need
-      -- two evidence terms for the same claim. But, since the evidence is partial, 
-      -- either evidence may do in some cases; see TcSMonad.isGoodRecEv.
-      -- See also Example 3 in Note [Superclasses and recursive dictionaries] 
-  | isDerived ifl && isDerived wfl 
-  = noInteraction workItem 
-
-  | wfl `canRewrite` ifl 
-  = do { unless (isGiven ifl) $ setEvBind iid (EvId wid)
-                -- Overwrite the binding, if one exists
-                -- (For Givens, they are lambda-bound so nothing to overwrite,
-                -- but we still drop the overridden one and replace it in
-                -- the inert set with the new one
-       ; mkIRContinue workItem DropInert emptyCCan }
-       -- The order is important here: must do (wfl `canRewrite` ifl) first
-       -- so that we override the inert item with an inner given if possible.  
-       -- See Note [Overriding implicit parameters]
-
-  | otherwise   -- ifl `canRewrite` wfl
-  = do { unless (isGiven wfl) $ setEvBind wid (EvId iid) 
-       ; dischargeWorkItem }
+solveOneFromTheOther info (ev_term,ifl) workItem
+  | isDerived wfl
+  = mkIRStopK ("Solved[DW] " ++ info) emptyWorkList
+
+  | isDerived ifl -- The inert item is Derived, we can just throw it away, 
+                 -- The workItem is inert wrt earlier inert-set items, 
+                 -- so it's safe to continue on from this point
+  = mkIRContinue ("Solved[DI] " ++ info) workItem DropInert emptyWorkList
+  
+  | otherwise
+  = ASSERT( ifl `canSolve` wfl )
+      -- Because of Note [The Solver Invariant], plus Derived dealt with
+    do { when (isWanted wfl) $ setEvBind wid ev_term
+           -- Overwrite the binding, if one exists
+          -- If both are Given, we already have evidence; no need to duplicate
+       ; mkIRStopK ("Solved " ++ info) emptyWorkList }
   where 
      wfl = cc_flavor workItem
      wid = cc_id workItem
@@ -945,8 +1311,9 @@ our worklist.
 When we simplify a wanted constraint, if we first see a matching
 instance, we may produce new wanted work. To (1) avoid doing this work 
 twice in the future and (2) to handle recursive dictionaries we may ``cache'' 
-this item as solved (in effect, given) into our inert set and with that add 
-its superclass constraints (as given) in our worklist. 
+this item as given into our inert set WITHOUT adding its superclass constraints, 
+otherwise we'd be in danger of creating a loop [In fact this was the exact reason
+for doing the isGoodRecEv check in an older version of the type checker]. 
 
 But now we have added partially solved constraints to the worklist which may 
 interact with other wanteds. Consider the example: 
@@ -957,17 +1324,12 @@ Example 1:
     instance Eq a => Foo [a] a   --- fooDFun
 
 and wanted (Foo [t] t). We are first going to see that the instance matches 
-and create an inert set that includes the solved (Foo [t] t) and its 
-superclasses. 
+and create an inert set that includes the solved (Foo [t] t) but not its superclasses:
        d1 :_g Foo [t] t                 d1 := EvDFunApp fooDFun d3 
-       d2 :_g Eq t                      d2 := EvSuperClass d1 0 
 Our work list is going to contain a new *wanted* goal
        d3 :_w Eq t 
-It is wrong to react the wanted (Eq t) with the given (Eq t) because that would 
-construct loopy evidence. Hence the check isGoodRecEv in doInteractWithInert. 
 
-OK, so we have ruled out bad behaviour, but how do we ge recursive dictionaries, 
-at all? Consider
+Ok, so how do we get recursive dictionaries, at all: 
 
 Example 2:
 
@@ -1284,7 +1646,8 @@ we keep the synonym-using RHS without expansion.
 \begin{code}
 -- If a work item has any form of interaction with top-level we get this 
 data TopInteractResult 
-  = NoTopInt              -- No top-level interaction
+  = NoTopInt         -- No top-level interaction
+                     -- Equivalent to (SomeTopInt emptyWorkList (ContinueWith work_item))
   | SomeTopInt 
       { tir_new_work  :: WorkList      -- Sub-goals or new work (could be given, 
                                         --                        for superclasses)
@@ -1296,7 +1659,7 @@ data TopInteractResult
                                        -- arising from top-level instances.
 
 topReactionsStage :: SimplifierStage 
-topReactionsStage workItem inerts 
+topReactionsStage depth workItem inerts 
   = do { tir <- tryTopReact workItem 
        ; case tir of 
            NoTopInt -> 
@@ -1304,10 +1667,14 @@ topReactionsStage workItem inerts
                            , sr_new_work = emptyWorkList 
                            , sr_stop     = ContinueWith workItem } 
            SomeTopInt tir_new_work tir_new_inert -> 
-               return $ SR { sr_inerts   = inerts 
-                           , sr_new_work = tir_new_work
-                           , sr_stop     = tir_new_inert
-                           }
+               do { bumpStepCountTcS
+                  ; traceFireTcS depth (ptext (sLit "Top react")
+                       <+> vcat [ ptext (sLit "Work =") <+> ppr workItem
+                                , ptext (sLit "New =") <+> ppr tir_new_work ])
+                  ; return $ SR { sr_inerts   = inerts 
+                               , sr_new_work = tir_new_work
+                               , sr_stop     = tir_new_inert
+                               } }
        }
 
 tryTopReact :: WorkItem -> TcS TopInteractResult 
@@ -1321,71 +1688,85 @@ tryTopReact workitem
          else return NoTopInt 
        } 
 
-allowedTopReaction :: Bool -> WorkItem -> Bool 
+allowedTopReaction :: Bool -> WorkItem -> Bool
 allowedTopReaction eqs_only (CDictCan {}) = not eqs_only
-allowedTopReaction _        _             = True 
-
+allowedTopReaction _        _             = True
 
 doTopReact :: WorkItem -> TcS TopInteractResult 
--- The work item does not react with the inert set, 
--- so try interaction with top-level instances
-doTopReact workItem@(CDictCan { cc_id = dv, cc_flavor = Wanted loc
-                              , cc_class = cls, cc_tyargs = xis }) 
+-- The work item does not react with the inert set, so try interaction with top-level instances
+-- NB: The place to add superclasses in *not* in doTopReact stage. Instead superclasses are 
+--     added in the worklist as part of the canonicalisation process. 
+-- See Note [Adding superclasses] in TcCanonical.
+
+-- Given dictionary
+-- See Note [Given constraint that matches an instance declaration]
+doTopReact (CDictCan { cc_flavor = Given {} })
+  = return NoTopInt -- NB: Superclasses already added since it's canonical
+
+-- Derived dictionary: just look for functional dependencies
+doTopReact workItem@(CDictCan { cc_flavor = fl@(Derived loc)
+                              , cc_class = cls, cc_tyargs = xis })
+  = do { instEnvs <- getInstEnvs
+       ; let fd_eqns = improveFromInstEnv instEnvs
+                                                (ClassP cls xis, pprArisingAt loc)
+       ; m <- rewriteWithFunDeps fd_eqns xis fl
+       ; case m of
+           Nothing -> return NoTopInt
+           Just (xis',_,fd_work) ->
+               let workItem' = workItem { cc_tyargs = xis' }
+                   -- Deriveds are not supposed to have identity (cc_id is unused!)
+               in return $ SomeTopInt { tir_new_work  = fd_work 
+                                      , tir_new_inert = ContinueWith workItem' } }
+
+-- Wanted dictionary
+doTopReact workItem@(CDictCan { cc_id = dv, cc_flavor = fl@(Wanted loc)
+                              , cc_class = cls, cc_tyargs = xis })
   = do { -- See Note [MATCHING-SYNONYMS]
        ; lkp_inst_res <- matchClassInst cls xis loc
-       ; case lkp_inst_res of 
-           NoInstance -> do { traceTcS "doTopReact/ no class instance for" (ppr dv) 
-                            ; funDepReact }
-           GenInst wtvs ev_term ->  -- Solved 
+       ; case lkp_inst_res of
+           NoInstance ->
+             do { traceTcS "doTopReact/ no class instance for" (ppr dv)
+
+                ; instEnvs <- getInstEnvs
+                ; let fd_eqns = improveFromInstEnv instEnvs
+                                                         (ClassP cls xis, pprArisingAt loc)
+                ; m <- rewriteWithFunDeps fd_eqns xis fl
+                ; case m of
+                    Nothing -> return NoTopInt
+                    Just (xis',cos,fd_work) ->
+                        do { let dict_co = mkTyConCoercion (classTyCon cls) cos
+                           ; dv'<- newDictVar cls xis'
+                           ; setDictBind dv (EvCast dv' dict_co)
+                           ; let workItem' = CDictCan { cc_id = dv', cc_flavor = fl, 
+                                                        cc_class = cls, cc_tyargs = xis' }
+                           ; return $ 
+                             SomeTopInt { tir_new_work  = workListFromNonEq workItem' `unionWorkList` fd_work
+                                        , tir_new_inert = Stop } } }
+
+           GenInst wtvs ev_term -- Solved 
                   -- No need to do fundeps stuff here; the instance 
                   -- matches already so we won't get any more info
                   -- from functional dependencies
-               do { traceTcS "doTopReact/ found class instance for" (ppr dv) 
-                  ; setDictBind dv ev_term 
-                  ; workList <- canWanteds wtvs
-                  ; if null wtvs
+             | null wtvs
+             -> do { traceTcS "doTopReact/ found nullary class instance for" (ppr dv) 
+                   ; setDictBind dv ev_term 
                     -- Solved in one step and no new wanted work produced. 
                     -- i.e we directly matched a top-level instance
-                   -- No point in caching this in 'inert', nor in adding superclasses
-                    then return $ SomeTopInt { tir_new_work  = emptyCCan 
-                                             , tir_new_inert = Stop }
-
-                    -- Solved and new wanted work produced, you may cache the 
-                   -- (tentatively solved) dictionary as Derived and its superclasses
-                    else do { let solved = makeSolved workItem
-                            ; sc_work <- newSCWorkFromFlavored dv (Derived loc) cls xis 
-                            ; return $ SomeTopInt 
-                                  { tir_new_work = workList `unionWorkLists` sc_work 
-                                  , tir_new_inert = ContinueWith solved } }
-                  }
-       }
-  where 
-    -- Try for a fundep reaction beween the wanted item 
-    -- and a top-level instance declaration
-    funDepReact 
-      = do { instEnvs <- getInstEnvs
-           ; let eqn_pred_locs = improveFromInstEnv (classInstances instEnvs)
-                                                    (ClassP cls xis, ppr dv)
-           ; wevvars <- mkWantedFunDepEqns loc eqn_pred_locs 
-                     -- NB: fundeps generate some wanted equalities, but 
-                     --     we don't use their evidence for anything
-           ; fd_work <- canWanteds wevvars 
-           ; sc_work <- newSCWorkFromFlavored dv (Derived loc) cls xis
-           ; return $ SomeTopInt { tir_new_work = fd_work `unionWorkLists` sc_work
-                                 , tir_new_inert = ContinueWith workItem }
-           -- NB: workItem is inert, but it isn't solved
-          -- keep it as inert, although it's not solved because we
-           -- have now reacted all its top-level fundep-induced equalities!
-                    
-           -- See Note [FunDep Reactions]
-           }
-
--- Otherwise, we have a given or derived 
-doTopReact workItem@(CDictCan { cc_id = dv, cc_flavor = fl
-                              , cc_class = cls, cc_tyargs = xis }) 
-  = do { sc_work <- newSCWorkFromFlavored dv fl cls xis 
-       ; return $ SomeTopInt sc_work (ContinueWith workItem) }
-    -- See Note [Given constraint that matches an instance declaration]
+                    -- No point in caching this in 'inert'; hence Stop
+                   ; return $ SomeTopInt { tir_new_work  = emptyWorkList 
+                                         , tir_new_inert = Stop } }
+
+             | otherwise
+             -> do { traceTcS "doTopReact/ found nullary class instance for" (ppr dv) 
+                   ; setDictBind dv ev_term 
+                        -- Solved and new wanted work produced, you may cache the 
+                        -- (tentatively solved) dictionary as Given! (used to be: Derived)
+                   ; let solved   = workItem { cc_flavor = given_fl }
+                         given_fl = Given (setCtLocOrigin loc UnkSkol) 
+                   ; inst_work <- canWanteds wtvs
+                   ; return $ SomeTopInt { tir_new_work  = inst_work
+                                         , tir_new_inert = ContinueWith solved } }
+       }          
 
 -- Type functions
 doTopReact (CFunEqCan { cc_id = cv, cc_flavor = fl
@@ -1404,16 +1785,16 @@ doTopReact (CFunEqCan { cc_id = cv, cc_flavor = fl
                             -- See Note [Type synonym families] in TyCon
                          coe = mkTyConApp coe_tc rep_tys 
                    ; cv' <- case fl of
-                              Wanted {} -> do { cv' <- newWantedCoVar rhs_ty xi
-                                              ; setWantedCoBind cv $ 
+                              Wanted {} -> do { cv' <- newCoVar rhs_ty xi
+                                              ; setCoBind cv $ 
                                                     coe `mkTransCoercion`
                                                       mkCoVarCoercion cv'
                                               ; return cv' }
-                              _ -> newGivOrDerCoVar xi rhs_ty $ 
-                                   mkSymCoercion (mkCoVarCoercion cv) `mkTransCoercion` coe 
-
-                   ; workList <- mkCanonical fl cv'
-                   ; return $ SomeTopInt workList Stop }
+                              Given {}   -> newGivenCoVar xi rhs_ty $ 
+                                            mkSymCoercion (mkCoVarCoercion cv) `mkTransCoercion` coe 
+                              Derived {} -> newDerivedId (EqPred xi rhs_ty)
+                   ; can_cts <- mkCanonical fl cv'
+                   ; return $ SomeTopInt can_cts Stop }
            _ 
              -> panicTcS $ text "TcSMonad.matchFam returned multiple instances!"
        }
@@ -1423,6 +1804,7 @@ doTopReact (CFunEqCan { cc_id = cv, cc_flavor = fl
 doTopReact _workItem = return NoTopInt 
 \end{code}
 
+
 Note [FunDep and implicit parameter reactions] 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Currently, our story of interacting two dictionaries (or a dictionary
@@ -1451,7 +1833,17 @@ might dischard d2 directly:
         d2 := d1 |> D Int cv
 
 But in general it's a bit painful to figure out the necessary coercion,
-so we just take the first approach.
+so we just take the first approach. Here is a better example. Consider:
+    class C a b c | a -> b 
+And: 
+     [Given]  d1 : C T Int Char 
+     [Wanted] d2 : C T beta Int 
+In this case, it's *not even possible* to solve the wanted immediately. 
+So we should simply output the functional dependency and add this guy
+[but NOT its superclasses] back in the worklist. Even worse: 
+     [Given] d1 : C T Int beta 
+     [Wanted] d2: C T beta Int 
+Then it is solvable, but its very hard to detect this on the spot. 
 
 It's exactly the same with implicit parameters, except that the
 "aggressive" approach would be much easier to implement.
@@ -1538,19 +1930,10 @@ We are choosing option 2 below but we might consider having a flag as well.
 
 Note [New Wanted Superclass Work] 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Even in the case of wanted constraints, we add all of its superclasses as 
-new given work. There are several reasons for this: 
-     a) to minimise error messages; 
-        eg suppose we have wanted (Eq a, Ord a)
-            then we report only (Ord a) unsoluble
-
-     b) to make the smallest number of constraints when *inferring* a type
-        (same Eq/Ord example)
+Even in the case of wanted constraints, we may add some superclasses 
+as new given work. The reason is: 
 
-     c) for recursive dictionaries we *must* add the superclasses
-        so that we can use them when solving a sub-problem
-
-     d) To allow FD-like improvement for type families. Assume that 
+        To allow FD-like improvement for type families. Assume that 
         we have a class 
              class C a b | a -> b 
         and we have to solve the implication constraint: 
@@ -1563,21 +1946,24 @@ new given work. There are several reasons for this:
         Now suppose that we have: 
                given: C a b 
                wanted: C a beta 
-        By interacting the given we will get that (F a ~ b) which is not 
+        By interacting the given we will get given (F a ~ b) which is not 
         enough by itself to make us discharge (C a beta). However, we 
-        may create a new given equality from the super-class that we promise
-        to solve: (F a ~ beta). Now we may interact this with the rest of 
-        constraint to finally get: 
-                  given :  beta ~ b 
-        
+        may create a new derived equality from the super-class of the
+        wanted constraint (C a beta), namely derived (F a ~ beta). 
+        Now we may interact this with given (F a ~ b) to get: 
+                  derived :  beta ~ b 
         But 'beta' is a touchable unification variable, and hence OK to 
-        unify it with 'b', replacing the given evidence with the identity. 
+        unify it with 'b', replacing the derived evidence with the identity. 
+
+        This requires trySpontaneousSolve to solve *derived*
+        equalities that have a touchable in their RHS, *in addition*
+        to solving wanted equalities.
+
+We also need to somehow use the superclasses to quantify over a minimal, 
+constraint see note [Minimize by Superclasses] in TcSimplify.
 
-        This requires trySpontaneousSolve to solve given equalities that
-        have a touchable in their RHS, *in addition* to solving wanted 
-        equalities. 
 
-Here is another example where this is useful. 
+Finally, here is another example where this is useful. 
 
 Example 1:
 ----------
@@ -1615,23 +2001,6 @@ NB: The desugarer needs be more clever to deal with equalities
     that participate in recursive dictionary bindings. 
 
 \begin{code}
-newSCWorkFromFlavored :: EvVar -> CtFlavor -> Class -> [Xi]
-                      -> TcS WorkList
-newSCWorkFromFlavored ev flavor cls xis
-  | Given loc <- flavor                 -- The NoScSkol says "don't add superclasses"
-  , NoScSkol <- ctLocOrigin loc  -- Very important!
-  = return emptyWorkList
-    
-  | otherwise
-  = do { let (tyvars, sc_theta, _, _) = classBigSig cls 
-             sc_theta1 = substTheta (zipTopTvSubst tyvars xis) sc_theta
-             -- Add *all* its superclasses (equalities or not) as new given work 
-             -- See Note [New Wanted Superclass Work] 
-       ; sc_vars <- zipWithM inst_one sc_theta1 [0..]
-       ; mkCanonicals flavor sc_vars } 
-  where
-    inst_one pred n = newGivOrDerEvVar pred (EvSuperClass ev n)
-
 data LookupInstResult
   = NoInstance
   | GenInst [WantedEvVar] EvTerm 
@@ -1656,13 +2025,11 @@ matchClassInst clas tys loc
                  ; tys <- instDFunTypes mb_inst_tys 
                  ; let (theta, _) = tcSplitPhiTy (applyTys (idType dfun_id) tys)
                  ; if null theta then
-                       return (GenInst [] (EvDFunApp dfun_id tys [])) 
+                       return (GenInst [] (EvDFunApp dfun_id tys []))
                    else do
                      { ev_vars <- instDFunConstraints theta
-                     ; let wevs = [WantedEvVar w loc | w <- ev_vars]
+                     ; let wevs = [EvVarX w loc | w <- ev_vars]
                      ; return $ GenInst wevs (EvDFunApp dfun_id tys ev_vars) }
                  }
         }
 \end{code}
-
-