Refactor (~) to reduce the suerpclass stack

The constraint (~) used to be (effectively):
  class a ~~ b => (a :: k) ~ (b :: k)

but, with this patch, it is now defined uniformly with
(~~) and Coercible like this:
  class a ~# b => (a :: k) ~ (b :: k)

Result:
  * One less superclass selection when goinng from (~) to (~#)
    Better for compile time and better for debugging with -ddump-simpl

  * The code for (~), (~~), and Coercible looks uniform, and appears
    together, e.g. in TysWiredIn and ClsInst.matchGlobalInst.
    Previously the code for (~) was different, and unique.

Not only is this simpler, but it also makes the compiler a bit faster;
  T12227: 9% less allocation
  T12545: 7% less allocation

This patch fixes Trac #15421

1 files changed, 14 insertions, 11 deletions

diff --git a/compiler/prelude/TysPrim.hs b/compiler/prelude/TysPrim.hs
index 754bb8fb09..30dca25eea 100644
--- a/compiler/prelude/TysPrim.hs
+++ b/compiler/prelude/TysPrim.hs
@@ -599,7 +599,7 @@ GHC sports a veritable menagerie of equality types:
 -----------------------------------------------------------------------------------------
 ~#         T        U      hetero   nominal   eqPrimTyCon      GHC.Prim
 ~~         C        L      hetero   nominal   hEqTyCon         GHC.Types
-~          C        L      homo     nominal   eqTyCon          Data.Type.Equality
+~          C        L      homo     nominal   eqTyCon          GHC.Types
 :~:        T        L      homo     nominal   (not built-in)   Data.Type.Equality
 :~~:       T        L      hetero   nominal   (not built-in)   Data.Type.Equality
 
@@ -642,6 +642,7 @@ This is (almost) an ordinary class, defined as if by
   class a ~# b => a ~~ b
   instance a ~# b => a ~~ b
 Here's what's unusual about it:
+
  * We can't actually declare it that way because we don't have syntax for ~#.
    And ~# isn't a constraint, so even if we could write it, it wouldn't kind
    check.
@@ -671,21 +672,23 @@ Within GHC, ~~ is called heqTyCon, and it is defined in TysWiredIn.
     --------------------------
     (~) :: forall k. k -> k -> Constraint
     --------------------------
-This is defined in Data.Type.Equality:
-  class a ~~ b => (a :: k) ~ (b :: k)
-  instance a ~~ b => a ~ b
-This is even more so an ordinary class than (~~), with the following exceptions:
- * Users cannot write instances of it.
+This is /exactly/ like (~~), except with a homogeneous kind.
+It is an almost-ordinary class defined as if by
+  class a ~# b => (a :: k) ~ (b :: k)
+  instance a ~# b => a ~ b
 
- * It is "naturally coherent". (See (~~).)
+ * All the bullets for (~~) apply
 
- * (~) is magical syntax, as ~ is a reserved symbol.
+ * In addition (~) is magical syntax, as ~ is a reserved symbol.
    It cannot be exported or imported.
 
- * It always terminates.
+Within GHC, ~ is called eqTyCon, and it is defined in TysWiredIn.
 
-Within GHC, ~ is called eqTyCon, and it is defined in PrelNames. Note that
-it is *not* wired in.
+Historical note: prior to July 18 (~) was defined as a
+  more-ordinary class with (~~) as a superclass.  But that made it
+  special in different ways; and the extra superclass selections to
+  get from (~) to (~#) via (~~) were tiresome.  Now it's defined
+  uniformly with (~~) and Coercible; much nicer.)
 
 
     --------------------------