Whitespace only in types/FamInstEnv.lhs

1 files changed, 135 insertions, 142 deletions

diff --git a/compiler/types/FamInstEnv.lhs b/compiler/types/FamInstEnv.lhs
index c7b9dedd37..f30d783b84 100644
--- a/compiler/types/FamInstEnv.lhs
+++ b/compiler/types/FamInstEnv.lhs
@@ -5,28 +5,21 @@
 FamInstEnv: Type checked family instance declarations
 
 \begin{code}
-{-# OPTIONS -fno-warn-tabs #-}
--- The above warning supression flag is a temporary kludge.
--- While working on this module you are encouraged to remove it and
--- detab the module (please do the detabbing in a separate patch). See
---     http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#TabsvsSpaces
--- for details
-
 module FamInstEnv (
-	FamInst(..), FamFlavor(..), famInstAxiom, 
-        famInstsRepTyCons, famInstRepTyCon_maybe, dataFamInstRepTyCon, 
+        FamInst(..), FamFlavor(..), famInstAxiom,
+        famInstsRepTyCons, famInstRepTyCon_maybe, dataFamInstRepTyCon,
         famInstLHS,
-	pprFamInst, pprFamInstHdr, pprFamInsts, 
-	mkSynFamInst, mkDataFamInst, mkImportedFamInst,
+        pprFamInst, pprFamInstHdr, pprFamInsts,
+        mkSynFamInst, mkDataFamInst, mkImportedFamInst,
+
+        FamInstEnvs, FamInstEnv, emptyFamInstEnv, emptyFamInstEnvs,
+        extendFamInstEnv, deleteFromFamInstEnv, extendFamInstEnvList,
+        identicalFamInst, famInstEnvElts, familyInstances,
 
-	FamInstEnvs, FamInstEnv, emptyFamInstEnv, emptyFamInstEnvs, 
-	extendFamInstEnv, deleteFromFamInstEnv, extendFamInstEnvList, 
-	identicalFamInst, famInstEnvElts, familyInstances,
+        lookupFamInstEnv, lookupFamInstEnvConflicts, lookupFamInstEnvConflicts',
 
-	lookupFamInstEnv, lookupFamInstEnvConflicts, lookupFamInstEnvConflicts',
-	
-	-- Normalisation
-	topNormaliseType, normaliseType, normaliseTcApp
+        -- Normalisation
+        topNormaliseType, normaliseType, normaliseTcApp
     ) where
 
 #include "HsVersions.h"
@@ -49,9 +42,9 @@ import FastString
 
 
 %************************************************************************
-%*									*
+%*                                                                      *
 \subsection{Type checked family instance heads}
-%*									*
+%*                                                                      *
 %************************************************************************
 
 Note [FamInsts and CoAxioms]
@@ -62,7 +55,7 @@ Note [FamInsts and CoAxioms]
 * A CoAxiom is a System-FC thing: it can relate any two types
 
 * A FamInst is a Haskell source-language thing, corresponding
-  to a type/data family instance declaration.  
+  to a type/data family instance declaration.
     - The FamInst contains a CoAxiom, which is the evidence
       for the instance
 
@@ -76,25 +69,25 @@ data FamInst  -- See Note [FamInsts and CoAxioms]
                                         -- by this family instance
             , fi_flavor :: FamFlavor
 
-            -- Everything below here is a redundant, 
+            -- Everything below here is a redundant,
             -- cached version of the two things above
-            , fi_fam   :: Name		-- Family name
-		-- INVARIANT: fi_fam = name of fi_fam_tc
+            , fi_fam   :: Name          -- Family name
+                -- INVARIANT: fi_fam = name of fi_fam_tc
 
-		-- Used for "rough matching"; same idea as for class instances
+                -- Used for "rough matching"; same idea as for class instances
                 -- See Note [Rough-match field] in InstEnv
-	    , fi_tcs   :: [Maybe Name]	-- Top of type args
-		-- INVARIANT: fi_tcs = roughMatchTcs fi_tys
+            , fi_tcs   :: [Maybe Name]  -- Top of type args
+                -- INVARIANT: fi_tcs = roughMatchTcs fi_tys
 
-		-- Used for "proper matching"; ditto
-	    , fi_tvs    :: TyVarSet	-- Template tyvars for full match
+                -- Used for "proper matching"; ditto
+            , fi_tvs    :: TyVarSet     -- Template tyvars for full match
             , fi_fam_tc :: TyCon        -- Family tycon
-	    , fi_tys    :: [Type]	--   and its arg types
-		-- INVARIANT: fi_tvs = coAxiomTyVars fi_axiom
-		--	      (fi_fam_tc, fi_tys) = coAxiomSplitLHS fi_axiom
+            , fi_tys    :: [Type]       --   and its arg types
+                -- INVARIANT: fi_tvs = coAxiomTyVars fi_axiom
+                --            (fi_fam_tc, fi_tys) = coAxiomSplitLHS fi_axiom
             }
 
-data FamFlavor 
+data FamFlavor
   = SynFamilyInst         -- A synonym family
   | DataFamilyInst TyCon  -- A data family, with its representation TyCon
 \end{code}
@@ -114,13 +107,13 @@ famInstsRepTyCons fis = [tc | FamInst { fi_flavor = DataFamilyInst tc } <- fis]
 
 -- Extracts the TyCon for this *data* (or newtype) instance
 famInstRepTyCon_maybe :: FamInst -> Maybe TyCon
-famInstRepTyCon_maybe fi 
+famInstRepTyCon_maybe fi
   = case fi_flavor fi of
        DataFamilyInst tycon -> Just tycon
        SynFamilyInst        -> Nothing
 
 dataFamInstRepTyCon :: FamInst -> TyCon
-dataFamInstRepTyCon fi 
+dataFamInstRepTyCon fi
   = case fi_flavor fi of
        DataFamilyInst tycon -> tycon
        SynFamilyInst        -> pprPanic "dataFamInstRepTyCon" (ppr fi)
@@ -147,15 +140,15 @@ pprFamInstHdr :: FamInst -> SDoc
 pprFamInstHdr (FamInst {fi_axiom = axiom, fi_flavor = flavor})
   = pprTyConSort <+> pp_instance <+> pprHead
   where
-    (fam_tc, tys) = coAxiomSplitLHS axiom 
-    
-    -- For *associated* types, say "type T Int = blah" 
+    (fam_tc, tys) = coAxiomSplitLHS axiom
+
+    -- For *associated* types, say "type T Int = blah"
     -- For *top level* type instances, say "type instance T Int = blah"
-    pp_instance 
+    pp_instance
       | isTyConAssoc fam_tc = empty
       | otherwise           = ptext (sLit "instance")
 
-    pprHead = sep [ ifPprDebug (ptext (sLit "forall") 
+    pprHead = sep [ ifPprDebug (ptext (sLit "forall")
                        <+> pprTvBndrs (coAxiomTyVars axiom))
                   , pprTypeApp fam_tc tys ]
     pprTyConSort = case flavor of
@@ -170,7 +163,7 @@ pprFamInsts :: [FamInst] -> SDoc
 pprFamInsts finsts = vcat (map pprFamInst finsts)
 
 -- | Create a coercion identifying a @type@ family instance.
--- It has the form @Co tvs :: F ts ~ R@, where @Co@ is 
+-- It has the form @Co tvs :: F ts ~ R@, where @Co@ is
 -- the coercion constructor built here, @F@ the family tycon and @R@ the
 -- right-hand side of the type family instance.
 mkSynFamInst :: Name       -- ^ Unique name for the coercion tycon
@@ -192,7 +185,7 @@ mkSynFamInst name tvs fam_tc inst_tys rep_ty
                     , co_ax_name     = name
                     , co_ax_implicit = False
                     , co_ax_tvs      = tvs
-                    , co_ax_lhs      = mkTyConApp fam_tc inst_tys 
+                    , co_ax_lhs      = mkTyConApp fam_tc inst_tys
                     , co_ax_rhs      = rep_ty }
 
 -- | Create a coercion identifying a @data@ or @newtype@ representation type
@@ -218,7 +211,7 @@ mkDataFamInst name tvs fam_tc inst_tys rep_tc
                     , co_ax_name     = name
                     , co_ax_implicit = False
                     , co_ax_tvs      = tvs
-                    , co_ax_lhs      = mkTyConApp fam_tc inst_tys 
+                    , co_ax_lhs      = mkTyConApp fam_tc inst_tys
                     , co_ax_rhs      = mkTyConApp rep_tc (mkTyVarTys tvs) }
 
 -- Make a family instance representation from the information found in an
@@ -237,7 +230,7 @@ mkImportedFamInst fam mb_tcs axiom
       fi_tys    = tys,
       fi_axiom  = axiom,
       fi_flavor = flavor }
-  where 
+  where
      (fam_tc, tys) = coAxiomSplitLHS axiom
 
          -- Derive the flavor for an imported FamInst rather disgustingly
@@ -253,9 +246,9 @@ mkImportedFamInst fam mb_tcs axiom
 
 
 %************************************************************************
-%*									*
-		FamInstEnv
-%*									*
+%*                                                                      *
+                FamInstEnv
+%*                                                                      *
 %************************************************************************
 
 Note [FamInstEnv]
@@ -274,28 +267,28 @@ Neverthless it is still useful to have data families in the FamInstEnv:
  - For finding the representation type...see FamInstEnv.topNormaliseType
    and its call site in Simplify
 
- - In standalone deriving instance Eq (T [Int]) we need to find the 
+ - In standalone deriving instance Eq (T [Int]) we need to find the
    representation type for T [Int]
 
 \begin{code}
-type FamInstEnv = UniqFM FamilyInstEnv	-- Maps a family to its instances
+type FamInstEnv = UniqFM FamilyInstEnv  -- Maps a family to its instances
      -- See Note [FamInstEnv]
 
 type FamInstEnvs = (FamInstEnv, FamInstEnv)
      -- External package inst-env, Home-package inst-env
 
 data FamilyInstEnv
-  = FamIE [FamInst]	-- The instances for a particular family, in any order
-  	  Bool 		-- True <=> there is an instance of form T a b c
-			-- 	If *not* then the common case of looking up
-			--	(T a b c) can fail immediately
+  = FamIE [FamInst]     -- The instances for a particular family, in any order
+          Bool          -- True <=> there is an instance of form T a b c
+                        --      If *not* then the common case of looking up
+                        --      (T a b c) can fail immediately
 
 instance Outputable FamilyInstEnv where
   ppr (FamIE fs b) = ptext (sLit "FamIE") <+> ppr b <+> vcat (map ppr fs)
 
 -- INVARIANTS:
 --  * The fs_tvs are distinct in each FamInst
---	of a range value of the map (so we can safely unify them)
+--      of a range value of the map (so we can safely unify them)
 
 emptyFamInstEnvs :: (FamInstEnv, FamInstEnv)
 emptyFamInstEnvs = (emptyFamInstEnv, emptyFamInstEnv)
@@ -311,8 +304,8 @@ familyInstances (pkg_fie, home_fie) fam
   = get home_fie ++ get pkg_fie
   where
     get env = case lookupUFM env fam of
-		Just (FamIE insts _) -> insts
-		Nothing	             -> []
+                Just (FamIE insts _) -> insts
+                Nothing              -> []
 
 extendFamInstEnvList :: FamInstEnv -> [FamInst] -> FamInstEnv
 extendFamInstEnvList inst_env fis = foldl extendFamInstEnv inst_env fis
@@ -322,7 +315,7 @@ extendFamInstEnv inst_env ins_item@(FamInst {fi_fam = cls_nm, fi_tcs = mb_tcs})
   = addToUFM_C add inst_env cls_nm (FamIE [ins_item] ins_tyvar)
   where
     add (FamIE items tyvar) _ = FamIE (ins_item:items)
-				      (ins_tyvar || tyvar)
+                                      (ins_tyvar || tyvar)
     ins_tyvar = not (any isJust mb_tcs)
 
 deleteFromFamInstEnv :: FamInstEnv -> FamInst -> FamInstEnv
@@ -344,13 +337,13 @@ identicalFamInst (FamInst { fi_axiom = ax1 }) (FamInst { fi_axiom = ax2 })
      tvs2 = coAxiomTyVars ax2
      rn_env = ASSERT( equalLength tvs1 tvs2 )
               rnBndrs2 (mkRnEnv2 emptyInScopeSet) tvs1 tvs2
-                       
+
 \end{code}
 
 %************************************************************************
-%*									*
-		Looking up a family instance
-%*									*
+%*                                                                      *
+                Looking up a family instance
+%*                                                                      *
 %************************************************************************
 
 @lookupFamInstEnv@ looks up in a @FamInstEnv@, using a one-way match.
@@ -376,8 +369,8 @@ type FamInstMatch = (FamInst, [Type])           -- Matching type instance
 
 lookupFamInstEnv
     :: FamInstEnvs
-    -> TyCon -> [Type]		-- What we are looking for
-    -> [FamInstMatch] 	        -- Successful matches
+    -> TyCon -> [Type]          -- What we are looking for
+    -> [FamInstMatch]           -- Successful matches
 -- Precondition: the tycon is saturated (or over-saturated)
 
 lookupFamInstEnv
@@ -387,14 +380,14 @@ lookupFamInstEnv
 
 lookupFamInstEnvConflicts
     :: FamInstEnvs
-    -> FamInst		-- Putative new instance
-    -> [TyVar]		-- Unique tyvars, matching arity of FamInst
-    -> [FamInstMatch] 	-- Conflicting matches
+    -> FamInst          -- Putative new instance
+    -> [TyVar]          -- Unique tyvars, matching arity of FamInst
+    -> [FamInstMatch]   -- Conflicting matches
 -- E.g. when we are about to add
 --    f : type instance F [a] = a->a
 -- we do (lookupFamInstConflicts f [b])
 -- to find conflicting matches
--- The skolem tyvars are needed because we don't have a 
+-- The skolem tyvars are needed because we don't have a
 -- unique supply to hand
 --
 -- Precondition: the tycon is saturated (or over-saturated)
@@ -406,20 +399,20 @@ lookupFamInstEnvConflicts envs fam_inst skol_tvs
     (fam, tys) = famInstLHS fam_inst
     skol_tys   = mkTyVarTys skol_tvs
     tys1       = substTys (zipTopTvSubst (coAxiomTyVars inst_axiom) skol_tys) tys
-        -- In example above,   fam tys' = F [b]   
+        -- In example above,   fam tys' = F [b]
 
     my_unify old_fam_inst tpl_tvs tpl_tys match_tys
        = ASSERT2( tyVarsOfTypes tys1 `disjointVarSet` tpl_tvs,
-		  (ppr fam <+> ppr tys1) $$
-		  (ppr tpl_tvs <+> ppr tpl_tys) )
-		-- Unification will break badly if the variables overlap
-		-- They shouldn't because we allocate separate uniques for them
+                  (ppr fam <+> ppr tys1) $$
+                  (ppr tpl_tvs <+> ppr tpl_tys) )
+                -- Unification will break badly if the variables overlap
+                -- They shouldn't because we allocate separate uniques for them
          case tcUnifyTys instanceBindFun tpl_tys match_tys of
-	      Just subst | conflicting old_fam_inst subst -> Just subst
-	      _other	   	              	          -> Nothing
+              Just subst | conflicting old_fam_inst subst -> Just subst
+              _other                                      -> Nothing
 
       -- Note [Family instance overlap conflicts]
-    conflicting old_fam_inst subst 
+    conflicting old_fam_inst subst
       | isAlgTyCon fam = True
       | otherwise      = not (old_rhs `eqType` new_rhs)
       where
@@ -445,7 +438,7 @@ Note [Family instance overlap conflicts]
   overlap substitution.  eg
        type instance F a Int = a
        type instance F Int b = b
-  These two overlap on (F Int Int) but then both RHSs are Int, 
+  These two overlap on (F Int Int) but then both RHSs are Int,
   so all is well. We require that they are syntactically equal;
   anything else would be difficult to test for at this stage.
 
@@ -463,35 +456,35 @@ indexed synonyms and we don't want to slow that down by needless unification.
 \begin{code}
 ------------------------------------------------------------
 -- Might be a one-way match or a unifier
-type MatchFun =  FamInst		-- The FamInst template
-     	      -> TyVarSet -> [Type]	--   fi_tvs, fi_tys of that FamInst
-	      -> [Type]			-- Target to match against
-	      -> Maybe TvSubst
+type MatchFun =  FamInst                -- The FamInst template
+              -> TyVarSet -> [Type]     --   fi_tvs, fi_tys of that FamInst
+              -> [Type]                 -- Target to match against
+              -> Maybe TvSubst
 
 type OneSidedMatch = Bool     -- Are optimisations that are only valid for
                               -- one sided matches allowed?
 
-lookup_fam_inst_env' 	      -- The worker, local to this module
+lookup_fam_inst_env'          -- The worker, local to this module
     :: MatchFun
     -> OneSidedMatch
     -> FamInstEnv
-    -> TyCon -> [Type]		-- What we are looking for
-    -> [FamInstMatch] 	        -- Successful matches
+    -> TyCon -> [Type]          -- What we are looking for
+    -> [FamInstMatch]           -- Successful matches
 lookup_fam_inst_env' match_fun one_sided ie fam tys
-  | not (isFamilyTyCon fam) 
+  | not (isFamilyTyCon fam)
   = []
   | otherwise
-  = ASSERT2( n_tys >= arity, ppr fam <+> ppr tys )	-- Family type applications must be saturated
+  = ASSERT2( n_tys >= arity, ppr fam <+> ppr tys )      -- Family type applications must be saturated
     lookup ie
   where
     -- See Note [Over-saturated matches]
     arity = tyConArity fam
     n_tys = length tys
     extra_tys = drop arity tys
-    (match_tys, add_extra_tys) 
+    (match_tys, add_extra_tys)
        | arity < n_tys = (take arity tys, \res_tys -> res_tys ++ extra_tys)
        | otherwise     = (tys,            \res_tys -> res_tys)
-       	 -- The second case is the common one, hence functional representation
+         -- The second case is the common one, hence functional representation
 
     --------------
     rough_tcs = roughMatchTcs match_tys
@@ -499,20 +492,20 @@ lookup_fam_inst_env' match_fun one_sided ie fam tys
 
     --------------
     lookup env = case lookupUFM env fam of
-		   Nothing -> []	-- No instances for this class
-		   Just (FamIE insts has_tv_insts)
-		       -- Short cut for common case:
-		       --   The thing we are looking up is of form (C a
-		       --   b c), and the FamIE has no instances of
-		       --   that form, so don't bother to search 
-		     | all_tvs && not has_tv_insts -> []
-		     | otherwise                   -> find insts
+                   Nothing -> []        -- No instances for this class
+                   Just (FamIE insts has_tv_insts)
+                       -- Short cut for common case:
+                       --   The thing we are looking up is of form (C a
+                       --   b c), and the FamIE has no instances of
+                       --   that form, so don't bother to search
+                     | all_tvs && not has_tv_insts -> []
+                     | otherwise                   -> find insts
 
     --------------
     find [] = []
-    find (item@(FamInst { fi_tcs = mb_tcs, fi_tvs = tpl_tvs, 
-			  fi_tys = tpl_tys, fi_axiom = axiom }) : rest)
-	-- Fast check for no match, uses the "rough match" fields
+    find (item@(FamInst { fi_tcs = mb_tcs, fi_tvs = tpl_tvs,
+                          fi_tys = tpl_tys, fi_axiom = axiom }) : rest)
+        -- Fast check for no match, uses the "rough match" fields
       | instanceCantMatch rough_tcs mb_tcs
       = find rest
 
@@ -525,16 +518,16 @@ lookup_fam_inst_env' match_fun one_sided ie fam tys
       = find rest
 -- Precondition: the tycon is saturated (or over-saturated)
 
-lookup_fam_inst_env 	      -- The worker, local to this module
+lookup_fam_inst_env           -- The worker, local to this module
     :: MatchFun
     -> OneSidedMatch
     -> FamInstEnvs
-    -> TyCon -> [Type]		-- What we are looking for
-    -> [FamInstMatch] 	        -- Successful matches
+    -> TyCon -> [Type]          -- What we are looking for
+    -> [FamInstMatch]           -- Successful matches
 
 -- Precondition: the tycon is saturated (or over-saturated)
 
-lookup_fam_inst_env match_fun one_sided (pkg_ie, home_ie) fam tys = 
+lookup_fam_inst_env match_fun one_sided (pkg_ie, home_ie) fam tys =
     lookup_fam_inst_env' match_fun one_sided home_ie fam tys ++
     lookup_fam_inst_env' match_fun one_sided pkg_ie  fam tys
 
@@ -550,7 +543,7 @@ The type instance gives rise to a newtype TyCon (at a higher kind
 which you can't do in Haskell!):
      newtype FPair a b = FP (Either (a->b))
 
-Then looking up (F (Int,Bool) Char) will return a FamInstMatch 
+Then looking up (F (Int,Bool) Char) will return a FamInstMatch
      (FPair, [Int,Bool,Char])
 
 The "extra" type argument [Char] just stays on the end.
@@ -559,19 +552,19 @@ The "extra" type argument [Char] just stays on the end.
 
 
 %************************************************************************
-%*									*
-		Looking up a family instance
-%*									*
+%*                                                                      *
+                Looking up a family instance
+%*                                                                      *
 %************************************************************************
 
 \begin{code}
 topNormaliseType :: FamInstEnvs
-		 -> Type
-	   	 -> Maybe (Coercion, Type)
+                 -> Type
+                 -> Maybe (Coercion, Type)
 
--- Get rid of *outermost* (or toplevel) 
---	* type functions 
---	* newtypes
+-- Get rid of *outermost* (or toplevel)
+--      * type functions
+--      * newtypes
 -- using appropriate coercions.
 -- By "outer" we mean that toplevelNormaliseType guarantees to return
 -- a type that does not have a reducible redex (F ty1 .. tyn) as its
@@ -584,22 +577,22 @@ topNormaliseType env ty
   = go [] ty
   where
     go :: [TyCon] -> Type -> Maybe (Coercion, Type)
-    go rec_nts ty | Just ty' <- coreView ty 	-- Expand synonyms
-	= go rec_nts ty'	
+    go rec_nts ty | Just ty' <- coreView ty     -- Expand synonyms
+        = go rec_nts ty'
 
     go rec_nts (TyConApp tc tys)
-        | isNewTyCon tc		-- Expand newtypes
-	= if tc `elem` rec_nts 	-- See Note [Expanding newtypes] in Type.lhs
-	  then Nothing
+        | isNewTyCon tc         -- Expand newtypes
+        = if tc `elem` rec_nts  -- See Note [Expanding newtypes] in Type.lhs
+          then Nothing
           else let nt_co = mkAxInstCo (newTyConCo tc) tys
                in add_co nt_co rec_nts' nt_rhs
 
-	| isFamilyTyCon tc		-- Expand open tycons
-	, (co, ty) <- normaliseTcApp env tc tys
-		-- Note that normaliseType fully normalises 'tys', 
-		-- It has do to so to be sure that nested calls like
-		--    F (G Int)
-		-- are correctly top-normalised
+        | isFamilyTyCon tc              -- Expand open tycons
+        , (co, ty) <- normaliseTcApp env tc tys
+                -- Note that normaliseType fully normalises 'tys',
+                -- It has do to so to be sure that nested calls like
+                --    F (G Int)
+                -- are correctly top-normalised
         , not (isReflCo co)
         = add_co co rec_nts ty
         where
@@ -609,48 +602,48 @@ topNormaliseType env ty
 
     go _ _ = Nothing
 
-    add_co co rec_nts ty 
-	= case go rec_nts ty of
-		Nothing 	-> Just (co, ty)
-		Just (co', ty') -> Just (mkTransCo co co', ty')
-	 
+    add_co co rec_nts ty
+        = case go rec_nts ty of
+                Nothing         -> Just (co, ty)
+                Just (co', ty') -> Just (mkTransCo co co', ty')
+
 
 ---------------
 normaliseTcApp :: FamInstEnvs -> TyCon -> [Type] -> (Coercion, Type)
 normaliseTcApp env tc tys
   | isFamilyTyCon tc
-  , tyConArity tc <= length tys	   -- Unsaturated data families are possible
-  , [(fam_inst, inst_tys)] <- lookupFamInstEnv env tc ntys 
+  , tyConArity tc <= length tys    -- Unsaturated data families are possible
+  , [(fam_inst, inst_tys)] <- lookupFamInstEnv env tc ntys
   = let    -- A matching family instance exists
         ax              = famInstAxiom fam_inst
         co              = mkAxInstCo  ax inst_tys
         rhs             = mkAxInstRHS ax inst_tys
-	first_coi       = mkTransCo tycon_coi co
-	(rest_coi,nty)  = normaliseType env rhs
-	fix_coi         = mkTransCo first_coi rest_coi
-    in 
+        first_coi       = mkTransCo tycon_coi co
+        (rest_coi,nty)  = normaliseType env rhs
+        fix_coi         = mkTransCo first_coi rest_coi
+    in
     (fix_coi, nty)
 
   | otherwise   -- No unique matching family instance exists;
-		-- we do not do anything
+                -- we do not do anything
   = (tycon_coi, TyConApp tc ntys)
 
   where
-	-- Normalise the arg types so that they'll match 
-	-- when we lookup in in the instance envt
+        -- Normalise the arg types so that they'll match
+        -- when we lookup in in the instance envt
     (cois, ntys) = mapAndUnzip (normaliseType env) tys
     tycon_coi    = mkTyConAppCo tc cois
 
 ---------------
-normaliseType :: FamInstEnvs 		-- environment with family instances
-	      -> Type  			-- old type
-	      -> (Coercion, Type)	-- (coercion,new type), where
-					-- co :: old-type ~ new_type
+normaliseType :: FamInstEnvs            -- environment with family instances
+              -> Type                   -- old type
+              -> (Coercion, Type)       -- (coercion,new type), where
+                                        -- co :: old-type ~ new_type
 -- Normalise the input type, by eliminating *all* type-function redexes
 -- Returns with Refl if nothing happens
 
-normaliseType env ty 
-  | Just ty' <- coreView ty = normaliseType env ty' 
+normaliseType env ty
+  | Just ty' <- coreView ty = normaliseType env ty'
 normaliseType env (TyConApp tc tys)
   = normaliseTcApp env tc tys
 normaliseType _env ty@(LitTy {}) = (Refl ty, ty)