Error message modifications following ghc-new-solver modifications
authorDimitrios.Vytiniotis <dimitris@microsoft.com>
Wed, 4 Apr 2012 13:41:11 +0000 (14:41 +0100)
committerDimitrios.Vytiniotis <dimitris@microsoft.com>
Wed, 4 Apr 2012 13:41:11 +0000 (14:41 +0100)
20 files changed:
testsuite/tests/gadt/T3169.stderr
testsuite/tests/gadt/T3651.stderr
testsuite/tests/indexed-types/should_compile/T3017.stderr
testsuite/tests/indexed-types/should_compile/T3208b.stderr
testsuite/tests/indexed-types/should_fail/SimpleFail16.stderr
testsuite/tests/indexed-types/should_fail/T1900.stderr
testsuite/tests/indexed-types/should_fail/T2664.stderr
testsuite/tests/indexed-types/should_fail/T3330a.stderr
testsuite/tests/indexed-types/should_fail/T3330c.stderr
testsuite/tests/indexed-types/should_fail/T4272.stderr
testsuite/tests/parser/should_fail/readFail003.stderr
testsuite/tests/typecheck/should_compile/FD2.stderr
testsuite/tests/typecheck/should_compile/FD3.stderr
testsuite/tests/typecheck/should_compile/T2494.stderr
testsuite/tests/typecheck/should_fail/FrozenErrorTests.stderr
testsuite/tests/typecheck/should_fail/T1899.stderr
testsuite/tests/typecheck/should_fail/T3950.stderr
testsuite/tests/typecheck/should_fail/tcfail072.stderr
testsuite/tests/typecheck/should_fail/tcfail153.stderr
testsuite/tests/typecheck/should_fail/tcfail201.stderr

index c1ee5b5..7ca72f9 100644 (file)
@@ -1,25 +1,25 @@
 
-T3169.hs:13:13:
-    Could not deduce (elt ~ Map b elt)
+T3169.hs:13:22:
+    Could not deduce (Map a ~ MP a b)
     from the context (Key a, Key b)
       bound by the instance declaration at T3169.hs:10:10-36
-      `elt' is a rigid type variable bound by
-            the type signature for
-              lookup :: (a, b) -> Map (a, b) elt -> Maybe elt
-            at T3169.hs:12:3
-    Expected type: Maybe (Map b elt)
-      Actual type: Maybe elt
-    In the return type of a call of `lookup'
+    Expected type: Map a (Map b elt)
+      Actual type: Map (a, b) elt
+    In the second argument of `lookup', namely `m'
     In the expression: lookup a m :: Maybe (Map b elt)
     In the expression:
       case lookup a m :: Maybe (Map b elt) of {
         Just (m2 :: Map b elt) -> lookup b m2 :: Maybe elt }
 
 T3169.hs:13:22:
-    Could not deduce (Map a ~ MP a b)
+    Could not deduce (elt ~ Map b elt)
     from the context (Key a, Key b)
       bound by the instance declaration at T3169.hs:10:10-36
-    Expected type: Map a elt
+      `elt' is a rigid type variable bound by
+            the type signature for
+              lookup :: (a, b) -> Map (a, b) elt -> Maybe elt
+            at T3169.hs:12:3
+    Expected type: Map a (Map b elt)
       Actual type: Map (a, b) elt
     In the second argument of `lookup', namely `m'
     In the expression: lookup a m :: Maybe (Map b elt)
index 283e429..778fe0f 100644 (file)
@@ -1,21 +1,35 @@
-\r
-T3651.hs:11:11:\r
-    Couldn't match type `Bool' with `()'\r
-    Inaccessible code in\r
-      a pattern with constructor U :: Z (), in an equation for `unsafe1'\r
-    In the pattern: U\r
-    In an equation for `unsafe1': unsafe1 B U = ()\r
-\r
-T3651.hs:14:11:\r
-    Couldn't match type `Bool' with `()'\r
-    Inaccessible code in\r
-      a pattern with constructor U :: Z (), in an equation for `unsafe2'\r
-    In the pattern: U\r
-    In an equation for `unsafe2': unsafe2 B U = ()\r
-\r
-T3651.hs:17:11:\r
-    Couldn't match type `Bool' with `()'\r
-    Inaccessible code in\r
-      a pattern with constructor U :: Z (), in an equation for `unsafe3'\r
-    In the pattern: U\r
-    In an equation for `unsafe3': unsafe3 B U = True\r
+
+T3651.hs:11:11:
+    Couldn't match type `Bool' with `()'
+    Inaccessible code in
+      a pattern with constructor U :: Z (), in an equation for `unsafe1'
+    In the pattern: U
+    In an equation for `unsafe1': unsafe1 B U = ()
+
+T3651.hs:11:15:
+    Couldn't match type `Bool' with `()'
+    Expected type: a
+      Actual type: ()
+    In the expression: ()
+    In an equation for `unsafe1': unsafe1 B U = ()
+
+T3651.hs:14:11:
+    Couldn't match type `Bool' with `()'
+    Inaccessible code in
+      a pattern with constructor U :: Z (), in an equation for `unsafe2'
+    In the pattern: U
+    In an equation for `unsafe2': unsafe2 B U = ()
+
+T3651.hs:14:15:
+    Couldn't match type `Bool' with `()'
+    Expected type: a
+      Actual type: ()
+    In the expression: ()
+    In an equation for `unsafe2': unsafe2 B U = ()
+
+T3651.hs:17:11:
+    Couldn't match type `Bool' with `()'
+    Inaccessible code in
+      a pattern with constructor U :: Z (), in an equation for `unsafe3'
+    In the pattern: U
+    In an equation for `unsafe3': unsafe3 B U = True
index d92f29f..5df49d5 100644 (file)
@@ -1,7 +1,7 @@
 TYPE SIGNATURES
     emptyL :: forall a. ListColl a
     test2 :: forall c t t1.
-             (Num t1, Num t, Coll c, Elem c ~ (t, t1)) =>
+             (Num t, Num t1, Coll c, Elem c ~ (t, t1)) =>
              c -> c
 TYPE CONSTRUCTORS
   class Coll c
index 292a91a..fc697fb 100644 (file)
@@ -12,15 +12,3 @@ T3208b.hs:15:10:
       Actual type: OTerm a0
     In the expression: fce (apply f)
     In an equation for fce': fce' f = fce (apply f)
-
-T3208b.hs:15:15:
-    Could not deduce (STerm a ~ OTerm a0)
-    from the context (OTerm a ~ STerm a, OBJECT a, SUBST a)
-      bound by the type signature for
-                 fce' :: (OTerm a ~ STerm a, OBJECT a, SUBST a) => a -> c
-      at T3208b.hs:14:9-56
-    The type variable `a0' is ambiguous
-    Possible fix: add a type signature that fixes these type variable(s)
-    In the first argument of `fce', namely `(apply f)'
-    In the expression: fce (apply f)
-    In an equation for fce': fce' f = fce (apply f)
index 41812ea..9466ee1 100644 (file)
@@ -1,11 +1,11 @@
-\r
-SimpleFail16.hs:10:12:\r
-    Couldn't match expected type `p0 a0' with actual type `F ()'\r
-    The type variables `p0', `a0' are ambiguous\r
-    Possible cause: the monomorphism restriction applied to the following:\r
-      bar :: p0 a0 (bound at SimpleFail16.hs:10:1)\r
-    Probable fix: give these definition(s) an explicit type signature\r
-                  or use -XNoMonomorphismRestriction\r
-    In the first argument of `foo', namely `(undefined :: F ())'\r
-    In the expression: foo (undefined :: F ())\r
-    In an equation for `bar': bar = foo (undefined :: F ())\r
+
+SimpleFail16.hs:10:12:
+    Couldn't match expected type `F ()' with actual type `p0 a0'
+    The type variables `p0', `a0' are ambiguous
+    Possible cause: the monomorphism restriction applied to the following:
+      bar :: p0 a0 (bound at SimpleFail16.hs:10:1)
+    Probable fix: give these definition(s) an explicit type signature
+                  or use -XNoMonomorphismRestriction
+    In the first argument of `foo', namely `(undefined :: F ())'
+    In the expression: foo (undefined :: F ())
+    In an equation for `bar': bar = foo (undefined :: F ())
index 8ea8471..d20a632 100644 (file)
@@ -1,20 +1,19 @@
 
 T1900.hs:11:12:
-    No instance for (Num ())
-      arising from a use of `+'
+    No instance for (Num ()) arising from a use of `+'
     Possible fix: add an instance declaration for (Num ())
     In the expression: (+ 1)
     In an equation for `trans': trans = (+ 1)
     In the instance declaration for `Bug Int'
 
-T1900.hs:14:22:
-    Could not deduce (Depend s0 ~ Depend s)
+T1900.hs:14:16:
+    Could not deduce (Depend s ~ Depend s0)
     from the context (Bug s)
       bound by the type signature for check :: Bug s => Depend s -> Bool
       at T1900.hs:13:10-36
     NB: `Depend' is a type function, and may not be injective
     The type variable `s0' is ambiguous
     Possible fix: add a type signature that fixes these type variable(s)
-    In the first argument of `trans', namely `d'
+    In the return type of a call of `trans'
     In the second argument of `(==)', namely `trans d'
     In the expression: d == trans d
index 2b5dd24..cfd248d 100644 (file)
@@ -1,6 +1,6 @@
 
-T2664.hs:31:33:
-    Could not deduce (Dual b ~ Dual a)
+T2664.hs:31:52:
+    Could not deduce (b ~ a)
     from the context (Connect a, Connect b)
       bound by the instance declaration at T2664.hs:22:10-52
     or from ((a :*: b) ~ Dual c, c ~ Dual (a :*: b))
@@ -8,12 +8,13 @@ T2664.hs:31:33:
                  newPChan :: ((a :*: b) ~ Dual c, c ~ Dual (a :*: b)) =>
                              IO (PChan (a :*: b), PChan c)
       at T2664.hs:(23,5)-(31,87)
-    NB: `Dual' is a type function, and may not be injective
-    Expected type: PChan c
-      Actual type: PChan (Dual b :+: Dual a)
-    In the return type of a call of `E'
+      `b' is a rigid type variable bound by
+          the instance declaration at T2664.hs:22:10
+      `a' is a rigid type variable bound by
+          the instance declaration at T2664.hs:22:10
+    Expected type: Dual (Dual a)
+      Actual type: b
+    In the third argument of `pchoose', namely `newPChan'
+    In the first argument of `E', namely `(pchoose Right v newPChan)'
     In the expression:
       E (pchoose Right v newPChan) (pchoose Left v newPChan)
-    In the first argument of `return', namely
-      `(O $ takeMVar v, 
-        E (pchoose Right v newPChan) (pchoose Left v newPChan))'
index 6d76ade..9f423e0 100644 (file)
@@ -1,22 +1,22 @@
-\r
-T3330a.hs:19:34:\r
-    Couldn't match type `s' with `(->) (s0 ix1 -> ix1)'\r
-      `s' is a rigid type variable bound by\r
-          the type signature for children :: s ix -> PF s r ix -> [AnyF s]\r
-          at T3330a.hs:18:13\r
-    Expected type: (s0 ix0 -> ix1) -> r ix1 -> Writer [AnyF s] (r ix1)\r
-      Actual type: s ix\r
-    In the first argument of `hmapM', namely `p'\r
-    In the first argument of `execWriter', namely `(hmapM p collect x)'\r
-    In the expression: execWriter (hmapM p collect x)\r
-\r
-T3330a.hs:19:36:\r
-    Couldn't match type `ix' with `r ix0 -> Writer [AnyF s0] (r ix0)'\r
-      `ix' is a rigid type variable bound by\r
-           the type signature for children :: s ix -> PF s r ix -> [AnyF s]\r
-           at T3330a.hs:18:13\r
-    Expected type: s0 ix0 -> ix\r
-      Actual type: s0 ix0 -> r ix0 -> Writer [AnyF s0] (r ix0)\r
-    In the second argument of `hmapM', namely `collect'\r
-    In the first argument of `execWriter', namely `(hmapM p collect x)'\r
-    In the expression: execWriter (hmapM p collect x)\r
+
+T3330a.hs:19:34:
+    Couldn't match type `s' with `(->) (s0 ix1 -> ix1)'
+      `s' is a rigid type variable bound by
+          the type signature for children :: s ix -> PF s r ix -> [AnyF s]
+          at T3330a.hs:18:13
+    Expected type: (s0 ix0 -> ix1) -> r ix1 -> Writer [AnyF s] (r ix1)
+      Actual type: s ix
+    In the first argument of `hmapM', namely `p'
+    In the first argument of `execWriter', namely `(hmapM p collect x)'
+    In the expression: execWriter (hmapM p collect x)
+
+T3330a.hs:19:44:
+    Couldn't match type `ix' with `r ix0 -> Writer [AnyF s0] (r ix0)'
+      `ix' is a rigid type variable bound by
+           the type signature for children :: s ix -> PF s r ix -> [AnyF s]
+           at T3330a.hs:18:13
+    Expected type: PF s r (r ix0 -> Writer [AnyF s0] (r ix0))
+      Actual type: PF s r ix
+    In the third argument of `hmapM', namely `x'
+    In the first argument of `execWriter', namely `(hmapM p collect x)'
+    In the expression: execWriter (hmapM p collect x)
index b7341bb..c9b6348 100644 (file)
@@ -1,10 +1,10 @@
 
 T3330c.hs:23:43:
-    Couldn't match kind `* -> *' with `*'
-    Expected type: Der ((->) x) (t0 x)
+    Couldn't match kind `*' with `* -> *'
+    Expected type: Der ((->) x) (f1 x)
       Actual type: R f1
     Kind incompatibility when matching types:
-      f1 :: * -> *
-      t0 x :: *
+      Der ((->) x) :: * -> *
+      R :: (* -> *) -> *
     In the first argument of `plug', namely `rf'
     In the first argument of `Inl', namely `(plug rf df x)'
index 24f0cbd..e809d9c 100644 (file)
@@ -1,29 +1,6 @@
 
-T4272.hs:11:16:
-    Couldn't match type `TermFamily (TermFamily x0 x0)'
-                  with `TermFamily x0'
-    NB: `TermFamily' is a type function, and may not be injective
-    The type variable `x0' is ambiguous
-    Possible fix: add a type signature that fixes these type variable(s)
-    Expected type: TermFamily x0 x0
-      Actual type: TermFamily a a
-    In the first argument of `prune', namely `t'
-    In the expression: prune t (terms (undefined :: TermFamily a a))
-    In an equation for `laws':
-        laws t = prune t (terms (undefined :: TermFamily a a))
-
-T4272.hs:11:16:
-    Occurs check: cannot construct the infinite type:
-      x0 = TermFamily x0 x0
-    Expected type: TermFamily x0 x0
-      Actual type: TermFamily a a
-    In the first argument of `prune', namely `t'
-    In the expression: prune t (terms (undefined :: TermFamily a a))
-    In an equation for `laws':
-        laws t = prune t (terms (undefined :: TermFamily a a))
-
-T4272.hs:11:19:
-    Could not deduce (a ~ TermFamily x0 x0)
+T4272.hs:11:26:
+    Could not deduce (a ~ TermFamily a a)
     from the context (TermLike a)
       bound by the type signature for
                  laws :: TermLike a => TermFamily a a -> b
@@ -31,7 +8,10 @@ T4272.hs:11:19:
       `a' is a rigid type variable bound by
           the type signature for laws :: TermLike a => TermFamily a a -> b
           at T4272.hs:10:16
-    In the return type of a call of `terms'
+    Expected type: TermFamily a (TermFamily a a)
+      Actual type: TermFamily a a
+    In the first argument of `terms', namely
+      `(undefined :: TermFamily a a)'
     In the second argument of `prune', namely
       `(terms (undefined :: TermFamily a a))'
     In the expression: prune t (terms (undefined :: TermFamily a a))
index 7ef9ce1..fe8ce00 100644 (file)
@@ -1,12 +1,36 @@
-\r
-readFail003.hs:4:27:\r
-    Occurs check: cannot construct the infinite type:\r
-      t0 = (t0, [a0], [a1])\r
-    In the expression: a\r
-    In a pattern binding:\r
-      ~(a, b, c)\r
-        | nullity b = a\r
-        | nullity c = a\r
-        | otherwise = a\r
-        where\r
-            nullity = null\r
+
+readFail003.hs:4:27:
+    Occurs check: cannot construct the infinite type:
+      t0 = (t0, [a0], [a1])
+    In the expression: a
+    In a pattern binding:
+      ~(a, b, c)
+        | nullity b = a
+        | nullity c = a
+        | otherwise = a
+        where
+            nullity = null
+
+readFail003.hs:5:27:
+    Occurs check: cannot construct the infinite type:
+      t0 = (t0, [a0], [a1])
+    In the expression: a
+    In a pattern binding:
+      ~(a, b, c)
+        | nullity b = a
+        | nullity c = a
+        | otherwise = a
+        where
+            nullity = null
+
+readFail003.hs:6:27:
+    Occurs check: cannot construct the infinite type:
+      t0 = (t0, [a0], [a1])
+    In the expression: a
+    In a pattern binding:
+      ~(a, b, c)
+        | nullity b = a
+        | nullity c = a
+        | otherwise = a
+        where
+            nullity = null
index 564917c..47221c5 100644 (file)
@@ -1,25 +1,25 @@
-\r
-FD2.hs:26:36:\r
-    Could not deduce (e ~ e1)\r
-    from the context (Foldable a)\r
-      bound by the class declaration for `Foldable'\r
-      at FD2.hs:(17,1)-(26,39)\r
-    or from (Elem a e)\r
-      bound by the type signature for\r
-                 foldr1 :: Elem a e => (e -> e -> e) -> a -> e\r
-      at FD2.hs:21:13-47\r
-    or from (Elem a e1)\r
-      bound by the type signature for\r
-                 mf :: Elem a e1 => e1 -> Maybe e1 -> Maybe e1\r
-      at FD2.hs:24:18-54\r
-      `e' is a rigid type variable bound by\r
-          the type signature for\r
-            foldr1 :: Elem a e => (e -> e -> e) -> a -> e\r
-          at FD2.hs:21:13\r
-      `e1' is a rigid type variable bound by\r
-           the type signature for\r
-             mf :: Elem a e1 => e1 -> Maybe e1 -> Maybe e1\r
-           at FD2.hs:24:18\r
-    In the first argument of `f', namely `x'\r
-    In the first argument of `Just', namely `(f x y)'\r
-    In the expression: Just (f x y)\r
+
+FD2.hs:26:34:
+    Could not deduce (e1 ~ e)
+    from the context (Foldable a)
+      bound by the class declaration for `Foldable'
+      at FD2.hs:(17,1)-(26,39)
+    or from (Elem a e)
+      bound by the type signature for
+                 foldr1 :: Elem a e => (e -> e -> e) -> a -> e
+      at FD2.hs:21:13-47
+    or from (Elem a e1)
+      bound by the type signature for
+                 mf :: Elem a e1 => e1 -> Maybe e1 -> Maybe e1
+      at FD2.hs:24:18-54
+      `e1' is a rigid type variable bound by
+           the type signature for
+             mf :: Elem a e1 => e1 -> Maybe e1 -> Maybe e1
+           at FD2.hs:24:18
+      `e' is a rigid type variable bound by
+          the type signature for
+            foldr1 :: Elem a e => (e -> e -> e) -> a -> e
+          at FD2.hs:21:13
+    In the return type of a call of `f'
+    In the first argument of `Just', namely `(f x y)'
+    In the expression: Just (f x y)
index 68639ce..9285bb8 100644 (file)
@@ -1,13 +1,13 @@
-\r
-FD3.hs:15:15:\r
-    Couldn't match type `a' with `([Char], a)'\r
-      `a' is a rigid type variable bound by\r
-          the type signature for translate :: (String, a) -> A a\r
-          at FD3.hs:14:14\r
-    When using functional dependencies to combine\r
-      MkA a a,\r
-        arising from the dependency `a -> b'\r
-        in the instance declaration at FD3.hs:12:10\r
-      MkA ([Char], a) a, arising from a use of `mkA' at FD3.hs:15:15-17\r
-    In the expression: mkA a\r
-    In an equation for `translate': translate a = mkA a\r
+
+FD3.hs:15:15:
+    Couldn't match type `a' with `([Char], a)'
+      `a' is a rigid type variable bound by
+          the type signature for translate :: (String, a) -> A a
+          at FD3.hs:14:14
+    When using functional dependencies to combine
+      MkA a a,
+        arising from the dependency `a -> b'
+        in the instance declaration at FD3.hs:12:10
+      MkA (String, a) a, arising from a use of `mkA' at FD3.hs:15:15-17
+    In the expression: mkA a
+    In an equation for `translate': translate a = mkA a
index 8b173d5..35c9e95 100644 (file)
@@ -1,24 +1,24 @@
-\r
-T2494.hs:15:7:\r
-    Couldn't match type `b' with `a'\r
-      `b' is a rigid type variable bound by\r
-          the RULE "foo/foo" at T2494.hs:14:16\r
-      `a' is a rigid type variable bound by\r
-          the RULE "foo/foo" at T2494.hs:13:16\r
-    Expected type: Maybe (m b) -> Maybe (m b)\r
-      Actual type: Maybe (m a) -> Maybe (m a)\r
-    In the first argument of `foo', namely `f'\r
-    In the expression: foo f (foo g x)\r
-    When checking the transformation rule "foo/foo"\r
-\r
-T2494.hs:15:30:\r
-    Couldn't match type `b' with `a'\r
-      `b' is a rigid type variable bound by\r
-          the RULE "foo/foo" at T2494.hs:14:16\r
-      `a' is a rigid type variable bound by\r
-          the RULE "foo/foo" at T2494.hs:13:16\r
-    Expected type: Maybe (m b) -> Maybe (m a)\r
-      Actual type: Maybe (m b) -> Maybe (m b)\r
-    In the second argument of `(.)', namely `g'\r
-    In the first argument of `foo', namely `(f . g)'\r
-    In the expression: foo (f . g) x\r
+
+T2494.hs:15:14:
+    Couldn't match type `a' with `b'
+      `a' is a rigid type variable bound by
+          the RULE "foo/foo" at T2494.hs:13:16
+      `b' is a rigid type variable bound by
+          the RULE "foo/foo" at T2494.hs:14:16
+    Expected type: Maybe (m a) -> Maybe (m a)
+      Actual type: Maybe (m b) -> Maybe (m b)
+    In the first argument of `foo', namely `g'
+    In the second argument of `foo', namely `(foo g x)'
+    In the expression: foo f (foo g x)
+
+T2494.hs:15:30:
+    Couldn't match type `b' with `a'
+      `b' is a rigid type variable bound by
+          the RULE "foo/foo" at T2494.hs:14:16
+      `a' is a rigid type variable bound by
+          the RULE "foo/foo" at T2494.hs:13:16
+    Expected type: Maybe (m a) -> Maybe (m a)
+      Actual type: Maybe (m b) -> Maybe (m b)
+    In the second argument of `(.)', namely `g'
+    In the first argument of `foo', namely `(f . g)'
+    In the expression: foo (f . g) x
index f6df417..d4ce2ce 100644 (file)
@@ -40,7 +40,7 @@ FrozenErrorTests.hs:33:9:
     In an equation for `test1': test1 = goo1 False undefined
 
 FrozenErrorTests.hs:36:15:
-    Couldn't match type `[Int]' with `Int'
+    Couldn't match type `Int' with `[Int]'
     Expected type: [[Int]]
       Actual type: F [Int] Bool
     In the first argument of `goo2', namely `(goo1 False undefined)'
@@ -48,7 +48,7 @@ FrozenErrorTests.hs:36:15:
     In an equation for `test2': test2 = goo2 (goo1 False undefined)
 
 FrozenErrorTests.hs:37:9:
-    Couldn't match type `Int' with `[Int]'
+    Couldn't match type `[Int]' with `Int'
     Expected type: [[Int]]
       Actual type: F [Int] Bool
     In the expression: goo1 False (goo2 undefined)
index 9cb479c..d7ab2be 100644 (file)
@@ -1,11 +1,9 @@
-\r
-T1899.hs:14:36:\r
-    Couldn't match type `a' with `Proposition a0'\r
-      `a' is a rigid type variable bound by\r
-          the type signature for transRHS :: [a] -> Int -> Constraint a\r
-          at T1899.hs:9:14\r
-    Expected type: [Proposition a0]\r
-      Actual type: [a]\r
-    In the first argument of `Auxiliary', namely `varSet'\r
-    In the first argument of `Prop', namely `(Auxiliary varSet)'\r
-    In the expression: Prop (Auxiliary varSet)\r
+
+T1899.hs:12:29:
+    Couldn't match expected type `a' with actual type `Proposition a0'
+      `a' is a rigid type variable bound by
+          the type signature for transRHS :: [a] -> Int -> Constraint a
+          at T1899.hs:9:14
+    In the return type of a call of `Auxiliary'
+    In the first argument of `Prop', namely `(Auxiliary undefined)'
+    In the expression: Prop (Auxiliary undefined)
index c8d8340..876a499 100644 (file)
@@ -1,13 +1,10 @@
 
 T3950.hs:15:13:
-    Couldn't match type `Id p0 x0' with `Id p'
+    Couldn't match kind `* -> *' with `*'
     Expected type: w (Id p)
       Actual type: Sealed (Id p0 x0)
+    Kind incompatibility when matching types:
+      w :: (* -> * -> *) -> *
+      Sealed :: (* -> *) -> *
     In the first argument of `Just', namely rp'
     In the expression: Just rp'
-    In an equation for `rp':
-        rp _
-          = Just rp'
-          where
-              rp' :: Sealed (Id p x)
-              rp' = undefined
index a8b7bc0..b56f162 100644 (file)
@@ -1,12 +1,11 @@
 
 tcfail072.hs:23:13:
-    Could not deduce (Ord p0)
-      arising from a use of `g'
+    Could not deduce (Ord q0) arising from a use of `g'
     from the context (Ord p, Ord q)
       bound by the type signature for
                  g :: (Ord p, Ord q) => AB p q -> Bool
       at tcfail072.hs:22:6-38
-    The type variable `p0' is ambiguous
+    The type variable `q0' is ambiguous
     Possible fix: add a type signature that fixes these type variable(s)
     Note: there are several potential instances:
       instance Ord () -- Defined in `GHC.Classes'
index e648dc5..200df0b 100644 (file)
@@ -1,9 +1,11 @@
 
-tcfail153.hs:6:9:
-    Couldn't match expected type `a' with actual type `Bool'
+tcfail153.hs:6:7:
+    Couldn't match type `a' with `Bool'
       `a' is a rigid type variable bound by
           the type signature for f :: a -> [a] at tcfail153.hs:5:6
-    In the first argument of `g', namely `x'
+    Expected type: [a]
+      Actual type: [Bool]
+    In the return type of a call of `g'
     In the expression: g x
     In an equation for `f':
         f x
index 1c5f59a..6a60b9f 100644 (file)
@@ -1,15 +1,14 @@
-\r
-tcfail201.hs:18:28:\r
-    Couldn't match expected type `a' with actual type `HsDoc id0'\r
-      `a' is a rigid type variable bound by\r
-          the type signature for\r
-            gfoldl' :: (forall a1 b. c (a1 -> b) -> a1 -> c b)\r
-                       -> (forall g. g -> c g) -> a -> c a\r
-          at tcfail201.hs:15:12\r
-    In the pattern: DocParagraph hsDoc\r
-    In a case alternative:\r
-        (DocParagraph hsDoc) -> z DocParagraph `k` hsDoc\r
-    In the expression:\r
-      case hsDoc of {\r
-        DocEmpty -> z DocEmpty\r
-        (DocParagraph hsDoc) -> z DocParagraph `k` hsDoc }\r
+
+tcfail201.hs:17:27:
+    Couldn't match expected type `a' with actual type `HsDoc t0'
+      `a' is a rigid type variable bound by
+          the type signature for
+            gfoldl' :: (forall a1 b. c (a1 -> b) -> a1 -> c b)
+                       -> (forall g. g -> c g) -> a -> c a
+          at tcfail201.hs:15:12
+    In the pattern: DocEmpty
+    In a case alternative: DocEmpty -> z DocEmpty
+    In the expression:
+      case hsDoc of {
+        DocEmpty -> z DocEmpty
+        (DocParagraph hsDoc) -> z DocParagraph `k` hsDoc }