Historical (SCE2).  Fundep constraints never "escape" into the

    main solver and so never show up in error messages.

    Errors which arise from the interaction of two Wanted fun-dep constraints.

    Example:

 newFlexiTyVarQL do_ql occ info kind

   = do { lvl  <- getTcLevelQL do_ql

        ; ref  <- newMutVar Flexi

                                 -- in GHC.Tc.Utils.TcMType

        ; let details = MetaTv { mtv_info  = info

                               , mtv_ref   = ref

 import Data.Maybe( mapMaybe )

 Here is our plan for dealing with functional dependencies

 * When we have failed to solve a Wanted constraint, do this

        - tryDictFunDeps: for class constraints (C t1 .. tn)

          we look at top-level instances and inert Givens

        - tryEqFunDeps: for type-family equalities (F t1 .. tn ~ ty)

          we look at top-level family instances

                     and inert Given family equalities

   solver.  Key property:

       The ONLY effect of `solveFunDeps` is possibly to perform unifications:

       - It entirely discards any unsolved fundep equalities.

       - It entirely discards any evidence arising from solving fundep equalities

   current unsolved Wanted.  It might now be soluble!

 * For Given constraints, things are different:

     in_scope = mkInScopeSet (tyCoVarsOfType work_rhs)

     trim_qtvs :: Subst -> [TcTyVar] -> (Subst,[TcTyVar])

     trim_qtvs subst []       = (subst, [])

     trim_qtvs subst (tv:tvs)

       | tv `elemSubst` subst = trim_qtvs subst tvs

 --

 -- The returned Bool is True if some unifications happened

 --

 solveFunDeps work_ev fd_eqns

   | null fd_eqns

   = return False -- Common case no-op

 (IW4) Historical note: we used to have equalities arising from

    Wanted/Wanted fundep interactions, which we did not want to treat

    as insoluble.  But now such fundep constraints never escape.

 Note [Insoluble holes]

 ~~~~~~~~~~~~~~~~~~~~~~

   | ArrowCmdOrigin      -- Arising from an arrow command

   | AnnOrigin           -- An annotation

   | InjTFOrigin1    -- injective type family equation combining

       PredType CtOrigin RealSrcSpan    -- This constraint arising from ...

 Note [Name of a unification variable]

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 -}

 newMetaTyVarName :: FastString -> TcM Name

   = newSysName (mkTyVarOccFS str)

 cloneMetaTyVarName :: Name -> TcM Name

 cloneMetaTyVarName name

   = newSysName (nameOccName name)

 default-fail05.hs:11:10: error: [GHC-39999]

       Potentially matching instances:

         instance Foldable (Either a)

           -- Defined in ‘GHC.Internal.Data.Foldable’

       In a stmt of a 'do' block: print (toList $ pure 21)

 default-fail05.hs:11:19: error: [GHC-39999]

       Potentially matching instances:

         instance Applicative IO -- Defined in ‘GHC.Internal.Base’

         instance Applicative Maybe -- Defined in ‘GHC.Internal.Base’

       In a stmt of a 'do' block: print (toList $ pure 21)

 default-fail05.hs:12:3: error: [GHC-39999]

       Relevant bindings include

       Potentially matching instances:

         instance Traversable (Either a)

           -- Defined in ‘GHC.Internal.Data.Traversable’

                  traverse print (pure 42)

 default-fail05.hs:12:19: error: [GHC-39999]

       Relevant bindings include

       Potentially matching instances:

         instance Applicative IO -- Defined in ‘GHC.Internal.Base’

         instance Applicative Maybe -- Defined in ‘GHC.Internal.Base’

 T1897b.hs:16:1: error: [GHC-83865]

       Note: ‘Depend’ is a non-injective type family.

     • In the ambiguity check for the inferred type for ‘isValid’

       To defer the ambiguity check to use sites, enable AllowAmbiguousTypes

       When checking the inferred type

 T9662.hs:49:8: error: [GHC-25897]

       Expected: Exp (((sh :. k) :. m) :. n)

                 -> Exp (((sh :. m) :. n) :. k)

         Actual: Exp

                   (Tuple (((Atom a0 :. Atom Int) :. Atom Int) :. Atom Int))

                 -> Exp

                      (Plain (((Unlifted (Atom a0) :. Exp Int) :. Exp Int) :. Exp Int))

         the type signature for:

           test :: forall sh k m n.

                   Shape (((sh :. k) :. m) :. n) -> Shape (((sh :. m) :. n) :. k)

     • In the second argument of ‘($)’, namely ‘a {foo.bar.baz.quux}’

       In a stmt of a 'do' block: print $ a {foo.bar.baz.quux}

       In the expression:

         do let a = Foo {foo = ...}

            let quux = "Expecto patronum!"

            print $ a {foo.bar.baz.quux}

     • In the second argument of ‘($)’, namely ‘a {foo}’

       In a stmt of a 'do' block: print $ a {foo}

       In the expression:

            print $ a {foo}

 T14040a.hs:26:46: error: [GHC-46956]

         but ‘xs’ has kind ‘WeirdList (WeirdList z)’

         because kind variable ‘z’ would escape its scope

       This (rigid, skolem) kind variable is bound by

                                                                                            -> p _ wl

 T14040a.hs:27:27: error: [GHC-46956]

         but ‘WeirdCons x xs’ has kind ‘WeirdList z’

         because kind variable ‘z’ would escape its scope

       This (rigid, skolem) kind variable is bound by

         • *

       Cannot unify ‘r’ with the type variable ‘q0’

       because the former is not a concrete ‘RuntimeRep’.

       In an equation for ‘test2’: test2 = (`g` undefined)

 T14040.hs:27:46: error: [GHC-46956]

         but ‘xs’ has kind ‘WeirdList (WeirdList z)’

         because kind variable ‘z’ would escape its scope

       This (rigid, skolem) kind variable is bound by

                                                                                            -> p _ wl

 T14040.hs:28:27: error: [GHC-46956]

         but ‘WeirdCons x xs’ has kind ‘WeirdList z’

         because kind variable ‘z’ would escape its scope

       This (rigid, skolem) kind variable is bound by

 test('T13603', normal, compile, [''])

 test('T13333', normal, compile, [''])

 test('T13585', [extra_files(['T13585.hs', 'T13585a.hs', 'T13585b.hs'])], makefile_test, [])

 test('T13651a', normal, compile, [''])

 test('T13680', normal, compile, [''])

 test('T13785', normal, compile, [''])

       When matching types

         m0 :: * -> *

         [a2] :: *

     • The function ‘lift’ is applied to two visible arguments,

         but its type ‘(Control.Monad.Trans.Class.MonadTrans t, Monad m) =>

                       m a -> t m a’