index ecc9577..e41d8c1 100644 (file)
@@ -1,43 +1,64 @@

-TcCoercibleFail.hs:10:8:
-    No instance for (Coercible Int ())
-      because ‛Int’ and ‛()’ are different types.
-      arising from a use of ‛coerce’
+TcCoercibleFail.hs:11:8: error:
+    Couldn't match representation of type ‘Int’ with that of ‘()’
+      arising from a use of ‘coerce’
In the expression: coerce
In the expression: coerce \$ one :: ()
-    In an equation for â\80\9bfoo1’: foo1 = coerce \$ one :: ()
-
-TcCoercibleFail.hs:13:8:
-    Could not deduce (Coercible (m Int) (m Age))
-      because ‛m Int’ and ‛m Age’ are different types.
-      arising from a use of ‛coerce’
-    from the context (Monad m)
-      bound by the type signature for foo2 :: Monad m => m Age
-      at TcCoercibleFail.hs:12:9-34
+    In an equation for â\80\98foo1’: foo1 = coerce \$ one :: ()
+
+TcCoercibleFail.hs:14:8: error:
+    Couldn't match representation of type ‘m Int’ with that of ‘m Age’
+      arising from a use of ‘coerce’
+    NB: We cannot know what roles the parameters to ‘m’ have;
+      we must assume that the role is nominal
+    Relevant bindings include
+      foo2 :: m Age (bound at TcCoercibleFail.hs:14:1)
In the expression: coerce
In the expression: coerce \$ (return one :: m Int)
-    In an equation for â\80\9bfoo2’: foo2 = coerce \$ (return one :: m Int)
+    In an equation for â\80\98foo2’: foo2 = coerce \$ (return one :: m Int)

-TcCoercibleFail.hs:15:8:
-    No instance for (Coercible (Map Int ()) (Map Age ()))
-      because the first type argument of ‛Map’ has role Nominal,
-      but the arguments ‛Int’ and ‛Age’ differ
-      arising from a use of ‛coerce’
+TcCoercibleFail.hs:16:8: error:
+    Couldn't match type ‘Int’ with ‘Age’ arising from a use of ‘coerce’
In the expression: coerce
In the expression: coerce \$ Map one () :: Map Age ()
-    In an equation for â\80\9bfoo3’: foo3 = coerce \$ Map one () :: Map Age ()
+    In an equation for â\80\98foo3’: foo3 = coerce \$ Map one () :: Map Age ()

-TcCoercibleFail.hs:17:8:
-    No instance for (Coercible Int (Down Int))
-    because the constructor of ‛Down’ is not imported
-      arising from a use of ‛coerce’
+TcCoercibleFail.hs:18:8: error:
+    Couldn't match representation of type ‘Int’ with that of ‘Down Int’
+      arising from a use of ‘coerce’
+    The data constructor ‘Down’ of newtype ‘Down’ is not in scope
In the expression: coerce
In the expression: coerce \$ one :: Down Int
-    In an equation for ‛foo4’: foo4 = coerce \$ one :: Down Int
-
-TcCoercibleFail.hs:21:8:
-    No instance for (Coercible (Void ()) ())
-      because ‛Void’ is a recursive type constuctor
-      arising from a use of ‛coerce’
-    In the expression: coerce :: (Void ()) -> ()
-    In an equation for ‛foo5’: foo5 = coerce :: (Void ()) -> ()
+    In an equation for ‘foo4’: foo4 = coerce \$ one :: Down Int
+
+TcCoercibleFail.hs:21:8: error:
+    Couldn't match representation of type ‘Void’ with that of ‘()’
+      arising from a use of ‘coerce’
+    In the expression: coerce :: Void -> ()
+    In an equation for ‘foo5’: foo5 = coerce :: Void -> ()
+
+TcCoercibleFail.hs:24:9: error:
+    Couldn't match representation of type ‘VoidBad ()’
+                             with that of ‘()’
+      arising from a use of ‘coerce’
+    In the expression: coerce :: (VoidBad ()) -> ()
+    In an equation for ‘foo5'’: foo5' = coerce :: (VoidBad ()) -> ()
+
+TcCoercibleFail.hs:28:8: error:
+    Reduction stack overflow; size = 201
+    When simplifying the following type: Fix (Either Age)
+    Use -freduction-depth=0 to disable this check
+    (any upper bound you could choose might fail unpredictably with
+     minor updates to GHC, so disabling the check is recommended if
+     you're sure that type checking should terminate)
+    In the expression: coerce :: Fix (Either Int) -> Fix (Either Age)
+    In an equation for ‘foo6’:
+        foo6 = coerce :: Fix (Either Int) -> Fix (Either Age)
+
+TcCoercibleFail.hs:29:8: error:
+    Couldn't match representation of type ‘Either
+                                             Int (Fix (Either Int))’
+                             with that of ‘()’
+      arising from a use of ‘coerce’
+    In the expression: coerce :: Fix (Either Int) -> ()
+    In an equation for ‘foo7’: foo7 = coerce :: Fix (Either Int) -> ()