Lots of error message wibbling, following the
authorSimon Peyton Jones <simonpj@microsoft.com>
Thu, 12 Jan 2012 15:13:32 +0000 (15:13 +0000)
committerSimon Peyton Jones <simonpj@microsoft.com>
Thu, 12 Jan 2012 15:13:32 +0000 (15:13 +0000)
major TcErrors refactoring

136 files changed:
testsuite/tests/annotations/should_fail/annfail08.stderr
testsuite/tests/annotations/should_fail/annfail10.stderr
testsuite/tests/arrows/should_fail/T5380.stderr
testsuite/tests/deriving/should_fail/T5287.stderr
testsuite/tests/gadt/T3169.stderr
testsuite/tests/gadt/rw.stderr
testsuite/tests/ghci.debugger/scripts/break003.stderr
testsuite/tests/ghci.debugger/scripts/break006.stderr
testsuite/tests/ghci.debugger/scripts/break018.stderr
testsuite/tests/ghci.debugger/scripts/dynbrk004.stderr
testsuite/tests/ghci.debugger/scripts/print006.stdout
testsuite/tests/ghci.debugger/scripts/print007.stderr
testsuite/tests/ghci.debugger/scripts/print019.stderr
testsuite/tests/ghci/scripts/Defer02.script [new file with mode: 0755]
testsuite/tests/ghci/scripts/Defer02.stderr [new file with mode: 0644]
testsuite/tests/ghci/scripts/T3263.stderr
testsuite/tests/ghci/scripts/T5130.stderr
testsuite/tests/ghci/scripts/all.T [changed mode: 0644->0755]
testsuite/tests/ghci/scripts/ghci031.stderr
testsuite/tests/ghci/scripts/ghci047.stderr
testsuite/tests/ghci/scripts/ghci050.stderr
testsuite/tests/ghci/scripts/ghci051.stderr
testsuite/tests/indexed-types/should_compile/Simple14.stderr
testsuite/tests/indexed-types/should_compile/T3208b.stderr
testsuite/tests/indexed-types/should_fail/GADTwrong1.stderr
testsuite/tests/indexed-types/should_fail/NoMatchErr.stderr
testsuite/tests/indexed-types/should_fail/SimpleFail16.stderr
testsuite/tests/indexed-types/should_fail/SimpleFail5b.stderr
testsuite/tests/indexed-types/should_fail/T1897b.stderr
testsuite/tests/indexed-types/should_fail/T1900.stderr
testsuite/tests/indexed-types/should_fail/T2239.stderr
testsuite/tests/indexed-types/should_fail/T2544.stderr
testsuite/tests/indexed-types/should_fail/T2664.stderr
testsuite/tests/indexed-types/should_fail/T2693.stderr
testsuite/tests/indexed-types/should_fail/T3330a.hs
testsuite/tests/indexed-types/should_fail/T3330a.stderr
testsuite/tests/indexed-types/should_fail/T3330c.stderr
testsuite/tests/indexed-types/should_fail/T3440.stderr
testsuite/tests/indexed-types/should_fail/T4099.stderr
testsuite/tests/indexed-types/should_fail/T4174.stderr
testsuite/tests/indexed-types/should_fail/T4179.stderr
testsuite/tests/indexed-types/should_fail/T4272.hs
testsuite/tests/indexed-types/should_fail/T4272.stderr
testsuite/tests/indexed-types/should_fail/T4485.stderr
testsuite/tests/indexed-types/should_fail/T5439.stderr
testsuite/tests/indexed-types/should_fail/all.T
testsuite/tests/layout/layout001.stdout
testsuite/tests/layout/layout003.stdout
testsuite/tests/layout/layout006.stdout
testsuite/tests/parser/should_compile/read064.stderr
testsuite/tests/parser/should_compile/read066.stderr
testsuite/tests/rebindable/DoParamM.stderr
testsuite/tests/rebindable/rebindable6.stderr
testsuite/tests/safeHaskell/safeLanguage/SafeLang03.stderr
testsuite/tests/simplCore/should_compile/simpl017.stderr
testsuite/tests/th/T5358.stderr
testsuite/tests/th/TH_reifyDecl1.hs
testsuite/tests/th/TH_reifyDecl1.stderr
testsuite/tests/th/TH_reifyMkName.hs
testsuite/tests/th/TH_reifyMkName.stderr
testsuite/tests/typecheck/prog001/typecheck.prog001.stderr-ghc
testsuite/tests/typecheck/should_compile/FD2.stderr
testsuite/tests/typecheck/should_compile/T2494.stderr
testsuite/tests/typecheck/should_compile/T4912.stderr
testsuite/tests/typecheck/should_compile/tc168.stderr
testsuite/tests/typecheck/should_compile/tc211.stderr
testsuite/tests/typecheck/should_fail/FrozenErrorTests.stderr
testsuite/tests/typecheck/should_fail/T1897a.stderr
testsuite/tests/typecheck/should_fail/T1899.stderr
testsuite/tests/typecheck/should_fail/T2414.stderr
testsuite/tests/typecheck/should_fail/T2688.stderr
testsuite/tests/typecheck/should_fail/T2714.stderr
testsuite/tests/typecheck/should_fail/T2846b.stderr
testsuite/tests/typecheck/should_fail/T3102.stderr
testsuite/tests/typecheck/should_fail/T3613.stderr
testsuite/tests/typecheck/should_fail/T3950.stderr
testsuite/tests/typecheck/should_fail/T5236.stderr
testsuite/tests/typecheck/should_fail/T5300.stderr
testsuite/tests/typecheck/should_fail/T5573a.stderr
testsuite/tests/typecheck/should_fail/T5684.stderr
testsuite/tests/typecheck/should_fail/T5689.stderr
testsuite/tests/typecheck/should_fail/all.T
testsuite/tests/typecheck/should_fail/mc19.stderr
testsuite/tests/typecheck/should_fail/mc21.stderr
testsuite/tests/typecheck/should_fail/mc22.stderr
testsuite/tests/typecheck/should_fail/mc23.stderr
testsuite/tests/typecheck/should_fail/mc24.stderr
testsuite/tests/typecheck/should_fail/mc25.stderr
testsuite/tests/typecheck/should_fail/tcfail001.stderr
testsuite/tests/typecheck/should_fail/tcfail005.stderr
testsuite/tests/typecheck/should_fail/tcfail008.stderr
testsuite/tests/typecheck/should_fail/tcfail010.stderr
testsuite/tests/typecheck/should_fail/tcfail016.stderr
testsuite/tests/typecheck/should_fail/tcfail018.stderr
testsuite/tests/typecheck/should_fail/tcfail040.stderr
testsuite/tests/typecheck/should_fail/tcfail043.stderr
testsuite/tests/typecheck/should_fail/tcfail065.stderr
testsuite/tests/typecheck/should_fail/tcfail067.stderr
testsuite/tests/typecheck/should_fail/tcfail068.stderr
testsuite/tests/typecheck/should_fail/tcfail072.stderr
testsuite/tests/typecheck/should_fail/tcfail076.stderr
testsuite/tests/typecheck/should_fail/tcfail080.hs
testsuite/tests/typecheck/should_fail/tcfail080.stderr
testsuite/tests/typecheck/should_fail/tcfail099.stderr
testsuite/tests/typecheck/should_fail/tcfail103.stderr
testsuite/tests/typecheck/should_fail/tcfail104.stderr
testsuite/tests/typecheck/should_fail/tcfail128.stderr
testsuite/tests/typecheck/should_fail/tcfail133.stderr
testsuite/tests/typecheck/should_fail/tcfail140.stderr
testsuite/tests/typecheck/should_fail/tcfail142.stderr
testsuite/tests/typecheck/should_fail/tcfail143.stderr
testsuite/tests/typecheck/should_fail/tcfail153.stderr
testsuite/tests/typecheck/should_fail/tcfail168.hs
testsuite/tests/typecheck/should_fail/tcfail168.stderr
testsuite/tests/typecheck/should_fail/tcfail171.stderr
testsuite/tests/typecheck/should_fail/tcfail174.stderr
testsuite/tests/typecheck/should_fail/tcfail175.stderr
testsuite/tests/typecheck/should_fail/tcfail177.stderr
testsuite/tests/typecheck/should_fail/tcfail178.stderr
testsuite/tests/typecheck/should_fail/tcfail179.stderr
testsuite/tests/typecheck/should_fail/tcfail181.stderr
testsuite/tests/typecheck/should_fail/tcfail186.stderr
testsuite/tests/typecheck/should_fail/tcfail189.stderr
testsuite/tests/typecheck/should_fail/tcfail191.stderr
testsuite/tests/typecheck/should_fail/tcfail192.stderr
testsuite/tests/typecheck/should_fail/tcfail193.stderr
testsuite/tests/typecheck/should_fail/tcfail194.stderr
testsuite/tests/typecheck/should_fail/tcfail198.stderr
testsuite/tests/typecheck/should_fail/tcfail201.stderr
testsuite/tests/typecheck/should_fail/tcfail206.hs
testsuite/tests/typecheck/should_fail/tcfail206.stderr
testsuite/tests/typecheck/should_fail/tcfail207.stderr
testsuite/tests/typecheck/should_run/Defer01.hs [new file with mode: 0755]
testsuite/tests/typecheck/should_run/Defer01.stdout [new file with mode: 0644]
testsuite/tests/typecheck/should_run/all.T [changed mode: 0644->0755]
testsuite/tests/typecheck/should_run/tcrun041.hs

index a97ca4e..7e9b112 100644 (file)
@@ -1,15 +1,19 @@
-\r
-annfail08.hs:9:1:\r
-    No instance for (Data.Data.Data (a0 -> a0))\r
-      arising from an annotation\r
-    Possible fix:\r
-      add an instance declaration for (Data.Data.Data (a0 -> a0))\r
-    In the expression: (id + 1)\r
-    In the annotation: {-# ANN f (id + 1) #-}\r
-\r
-annfail08.hs:9:15:\r
-    No instance for (Num (a0 -> a0))\r
-      arising from a use of `+'\r
-    Possible fix: add an instance declaration for (Num (a0 -> a0))\r
-    In the expression: (id + 1)\r
-    In the annotation: {-# ANN f (id + 1) #-}\r
+
+annfail08.hs:9:1:
+    No instance for (Data.Data.Data (a0 -> a0))
+      arising from an annotation
+    The type variable `a0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
+    Possible fix:
+      add an instance declaration for (Data.Data.Data (a0 -> a0))
+    In the expression: (id + 1)
+    In the annotation: {-# ANN f (id + 1) #-}
+
+annfail08.hs:9:15:
+    No instance for (Num (a0 -> a0))
+      arising from a use of `+'
+    The type variable `a0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
+    Possible fix: add an instance declaration for (Num (a0 -> a0))
+    In the expression: (id + 1)
+    In the annotation: {-# ANN f (id + 1) #-}
index eac3002..33a4c16 100644 (file)
@@ -1,9 +1,16 @@
 
 annfail10.hs:9:1:
-    Ambiguous type variable `a0' in the constraints:
-      (Data.Data.Data a0) arising from an annotation
-                          at annfail10.hs:9:1-15
-      (Num a0) arising from the literal `1' at annfail10.hs:9:11
-    Probable fix: add a type signature that fixes these type variable(s)
+    No instance for (Data.Data.Data a0)
+      arising from an annotation
+    The type variable `a0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
+    In the expression: 1
+    In the annotation: {-# ANN f 1 #-}
+
+annfail10.hs:9:11:
+    No instance for (Num a0)
+      arising from the literal `1'
+    The type variable `a0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
     In the expression: 1
     In the annotation: {-# ANN f 1 #-}
index 07b89ee..c9df47c 100644 (file)
@@ -1,22 +1,24 @@
-\r
-T5380.hs:7:27:\r
-    Couldn't match type `not_bool' with `Bool'\r
-      `not_bool' is a rigid type variable bound by\r
-                 the type signature for\r
-                   testB :: not_bool -> (() -> ()) -> () -> not_unit\r
-                 at T5380.hs:7:1\r
-    In the expression: b\r
-    In the expression: proc () -> if b then f -< () else f -< ()\r
-    In an equation for `testB':\r
-        testB b f = proc () -> if b then f -< () else f -< ()\r
-\r
-T5380.hs:7:34:\r
-    Couldn't match type `not_unit' with `()'\r
-      `not_unit' is a rigid type variable bound by\r
-                 the type signature for\r
-                   testB :: not_bool -> (() -> ()) -> () -> not_unit\r
-                 at T5380.hs:7:1\r
-    Expected type: () -> not_unit\r
-      Actual type: () -> ()\r
-    In the expression: f\r
-    In the expression: proc () -> if b then f -< () else f -< ()\r
+
+T5380.hs:7:27:
+    Couldn't match expected type `not_bool' with actual type `Bool'
+      `not_bool' is a rigid type variable bound by
+                 the type signature for
+                   testB :: not_bool -> (() -> ()) -> () -> not_unit
+                 at T5380.hs:7:1
+    In the expression: b
+    In the expression: proc () -> if b then f -< () else f -< ()
+    In an equation for `testB':
+        testB b f = proc () -> if b then f -< () else f -< ()
+
+T5380.hs:7:34:
+    Couldn't match type `not_unit' with `()'
+      `not_unit' is a rigid type variable bound by
+                 the type signature for
+                   testB :: not_bool -> (() -> ()) -> () -> not_unit
+                 at T5380.hs:7:1
+    Expected type: () -> not_unit
+      Actual type: () -> ()
+    In the expression: f
+    In the expression: proc () -> if b then f -< () else f -< ()
+    In an equation for `testB':
+        testB b f = proc () -> if b then f -< () else f -< ()
index 4067522..e95212f 100644 (file)
@@ -1,7 +1,10 @@
-\r
-T5287.hs:6:29:\r
-    Ambiguous type variable `oops' in the constraint:\r
-      (A e oops)\r
-        arising from the 'deriving' clause of a data type declaration\r
-    Probable fix: use a 'standalone deriving' declaration instead\r
-    When deriving the instance for (Read (E e))\r
+
+T5287.hs:6:29:
+    No instance for (A e oops)
+      arising from the 'deriving' clause of a data type declaration
+    The type variable `oops' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
+    Possible fix:
+      use a standalone 'deriving instance' declaration,
+        so you can specify the instance context yourself
+    When deriving the instance for (Read (E e))
index 878324c..c1ee5b5 100644 (file)
@@ -1,11 +1,28 @@
-\r
-T3169.hs:13:13:\r
-    Couldn't match type `elt' with `Map b elt'\r
-      `elt' is a rigid type variable bound by\r
-            the type signature for\r
-              lookup :: (a, b) -> Map (a, b) elt -> Maybe elt\r
-            at T3169.hs:12:3\r
-    Expected type: Maybe (Map b elt)\r
-      Actual type: Maybe elt\r
-    In the return type of a call of `lookup'\r
-    In the expression: lookup a m :: Maybe (Map b elt)\r
+
+T3169.hs:13:13:
+    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
+      `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'
+    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)
+    from the context (Key a, Key b)
+      bound by the instance declaration at T3169.hs:10:10-36
+    Expected type: Map a 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 }
index 4c0c0ce..752d0fd 100644 (file)
@@ -1,19 +1,20 @@
-\r
-rw.hs:14:47:\r
-    Couldn't match type `a' with `Int'\r
-      `a' is a rigid type variable bound by\r
-          the type signature for writeInt :: T a -> IORef a -> IO ()\r
-          at rw.hs:13:1\r
-    In the second argument of `writeIORef', namely `(1 :: Int)'\r
-    In the expression: writeIORef ref (1 :: Int)\r
-    In a case alternative: ~(Li x) -> writeIORef ref (1 :: Int)\r
-\r
-rw.hs:19:51:\r
-    Couldn't match type `a' with `Bool'\r
-      `a' is a rigid type variable bound by\r
-          the type signature for readBool :: T a -> IORef a -> IO ()\r
-          at rw.hs:17:1\r
-    Expected type: a -> Bool\r
-      Actual type: Bool -> Bool\r
-    In the second argument of `(.)', namely `not'\r
-    In the second argument of `(>>=)', namely `(print . not)'\r
+
+rw.hs:14:47:
+    Couldn't match expected type `a' with actual type `Int'
+      `a' is a rigid type variable bound by
+          the type signature for writeInt :: T a -> IORef a -> IO ()
+          at rw.hs:13:1
+    In the second argument of `writeIORef', namely `(1 :: Int)'
+    In the expression: writeIORef ref (1 :: Int)
+    In a case alternative: ~(Li x) -> writeIORef ref (1 :: Int)
+
+rw.hs:19:51:
+    Couldn't match type `a' with `Bool'
+      `a' is a rigid type variable bound by
+          the type signature for readBool :: T a -> IORef a -> IO ()
+          at rw.hs:17:1
+    Expected type: a -> Bool
+      Actual type: Bool -> Bool
+    In the second argument of `(.)', namely `not'
+    In the second argument of `(>>=)', namely `(print . not)'
+    In the expression: readIORef ref >>= (print . not)
index f594409..58f1b68 100644 (file)
@@ -2,5 +2,7 @@
 <interactive>:5:1:
     No instance for (Show (t -> a))
       arising from a use of `print'
+    Cannot resolve unknown runtime types `t', `a'
+    Use :print or :force to determine these types
     Possible fix: add an instance declaration for (Show (t -> a))
     In a stmt of an interactive GHCi command: print it
index 40bb786..7ee0898 100644 (file)
@@ -1,14 +1,14 @@
 
 <interactive>:6:1:
-    Ambiguous type variable `a' in the constraint:
-      (Show a) arising from a use of `print'
-    Cannot resolve unknown runtime types: a
+    No instance for (Show a)
+      arising from a use of `print'
+    Cannot resolve unknown runtime type `a'
     Use :print or :force to determine these types
     In a stmt of an interactive GHCi command: print it
 
 <interactive>:8:1:
-    Ambiguous type variable `a' in the constraint:
-      (Show a) arising from a use of `print'
-    Cannot resolve unknown runtime types: a
+    No instance for (Show a)
+      arising from a use of `print'
+    Cannot resolve unknown runtime type `a'
     Use :print or :force to determine these types
     In a stmt of an interactive GHCi command: print it
index 0107b58..d0bb1e0 100644 (file)
@@ -1,3 +1,3 @@
-\r
-<no location info>:\r
-    Warning: -XRecursiveDo is deprecated: use -XDoRec or pragma {-# LANGUAGE DoRec #-} instead\r
+
+<no location info>: Warning:
+    -XRecursiveDo is deprecated: use -XDoRec or pragma {-# LANGUAGE DoRec #-} instead
index 0107b58..d0bb1e0 100644 (file)
@@ -1,3 +1,3 @@
-\r
-<no location info>:\r
-    Warning: -XRecursiveDo is deprecated: use -XDoRec or pragma {-# LANGUAGE DoRec #-} instead\r
+
+<no location info>: Warning:
+    -XRecursiveDo is deprecated: use -XDoRec or pragma {-# LANGUAGE DoRec #-} instead
index 1cf7de8..72a0328 100644 (file)
@@ -2,7 +2,7 @@ t = O (_t1::a)
 ()
 t = O ((_t2::a1) : (_t3::[a1]))
 ()
-t = O ((_t4::a2) : (_t5::a2) : (_t6::[a2]))
+t = O ((_t4::a1) : (_t5::a1) : (_t6::[a1]))
 ()
 t = O ((_t7::Maybe [Integer]) : Just [2,2] :
        (_t8::[Maybe [Integer]]))
index 713c629..d298a59 100644 (file)
@@ -1,3 +1,3 @@
 
-<no location info>:
-    Warning: -O conflicts with --interactive; -O ignored.
+<no location info>: Warning:
+    -O conflicts with --interactive; -O ignored.
index 5cc3466..e272ce9 100644 (file)
@@ -1,7 +1,7 @@
 
 <interactive>:11:1:
-    Ambiguous type variable `a1' in the constraint:
-      (Show a1) arising from a use of `print'
-    Cannot resolve unknown runtime types: a1
+    No instance for (Show a1)
+      arising from a use of `print'
+    Cannot resolve unknown runtime type `a1'
     Use :print or :force to determine these types
     In a stmt of an interactive GHCi command: print it
diff --git a/testsuite/tests/ghci/scripts/Defer02.script b/testsuite/tests/ghci/scripts/Defer02.script
new file mode 100755 (executable)
index 0000000..3fc6aff
--- /dev/null
@@ -0,0 +1,14 @@
+-- Test -fwarn-type-errors
+-- This test shows how each error is printed at runtime
+:l ../../typecheck/should_run/Defer01
+t5624
+print a
+print (b B)
+print (c (C2 True))
+print (d ())
+print f
+print (h ())
+print (i ())
+print j
+print (k 2)
+l
\ No newline at end of file
diff --git a/testsuite/tests/ghci/scripts/Defer02.stderr b/testsuite/tests/ghci/scripts/Defer02.stderr
new file mode 100644 (file)
index 0000000..4a17b34
--- /dev/null
@@ -0,0 +1,92 @@
+
+../../typecheck/should_run/Defer01.hs:11:40: Warning:
+    Couldn't match type `Char' with `[Char]'
+    Expected type: String
+      Actual type: Char
+    In the first argument of `putStr', namely ','
+    In the second argument of `(>>)', namely putStr ','
+    In the expression: putStr "Hello World" >> putStr ','
+
+../../typecheck/should_run/Defer01.hs:14:5: Warning:
+    Couldn't match expected type `Int' with actual type `Char'
+    In the expression: 'p'
+    In an equation for `a': a = 'p'
+
+../../typecheck/should_run/Defer01.hs:18:9: Warning:
+    No instance for (Eq B)
+      arising from a use of `=='
+    Possible fix: add an instance declaration for (Eq B)
+    In the expression: x == x
+    In an equation for `b': b x = x == x
+
+../../typecheck/should_run/Defer01.hs:28:5: Warning:
+    No instance for (Num (a -> a))
+      arising from the literal `1'
+    Possible fix: add an instance declaration for (Num (a -> a))
+    In the expression: 1
+    In an equation for `d': d = 1
+
+../../typecheck/should_run/Defer01.hs:31:5: Warning:
+    Couldn't match expected type `Char -> t' with actual type `Char'
+    The function `e' is applied to one argument,
+    but its type `Char' has none
+    In the expression: e 'q'
+    In an equation for `f': f = e 'q'
+
+../../typecheck/should_run/Defer01.hs:34:8: Warning:
+    Couldn't match expected type `a' with actual type `Char'
+      `a' is a rigid type variable bound by
+          the type signature for h :: a -> (Char, Char)
+          at ../../typecheck/should_run/Defer01.hs:34:1
+    In the expression: x
+    In the expression: (x, 'c')
+    In an equation for `h': h x = (x, 'c')
+
+../../typecheck/should_run/Defer01.hs:39:17: Warning:
+    Couldn't match expected type `Bool' with actual type `T a'
+    In the return type of a call of `K'
+    In the first argument of `not', namely `(K a)'
+    In the first argument of `seq', namely `(not (K a))'
+
+../../typecheck/should_run/Defer01.hs:43:5: Warning:
+    No instance for (MyClass a1)
+      arising from a use of `myOp'
+    The type variable `a1' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
+    In the expression: myOp 23
+    In an equation for `j': j = myOp 23
+
+../../typecheck/should_run/Defer01.hs:43:10: Warning:
+    No instance for (Num a1)
+      arising from the literal `23'
+    The type variable `a1' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
+    In the first argument of `myOp', namely `23'
+    In the expression: myOp 23
+    In an equation for `j': j = myOp 23
+
+../../typecheck/should_run/Defer01.hs:46:7: Warning:
+    Couldn't match expected type `Bool' with actual type `Int'
+    In the expression: x
+    In an equation for `k': k x = x
+
+../../typecheck/should_run/Defer01.hs:49:5: Warning:
+    Couldn't match expected type `IO a0'
+                with actual type `Char -> IO ()'
+    In the first argument of `(>>)', namely `putChar'
+    In the expression: putChar >> putChar 'p'
+    In an equation for `l': l = putChar >> putChar 'p'
+
+<interactive>:8:11:
+    Couldn't match type `Bool' with `Int'
+    Expected type: C Int
+      Actual type: C Bool
+    In the return type of a call of `C2'
+    In the first argument of `c', namely `(C2 True)'
+    In the first argument of `print', namely `(c (C2 True))'
+
+<interactive>:14:8:
+    Couldn't match expected type `Bool' with actual type `Int'
+    In the first argument of `print', namely `(k 2)'
+    In the expression: print (k 2)
+    In an equation for `it': it = print (k 2)
index a7924e4..b8c4788 100644 (file)
@@ -1,5 +1,5 @@
 
-T3263.hs:8:12:
-    Warning: A do-notation statement discarded a result of type Char.
-             Suppress this warning by saying "_ <- getChar",
-             or by using the flag -fno-warn-unused-do-bind
+T3263.hs:8:12: Warning:
+    A do-notation statement discarded a result of type Char.
+    Suppress this warning by saying "_ <- getChar",
+    or by using the flag -fno-warn-unused-do-bind
index b68777e..3c31593 100644 (file)
@@ -1,6 +1,6 @@
 
 <interactive>:3:27:
-    Couldn't match type `a' with `[Char]'
+    Couldn't match expected type `a' with actual type `[Char]'
     In the expression: "hi"
     In the expression: [x, "hi"]
     In the expression: (\ (x :: a, y :: a) -> [x, "hi"])
old mode 100644 (file)
new mode 100755 (executable)
index d8c1501..b559dcf
@@ -108,3 +108,4 @@ test('T5557', normal, ghci_script, ['T5557.script'])
 test('T5566', normal, ghci_script, ['T5566.script'])
 test('GhciKinds', normal, ghci_script, ['GhciKinds.script'])
 test('T5564', normal, ghci_script, ['T5564.script'])
+test('Defer02', normal, ghci_script, ['Defer02.script'])
\ No newline at end of file
index 8e4256c..6f72f60 100644 (file)
@@ -1,3 +1,3 @@
 
-ghci031.hs:1:14:
-    Warning: -XDatatypeContexts is deprecated: It was widely considered a misfeature, and has been removed from the Haskell language.
+ghci031.hs:1:14: Warning:
+    -XDatatypeContexts is deprecated: It was widely considered a misfeature, and has been removed from the Haskell language.
index 1807dcb..0051710 100644 (file)
@@ -1,12 +1,16 @@
 
 <interactive>:38:1:
     Couldn't match type `HFalse' with `HTrue'
+    Expected type: HTrue
+      Actual type: Or HFalse HFalse
     In the expression: f
     In the expression: f $ Baz 'a'
     In an equation for `it': it = f $ Baz 'a'
 
 <interactive>:39:1:
     Couldn't match type `HFalse' with `HTrue'
+    Expected type: HTrue
+      Actual type: Or HFalse HFalse
     In the expression: f
     In the expression: f $ Quz
     In an equation for `it': it = f $ Quz
index 6f0e2c2..74dc9a9 100644 (file)
@@ -1,8 +1,9 @@
-\r
-<interactive>:6:49:\r
-    Couldn't match type `a' with `ListableElem (a, a)'\r
-      `a' is a rigid type variable bound by\r
-          the instance declaration at <interactive>:6:20\r
-    In the expression: a\r
-    In the expression: [a, b]\r
-    In an equation for `asList': asList (a, b) = [a, b]\r
+
+<interactive>:6:49:
+    Couldn't match expected type `a'
+                with actual type `ListableElem (a, a)'
+      `a' is a rigid type variable bound by
+          the instance declaration at <interactive>:6:20
+    In the expression: a
+    In the expression: [a, b]
+    In an equation for `asList': asList (a, b) = [a, b]
index 3a78849..130d001 100644 (file)
@@ -1,5 +1,7 @@
 
 <interactive>:7:9:
-    Couldn't match expected type T' with actual type `T'
+    Couldn't match type `T' with `main::Interactive.T'
+    Expected type: T'
+      Actual type: T
     In the expression: C :: T'
     In an equation for `c': c = C :: T'
index a5250d5..c86fffe 100644 (file)
@@ -8,6 +8,8 @@ Simple14.hs:17:12:
       `n' is a rigid type variable bound by
           the type signature for foo :: EQ_ (Maybe m) (Maybe n)
           at Simple14.hs:17:1
+    Expected type: EQ_ z0 z0
+      Actual type: EQ_ m n
     In the second argument of `eqE', namely `(eqI :: EQ_ m n)'
     In the first argument of `ntI', namely `(`eqE` (eqI :: EQ_ m n))'
     In the expression: ntI (`eqE` (eqI :: EQ_ m n))
index 2256e61..f8c8db4 100644 (file)
@@ -6,17 +6,21 @@ T3208b.hs:15:10:
                  fce' :: (OTerm a ~ STerm a, OBJECT a, SUBST a) => a -> c
       at T3208b.hs:15:1-22
     NB: `STerm' is a type function, and may not be injective
+    The type variable `a0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
     Expected type: STerm a0
       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 (OTerm a0 ~ STerm a)
+    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:15:1-22
+    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 e565aa6..6ec39c3 100644 (file)
@@ -1,18 +1,18 @@
 
 GADTwrong1.hs:12:19:
-    Could not deduce (a1 ~ b)
+    Could not deduce (b ~ a1)
     from the context (() ~ Const a1)
       bound by a pattern with constructor
                  T :: forall a. a -> T (Const a),
                in a case alternative
       at GADTwrong1.hs:12:12-14
+      `b' is a rigid type variable bound by
+          the type signature for coerce :: a -> b at GADTwrong1.hs:11:1
       `a1' is a rigid type variable bound by
            a pattern with constructor
              T :: forall a. a -> T (Const a),
            in a case alternative
            at GADTwrong1.hs:12:12
-      `b' is a rigid type variable bound by
-          the type signature for coerce :: a -> b at GADTwrong1.hs:11:1
     In the expression: y
     In a case alternative: T y -> y
     In the expression: case T x :: T (Const b) of { T y -> y }
index 713afea..77d93e8 100644 (file)
@@ -5,8 +5,8 @@ NoMatchErr.hs:20:5:
       bound by the type signature for f :: Fun d => Memo d a -> Memo d a
       at NoMatchErr.hs:20:1-15
     NB: `Memo' is a type function, and may not be injective
-    Expected type: Memo d a
-      Actual type: Memo d0 a
+    The type variable `d0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
     Expected type: Memo d a -> Memo d a
       Actual type: Memo d0 a -> Memo d0 a
     In the expression: abst . appl
index 0573e15..41812ea 100644 (file)
@@ -1,6 +1,11 @@
-
-SimpleFail16.hs:10:12:
-    Couldn't match type `F ()' with `p0 a0'
-    In the first argument of `foo', namely `(undefined :: F ())'
-    In the expression: foo (undefined :: F ())
-    In an equation for `bar': bar = foo (undefined :: F ())
+\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
index 34e7cab..bd28918 100644 (file)
@@ -1,6 +1,6 @@
 
 SimpleFail5b.hs:31:12:
-    Couldn't match expected type `Int' with actual type `Char'
+    Couldn't match type `Char' with `Int'
     Expected type: S3 Int
       Actual type: S3 Char
     In the pattern: D3Char
index f2f5250..ff0667a 100644 (file)
@@ -1,13 +1,15 @@
-
-T1897b.hs:16:1:
-    Could not deduce (Depend a ~ Depend a0)
-    from the context (Bug a)
-      bound by the inferred type for `isValid':
-                 Bug a => [Depend a] -> Bool
-      at T1897b.hs:16:1-41
-    NB: `Depend' is a type function, and may not be injective
-    Expected type: [Depend a] -> Bool
-      Actual type: [Depend a0] -> Bool
-    When checking that `isValid'
-      has the inferred type `forall a1. Bug a1 => [Depend a1] -> Bool'
-    Probable cause: the inferred type is ambiguous
+\r
+T1897b.hs:16:1:\r
+    Could not deduce (Depend a ~ Depend a0)\r
+    from the context (Bug a)\r
+      bound by the inferred type for `isValid':\r
+                 Bug a => [Depend a] -> Bool\r
+      at T1897b.hs:16:1-41\r
+    NB: `Depend' is a type function, and may not be injective\r
+    The type variable `a0' is ambiguous\r
+    Possible fix: add a type signature that fixes these type variable(s)\r
+    Expected type: [Depend a] -> Bool\r
+      Actual type: [Depend a0] -> Bool\r
+    When checking that `isValid'\r
+      has the inferred type `forall a. Bug a => [Depend a] -> Bool'\r
+    Probable cause: the inferred type is ambiguous\r
index 8ea2bb9..2044c6c 100644 (file)
@@ -1,18 +1,20 @@
-\r
-T1900.hs:11:12:\r
-    No instance for (Num ())\r
-      arising from a use of `+'\r
-    Possible fix: add an instance declaration for (Num ())\r
-    In the expression: (+ 1)\r
-    In an equation for `trans': trans = (+ 1)\r
-    In the instance declaration for `Bug Int'\r
-\r
-T1900.hs:14:22:\r
-    Could not deduce (Depend s0 ~ Depend s)\r
-    from the context (Bug s)\r
-      bound by the type signature for check :: Bug s => Depend s -> Bool\r
-      at T1900.hs:14:1-22\r
-    NB: `Depend' is a type function, and may not be injective\r
-    In the first argument of `trans', namely `d'\r
-    In the second argument of `(==)', namely `trans d'\r
-    In the expression: d == trans d\r
+
+T1900.hs:11:12:
+    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)
+    from the context (Bug s)
+      bound by the type signature for check :: Bug s => Depend s -> Bool
+      at T1900.hs:14:1-22
+    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 second argument of `(==)', namely `trans d'
+    In the expression: d == trans d
index b8d5fc7..759ba2b 100644 (file)
@@ -1,10 +1,10 @@
 
 T2239.hs:47:13:
-    Couldn't match expected type `b -> b'
-                with actual type `forall b1. MyEq b1 Bool => b1 -> b1'
-    Expected type: (forall b1. MyEq b1 Bool => b1 -> b1) -> b -> b
-      Actual type: (forall b1. MyEq b1 Bool => b1 -> b1)
-                   -> forall b1. MyEq b1 Bool => b1 -> b1
+    Couldn't match type `forall b1. MyEq b1 Bool => b1 -> b1'
+                  with `b -> b'
+    Expected type: (forall b. MyEq b Bool => b -> b) -> b -> b
+      Actual type: (forall b. MyEq b Bool => b -> b)
+                   -> forall b. MyEq b Bool => b -> b
     In the expression:
         id ::
           (forall b. MyEq b Bool => b -> b)
@@ -16,11 +16,11 @@ T2239.hs:47:13:
               -> (forall b. MyEq b Bool => b -> b)
 
 T2239.hs:50:13:
-    Couldn't match expected type `b -> b'
-                with actual type `forall b1. b1 ~ Bool => b1 -> b1'
-    Expected type: (forall b1. b1 ~ Bool => b1 -> b1) -> b -> b
-      Actual type: (forall b1. b1 ~ Bool => b1 -> b1)
-                   -> forall b1. b1 ~ Bool => b1 -> b1
+    Couldn't match type `forall b1. b1 ~ Bool => b1 -> b1'
+                  with `b -> b'
+    Expected type: (forall b. b ~ Bool => b -> b) -> b -> b
+      Actual type: (forall b. b ~ Bool => b -> b)
+                   -> forall b. b ~ Bool => b -> b
     In the expression:
         id ::
           (forall b. b ~ Bool => b -> b) -> (forall b. b ~ Bool => b -> b)
index cacd5a3..b6bc222 100644 (file)
@@ -1,22 +1,13 @@
-\r
-T2544.hs:15:12:\r
-    Could not deduce (IxMap r ~ IxMap i1)\r
-    from the context (Ix l, Ix r)\r
-      bound by the instance declaration at T2544.hs:13:10-37\r
-    NB: `IxMap' is a type function, and may not be injective\r
-    Expected type: IxMap (l :|: r) [Int]\r
-      Actual type: BiApp (IxMap i0) (IxMap i1) [Int]\r
-    In the return type of a call of `BiApp'\r
-    In the expression: BiApp empty empty\r
-    In an equation for `empty': empty = BiApp empty empty\r
-\r
-T2544.hs:15:12:\r
-    Could not deduce (IxMap l ~ IxMap i0)\r
-    from the context (Ix l, Ix r)\r
-      bound by the instance declaration at T2544.hs:13:10-37\r
-    NB: `IxMap' is a type function, and may not be injective\r
-    Expected type: IxMap (l :|: r) [Int]\r
-      Actual type: BiApp (IxMap i0) (IxMap i1) [Int]\r
-    In the return type of a call of `BiApp'\r
-    In the expression: BiApp empty empty\r
-    In an equation for `empty': empty = BiApp empty empty\r
+
+T2544.hs:15:12:
+    Could not deduce (IxMap r ~ IxMap i1)
+    from the context (Ix l, Ix r)
+      bound by the instance declaration at T2544.hs:13:10-37
+    NB: `IxMap' is a type function, and may not be injective
+    The type variable `i1' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
+    Expected type: IxMap (l :|: r) [Int]
+      Actual type: BiApp (IxMap i0) (IxMap i1) [Int]
+    In the return type of a call of `BiApp'
+    In the expression: BiApp empty empty
+    In an equation for `empty': empty = BiApp empty empty
index a4a1a24..2b5dd24 100644 (file)
@@ -1,18 +1,19 @@
-\r
-T2664.hs:31:33:\r
-    Could not deduce (Dual b ~ Dual a)\r
-    from the context (Connect a, Connect b)\r
-      bound by the instance declaration at T2664.hs:22:10-52\r
-    or from ((a :*: b) ~ Dual c, c ~ Dual (a :*: b))\r
-      bound by the type signature for\r
-                 newPChan :: ((a :*: b) ~ Dual c, c ~ Dual (a :*: b)) =>\r
-                             IO (PChan (a :*: b), PChan c)\r
-      at T2664.hs:(23,5)-(31,87)\r
-    NB: `Dual' is a type function, and may not be injective\r
-    Expected type: c\r
-      Actual type: Dual b :+: Dual a\r
-    Expected type: PChan c\r
-      Actual type: PChan (Dual b :+: Dual a)\r
-    In the return type of a call of `E'\r
-    In the expression:\r
-      E (pchoose Right v newPChan) (pchoose Left v newPChan)\r
+
+T2664.hs:31:33:
+    Could not deduce (Dual b ~ Dual 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))
+      bound by the type signature for
+                 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'
+    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 9bbe1c3..4894b89 100644 (file)
@@ -1,33 +1,16 @@
-
-T2693.hs:10:7:
-    Couldn't match type `TFn a' with `TFn a0'
-    NB: `TFn' is a type function, and may not be injective
-    When checking that `x' has the inferred type `forall a. TFn a'
-    Probable cause: the inferred type is ambiguous
-    In the expression:
-      do { let Just x = ...;
-           let n = fst x + fst x;
-           return () }
-    In an equation for `f':
-        f = do { let Just x = ...;
-                 let n = ...;
-                 return () }
-
-T2693.hs:18:15:
-    Couldn't match type `TFn a3' with `(a2, b0)'
-    In the first argument of `fst', namely `x'
-    In the first argument of `(+)', namely `fst x'
-    In the expression: fst x + snd x
-
-T2693.hs:18:23:
-    Couldn't match type `TFn a5' with `(a4, a2)'
-    In the first argument of `snd', namely `x'
-    In the second argument of `(+)', namely `snd x'
-    In the expression: fst x + snd x
-
-T2693.hs:28:20:
-    Couldn't match type `TFn a0' with `PVR a1'
-    Expected type: () -> Maybe (PVR a1)
-      Actual type: () -> Maybe (TFn a0)
-    In the first argument of `mapM', namely `g'
-    In a stmt of a 'do' block: pvs <- mapM g undefined
+\r
+T2693.hs:10:7:\r
+    Couldn't match expected type `TFn a' with actual type `TFn a0'\r
+    NB: `TFn' is a type function, and may not be injective\r
+    The type variable `a0' is ambiguous\r
+    Possible fix: add a type signature that fixes these type variable(s)\r
+    When checking that `x' has the inferred type `forall a. TFn a'\r
+    Probable cause: the inferred type is ambiguous\r
+    In the expression:\r
+      do { let Just x = ...;\r
+           let n = fst x + fst x;\r
+           return () }\r
+    In an equation for `f':\r
+        f = do { let Just x = ...;\r
+                 let n = ...;\r
+                 return () }\r
index c09eb0f..c13760c 100644 (file)
@@ -7,7 +7,9 @@
 
 module T3330a where
 
-import Control.Monad.Writer
+newtype Writer w a = Writer { runWriter :: (a, w) }
+execWriter :: Writer w a -> w
+execWriter m = snd (runWriter m)
 
 data AnyF (s :: * -> *) = AnyF
 class HFunctor (f :: (* -> *) -> * -> *)
index cafc6bc..d8b5d26 100644 (file)
@@ -1,9 +1,22 @@
 \r
-T3330a.hs:17:34:\r
-    Couldn't match type `s' with `(->) (s ix1 -> ix1)'\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:17:1\r
+          at T3330a.hs:19:1\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:19:1\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
index b35db0d..b9db62a 100644 (file)
@@ -1,17 +1,20 @@
 
-T3330c.hs:23:33:
-    Kind incompatibility when matching types:
-      f0 :: * -> *
-      f0 x :: *
-    In the return type of a call of `Inl'
-    In the expression: Inl (plug rf df x)
-    In an equation for plug':
-        plug' (RSum rf rg) (Inl df) x = Inl (plug rf df x)
-
 T3330c.hs:23:43:
-    Couldn't match kind `*' with `* -> *'
-    Kind incompatibility when matching types:
-      Der ((->) x) :: * -> *
-      R :: (* -> *) -> *
+    Could not deduce (f1 ~ t0 x)
+    from the context (f ~ (f1 :+: g))
+      bound by a pattern with constructor
+                 RSum :: forall (f :: * -> *) (g :: * -> *).
+                         R f -> R g -> R (f :+: g),
+               in an equation for plug'
+      at T3330c.hs:23:8-17
+      `f1' is a rigid type variable bound by
+           a pattern with constructor
+             RSum :: forall (f :: * -> *) (g :: * -> *).
+                     R f -> R g -> R (f :+: g),
+           in an equation for plug'
+           at T3330c.hs:23:8
+    Expected type: Der ((->) x) (t0 x)
+      Actual type: R f1
     In the first argument of `plug', namely `rf'
     In the first argument of `Inl', namely `(plug rf df x)'
+    In the expression: Inl (plug rf df x)
index fe61b1d..4e77eef 100644 (file)
@@ -1,19 +1,19 @@
 
 T3440.hs:11:22:
-    Could not deduce (a1 ~ a)
+    Could not deduce (a ~ a1)
     from the context (Fam a ~ Fam a1)
       bound by a pattern with constructor
                  GADT :: forall a. a -> Fam a -> GADT (Fam a),
                in an equation for `unwrap'
       at T3440.hs:11:9-16
+      `a' is a rigid type variable bound by
+          the type signature for unwrap :: GADT (Fam a) -> (a, Fam a)
+          at T3440.hs:11:1
       `a1' is a rigid type variable bound by
            a pattern with constructor
              GADT :: forall a. a -> Fam a -> GADT (Fam a),
            in an equation for `unwrap'
            at T3440.hs:11:9
-      `a' is a rigid type variable bound by
-          the type signature for unwrap :: GADT (Fam a) -> (a, Fam a)
-          at T3440.hs:11:1
     In the expression: x
     In the expression: (x, y)
     In an equation for `unwrap': unwrap (GADT x y) = (x, y)
index 926579d..3512e32 100644 (file)
@@ -1,13 +1,17 @@
-\r
-T4099.hs:11:14:\r
-    Couldn't match type `T b' with `T a0'\r
-    NB: `T' is a type function, and may not be injective\r
-    In the first argument of `foo', namely `x'\r
-    In the expression: foo x\r
-    In an equation for `bar1': bar1 x = foo x\r
-\r
-T4099.hs:14:14:\r
-    Couldn't match type `T a1' with `Maybe b'\r
-    In the first argument of `foo', namely `x'\r
-    In the expression: foo x\r
-    In an equation for `bar2': bar2 x = foo x\r
+
+T4099.hs:11:14:
+    Couldn't match expected type `T a0' with actual type `T b'
+    NB: `T' is a type function, and may not be injective
+    The type variable `a0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
+    In the first argument of `foo', namely `x'
+    In the expression: foo x
+    In an equation for `bar1': bar1 x = foo x
+
+T4099.hs:14:14:
+    Couldn't match expected type `T a1' with actual type `Maybe b'
+    The type variable `a1' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
+    In the first argument of `foo', namely `x'
+    In the expression: foo x
+    In an equation for `bar2': bar2 x = foo x
index 2a40378..81fb603 100644 (file)
@@ -1,5 +1,7 @@
 
 T4174.hs:42:12:
     Couldn't match type `False' with `True'
+    Expected type: True
+      Actual type: GHCVersion (WayOf m) :>=: GHC6'10 Minor1
     In the expression: sync_large_objects
     In an equation for `testcase': testcase = sync_large_objects
index 1903d7c..021e73e 100644 (file)
@@ -1,24 +1,5 @@
 
 T4179.hs:26:16:
-    Could not deduce (DoC (x (A2 (x (Con x)) -> A3 (x (Con x)))))
-      arising from a use of `op'
-    from the context (Functor x, DoC (FCon x))
-      bound by the type signature for
-                 fCon :: (Functor x, DoC (FCon x)) =>
-                         Con x -> A2 (FCon x) -> A3 (FCon x)
-      at T4179.hs:26:1-17
-    Possible fix:
-      add (DoC (x (A2 (x (Con x)) -> A3 (x (Con x))))) to the context of
-        the type signature for
-          fCon :: (Functor x, DoC (FCon x)) =>
-                  Con x -> A2 (FCon x) -> A3 (FCon x)
-      or add an instance declaration for
-         (DoC (x (A2 (x (Con x)) -> A3 (x (Con x)))))
-    In the first argument of `foldDoC', namely `op'
-    In the expression: foldDoC op
-    In an equation for `fCon': fCon = foldDoC op
-
-T4179.hs:26:16:
     Could not deduce (A3 (x (A2 (x (Con x)) -> A3 (x (Con x))))
                       ~ A3 (x (Con x)))
     from the context (Functor x, DoC (FCon x))
@@ -27,29 +8,6 @@ T4179.hs:26:16:
                          Con x -> A2 (FCon x) -> A3 (FCon x)
       at T4179.hs:26:1-17
     NB: `A3' is a type function, and may not be injective
-    Expected type: A2 (x (Con x)) -> A3 (x (Con x))
-      Actual type: A2 (x (A2 (x (Con x)) -> A3 (x (Con x))))
-                   -> A3 (x (A2 (x (Con x)) -> A3 (x (Con x))))
-    Expected type: x (A2 (x (Con x)) -> A3 (x (Con x)))
-                   -> A2 (x (Con x)) -> A3 (x (Con x))
-      Actual type: x (A2 (x (Con x)) -> A3 (x (Con x)))
-                   -> A2 (x (A2 (x (Con x)) -> A3 (x (Con x))))
-                   -> A3 (x (A2 (x (Con x)) -> A3 (x (Con x))))
-    In the first argument of `foldDoC', namely `op'
-    In the expression: foldDoC op
-
-T4179.hs:26:16:
-    Could not deduce (A2 (x (A2 (x (Con x)) -> A3 (x (Con x))))
-                      ~ A2 (x (Con x)))
-    from the context (Functor x, DoC (FCon x))
-      bound by the type signature for
-                 fCon :: (Functor x, DoC (FCon x)) =>
-                         Con x -> A2 (FCon x) -> A3 (FCon x)
-      at T4179.hs:26:1-17
-    NB: `A2' is a type function, and may not be injective
-    Expected type: A2 (x (Con x)) -> A3 (x (Con x))
-      Actual type: A2 (x (A2 (x (Con x)) -> A3 (x (Con x))))
-                   -> A3 (x (A2 (x (Con x)) -> A3 (x (Con x))))
     Expected type: x (A2 (x (Con x)) -> A3 (x (Con x)))
                    -> A2 (x (Con x)) -> A3 (x (Con x))
       Actual type: x (A2 (x (Con x)) -> A3 (x (Con x)))
@@ -57,3 +15,4 @@ T4179.hs:26:16:
                    -> A3 (x (A2 (x (Con x)) -> A3 (x (Con x))))
     In the first argument of `foldDoC', namely `op'
     In the expression: foldDoC op
+    In an equation for `fCon': fCon = foldDoC op
index 3370fc3..d9fd6d9 100644 (file)
@@ -10,7 +10,7 @@ class Family (TermFamily a) => TermLike a where
 laws :: forall a b. TermLike a => TermFamily a a -> b  
 laws t = prune t (terms (undefined :: TermFamily a a))
 
-prune :: TermLike a => TermFamily a a -> TermFamily a a -> b
+prune :: TermLike x => TermFamily x x -> TermFamily x x -> b
 prune = undefined  
 
 -- terms :: Family f => f a -> a
index 5c6e38f..0a6b3be 100644 (file)
@@ -1,8 +1,37 @@
-\r
-T4272.hs:11:16:\r
-    Occurs check: cannot construct the infinite type:\r
-      a0 = TermFamily a0 a0\r
-    In the first argument of `prune', namely `t'\r
-    In the expression: prune t (terms (undefined :: TermFamily a a))\r
-    In an equation for `laws':\r
-        laws t = prune t (terms (undefined :: TermFamily a a))\r
+
+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)
+    from the context (TermLike a)
+      bound by the type signature for
+                 laws :: TermLike a => TermFamily a a -> b
+      at T4272.hs:11:1-54
+      `a' is a rigid type variable bound by
+          the type signature for laws :: TermLike a => TermFamily a a -> b
+          at T4272.hs:11:1
+    In the return type of a call of `terms'
+    In the second argument of `prune', namely
+      `(terms (undefined :: TermFamily a a))'
+    In the expression: prune t (terms (undefined :: TermFamily a a))
index d8ebccb..21811da 100644 (file)
@@ -1,19 +1,29 @@
-
-T4485.hs:47:15:
-    Overlapping instances for EmbedAsChild
-                                (IdentityT IO) (XMLGenT m0 (XML m0))
-      arising from a use of `asChild'
-    Matching instances:
-      instance [overlap ok] (EmbedAsChild m c, m1 ~ m) =>
-                            EmbedAsChild m (XMLGenT m1 c)
-        -- Defined at T4485.hs:29:10
-      instance [overlap ok] EmbedAsChild
-                              (IdentityT IO) (XMLGenT Identity ())
-        -- Defined at T4485.hs:42:10
-    (The choice depends on the instantiation of `m0'
-     To pick the first instance above, use -XIncoherentInstances
-     when compiling the other instance declarations)
-    In the expression: asChild
-    In the expression: asChild $ (genElement "foo")
-    In an equation for `asChild':
-        asChild b = asChild $ (genElement "foo")
+\r
+T4485.hs:47:15:\r
+    Overlapping instances for EmbedAsChild\r
+                                (IdentityT IO) (XMLGenT m0 (XML m0))\r
+      arising from a use of `asChild'\r
+    Matching instances:\r
+      instance [overlap ok] (EmbedAsChild m c, m1 ~ m) =>\r
+                            EmbedAsChild m (XMLGenT m1 c)\r
+        -- Defined at T4485.hs:29:10\r
+      instance [overlap ok] EmbedAsChild\r
+                              (IdentityT IO) (XMLGenT Identity ())\r
+        -- Defined at T4485.hs:42:10\r
+    (The choice depends on the instantiation of `m0'\r
+     To pick the first instance above, use -XIncoherentInstances\r
+     when compiling the other instance declarations)\r
+    In the expression: asChild\r
+    In the expression: asChild $ (genElement "foo")\r
+    In an equation for `asChild':\r
+        asChild b = asChild $ (genElement "foo")\r
+\r
+T4485.hs:47:26:\r
+    No instance for (XMLGen m0)\r
+      arising from a use of `genElement'\r
+    The type variable `m0' is ambiguous\r
+    Possible fix: add a type signature that fixes these type variable(s)\r
+    In the second argument of `($)', namely `(genElement "foo")'\r
+    In the expression: asChild $ (genElement "foo")\r
+    In an equation for `asChild':\r
+        asChild b = asChild $ (genElement "foo")\r
index 6f4a9c9..4d8742c 100644 (file)
@@ -1,4 +1,14 @@
 
+T5439.hs:83:28:
+    Couldn't match type `Attempt (WaitOpResult (WaitOps rs))'
+                  with `Attempt (HNth n0 l0) -> Attempt (HElemOf l0)'
+    Expected type: f (Attempt (HNth n0 l0) -> Attempt (HElemOf l0))
+      Actual type: f (Attempt (WaitOpResult (WaitOps rs)))
+    In the first argument of `complete', namely `ev'
+    In the expression: complete ev
+    In a stmt of a 'do' block:
+      c <- complete ev $ inj $ Failure (e :: SomeException)
+
 T5439.hs:83:39:
     Couldn't match expected type `Peano n0'
                 with actual type `Attempt α0'
index 4f0b077..1f8f99a 100644 (file)
@@ -56,7 +56,7 @@ test('T4272', normal, compile_fail, [''])
 test('T4246', normal, compile_fail, [''])
 test('T4093a', normal, compile_fail, [''])
 test('T4093b', normal, compile_fail, [''])
-test('T3330a', reqlib('mtl'), compile_fail, [''])
+test('T3330a', normal, compile_fail, [''])
 test('T3330b', normal, compile_fail, [''])
 test('T3330c', normal, compile_fail, [''])
 test('T4179', normal, compile_fail, [''])
@@ -72,4 +72,5 @@ test('T2544', normal, compile_fail, [''])
 test('T1897b', normal, compile_fail, [''])
 test('T5439', normal, compile_fail, [''])
 test('T5515', normal, compile_fail, [''])
+test('T5763', expect_broken(5673), compile_fail, [''])
 
index be1cd62..4273843 100644 (file)
@@ -4,6 +4,6 @@ Running with -XAlternativeLayoutRule
 layout001.hs:6:3: parse error on input `where'
 Running with -XAlternativeLayoutRule -XAlternativeLayoutRuleTransitional
 
-layout001.hs:6:3:
+layout001.hs:6:3: Warning:
     transitional layout will not be accepted in the future:
     `where' clause at the same depth as implicit layout block
index e40bac2..1eb8638 100644 (file)
@@ -4,6 +4,6 @@ Running with -XAlternativeLayoutRule
 layout003.hs:11:4: parse error on input `|'
 Running with -XAlternativeLayoutRule -XAlternativeLayoutRuleTransitional
 
-layout003.hs:11:4:
+layout003.hs:11:4: Warning:
     transitional layout will not be accepted in the future:
     `|' at the same depth as implicit layout block
index ab33a6e..84704ba 100644 (file)
@@ -4,6 +4,6 @@ Running with -XAlternativeLayoutRule
 layout006.hs:12:2: parse error on input `|'
 Running with -XAlternativeLayoutRule -XAlternativeLayoutRuleTransitional
 
-layout006.hs:12:2:
+layout006.hs:12:2: Warning:
     transitional layout will not be accepted in the future:
     `|' at the same depth as implicit layout block
index 7c09544..09d2370 100644 (file)
@@ -6,20 +6,29 @@ DoParamM.hs:146:25:
     In a stmt of a 'do' block: return (v == v')
 
 DoParamM.hs:286:28:
-    Couldn't match expected type `Locked' with actual type `Unlocked'
-    Expected type: LIO Locked r0 b0
+    Couldn't match type `Unlocked' with `Locked'
+    Expected type: LIO Locked Locked ()
       Actual type: LIO Unlocked Locked ()
     In a stmt of a 'do' block: tlock2_do
     In the expression:
       do { tlock2_do;
            tlock2_do }
+    In an equation for `tlock4_do':
+        tlock4_do
+          = do { tlock2_do;
+                 tlock2_do }
 
 DoParamM.hs:302:37:
-    Couldn't match expected type `Unlocked' with actual type `Locked'
-    Expected type: LIO Unlocked r0 b0
+    Couldn't match type `Locked' with `Unlocked'
+    Expected type: LIO Unlocked Unlocked ()
       Actual type: LIO Locked Unlocked ()
     In a stmt of a 'do' block: unlock
     In the expression:
       do { tlock2_do;
            unlock;
            unlock }
+    In an equation for `tlock4'_do':
+        tlock4'_do
+          = do { tlock2_do;
+                 unlock;
+                 unlock }
index d451400..d38e53d 100644 (file)
@@ -2,6 +2,8 @@
 rebindable6.hs:106:17:
     No instance for (HasSeq (IO a -> t0 -> IO b))
       arising from a do statement
+    The type variable `t0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
     Possible fix:
       add an instance declaration for (HasSeq (IO a -> t0 -> IO b))
     In a stmt of a 'do' block: f
@@ -16,27 +18,15 @@ rebindable6.hs:106:17:
                  return b }
 
 rebindable6.hs:107:17:
-    No instance for (HasFail ([Prelude.Char] -> t1))
+    No instances for (HasBind (IO (Maybe b) -> (Maybe b -> t1) -> t0),
+                      HasFail ([Prelude.Char] -> t1))
       arising from a do statement
+    The type variables `t0', `t1' are ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
     Possible fix:
-      add an instance declaration for (HasFail ([Prelude.Char] -> t1))
-    In a stmt of a 'do' block: Just (b :: b) <- g
-    In the expression:
-      do { f;
-           Just (b :: b) <- g;
-           return b }
-    In an equation for `test_do':
-        test_do f g
-          = do { f;
-                 Just (b :: b) <- g;
-                 return b }
-
-rebindable6.hs:107:17:
-    No instance for (HasBind (IO (Maybe b) -> (Maybe b -> t1) -> t0))
-      arising from a do statement
-    Possible fix:
-      add an instance declaration for
-      (HasBind (IO (Maybe b) -> (Maybe b -> t1) -> t0))
+      add instance declarations for
+      (HasBind (IO (Maybe b) -> (Maybe b -> t1) -> t0),
+       HasFail ([Prelude.Char] -> t1))
     In a stmt of a 'do' block: Just (b :: b) <- g
     In the expression:
       do { f;
@@ -51,6 +41,8 @@ rebindable6.hs:107:17:
 rebindable6.hs:108:17:
     No instance for (HasReturn (b -> t1))
       arising from a use of `return'
+    The type variable `t1' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
     Possible fix: add an instance declaration for (HasReturn (b -> t1))
     In a stmt of a 'do' block: return b
     In the expression:
index fdcc599..33a66e6 100644 (file)
@@ -1,4 +1,4 @@
 
-SafeLang03.hs:7:11:
+SafeLang03.hs:7:11: Warning:
     Rule "f" ignored
     User defined rules are disabled under Safe Haskell
index 325920f..497bc8b 100644 (file)
@@ -1,20 +1,28 @@
-\r
-simpl017.hs:44:12:\r
-    Couldn't match expected type `forall v. [E m i] -> E' v m a'\r
-                with actual type `[E m i] -> E' v0 m a'\r
-    In the first argument of `return', namely `f'\r
-    In a stmt of a 'do' block: return f\r
-    In the first argument of `E', namely\r
-      `(do { let ix :: [E m i] -> m i\r
-                 ix [i] = runE i\r
-                 {-# INLINE f #-}\r
-                 ....;\r
-             return f })'\r
-\r
-simpl017.hs:63:5:\r
-    Couldn't match expected type `t0 -> t1'\r
-                with actual type `forall v. [E m0 Int] -> E' v m0 Int'\r
-    The function `a' is applied to one argument,\r
-    but its type `forall v. [E m0 Int] -> E' v m0 Int' has none\r
-    In the first argument of `plus', namely `a [one]'\r
-    In a stmt of a 'do' block: a [one] `plus` a [one]\r
+
+simpl017.hs:44:12:
+    Couldn't match expected type `forall v. [E m i] -> E' v m a'
+                with actual type `[E m i] -> E' v0 m a'
+    In the first argument of `return', namely `f'
+    In a stmt of a 'do' block: return f
+    In the first argument of `E', namely
+      `(do { let ix :: [E m i] -> m i
+                 ix [i] = runE i
+                 {-# INLINE f #-}
+                 ....;
+             return f })'
+
+simpl017.hs:63:5:
+    Couldn't match expected type `[E (ST t0) Int] -> E (ST s) Int'
+                with actual type `forall v. [E (ST s) Int] -> E' v (ST s) Int'
+    The function `a' is applied to one argument,
+    but its type `forall v. [E (ST s) Int] -> E' v (ST s) Int' has none
+    In the first argument of `plus', namely `a [one]'
+    In a stmt of a 'do' block: a [one] `plus` a [one]
+
+simpl017.hs:63:19:
+    Couldn't match expected type `[E (ST t1) Int] -> E (ST s) Int'
+                with actual type `forall v. [E (ST s) Int] -> E' v (ST s) Int'
+    The function `a' is applied to one argument,
+    but its type `forall v. [E (ST s) Int] -> E' v (ST s) Int' has none
+    In the second argument of `plus', namely `a [one]'
+    In a stmt of a 'do' block: a [one] `plus` a [one]
index 4a1bfbd..01f1ffa 100644 (file)
@@ -1,15 +1,24 @@
 
 T5358.hs:7:1:
+    Couldn't match expected type `t1 -> t1' with actual type `Int'
     The equation(s) for `t1' have one argument,
     but its type `Int' has none
 
 T5358.hs:8:1:
+    Couldn't match expected type `t0 -> t0' with actual type `Int'
     The equation(s) for `t2' have one argument,
     but its type `Int' has none
 
 T5358.hs:10:13:
+    Couldn't match expected type `t0 -> a0' with actual type `Int'
     The function `t1' is applied to one argument,
     but its type `Int' has none
     In the first argument of `(==)', namely `t1 x'
     In the expression: t1 x == t2 x
-    In an equation for `prop_x1': prop_x1 x = t1 x == t2 x
+
+T5358.hs:10:21:
+    Couldn't match expected type `t0 -> a0' with actual type `Int'
+    The function `t2' is applied to one argument,
+    but its type `Int' has none
+    In the second argument of `(==)', namely `t2 x'
+    In the expression: t1 x == t2 x
index 9c0880b..f2f5dd8 100644 (file)
@@ -3,6 +3,7 @@
 {-# LANGUAGE TypeFamilies #-}
 module TH_reifyDecl1 where
 
+import System.IO
 import Language.Haskell.TH
 import Text.PrettyPrint.HughesPJ
 
@@ -62,7 +63,7 @@ data instance DF2 Bool = DBool
 test :: ()
 test = $(let 
          display :: Name -> Q ()
-         display q = do { i <- reify q; report False (pprint i) }
+         display q = do { i <- reify q; runIO $ hPutStrLn stderr (pprint i) }
        in do { display ''T
              ; display ''R
              ; display ''List
index 7f4ae85..82a4f57 100644 (file)
@@ -1,67 +1,35 @@
-
-TH_reifyDecl1.hs:63:10:
-    data TH_reifyDecl1.T = TH_reifyDecl1.A | TH_reifyDecl1.B
-
-TH_reifyDecl1.hs:63:10:
-    data TH_reifyDecl1.R a_0 = TH_reifyDecl1.C a_0 | TH_reifyDecl1.D
-
-TH_reifyDecl1.hs:63:10:
-    data TH_reifyDecl1.List a_0
+data TH_reifyDecl1.T = TH_reifyDecl1.A | TH_reifyDecl1.B
+data TH_reifyDecl1.R a_0 = TH_reifyDecl1.C a_0 | TH_reifyDecl1.D
+data TH_reifyDecl1.List a_0
     = TH_reifyDecl1.Nil
     | TH_reifyDecl1.Cons a_0 (TH_reifyDecl1.List a_0)
-
-TH_reifyDecl1.hs:63:10:
-    data TH_reifyDecl1.Tree a_0
+data TH_reifyDecl1.Tree a_0
     = TH_reifyDecl1.Leaf
     | (TH_reifyDecl1.Tree a_0) TH_reifyDecl1.:+: (TH_reifyDecl1.Tree a_0)
-
-TH_reifyDecl1.hs:63:10:
-    type TH_reifyDecl1.IntList = [GHC.Types.Int]
-
-TH_reifyDecl1.hs:63:10:
-    newtype TH_reifyDecl1.Length = TH_reifyDecl1.Length GHC.Types.Int
-
-TH_reifyDecl1.hs:63:10:
-    Constructor from TH_reifyDecl1.Tree: TH_reifyDecl1.Leaf :: forall a_0 . TH_reifyDecl1.Tree a_0
-
-TH_reifyDecl1.hs:63:10:
-    Class op from TH_reifyDecl1.C1: TH_reifyDecl1.m1 :: forall a_0 . TH_reifyDecl1.C1 a_0 =>
+type TH_reifyDecl1.IntList = [GHC.Types.Int]
+newtype TH_reifyDecl1.Length = TH_reifyDecl1.Length GHC.Types.Int
+Constructor from TH_reifyDecl1.Tree: TH_reifyDecl1.Leaf :: forall a_0 . TH_reifyDecl1.Tree a_0
+Class op from TH_reifyDecl1.C1: TH_reifyDecl1.m1 :: forall a_0 . TH_reifyDecl1.C1 a_0 =>
                                                                  a_0 -> GHC.Types.Int
                                 infixl 3 TH_reifyDecl1.m1
-
-TH_reifyDecl1.hs:63:10:
-    class TH_reifyDecl1.C1 a_0
+class TH_reifyDecl1.C1 a_0
     where TH_reifyDecl1.m1 :: forall a_0 . TH_reifyDecl1.C1 a_0 =>
                                            a_0 -> GHC.Types.Int
-
-TH_reifyDecl1.hs:63:10:
-    class TH_reifyDecl1.C2 a_0
+class TH_reifyDecl1.C2 a_0
     where TH_reifyDecl1.m2 :: forall a_0 . TH_reifyDecl1.C2 a_0 =>
                                            a_0 -> GHC.Types.Int
 instance TH_reifyDecl1.C2 GHC.Types.Int
-
-TH_reifyDecl1.hs:63:10:
-    class TH_reifyDecl1.C3 a_0
+class TH_reifyDecl1.C3 a_0
 instance TH_reifyDecl1.C3 GHC.Types.Int
-
-TH_reifyDecl1.hs:63:10:
-    type family TH_reifyDecl1.AT1 a_0 :: * -> *
+type family TH_reifyDecl1.AT1 a_0 :: * -> *
 type instance TH_reifyDecl1.AT1 GHC.Types.Int = GHC.Types.Bool
-
-TH_reifyDecl1.hs:63:10:
-    data family TH_reifyDecl1.AT2 a_0 :: * -> *
+data family TH_reifyDecl1.AT2 a_0 :: * -> *
 data instance TH_reifyDecl1.AT2 GHC.Types.Int
     = TH_reifyDecl1.AT2Int
-
-TH_reifyDecl1.hs:63:10: type family TH_reifyDecl1.TF1 a_0 :: * -> *
-
-TH_reifyDecl1.hs:63:10:
-    type family TH_reifyDecl1.TF2 a_0 :: * -> *
+type family TH_reifyDecl1.TF1 a_0 :: * -> *
+type family TH_reifyDecl1.TF2 a_0 :: * -> *
 type instance TH_reifyDecl1.TF2 GHC.Types.Bool = GHC.Types.Bool
-
-TH_reifyDecl1.hs:63:10: data family TH_reifyDecl1.DF1 a_0 :: * -> *
-
-TH_reifyDecl1.hs:63:10:
-    data family TH_reifyDecl1.DF2 a_0 :: * -> *
+data family TH_reifyDecl1.DF1 a_0 :: * -> *
+data family TH_reifyDecl1.DF2 a_0 :: * -> *
 data instance TH_reifyDecl1.DF2 GHC.Types.Bool
     = TH_reifyDecl1.DBool
index c5d5ebe..7c4d719 100644 (file)
@@ -2,12 +2,13 @@
 
 module Foo where
 
+import System.IO
 import Language.Haskell.TH
 
 type C = Int
 
 $(do
   a <- reify $ mkName "C"
-  report False $ show a
+  runIO $ hPutStrLn stderr (show a)
   return []
   )
index 0537f1d..a82707f 100644 (file)
@@ -1,3 +1 @@
-
-TH_reifyMkName.hs:9:3:
-    TyConI (TySynD Foo.C [] (ConT GHC.Types.Int))
+TyConI (TySynD Foo.C [] (ConT GHC.Types.Int))
index ea4c0e8..04d55b4 100644 (file)
@@ -1,4 +1,4 @@
-
-B.hs:7:10:
-    Warning: No explicit method nor default method for `row'
-    In the instance declaration for `Matrix Bool Val'
+\r
+B.hs:7:10:\r
+    Warning: No explicit method or default declaration for `row'\r
+    In the instance declaration for `Matrix Bool Val'\r
index 4dd98e2..2b2fee3 100644 (file)
@@ -1,25 +1,25 @@
-\r
-FD2.hs:26:36:\r
-    Could not deduce (e1 ~ e)\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:(22,3)-(26,39)\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:(25,12)-(26,39)\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:25:12\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:22:3\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:36:
+    Could not deduce (e ~ e1)
+    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:(22,3)-(26,39)
+    or from (Elem a e1)
+      bound by the type signature for
+                 mf :: Elem a e1 => e1 -> Maybe e1 -> Maybe e1
+      at FD2.hs:(25,12)-(26,39)
+      `e' is a rigid type variable bound by
+          the type signature for
+            foldr1 :: Elem a e => (e -> e -> e) -> a -> e
+          at FD2.hs:22:3
+      `e1' is a rigid type variable bound by
+           the type signature for
+             mf :: Elem a e1 => e1 -> Maybe e1 -> Maybe e1
+           at FD2.hs:25:12
+    In the first argument of `f', namely `x'
+    In the first argument of `Just', namely `(f x y)'
+    In the expression: Just (f x y)
index 5e5661e..765858e 100644 (file)
@@ -1,22 +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:46\r
-      `a' is a rigid type variable bound by\r
-          the RULE "foo/foo" at T2494.hs:13:46\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
-\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:46\r
-      `a' is a rigid type variable bound by\r
-          the RULE "foo/foo" at T2494.hs:13:46\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
+
+T2494.hs:15:7:
+    Couldn't match type `b' with `a'
+      `b' is a rigid type variable bound by
+          the RULE "foo/foo" at T2494.hs:14:46
+      `a' is a rigid type variable bound by
+          the RULE "foo/foo" at T2494.hs:13:46
+    Expected type: Maybe (m b) -> Maybe (m b)
+      Actual type: Maybe (m a) -> Maybe (m a)
+    In the first argument of `foo', namely `f'
+    In the expression: foo f (foo g x)
+    When checking the transformation rule "foo/foo"
+
+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:46
+      `a' is a rigid type variable bound by
+          the RULE "foo/foo" at T2494.hs:13:46
+    Expected type: Maybe (m b) -> 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 c944dc1..50d2deb 100644 (file)
@@ -1,4 +1,4 @@
 
-T4912.hs:10:10: Warning: orphan instance: instance Foo TheirData
+T4912.hs:10:10: Warning: Orphan instance: instance Foo TheirData
 
-T4912.hs:13:10: Warning: orphan instance: instance Bar OurData
+T4912.hs:13:10: Warning: Orphan instance: instance Bar OurData
index 3a97b3f..cbaa0ac 100644 (file)
@@ -5,6 +5,8 @@ tc168.hs:17:1:
     from the context (C a1 (a, b))
       bound by the inferred type for `g': C a1 (a, b) => a1 -> a
       at tc168.hs:17:1-16
+    The type variable `b0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
     Possible fix: add an instance declaration for (C a1 (a, b0))
     When checking that `g'
       has the inferred type `forall a b a1. C a1 (a, b) => a1 -> a'
index 30d986c..e6c5675 100644 (file)
@@ -1,25 +1,24 @@
 
 tc211.hs:15:22:
-    Couldn't match expected type `a -> a'
-                with actual type `forall a1. a1 -> a1'
-      Expected type: [a -> a]
-        Actual type: [forall a1. a1 -> a1]
+    Couldn't match type `forall a1. a1 -> a1' with `a -> a'
+    Expected type: [a -> a]
+      Actual type: [forall a. a -> a]
     In the first argument of `head', namely `foo'
     In the first argument of `(:) ::
                                 (forall a. a -> a)
                                 -> [forall a. a -> a] -> [forall a. a -> a]', namely
       `(head foo)'
+    In the expression:
+      ((:) ::
+         (forall a. a -> a) -> [forall a. a -> a] -> [forall a. a -> a])
+        (head foo) foo
 
 tc211.hs:70:9:
-    Couldn't match expected type `a -> a'
-                with actual type `forall a1. a1 -> a1'
-      Expected type: List (forall a1. a1 -> a1)
-                     -> (forall a1. a1 -> a1)
-                     -> a
-                     -> a
-        Actual type: List (forall a1. a1 -> a1)
-                     -> (forall a1. a1 -> a1)
-                     -> forall a1. a1 -> a1
+    Couldn't match type `forall a1. a1 -> a1' with `a -> a'
+    Expected type: List (forall a. a -> a)
+                   -> (forall a. a -> a) -> a -> a
+      Actual type: List (forall a. a -> a)
+                   -> (forall a. a -> a) -> forall a. a -> a
     In the expression:
         foo2 ::
           List (forall a. a -> a) -> (forall a. a -> a) -> (forall a. a -> a)
@@ -28,3 +27,9 @@ tc211.hs:70:9:
          List (forall a. a -> a)
          -> (forall a. a -> a) -> (forall a. a -> a))
         xs1 (\ x -> x)
+    In an equation for `bar4':
+        bar4
+          = (foo2 ::
+               List (forall a. a -> a)
+               -> (forall a. a -> a) -> (forall a. a -> a))
+              xs1 (\ x -> x)
index 193d356..f5a49c8 100644 (file)
@@ -1,73 +1,70 @@
-\r
-FrozenErrorTests.hs:11:1:\r
-    Couldn't match type `a' with `T a'\r
-      `a' is a rigid type variable bound by\r
-          the type signature for foo :: a ~ T a => a -> a\r
-          at FrozenErrorTests.hs:11:1\r
-    Inaccessible code in\r
-      the type signature for foo :: a ~ T a => a -> a\r
-\r
-FrozenErrorTests.hs:14:12:\r
-    Couldn't match type `b' with `T b'\r
-      `b' is a rigid type variable bound by\r
-          a pattern with constructor\r
-            MkT2 :: forall a b. b ~ T b => b -> T a,\r
-          in a case alternative\r
-          at FrozenErrorTests.hs:14:12\r
-    Inaccessible code in\r
-      a pattern with constructor\r
-        MkT2 :: forall a b. b ~ T b => b -> T a,\r
-      in a case alternative\r
-    In the pattern: MkT2 y\r
-    In a case alternative: MkT2 y -> ()\r
-    In the expression: case x of { MkT2 y -> () }\r
-\r
-FrozenErrorTests.hs:19:12:\r
-    Couldn't match type `Int' with `Bool'\r
-    Inaccessible code in\r
-      a pattern with constructor\r
-        MkT3 :: forall a. a ~ Bool => T a,\r
-      in a case alternative\r
-    In the pattern: MkT3\r
-    In a case alternative: MkT3 -> ()\r
-    In the expression: case x of { MkT3 -> () }\r
-\r
-FrozenErrorTests.hs:33:9:\r
-    Occurs check: cannot construct the infinite type: a0 = [a0]\r
-    In the expression: goo1 False undefined\r
-    In an equation for `test1': test1 = goo1 False undefined\r
-\r
-FrozenErrorTests.hs:36:15:\r
-    Couldn't match type `[Int]' with `Int'\r
-    In the first argument of `goo2', namely `(goo1 False undefined)'\r
-    In the expression: goo2 (goo1 False undefined)\r
-    In an equation for `test2': test2 = goo2 (goo1 False undefined)\r
-\r
-FrozenErrorTests.hs:37:9:\r
-    Couldn't match type `Int' with `[Int]'\r
-    In the expression: goo1 False (goo2 undefined)\r
-    In an equation for `test3': test3 = goo1 False (goo2 undefined)\r
-\r
-FrozenErrorTests.hs:52:15:\r
-    Occurs check: cannot construct the infinite type:\r
-      c0 = T2 (T2 c0 c0) c0\r
-    In the first argument of `goo4', namely `(goo3 False undefined)'\r
-    In the expression: goo4 (goo3 False undefined)\r
-    In an equation for `test4': test4 = goo4 (goo3 False undefined)\r
-\r
-FrozenErrorTests.hs:52:15:\r
-    Couldn't match type `T2 c0' with `M'\r
-    In the first argument of `goo4', namely `(goo3 False undefined)'\r
-    In the expression: goo4 (goo3 False undefined)\r
-    In an equation for `test4': test4 = goo4 (goo3 False undefined)\r
-\r
-FrozenErrorTests.hs:53:9:\r
-    Occurs check: cannot construct the infinite type:\r
-      c0 = T2 (T2 c0 c0) c0\r
-    In the expression: goo3 False (goo4 undefined)\r
-    In an equation for `test5': test5 = goo3 False (goo4 undefined)\r
-\r
-FrozenErrorTests.hs:53:9:\r
-    Couldn't match type `T2 c0' with `M'\r
-    In the expression: goo3 False (goo4 undefined)\r
-    In an equation for `test5': test5 = goo3 False (goo4 undefined)\r
+
+FrozenErrorTests.hs:11:1:
+    Couldn't match type `a' with `T a'
+      `a' is a rigid type variable bound by
+          the type signature for foo :: a ~ T a => a -> a
+          at FrozenErrorTests.hs:11:1
+    Inaccessible code in
+      the type signature for foo :: a ~ T a => a -> a
+
+FrozenErrorTests.hs:14:12:
+    Couldn't match type `b' with `T b'
+      `b' is a rigid type variable bound by
+          a pattern with constructor
+            MkT2 :: forall a b. b ~ T b => b -> T a,
+          in a case alternative
+          at FrozenErrorTests.hs:14:12
+    Inaccessible code in
+      a pattern with constructor
+        MkT2 :: forall a b. b ~ T b => b -> T a,
+      in a case alternative
+    In the pattern: MkT2 y
+    In a case alternative: MkT2 y -> ()
+    In the expression: case x of { MkT2 y -> () }
+
+FrozenErrorTests.hs:19:12:
+    Couldn't match type `Int' with `Bool'
+    Inaccessible code in
+      a pattern with constructor
+        MkT3 :: forall a. a ~ Bool => T a,
+      in a case alternative
+    In the pattern: MkT3
+    In a case alternative: MkT3 -> ()
+    In the expression: case x of { MkT3 -> () }
+
+FrozenErrorTests.hs:33:9:
+    Occurs check: cannot construct the infinite type: a0 = [a0]
+    Expected type: [a0]
+      Actual type: F a0 Bool
+    In the expression: goo1 False undefined
+    In an equation for `test1': test1 = goo1 False undefined
+
+FrozenErrorTests.hs:36:15:
+    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)'
+    In the expression: goo2 (goo1 False undefined)
+    In an equation for `test2': test2 = goo2 (goo1 False undefined)
+
+FrozenErrorTests.hs:37:9:
+    Couldn't match type `Int' with `[Int]'
+    Expected type: [[Int]]
+      Actual type: F [Int] Bool
+    In the expression: goo1 False (goo2 undefined)
+    In an equation for `test3': test3 = goo1 False (goo2 undefined)
+
+FrozenErrorTests.hs:52:15:
+    Couldn't match type `T2 c0 c0' with `M (T2 (T2 c0 c0) c0)'
+    Expected type: T2 (M (T2 (T2 c0 c0) c0)) (T2 (T2 c0 c0) c0)
+      Actual type: F (T2 (T2 c0 c0) c0) Bool
+    In the first argument of `goo4', namely `(goo3 False undefined)'
+    In the expression: goo4 (goo3 False undefined)
+    In an equation for `test4': test4 = goo4 (goo3 False undefined)
+
+FrozenErrorTests.hs:53:9:
+    Couldn't match type `T2 c0 c0' with `M (T2 (T2 c0 c0) c0)'
+    Expected type: T2 (M (T2 (T2 c0 c0) c0)) (T2 (T2 c0 c0) c0)
+      Actual type: F (T2 (T2 c0 c0) c0) Bool
+    In the expression: goo3 False (goo4 undefined)
+    In an equation for `test5': test5 = goo3 False (goo4 undefined)
index bbbf826..6e5ee1c 100644 (file)
@@ -1,8 +1,12 @@
 
 T1897a.hs:9:1:
-    Ambiguous type variable `a0' in the constraint:
-      (Wob a0 b) arising from the ambiguity check for `foo'
-    Probable fix: add a type signature that fixes these type variable(s)
+    Could not deduce (Wob a0 b)
+      arising from the ambiguity check for `foo'
+    from the context (Wob a b)
+      bound by the inferred type for `foo': Wob a b => b -> [b]
+      at T1897a.hs:9:1-24
+    The type variable `a0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
     When checking that `foo'
       has the inferred type `forall a b. Wob a b => b -> [b]'
     Probable cause: the inferred type is ambiguous
index b0c0173..5779301 100644 (file)
@@ -1,10 +1,11 @@
-\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:10:2\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
+
+T1899.hs:14:36:
+    Couldn't match type `a' with `Proposition a0'
+      `a' is a rigid type variable bound by
+          the type signature for transRHS :: [a] -> Int -> Constraint a
+          at T1899.hs:10:2
+    Expected type: [Proposition a0]
+      Actual type: [a]
+    In the first argument of `Auxiliary', namely `varSet'
+    In the first argument of `Prop', namely `(Auxiliary varSet)'
+    In the expression: Prop (Auxiliary varSet)
index 030bf6e..5fa8f00 100644 (file)
@@ -5,3 +5,4 @@ T2414.hs:9:13:
       Actual type: b0 -> Maybe b0
     In the first argument of `unfoldr', namely `Just'
     In the expression: unfoldr Just
+    In an equation for `f': f = unfoldr Just
index a658d73..aa89656 100644 (file)
@@ -1,13 +1,13 @@
-\r
-T2688.hs:8:22:\r
-    Could not deduce (s ~ v)\r
-    from the context (VectorSpace v s)\r
-      bound by the class declaration for `VectorSpace'\r
-      at T2688.hs:(5,1)-(8,23)\r
-      `s' is a rigid type variable bound by\r
-          the class declaration for `VectorSpace' at T2688.hs:5:21\r
-      `v' is a rigid type variable bound by\r
-          the class declaration for `VectorSpace' at T2688.hs:5:19\r
-    In the second argument of `(/)', namely `s'\r
-    In the second argument of `(*^)', namely `(1 / s)'\r
-    In the expression: v *^ (1 / s)\r
+
+T2688.hs:8:22:
+    Could not deduce (v ~ s)
+    from the context (VectorSpace v s)
+      bound by the class declaration for `VectorSpace'
+      at T2688.hs:(5,1)-(8,23)
+      `v' is a rigid type variable bound by
+          the class declaration for `VectorSpace' at T2688.hs:5:19
+      `s' is a rigid type variable bound by
+          the class declaration for `VectorSpace' at T2688.hs:5:21
+    In the second argument of `(/)', namely `s'
+    In the second argument of `(*^)', namely `(1 / s)'
+    In the expression: v *^ (1 / s)
index da355fc..18e36fa 100644 (file)
@@ -14,8 +14,6 @@ T2714.hs:8:5:
       `c' is a rigid type variable bound by
           the type signature for f :: ((a -> b) -> b) -> c -> a
           at T2714.hs:8:1
-    Expected type: c
-      Actual type: f0 (a -> b)
     Expected type: ((a -> b) -> b) -> c -> a
       Actual type: ((a -> b) -> b) -> f0 (a -> b) -> f0 b
     In the expression: ffmap
index 79527c1..de90637 100644 (file)
@@ -2,6 +2,8 @@
 T2846b.hs:5:5:
     No instance for (Show (Num a0 => a0))
       arising from a use of `show'
+    The type variable `a0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
     Possible fix: add an instance declaration for (Show (Num a0 => a0))
     In the expression: show ([1, 2, 3] :: [Num a => a])
     In an equation for `f': f = show ([1, 2, 3] :: [Num a => a])
index cf34838..0cf9d52 100644 (file)
@@ -7,3 +7,4 @@ T3102.hs:11:12:
       Actual type: ((?p::Int) => a0) -> String
     In the first argument of `f', namely `t'
     In the expression: f t
+    In an equation for `result': result = f t
index feb4641..1373b71 100644 (file)
@@ -1,12 +1,16 @@
 
 T3613.hs:14:20:
-    Couldn't match expected type `Maybe a0' with actual type `IO ()'
+    Couldn't match type `IO' with `Maybe'
+    Expected type: Maybe ()
+      Actual type: IO ()
     In the first argument of `(>>)', namely `bar'
     In the first argument of `fooThen', namely `(bar >> undefined)'
     In the expression: fooThen (bar >> undefined)
 
 T3613.hs:17:24:
-    Couldn't match expected type `Maybe a0' with actual type `IO ()'
+    Couldn't match type `IO' with `Maybe'
+    Expected type: Maybe ()
+      Actual type: IO ()
     In a stmt of a 'do' block: bar
     In the first argument of `fooThen', namely
       `(do { bar;
index 8e6f948..c8d8340 100644 (file)
@@ -1,7 +1,13 @@
-\r
-T3950.hs:15:13:\r
-    Couldn't match expected type `Id p' with actual type `Id p x0'\r
-    Expected type: w (Id p)\r
-      Actual type: Sealed (Id p x0)\r
-    In the first argument of `Just', namely rp'\r
-    In the expression: Just rp'\r
+
+T3950.hs:15:13:
+    Couldn't match type `Id p0 x0' with `Id p'
+    Expected type: w (Id p)
+      Actual type: Sealed (Id p0 x0)
+    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 76f6de2..a2da439 100644 (file)
@@ -1,20 +1,10 @@
-\r
-T5236.hs:17:5:\r
-    Couldn't match type `A' with `B'\r
-    When using functional dependencies to combine\r
-      Id A A,\r
-        arising from the dependency `a -> b'\r
-        in the instance declaration at T5236.hs:10:10\r
-      Id A B, arising from a use of `loop' at T5236.hs:17:5-8\r
-    In the expression: loop\r
-    In an equation for `f': f = loop\r
-\r
-T5236.hs:17:5:\r
-    Couldn't match type `B' with `A'\r
-    When using functional dependencies to combine\r
-      Id B B,\r
-        arising from the dependency `b -> a'\r
-        in the instance declaration at T5236.hs:11:10\r
-      Id A B, arising from a use of `loop' at T5236.hs:17:5-8\r
-    In the expression: loop\r
-    In an equation for `f': f = loop\r
+
+T5236.hs:17:5:
+    Couldn't match type `A' with `B'
+    When using functional dependencies to combine
+      Id A A,
+        arising from the dependency `a -> b'
+        in the instance declaration at T5236.hs:10:10
+      Id A B, arising from a use of `loop' at T5236.hs:17:5-8
+    In the expression: loop
+    In an equation for `f': f = loop
index bc3bc06..a051692 100644 (file)
@@ -1,8 +1,13 @@
 
 T5300.hs:15:9:
-    Ambiguous type variable `c0' in the constraint:
-      (C1 a1 b2 c0) arising from a use of `f1'
-    Probable fix: add a type signature that fixes these type variable(s)
+    Could not deduce (C1 a1 b2 c0) arising from a use of `f1'
+    from the context (Monad m, C1 a1 b1 c1, C2 a2 b2 c2)
+      bound by the type signature for
+                 f2 :: (Monad m, C1 a1 b1 c1, C2 a2 b2 c2) =>
+                       a1 -> StateT (T b2) m a2
+      at T5300.hs:15:1-36
+    The type variable `c0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
     In the first argument of `(>>=)', namely `f1 fm'
     In the expression: f1 fm >>= return . undefined
     In an equation for `f2': f2 fm = f1 fm >>= return . undefined
index 7c599cc..52aa99a 100644 (file)
@@ -3,7 +3,7 @@ T5573a.hs:11:16:
     Couldn't match kind `ArgKind' against `(#)'
     Kind incompatibility when matching types:
       t0 :: ArgKind
-      (# t1, t2 #) :: (#)
+      (# t0, t1 #) :: (#)
     In the expression: (# True, False #)
     In the expression: (# x, (# True, False #) #)
 
@@ -11,6 +11,6 @@ T5573a.hs:14:6:
     Couldn't match kind `ArgKind' against `(#)'
     Kind incompatibility when matching types:
       t0 :: ArgKind
-      (# t1, t2 #) :: (#)
+      (# t0, t1 #) :: (#)
     In the pattern: (# x, y #)
     In an equation for `foo3': foo3 (# x, y #) = x
index 0d02978..0aa8b17 100644 (file)
@@ -1,20 +1,10 @@
-
-T5684.hs:24:12:
-    No instance for (B Char b5)
-      arising from a use of `op'
-    Possible fix: add an instance declaration for (B Char b5)
-    In the expression: op 'c' undefined
-    In the expression:
-      [op False False, op 'c' undefined, op True undefined]
-    In an equation for `flop1':
-        flop1 = [op False False, op 'c' undefined, op True undefined]
-
-T5684.hs:53:12:
-    No instance for (A Bool)
-      arising from a use of `op'
-    Possible fix: add an instance declaration for (A Bool)
-    In the expression: op False False
-    In the expression:
-      [op True undefined, op False False, op 'c' undefined]
-    In an equation for `flop6':
-        flop6 = [op True undefined, op False False, op 'c' undefined]
+\r
+T5684.hs:53:12:\r
+    No instance for (A Bool)\r
+      arising from a use of `op'\r
+    Possible fix: add an instance declaration for (A Bool)\r
+    In the expression: op False False\r
+    In the expression:\r
+      [op True undefined, op False False, op 'c' undefined]\r
+    In an equation for `flop6':\r
+        flop6 = [op True undefined, op False False, op 'c' undefined]\r
index cad433a..28f9c01 100644 (file)
@@ -1,7 +1,7 @@
-\r
-T5689.hs:10:36:\r
-    Couldn't match type `t' with `Bool'\r
-    In the expression: v\r
-    In the expression: if v then False else True\r
-    In the second argument of `writeIORef', namely\r
-      `(\ v -> if v then False else True)'\r
+
+T5689.hs:10:36:
+    Couldn't match expected type `t' with actual type `Bool'
+    In the expression: v
+    In the expression: if v then False else True
+    In the second argument of `writeIORef', namely
+      `(\ v -> if v then False else True)'
index 3585f4a..0459783 100644 (file)
@@ -67,7 +67,7 @@ test('tcfail076', normal, compile_fail, [''])
 test('tcfail077', normal, compile_fail, [''])
 test('tcfail078', normal, compile_fail, [''])
 test('tcfail079', only_compiler_types(['ghc']), compile_fail, [''])
-test('tcfail080', if_compiler_type('ghc', expect_fail), compile_fail, [''])
+test('tcfail080', normal, compile_fail, [''])
 test('tcfail082', normal, compile_fail, [''])
 test('tcfail083', normal, compile_fail, [''])
 test('tcfail084', normal, compile_fail, [''])
index b75e90a..7015d47 100644 (file)
@@ -1,9 +1,10 @@
-\r
-mc19.hs:10:31:\r
-    Couldn't match type `a' with `[a]'\r
-      `a' is a rigid type variable bound by\r
-          a type expected by the context: [a] -> [a] at mc19.hs:10:26\r
-    Expected type: [a] -> [a]\r
-      Actual type: [a] -> [[a]]\r
-    In the expression: inits\r
-    In a stmt of a monad comprehension: then inits\r
+
+mc19.hs:10:31:
+    Couldn't match type `a' with `[a]'
+      `a' is a rigid type variable bound by
+          a type expected by the context: [a] -> [a] at mc19.hs:10:26
+    Expected type: [a] -> [a]
+      Actual type: [a] -> [[a]]
+    In the expression: inits
+    In a stmt of a monad comprehension: then inits
+    In the expression: [x | x <- [3, 2, 1], then inits]
index 1e958c8..bd7bac1 100644 (file)
@@ -1,9 +1,10 @@
-\r
-mc21.hs:12:26:\r
-    Couldn't match type `a' with `[a]'\r
-      `a' is a rigid type variable bound by\r
-          a type expected by the context: [a] -> [[a]] at mc21.hs:12:9\r
-    Expected type: [a] -> [[a]]\r
-      Actual type: [a] -> [a]\r
-    In the return type of a call of `take'\r
-    In the expression: take 5\r
+
+mc21.hs:12:26:
+    Couldn't match type `a' with `[a]'
+      `a' is a rigid type variable bound by
+          a type expected by the context: [a] -> [[a]] at mc21.hs:12:9
+    Expected type: [a] -> [[a]]
+      Actual type: [a] -> [a]
+    In the return type of a call of `take'
+    In the expression: take 5
+    In a stmt of a monad comprehension: then group using take 5
index 57d9a01..a309d3b 100644 (file)
@@ -1,9 +1,32 @@
-\r
-mc22.hs:10:26:\r
-    Couldn't match type `a' with `t0 a'\r
-      `a' is a rigid type variable bound by\r
-          a type expected by the context: [a] -> [t0 a] at mc22.hs:10:9\r
-    Expected type: [a] -> [t0 a]\r
-      Actual type: [a] -> [a]\r
-    In the return type of a call of `take'\r
-    In the expression: take 5\r
+
+mc22.hs:8:11:
+    No instance for (Num (t0 [Char]))
+      arising from a use of `+'
+    The type variable `t0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
+    Possible fix: add an instance declaration for (Num (t0 [Char]))
+    In the expression: x + 1
+    In the expression:
+      [x + 1 | x <- ["Hello", "World"], then group using take 5]
+    In an equation for `foo':
+        foo = [x + 1 | x <- ["Hello", "World"], then group using take 5]
+
+mc22.hs:10:9:
+    No instance for (Functor t0)
+      arising from a use of `fmap'
+    The type variable `t0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
+    In the expression: fmap
+    In a stmt of a monad comprehension: then group using take 5
+    In the expression:
+      [x + 1 | x <- ["Hello", "World"], then group using take 5]
+
+mc22.hs:10:26:
+    Couldn't match type `a' with `t0 a'
+      `a' is a rigid type variable bound by
+          a type expected by the context: [a] -> [t0 a] at mc22.hs:10:9
+    Expected type: [a] -> [t0 a]
+      Actual type: [a] -> [a]
+    In the return type of a call of `take'
+    In the expression: take 5
+    In a stmt of a monad comprehension: then group using take 5
index ec632f8..6e69a1d 100644 (file)
@@ -1,8 +1,36 @@
 
+mc23.hs:9:15:
+    No instance for (Enum b0)
+      arising from the arithmetic sequence `1 .. 10'
+    The type variable `b0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
+    In a stmt of a monad comprehension: x <- [1 .. 10]
+    In a stmt of a monad comprehension: then take 5 by x
+    In the expression: [x | x <- [1 .. 10], then take 5 by x]
+
+mc23.hs:9:16:
+    No instance for (Num b0)
+      arising from the literal `1'
+    The type variable `b0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
+    In the expression: 1
+    In a stmt of a monad comprehension: x <- [1 .. 10]
+    In a stmt of a monad comprehension: then take 5 by x
+
+mc23.hs:9:24:
+    No instance for (Monad t0)
+      arising from a statement in a monad comprehension
+    The type variable `t0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
+    In a stmt of a monad comprehension: then take 5 by x
+    In the expression: [x | x <- [1 .. 10], then take 5 by x]
+    In an equation for `z': z = [x | x <- [1 .. 10], then take 5 by x]
+
 mc23.hs:9:29:
-    Couldn't match expected type `a -> t0' with actual type `[a0]'
-    Expected type: (a -> t0) -> [a] -> t1 a
+    Couldn't match type `[a0]' with `a -> b0'
+    Expected type: (a -> b0) -> [a] -> t0 a
       Actual type: [a0] -> [a0]
     In the return type of a call of `take'
     Probable cause: `take' is applied to too many arguments
     In the expression: take 5
+    In a stmt of a monad comprehension: then take 5 by x
index bee1592..4856dc7 100644 (file)
@@ -1,8 +1,39 @@
 
+mc24.hs:9:14:
+    No instance for (Enum a1)
+      arising from the arithmetic sequence `1 .. 10'
+    The type variable `a1' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
+    In a stmt of a monad comprehension: x <- [1 .. 10]
+    In a stmt of a monad comprehension: then group by x using take 2
+    In the expression:
+      [length x | x <- [1 .. 10], then group by x using take 2]
+
+mc24.hs:9:15:
+    No instance for (Num a1)
+      arising from the literal `1'
+    The type variable `a1' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
+    In the expression: 1
+    In a stmt of a monad comprehension: x <- [1 .. 10]
+    In a stmt of a monad comprehension: then group by x using take 2
+
+mc24.hs:10:9:
+    No instance for (Monad t0)
+      arising from a statement in a monad comprehension
+    The type variable `t0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
+    In a stmt of a monad comprehension: then group by x using take 2
+    In the expression:
+      [length x | x <- [1 .. 10], then group by x using take 2]
+    In an equation for `foo':
+        foo = [length x | x <- [1 .. 10], then group by x using take 2]
+
 mc24.hs:10:31:
-    Couldn't match expected type `a -> t0' with actual type `[a0]'
-    Expected type: (a -> t0) -> [a] -> t1 (t2 a)
+    Couldn't match type `[a0]' with `a -> a1'
+    Expected type: (a -> a1) -> [a] -> t0 [a]
       Actual type: [a0] -> [a0]
     In the return type of a call of `take'
     Probable cause: `take' is applied to too many arguments
     In the expression: take 2
+    In a stmt of a monad comprehension: then group by x using take 2
index 7016fad..71559fb 100644 (file)
@@ -1,7 +1,35 @@
 
+mc25.hs:9:15:
+    No instance for (Enum t0)
+      arising from the arithmetic sequence `1 .. 10'
+    The type variable `t0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
+    In a stmt of a monad comprehension: x <- [1 .. 10]
+    In a stmt of a monad comprehension: then group by x using take
+    In the expression: [x | x <- [1 .. 10], then group by x using take]
+
+mc25.hs:9:16:
+    No instance for (Num t0)
+      arising from the literal `1'
+    The type variable `t0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
+    In the expression: 1
+    In a stmt of a monad comprehension: x <- [1 .. 10]
+    In a stmt of a monad comprehension: then group by x using take
+
+mc25.hs:9:24:
+    No instance for (Functor t1)
+      arising from a use of `fmap'
+    The type variable `t1' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
+    In the expression: fmap
+    In a stmt of a monad comprehension: then group by x using take
+    In the expression: [x | x <- [1 .. 10], then group by x using take]
+
 mc25.hs:9:46:
-    Couldn't match expected type `a -> t0' with actual type `Int'
-    Expected type: (a -> t0) -> [a] -> t1 (t2 a)
-      Actual type: Int -> [a0] -> [a0]
+    Couldn't match type `Int' with `a -> t0'
+    Expected type: (a -> t0) -> [a] -> [t1 a]
+      Actual type: Int -> [a] -> [a]
     In the expression: take
     In a stmt of a monad comprehension: then group by x using take
+    In the expression: [x | x <- [1 .. 10], then group by x using take]
index 5fadcf6..7c9b8ba 100644 (file)
@@ -1,5 +1,6 @@
 
 tcfail001.hs:9:2:
+    Couldn't match expected type `[t0] -> [a0]' with actual type `[a]'
     The equation(s) for `op' have one argument,
     but its type `[a]' has none
     In the instance declaration for `A [a]'
index 8a158f5..66e6fa9 100644 (file)
@@ -1,5 +1,5 @@
 
 tcfail005.hs:3:9:
-    Couldn't match expected type `[t0]' with actual type `(t1, t2)'
+    Couldn't match expected type `[t0]' with actual type `(t1, Char)'
     In the expression: (1, 'a')
     In a pattern binding: (h : i) = (1, 'a')
index 2d31ee6..a6d97c7 100644 (file)
@@ -1,7 +1,24 @@
 
+tcfail008.hs:3:5:
+    No instance for (Num a0)
+      arising from the literal `1'
+    The type variable `a0' is ambiguous
+    Possible cause: the monomorphism restriction applied to the following:
+      o :: [a0] (bound at tcfail008.hs:3:1)
+    Probable fix: give these definition(s) an explicit type signature
+                  or use -XNoMonomorphismRestriction
+    In the first argument of `(:)', namely `1'
+    In the expression: 1 : 2
+    In an equation for `o': o = 1 : 2
+
 tcfail008.hs:3:7:
     No instance for (Num [a0])
       arising from the literal `2'
+    The type variable `a0' is ambiguous
+    Possible cause: the monomorphism restriction applied to the following:
+      o :: [a0] (bound at tcfail008.hs:3:1)
+    Probable fix: give these definition(s) an explicit type signature
+                  or use -XNoMonomorphismRestriction
     Possible fix: add an instance declaration for (Num [a0])
     In the second argument of `(:)', namely `2'
     In the expression: 1 : 2
index 20a6d22..9371d51 100644 (file)
@@ -1,8 +1,13 @@
-\r
-tcfail010.hs:3:17:\r
-    No instance for (Num [t0])\r
-      arising from a use of `+'\r
-    Possible fix: add an instance declaration for (Num [t0])\r
-    In the expression: z + 2\r
-    In the expression: \ (y : z) -> z + 2\r
-    In an equation for `q': q = \ (y : z) -> z + 2\r
+
+tcfail010.hs:3:17:
+    No instance for (Num [t0])
+      arising from a use of `+'
+    The type variable `t0' is ambiguous
+    Possible cause: the monomorphism restriction applied to the following:
+      q :: [t0] -> [t0] (bound at tcfail010.hs:3:1)
+    Probable fix: give these definition(s) an explicit type signature
+                  or use -XNoMonomorphismRestriction
+    Possible fix: add an instance declaration for (Num [t0])
+    In the expression: z + 2
+    In the expression: \ (y : z) -> z + 2
+    In an equation for `q': q = \ (y : z) -> z + 2
index 6420918..6c1fa9c 100644 (file)
@@ -1,7 +1,16 @@
 
 tcfail016.hs:9:20:
-    Couldn't match expected type `Expr t0'
-                with actual type `AnnExpr t0'
+    Couldn't match type `(t0, Expr t0)' with `Expr t0'
+    Expected type: Expr t0
+      Actual type: AnnExpr t0
     In the first argument of `g', namely `e1'
     In the first argument of `(++)', namely `(g e1)'
     In the expression: (g e1) ++ (g e2)
+
+tcfail016.hs:9:28:
+    Couldn't match type `(t0, Expr t0)' with `Expr t0'
+    Expected type: Expr t0
+      Actual type: AnnExpr t0
+    In the first argument of `g', namely `e2'
+    In the second argument of `(++)', namely `(g e2)'
+    In the expression: (g e1) ++ (g e2)
index 67ee509..1aa1362 100644 (file)
@@ -2,6 +2,11 @@
 tcfail018.hs:5:10:
     No instance for (Num [t0])
       arising from the literal `1'
+    The type variable `t0' is ambiguous
+    Possible cause: the monomorphism restriction applied to the following:
+      a :: t0 (bound at tcfail018.hs:5:2)
+    Probable fix: give these definition(s) an explicit type signature
+                  or use -XNoMonomorphismRestriction
     Possible fix: add an instance declaration for (Num [t0])
     In the expression: 1
     In a pattern binding: (a : []) = 1
index 19020b6..cd5ef7a 100644 (file)
@@ -1,8 +1,9 @@
-\r
-tcfail040.hs:19:5:\r
-    Ambiguous type variable `a0' in the constraint:\r
-      (ORD a0) arising from a use of `<<'\r
-    Probable fix: add a type signature that fixes these type variable(s)\r
-    In the first argument of `(===)', namely `(<<)'\r
-    In the expression: (<<) === (<<)\r
-    In an equation for `f': f = (<<) === (<<)\r
+
+tcfail040.hs:19:5:
+    No instance for (ORD a0)
+      arising from a use of `<<'
+    The type variable `a0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
+    In the first argument of `(===)', namely `(<<)'
+    In the expression: (<<) === (<<)
+    In an equation for `f': f = (<<) === (<<)
index 7cd3faf..cf161d4 100644 (file)
@@ -1,21 +1,37 @@
-
-tcfail043.hs:38:17:
-    Ambiguous type variable `a0' in the constraints:
-      (Ord_ a0) arising from a use of `gt' at tcfail043.hs:38:17-18
-      (Eq_ a0) arising from a use of `eq' at tcfail043.hs:40:25-26
-    Possible cause: the monomorphism restriction applied to the following:
-      search :: a0 -> [a0] -> Bool (bound at tcfail043.hs:37:1)
-    Probable fix: give these definition(s) an explicit type signature
-                  or use -XNoMonomorphismRestriction
-    In the expression: gt (hd bs) a
-    In the expression:
-      if gt (hd bs) a then
-          False
-      else
-          if eq a (hd bs) then True else search a (tl bs)
-    In the expression:
-      \ a bs
-        -> if gt (hd bs) a then
-               False
-           else
-               if eq a (hd bs) then True else search a (tl bs)
+\r
+tcfail043.hs:38:17:\r
+    No instance for (Ord_ a0)\r
+      arising from a use of `gt'\r
+    The type variable `a0' is ambiguous\r
+    Possible cause: the monomorphism restriction applied to the following:\r
+      search :: a0 -> [a0] -> Bool (bound at tcfail043.hs:37:1)\r
+    Probable fix: give these definition(s) an explicit type signature\r
+                  or use -XNoMonomorphismRestriction\r
+    In the expression: gt (hd bs) a\r
+    In the expression:\r
+      if gt (hd bs) a then\r
+          False\r
+      else\r
+          if eq a (hd bs) then True else search a (tl bs)\r
+    In the expression:\r
+      \ a bs\r
+        -> if gt (hd bs) a then\r
+               False\r
+           else\r
+               if eq a (hd bs) then True else search a (tl bs)\r
+\r
+tcfail043.hs:40:25:\r
+    No instance for (Eq_ a0)\r
+      arising from a use of `eq'\r
+    The type variable `a0' is ambiguous\r
+    Possible cause: the monomorphism restriction applied to the following:\r
+      search :: a0 -> [a0] -> Bool (bound at tcfail043.hs:37:1)\r
+    Probable fix: give these definition(s) an explicit type signature\r
+                  or use -XNoMonomorphismRestriction\r
+    In the expression: eq a (hd bs)\r
+    In the expression: if eq a (hd bs) then True else search a (tl bs)\r
+    In the expression:\r
+      if gt (hd bs) a then\r
+          False\r
+      else\r
+          if eq a (hd bs) then True else search a (tl bs)\r
index 0621cd7..3e9aecf 100644 (file)
@@ -1,11 +1,11 @@
-\r
-tcfail065.hs:29:20:\r
-    Couldn't match type `x1' with `x'\r
-      `x1' is a rigid type variable bound by\r
-           the type signature for setX :: x1 -> X x -> X x\r
-           at tcfail065.hs:29:3\r
-      `x' is a rigid type variable bound by\r
-          the instance declaration at tcfail065.hs:28:18\r
-    In the first argument of `X', namely `x'\r
-    In the expression: X x\r
-    In an equation for `setX': setX x (X _) = X x\r
+
+tcfail065.hs:29:20:
+    Couldn't match expected type `x' with actual type `x1'
+      `x' is a rigid type variable bound by
+          the instance declaration at tcfail065.hs:28:18
+      `x1' is a rigid type variable bound by
+           the type signature for setX :: x1 -> X x -> X x
+           at tcfail065.hs:29:3
+    In the first argument of `X', namely `x'
+    In the expression: X x
+    In an equation for `setX': setX x (X _) = X x
index 039a4e6..513f5e9 100644 (file)
@@ -30,12 +30,12 @@ tcfail067.hs:46:12:
           = show value ++ " :" ++ show lower ++ ".." ++ show upper
 
 tcfail067.hs:61:12:
-    Could not deduce (Ord a, Show a)
+    Could not deduce (Show a, Ord a)
       arising from a use of `numSubRangeNegate'
     from the context (Num a)
       bound by the instance declaration at tcfail067.hs:60:10-34
     Possible fix:
-      add (Ord a, Show a) to the context of the instance declaration
+      add (Show a, Ord a) to the context of the instance declaration
     In the expression: numSubRangeNegate
     In an equation for `negate': negate = numSubRangeNegate
     In the instance declaration for `Num (SubRange a)'
index 286d0e8..11d3961 100644 (file)
@@ -1,91 +1,97 @@
-\r
-tcfail068.hs:14:9:\r
-    Could not deduce (s1 ~ s)\r
-    from the context (Constructed a)\r
-      bound by the type signature for\r
-                 itgen :: Constructed a => (Int, Int) -> a -> IndTree s a\r
-      at tcfail068.hs:(12,1)-(14,31)\r
-      `s1' is a rigid type variable bound by\r
-           a type expected by the context: GHC.ST.ST s1 (IndTree s a)\r
-           at tcfail068.hs:13:9\r
-      `s' is a rigid type variable bound by\r
-          the type signature for\r
-            itgen :: Constructed a => (Int, Int) -> a -> IndTree s a\r
-          at tcfail068.hs:12:1\r
-    Expected type: GHC.ST.ST s (IndTree s1 a)\r
-      Actual type: GHC.ST.ST s (STArray s (Int, Int) a)\r
-    In the return type of a call of `newSTArray'\r
-    In the first argument of `runST', namely\r
-      `(newSTArray ((1, 1), n) x)'\r
-\r
-tcfail068.hs:19:21:\r
-    Could not deduce (s ~ s1)\r
-    from the context (Constructed a)\r
-      bound by the type signature for\r
-                 itiap :: Constructed a =>\r
-                          (Int, Int) -> (a -> a) -> IndTree s a -> IndTree s a\r
-      at tcfail068.hs:(17,1)-(21,19)\r
-      `s' is a rigid type variable bound by\r
-          the type signature for\r
-            itiap :: Constructed a =>\r
-                     (Int, Int) -> (a -> a) -> IndTree s a -> IndTree s a\r
-          at tcfail068.hs:17:1\r
-      `s1' is a rigid type variable bound by\r
-           a type expected by the context: GHC.ST.ST s1 (IndTree s a)\r
-           at tcfail068.hs:18:9\r
-    Expected type: STArray s1 (Int, Int) a\r
-      Actual type: IndTree s a\r
-    In the first argument of `readSTArray', namely `arr'\r
-    In the first argument of `(>>=)', namely `readSTArray arr i'\r
-\r
-tcfail068.hs:24:35:\r
-    Could not deduce (s ~ s1)\r
-    from the context (Constructed a)\r
-      bound by the type signature for\r
-                 itrap :: Constructed a =>\r
-                          ((Int, Int), (Int, Int)) -> (a -> a) -> IndTree s a -> IndTree s a\r
-      at tcfail068.hs:(24,1)-(32,41)\r
-      `s' is a rigid type variable bound by\r
-          the type signature for\r
-            itrap :: Constructed a =>\r
-                     ((Int, Int), (Int, Int)) -> (a -> a) -> IndTree s a -> IndTree s a\r
-          at tcfail068.hs:24:1\r
-      `s1' is a rigid type variable bound by\r
-           a type expected by the context: GHC.ST.ST s1 (IndTree s a)\r
-           at tcfail068.hs:24:29\r
-    Expected type: GHC.ST.ST s1 (IndTree s a)\r
-      Actual type: GHC.ST.ST s (IndTree s a)\r
-    In the return type of a call of itrap'\r
-    In the first argument of `runST', namely `(itrap' i k)'\r
-\r
-tcfail068.hs:36:46:\r
-    Could not deduce (s ~ s1)\r
-    from the context (Constructed b)\r
-      bound by the type signature for\r
-                 itrapstate :: Constructed b =>\r
-                               ((Int, Int), (Int, Int))\r
-                               -> (a -> b -> (a, b))\r
-                               -> ((Int, Int) -> c -> a)\r
-                               -> (a -> c)\r
-                               -> c\r
-                               -> IndTree s b\r
-                               -> (c, IndTree s b)\r
-      at tcfail068.hs:(36,1)-(45,66)\r
-      `s' is a rigid type variable bound by\r
-          the type signature for\r
-            itrapstate :: Constructed b =>\r
-                          ((Int, Int), (Int, Int))\r
-                          -> (a -> b -> (a, b))\r
-                          -> ((Int, Int) -> c -> a)\r
-                          -> (a -> c)\r
-                          -> c\r
-                          -> IndTree s b\r
-                          -> (c, IndTree s b)\r
-          at tcfail068.hs:36:1\r
-      `s1' is a rigid type variable bound by\r
-           a type expected by the context: GHC.ST.ST s1 (c, IndTree s b)\r
-           at tcfail068.hs:36:40\r
-    Expected type: GHC.ST.ST s1 (c, IndTree s b)\r
-      Actual type: GHC.ST.ST s (c, IndTree s b)\r
-    In the return type of a call of itrapstate'\r
-    In the first argument of `runST', namely `(itrapstate' i k s)'\r
+
+tcfail068.hs:14:9:
+    Could not deduce (s1 ~ s)
+    from the context (Constructed a)
+      bound by the type signature for
+                 itgen :: Constructed a => (Int, Int) -> a -> IndTree s a
+      at tcfail068.hs:(12,1)-(14,31)
+      `s1' is a rigid type variable bound by
+           a type expected by the context: GHC.ST.ST s1 (IndTree s a)
+           at tcfail068.hs:13:9
+      `s' is a rigid type variable bound by
+          the type signature for
+            itgen :: Constructed a => (Int, Int) -> a -> IndTree s a
+          at tcfail068.hs:12:1
+    Expected type: GHC.ST.ST s1 (IndTree s a)
+      Actual type: GHC.ST.ST s1 (STArray s1 (Int, Int) a)
+    In the return type of a call of `newSTArray'
+    In the first argument of `runST', namely
+      `(newSTArray ((1, 1), n) x)'
+    In the expression: runST (newSTArray ((1, 1), n) x)
+
+tcfail068.hs:19:21:
+    Could not deduce (s ~ s1)
+    from the context (Constructed a)
+      bound by the type signature for
+                 itiap :: Constructed a =>
+                          (Int, Int) -> (a -> a) -> IndTree s a -> IndTree s a
+      at tcfail068.hs:(17,1)-(21,19)
+      `s' is a rigid type variable bound by
+          the type signature for
+            itiap :: Constructed a =>
+                     (Int, Int) -> (a -> a) -> IndTree s a -> IndTree s a
+          at tcfail068.hs:17:1
+      `s1' is a rigid type variable bound by
+           a type expected by the context: GHC.ST.ST s1 (IndTree s a)
+           at tcfail068.hs:18:9
+    Expected type: STArray s1 (Int, Int) a
+      Actual type: IndTree s a
+    In the first argument of `readSTArray', namely `arr'
+    In the first argument of `(>>=)', namely `readSTArray arr i'
+    In the first argument of `runST', namely
+      `(readSTArray arr i
+        >>= \ val -> writeSTArray arr i (f val) >> return arr)'
+
+tcfail068.hs:24:35:
+    Could not deduce (s ~ s1)
+    from the context (Constructed a)
+      bound by the type signature for
+                 itrap :: Constructed a =>
+                          ((Int, Int), (Int, Int)) -> (a -> a) -> IndTree s a -> IndTree s a
+      at tcfail068.hs:(24,1)-(32,41)
+      `s' is a rigid type variable bound by
+          the type signature for
+            itrap :: Constructed a =>
+                     ((Int, Int), (Int, Int)) -> (a -> a) -> IndTree s a -> IndTree s a
+          at tcfail068.hs:24:1
+      `s1' is a rigid type variable bound by
+           a type expected by the context: GHC.ST.ST s1 (IndTree s a)
+           at tcfail068.hs:24:29
+    Expected type: GHC.ST.ST s1 (IndTree s a)
+      Actual type: GHC.ST.ST s (IndTree s a)
+    In the return type of a call of itrap'
+    In the first argument of `runST', namely `(itrap' i k)'
+    In the expression: runST (itrap' i k)
+
+tcfail068.hs:36:46:
+    Could not deduce (s ~ s1)
+    from the context (Constructed b)
+      bound by the type signature for
+                 itrapstate :: Constructed b =>
+                               ((Int, Int), (Int, Int))
+                               -> (a -> b -> (a, b))
+                               -> ((Int, Int) -> c -> a)
+                               -> (a -> c)
+                               -> c
+                               -> IndTree s b
+                               -> (c, IndTree s b)
+      at tcfail068.hs:(36,1)-(45,66)
+      `s' is a rigid type variable bound by
+          the type signature for
+            itrapstate :: Constructed b =>
+                          ((Int, Int), (Int, Int))
+                          -> (a -> b -> (a, b))
+                          -> ((Int, Int) -> c -> a)
+                          -> (a -> c)
+                          -> c
+                          -> IndTree s b
+                          -> (c, IndTree s b)
+          at tcfail068.hs:36:1
+      `s1' is a rigid type variable bound by
+           a type expected by the context: GHC.ST.ST s1 (c, IndTree s b)
+           at tcfail068.hs:36:40
+    Expected type: GHC.ST.ST s1 (c, IndTree s b)
+      Actual type: GHC.ST.ST s (c, IndTree s b)
+    In the return type of a call of itrapstate'
+    In the first argument of `runST', namely `(itrapstate' i k s)'
+    In the expression: runST (itrapstate' i k s)
index 469e758..4d6bd86 100644 (file)
@@ -1,14 +1,11 @@
 
 tcfail072.hs:23:13:
-    Ambiguous type variable `p0' in the constraint:
-      (Ord p0) arising from a use of `g'
-    Probable fix: add a type signature that fixes these type variable(s)
-    In the expression: g A
-    In an equation for `g': g (B _ _) = g A
-
-tcfail072.hs:23:13:
-    Ambiguous type variable `q0' in the constraint:
-      (Ord q0) arising from a use of `g'
-    Probable fix: add a type signature that fixes these type variable(s)
+    Could not deduce (Ord p0, 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:23:1-15
+    The type variables `p0', `q0' are ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
     In the expression: g A
     In an equation for `g': g (B _ _) = g A
index 9c380de..4ca4cf4 100644 (file)
@@ -11,3 +11,4 @@ tcfail076.hs:18:82:
       Actual type: m res
     In the return type of a call of `cont'
     In the expression: cont a
+    In the first argument of `KContT', namely `(\ cont' -> cont a)'
index b2a62ce..fa77ad8 100644 (file)
@@ -11,7 +11,9 @@
 -- Of course, it'd be hard to fill in the "..." in this particular
 -- case, but that relies on observations about the form of the types
 -- of the class methods, surely beyond what a compiler should do.
--- That's why GHC accepts it
+--
+-- Still, the type is ambiguous because there's nothing to fix 'c'
+
 
 module ShouldFail where
 
index e69de29..5200786 100644 (file)
@@ -0,0 +1,14 @@
+
+tcfail080.hs:27:1:
+    Could not deduce (Collection c0 a)
+      arising from the ambiguity check for `q'
+    from the context (Collection c a)
+      bound by the inferred type for `q': Collection c a => a -> Bool
+      at tcfail080.hs:27:1-27
+    The type variable `c0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
+    When checking that `q'
+      has the inferred type `forall (c :: * -> *) a.
+                             Collection c a =>
+                             a -> Bool'
+    Probable cause: the inferred type is ambiguous
index f97c5a1..aa7eb99 100644 (file)
@@ -1,13 +1,13 @@
 
 tcfail099.hs:9:20:
-    Couldn't match type `t' with `a'
-      `t' is a rigid type variable bound by
-          the inferred type of call :: DS -> t -> Int at tcfail099.hs:9:1
+    Couldn't match expected type `a' with actual type `t'
       `a' is a rigid type variable bound by
           a pattern with constructor
             C :: forall a. (a -> Int) -> DS,
           in an equation for `call'
           at tcfail099.hs:9:7
+      `t' is a rigid type variable bound by
+          the inferred type of call :: DS -> t -> Int at tcfail099.hs:9:1
     In the first argument of `f', namely `arg'
     In the expression: f arg
     In an equation for `call': call (C f) arg = f arg
index 2602859..7d6e4df 100644 (file)
@@ -1,11 +1,12 @@
-\r
-tcfail103.hs:15:23:\r
-    Couldn't match type `t' with `s'\r
-      `t' is a rigid type variable bound by\r
-          the type signature for f :: ST t Int at tcfail103.hs:11:1\r
-      `s' is a rigid type variable bound by\r
-          the type signature for g :: ST s Int at tcfail103.hs:15:9\r
-    Expected type: STRef s Int\r
-      Actual type: STRef t Int\r
-    In the first argument of `readSTRef', namely `v'\r
-    In the expression: readSTRef v\r
+
+tcfail103.hs:15:23:
+    Couldn't match type `t' with `s'
+      `t' is a rigid type variable bound by
+          the type signature for f :: ST t Int at tcfail103.hs:11:1
+      `s' is a rigid type variable bound by
+          the type signature for g :: ST s Int at tcfail103.hs:15:9
+    Expected type: STRef s Int
+      Actual type: STRef t Int
+    In the first argument of `readSTRef', namely `v'
+    In the expression: readSTRef v
+    In an equation for `g': g = readSTRef v
index 8bd4608..5e6fc3b 100644 (file)
@@ -1,6 +1,6 @@
 
 tcfail104.hs:16:19:
-    Couldn't match expected type `a0 -> a0'
+    Couldn't match expected type `Char -> Char'
                 with actual type `forall a. a -> a'
     In the expression: x
     In the expression: (\ x -> x)
index a3c99a9..90793cf 100644 (file)
@@ -2,6 +2,8 @@
 tcfail128.hs:18:16:
     No instance for (Data.Array.Base.MArray b0 FlatVector IO)
       arising from a use of `thaw'
+    The type variable `b0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
     Possible fix:
       add an instance declaration for
       (Data.Array.Base.MArray b0 FlatVector IO)
index 2808159..fb506dd 100644 (file)
@@ -2,9 +2,21 @@
 tcfail133.hs:2:61:
     Warning: -XDatatypeContexts is deprecated: It was widely considered a misfeature, and has been removed from the Haskell language.
 
+tcfail133.hs:68:7:
+    No instance for (Show a0)
+      arising from a use of `show'
+    The type variable `a0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
+    In the expression: show
+    In the expression: show $ add (One :@ Zero) (One :@ One)
+    In an equation for `foo':
+        foo = show $ add (One :@ Zero) (One :@ One)
+
 tcfail133.hs:68:14:
     No instance for (AddDigit (Zero :@ (One :@ One)) One a0)
       arising from a use of `add'
+    The type variable `a0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
     Possible fix:
       add an instance declaration for
       (AddDigit (Zero :@ (One :@ One)) One a0)
index bc888d2..f24a2a7 100644 (file)
@@ -1,22 +1,24 @@
 
 tcfail140.hs:10:7:
+    Couldn't match expected type `a0 -> t0' with actual type `Int'
     The function `f' is applied to two arguments,
     but its type `Int -> Int' has only one
     In the expression: f 3 9
     In an equation for `bar': bar = f 3 9
 
 tcfail140.hs:12:10:
+    Couldn't match expected type `a0 -> t0' with actual type `Int'
     The operator `f' takes two arguments,
     but its type `Int -> Int' has only one
     In the expression: 3 `f` 4
     In an equation for `rot': rot xs = 3 `f` 4
 
 tcfail140.hs:14:15:
+    Couldn't match expected type `a0 -> b0' with actual type `Int'
     The operator `f' takes two arguments,
     but its type `Int -> Int' has only one
     In the first argument of `map', namely `(3 `f`)'
     In the expression: map (3 `f`) xs
-    In an equation for `bot': bot xs = map (3 `f`) xs
 
 tcfail140.hs:16:8:
     Constructor `Just' should have 1 argument, but has been given none
@@ -25,5 +27,6 @@ tcfail140.hs:16:8:
     In the expression: ((\ Just x -> x) :: Maybe a -> a) (Just 1)
 
 tcfail140.hs:19:1:
+    Couldn't match expected type `t0 -> Bool' with actual type `Int'
     The equation(s) for `g' have two arguments,
     but its type `Int -> Int' has only one
index cd01616..3fd20cc 100644 (file)
@@ -1,8 +1,9 @@
 
 tcfail142.hs:21:12:
-    Ambiguous type variables `a0', `r0' in the constraint:
-      (Bar a0 r0) arising from a use of `bar'
-    Probable fix: add a type signature that fixes these type variable(s)
+    No instance for (Bar a0 r0)
+      arising from a use of `bar'
+    The type variables `a0', `r0' are ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
     In the first argument of `foo', namely `bar'
     In the expression: foo bar
     In an equation for `test': test = foo bar
index 2c3857e..846f8c0 100644 (file)
@@ -1,22 +1,11 @@
-\r
-tcfail143.hs:29:9:\r
-    Couldn't match type `S Z' with `Z'\r
-    When using functional dependencies to combine\r
-      MinMax a Z Z a,\r
-        arising from the dependency `a b -> c d'\r
-        in the instance declaration at tcfail143.hs:11:10\r
-      MinMax (S Z) Z Z Z,\r
-        arising from a use of `extend' at tcfail143.hs:29:9-16\r
-    In the expression: n1 `extend` n0\r
-    In an equation for `t2': t2 = n1 `extend` n0\r
-\r
-tcfail143.hs:29:9:\r
-    Couldn't match type `Z' with `S Z'\r
-    When using functional dependencies to combine\r
-      MinMax Z Z Z Z,\r
-        arising from the dependency `b c d -> a'\r
-        in the instance declaration at tcfail143.hs:10:10\r
-      MinMax (S Z) Z Z Z,\r
-        arising from a use of `extend' at tcfail143.hs:29:9-16\r
-    In the expression: n1 `extend` n0\r
-    In an equation for `t2': t2 = n1 `extend` n0\r
+
+tcfail143.hs:29:9:
+    Couldn't match type `S Z' with `Z'
+    When using functional dependencies to combine
+      MinMax a Z Z a,
+        arising from the dependency `a b -> c d'
+        in the instance declaration at tcfail143.hs:11:10
+      MinMax (S Z) Z Z Z,
+        arising from a use of `extend' at tcfail143.hs:29:9-16
+    In the expression: n1 `extend` n0
+    In an equation for `t2': t2 = n1 `extend` n0
index 0b40df4..ca0b42b 100644 (file)
@@ -1,6 +1,6 @@
 
 tcfail153.hs:6:9:
-    Couldn't match type `a' with `Bool'
+    Couldn't match expected type `a' with actual type `Bool'
       `a' is a rigid type variable bound by
           the type signature for f :: a -> [a] at tcfail153.hs:6:1
     In the first argument of `g', namely `x'
index 94a78a9..b6762d8 100644 (file)
@@ -63,4 +63,3 @@ foo = do
           putChar 'a'
           putChar 'a'
           putChar 'a'
-
index f16f65b..a6a5064 100644 (file)
@@ -1,12 +1,17 @@
 
-tcfail168.hs:8:11:
-    Couldn't match expected type `Char -> a0' with actual type `IO ()'
-    In the return type of a call of `putChar'
-    Probable cause: `putChar' is applied to too many arguments
-    In a stmt of a 'do' block: putChar 'a'
+tcfail168.hs:7:11:
+    Couldn't match expected type `IO a0'
+                with actual type `Char -> IO ()'
+    In a stmt of a 'do' block: putChar
     In the expression:
       do { putChar;
            putChar 'a';
            putChar 'a';
            putChar 'a';
            .... }
+    In an equation for `foo':
+        foo
+          = do { putChar;
+                 putChar 'a';
+                 putChar 'a';
+                 .... }
index b4efd33..714edb1 100644 (file)
@@ -1,6 +1,6 @@
 
 tcfail171.hs:9:10:
-    No instances for (PrintfType b, PrintfArg a)
+    No instances for (PrintfArg a, PrintfType b)
       arising from a use of `printf'
     In the expression: printf "0x%x" x
     In an equation for `phex': phex x = printf "0x%x" x
index cf8c4cc..89135d6 100644 (file)
@@ -1,29 +1,31 @@
-\r
-tcfail174.hs:9:10:\r
-    Couldn't match expected type `forall a. a -> a'\r
-                with actual type `a0 -> a0'\r
-    In the first argument of `Base', namely `id'\r
-    In the expression: Base id\r
-    In an equation for `g': g = Base id\r
-\r
-tcfail174.hs:13:14:\r
-    Couldn't match type `a' with `a1'\r
-      `a' is a rigid type variable bound by\r
-          the inferred type of h1 :: Capture a at tcfail174.hs:13:1\r
-      `a1' is a rigid type variable bound by\r
-           the type forall a. a -> a at tcfail174.hs:13:14\r
-    Expected type: Capture (forall x. x -> a)\r
-      Actual type: Capture (forall a. a -> a)\r
-    In the first argument of `Capture', namely `g'\r
-    In the expression: Capture g\r
-\r
-tcfail174.hs:16:14:\r
-    Couldn't match type `a' with `b'\r
-      `a' is a rigid type variable bound by\r
-          the type forall a. a -> a at tcfail174.hs:16:14\r
-      `b' is a rigid type variable bound by\r
-          the type signature for h2 :: Capture b at tcfail174.hs:16:1\r
-    Expected type: Capture (forall x. x -> b)\r
-      Actual type: Capture (forall a. a -> a)\r
-    In the first argument of `Capture', namely `g'\r
-    In the expression: Capture g\r
+
+tcfail174.hs:9:10:
+    Couldn't match expected type `forall a. a -> a'
+                with actual type `a0 -> a0'
+    In the first argument of `Base', namely `id'
+    In the expression: Base id
+    In an equation for `g': g = Base id
+
+tcfail174.hs:13:14:
+    Couldn't match type `a' with `a1'
+      `a' is a rigid type variable bound by
+          the inferred type of h1 :: Capture a at tcfail174.hs:13:1
+      `a1' is a rigid type variable bound by
+           the type forall a1. a1 -> a1 at tcfail174.hs:13:14
+    Expected type: Capture (forall x. x -> a)
+      Actual type: Capture (forall a. a -> a)
+    In the first argument of `Capture', namely `g'
+    In the expression: Capture g
+    In an equation for `h1': h1 = Capture g
+
+tcfail174.hs:16:14:
+    Couldn't match type `a' with `b'
+      `a' is a rigid type variable bound by
+          the type forall a. a -> a at tcfail174.hs:16:14
+      `b' is a rigid type variable bound by
+          the type signature for h2 :: Capture b at tcfail174.hs:16:1
+    Expected type: Capture (forall x. x -> b)
+      Actual type: Capture (forall a. a -> a)
+    In the first argument of `Capture', namely `g'
+    In the expression: Capture g
+    In an equation for `h2': h2 = Capture g
index f181c00..4fe5bfb 100644 (file)
@@ -1,6 +1,7 @@
 
 tcfail175.hs:11:1:
-    Couldn't match type `a' with `String -> String -> String'
+    Couldn't match expected type `a'
+                with actual type `String -> String -> String'
       `a' is a rigid type variable bound by
           the type signature for evalRHS :: Int -> a at tcfail175.hs:11:1
     The equation(s) for `evalRHS' have three arguments,
index 3107d1e..dc622da 100644 (file)
@@ -7,3 +7,165 @@ tcfail177.hs:10:12:
         [a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]
     In an equation for `allTests':
         allTests = foo [a ~?= b, "Three" ~?= "3", "Four" ~?= "4", ....]
+
+tcfail177.hs:20:13:
+    Couldn't match expected type `Bool' with actual type `[Char]'
+    In the expression: "Two"
+    In the first argument of `foo', namely
+      `[a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]'
+    In the expression:
+      foo
+        [a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]
+
+tcfail177.hs:20:20:
+    Couldn't match expected type `Bool' with actual type `[Char]'
+    In the expression: "Two"
+    In the first argument of `foo', namely
+      `[a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]'
+    In the expression:
+      foo
+        [a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]
+
+tcfail177.hs:20:27:
+    Couldn't match expected type `Bool' with actual type `[Char]'
+    In the expression: "Two"
+    In the first argument of `foo', namely
+      `[a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]'
+    In the expression:
+      foo
+        [a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]
+
+tcfail177.hs:21:13:
+    Couldn't match expected type `Bool' with actual type `[Char]'
+    In the expression: "Two"
+    In the first argument of `foo', namely
+      `[a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]'
+    In the expression:
+      foo
+        [a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]
+
+tcfail177.hs:21:20:
+    Couldn't match expected type `Bool' with actual type `[Char]'
+    In the expression: "Two"
+    In the first argument of `foo', namely
+      `[a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]'
+    In the expression:
+      foo
+        [a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]
+
+tcfail177.hs:21:27:
+    Couldn't match expected type `Bool' with actual type `[Char]'
+    In the expression: "Two"
+    In the first argument of `foo', namely
+      `[a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]'
+    In the expression:
+      foo
+        [a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]
+
+tcfail177.hs:22:13:
+    Couldn't match expected type `Bool' with actual type `[Char]'
+    In the expression: "Two"
+    In the first argument of `foo', namely
+      `[a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]'
+    In the expression:
+      foo
+        [a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]
+
+tcfail177.hs:22:20:
+    Couldn't match expected type `Bool' with actual type `[Char]'
+    In the expression: "Two"
+    In the first argument of `foo', namely
+      `[a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]'
+    In the expression:
+      foo
+        [a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]
+
+tcfail177.hs:22:27:
+    Couldn't match expected type `Bool' with actual type `[Char]'
+    In the expression: "Two"
+    In the first argument of `foo', namely
+      `[a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]'
+    In the expression:
+      foo
+        [a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]
+
+tcfail177.hs:23:13:
+    Couldn't match expected type `Bool' with actual type `[Char]'
+    In the expression: "Two"
+    In the first argument of `foo', namely
+      `[a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]'
+    In the expression:
+      foo
+        [a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]
+
+tcfail177.hs:23:20:
+    Couldn't match expected type `Bool' with actual type `[Char]'
+    In the expression: "Two"
+    In the first argument of `foo', namely
+      `[a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]'
+    In the expression:
+      foo
+        [a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]
+
+tcfail177.hs:23:27:
+    Couldn't match expected type `Bool' with actual type `[Char]'
+    In the expression: "Two"
+    In the first argument of `foo', namely
+      `[a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]'
+    In the expression:
+      foo
+        [a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]
+
+tcfail177.hs:24:13:
+    Couldn't match expected type `Bool' with actual type `[Char]'
+    In the expression: "Two"
+    In the first argument of `foo', namely
+      `[a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]'
+    In the expression:
+      foo
+        [a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]
+
+tcfail177.hs:24:20:
+    Couldn't match expected type `Bool' with actual type `[Char]'
+    In the expression: "Two"
+    In the first argument of `foo', namely
+      `[a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]'
+    In the expression:
+      foo
+        [a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]
+
+tcfail177.hs:24:27:
+    Couldn't match expected type `Bool' with actual type `[Char]'
+    In the expression: "Two"
+    In the first argument of `foo', namely
+      `[a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]'
+    In the expression:
+      foo
+        [a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]
+
+tcfail177.hs:25:13:
+    Couldn't match expected type `Bool' with actual type `[Char]'
+    In the expression: "Two"
+    In the first argument of `foo', namely
+      `[a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]'
+    In the expression:
+      foo
+        [a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]
+
+tcfail177.hs:25:20:
+    Couldn't match expected type `Bool' with actual type `[Char]'
+    In the expression: "Two"
+    In the first argument of `foo', namely
+      `[a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]'
+    In the expression:
+      foo
+        [a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]
+
+tcfail177.hs:25:27:
+    Couldn't match expected type `Bool' with actual type `[Char]'
+    In the expression: "Two"
+    In the first argument of `foo', namely
+      `[a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]'
+    In the expression:
+      foo
+        [a ~?= b, "Three" ~?= "3", "Four" ~?= "4", "Five" ~?= "5", ....]
index 63119af..66773a2 100644 (file)
@@ -1,10 +1,11 @@
 
 tcfail178.hs:15:7:
-    Couldn't match expected type `[a0]' with actual type `()'
+    Couldn't match type `()' with `[a0]'
     Expected type: Bool -> [a0]
       Actual type: Bool -> ()
     In the first argument of `a', namely `y'
     In the expression: a y
+    In an equation for `c': c = a y
 
 tcfail178.hs:18:7:
     Couldn't match expected type `Bool -> [a0]' with actual type `()'
index 6d723db..a24d404 100644 (file)
@@ -1,13 +1,13 @@
-\r
-tcfail179.hs:14:39:\r
-    Couldn't match type `x' with `s'\r
-      `x' is a rigid type variable bound by\r
-          a pattern with constructor\r
-            T :: forall s x. (s -> (x -> s) -> (x, s, Int)) -> T s,\r
-          in a case alternative\r
-          at tcfail179.hs:14:14\r
-      `s' is a rigid type variable bound by\r
-          the type signature for run :: T s -> Int at tcfail179.hs:13:1\r
-    In the first argument of `g', namely `x'\r
-    In the expression: g x id\r
-    In a pattern binding: (x, _, b) = g x id\r
+
+tcfail179.hs:14:39:
+    Couldn't match expected type `s' with actual type `x'
+      `s' is a rigid type variable bound by
+          the type signature for run :: T s -> Int at tcfail179.hs:13:1
+      `x' is a rigid type variable bound by
+          a pattern with constructor
+            T :: forall s x. (s -> (x -> s) -> (x, s, Int)) -> T s,
+          in a case alternative
+          at tcfail179.hs:14:14
+    In the first argument of `g', namely `x'
+    In the expression: g x id
+    In a pattern binding: (x, _, b) = g x id
index 59fe8b8..25e6cbf 100644 (file)
@@ -1,8 +1,9 @@
 
 tcfail181.hs:17:9:
-    Ambiguous type variable `m0' in the constraint:
-      (Monad m0) arising from a use of `foo'
-    Probable fix: add a type signature that fixes these type variable(s)
+    No instance for (Monad m0)
+      arising from a use of `foo'
+    The type variable `m0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
     In the expression: foo
     In the expression: foo {bar = return True}
     In an equation for `wog': wog x = foo {bar = return True}
index 3f4504b..b22e672 100644 (file)
@@ -1,7 +1,8 @@
 
 tcfail186.hs:7:9:
-    Couldn't match expected type `PhantomSyn a0'
-                with actual type `[Char]'
+    Couldn't match type `[Char]' with `Int'
+    Expected type: PhantomSyn a0
+      Actual type: [Char]
     In the first argument of `f', namely `"hoo"'
     In the expression: f "hoo"
     In an equation for `foo': foo = f "hoo"
index b3a6cb4..6364cc2 100644 (file)
@@ -1,8 +1,9 @@
 
 tcfail189.hs:10:31:
-    Couldn't match expected type `a -> t0' with actual type `[a0]'
-    Expected type: (a -> t0) -> [a] -> [[a]]
+    Couldn't match type `[a0]' with `a -> a1'
+    Expected type: (a -> a1) -> [a] -> [[a]]
       Actual type: [a0] -> [a0]
     In the return type of a call of `take'
     Probable cause: `take' is applied to too many arguments
     In the expression: take 2
+    In a stmt of a list comprehension: then group by x using take 2
index f69bd2c..a276a04 100644 (file)
@@ -1,9 +1,10 @@
-\r
-tcfail191.hs:11:26:\r
-    Couldn't match type `a' with `[a]'\r
-      `a' is a rigid type variable bound by\r
-          a type expected by the context: [a] -> [[a]] at tcfail191.hs:11:9\r
-    Expected type: [a] -> [[a]]\r
-      Actual type: [a] -> [a]\r
-    In the return type of a call of `take'\r
-    In the expression: take 5\r
+
+tcfail191.hs:11:26:
+    Couldn't match type `a' with `[a]'
+      `a' is a rigid type variable bound by
+          a type expected by the context: [a] -> [[a]] at tcfail191.hs:11:9
+    Expected type: [a] -> [[a]]
+      Actual type: [a] -> [a]
+    In the return type of a call of `take'
+    In the expression: take 5
+    In a stmt of a list comprehension: then group using take 5
index 097c02f..3491219 100644 (file)
@@ -1,19 +1,20 @@
-\r
-tcfail192.hs:8:11:\r
-    No instance for (Num [[Char]])\r
-      arising from a use of `+'\r
-    Possible fix: add an instance declaration for (Num [[Char]])\r
-    In the expression: x + 1\r
-    In the expression:\r
-      [x + 1 | x <- ["Hello", "World"], then group using take 5]\r
-    In an equation for `foo':\r
-        foo = [x + 1 | x <- ["Hello", "World"], then group using take 5]\r
-\r
-tcfail192.hs:10:26:\r
-    Couldn't match type `a' with `[a]'\r
-      `a' is a rigid type variable bound by\r
-          a type expected by the context: [a] -> [[a]] at tcfail192.hs:10:9\r
-    Expected type: [a] -> [[a]]\r
-      Actual type: [a] -> [a]\r
-    In the return type of a call of `take'\r
-    In the expression: take 5\r
+
+tcfail192.hs:8:11:
+    No instance for (Num [[Char]])
+      arising from a use of `+'
+    Possible fix: add an instance declaration for (Num [[Char]])
+    In the expression: x + 1
+    In the expression:
+      [x + 1 | x <- ["Hello", "World"], then group using take 5]
+    In an equation for `foo':
+        foo = [x + 1 | x <- ["Hello", "World"], then group using take 5]
+
+tcfail192.hs:10:26:
+    Couldn't match type `a' with `[a]'
+      `a' is a rigid type variable bound by
+          a type expected by the context: [a] -> [[a]] at tcfail192.hs:10:9
+    Expected type: [a] -> [[a]]
+      Actual type: [a] -> [a]
+    In the return type of a call of `take'
+    In the expression: take 5
+    In a stmt of a list comprehension: then group using take 5
index 988810e..47375e8 100644 (file)
@@ -1,9 +1,10 @@
-\r
-tcfail193.hs:10:31:\r
-    Couldn't match type `a' with `[a]'\r
-      `a' is a rigid type variable bound by\r
-          a type expected by the context: [a] -> [a] at tcfail193.hs:10:26\r
-    Expected type: [a] -> [a]\r
-      Actual type: [a] -> [[a]]\r
-    In the expression: inits\r
-    In a stmt of a list comprehension: then inits\r
+
+tcfail193.hs:10:31:
+    Couldn't match type `a' with `[a]'
+      `a' is a rigid type variable bound by
+          a type expected by the context: [a] -> [a] at tcfail193.hs:10:26
+    Expected type: [a] -> [a]
+      Actual type: [a] -> [[a]]
+    In the expression: inits
+    In a stmt of a list comprehension: then inits
+    In the expression: [x | x <- [3, 2, 1], then inits]
index be6e37e..c206bd5 100644 (file)
@@ -1,8 +1,27 @@
 
+tcfail194.hs:9:15:
+    No instance for (Enum t0)
+      arising from the arithmetic sequence `1 .. 10'
+    The type variable `t0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
+    In the expression: [1 .. 10]
+    In a stmt of a list comprehension: x <- [1 .. 10]
+    In a stmt of a list comprehension: then take 5 by x
+
+tcfail194.hs:9:16:
+    No instance for (Num t0)
+      arising from the literal `1'
+    The type variable `t0' is ambiguous
+    Possible fix: add a type signature that fixes these type variable(s)
+    In the expression: 1
+    In the expression: [1 .. 10]
+    In a stmt of a list comprehension: x <- [1 .. 10]
+
 tcfail194.hs:9:29:
-    Couldn't match expected type `a -> t0' with actual type `[a0]'
+    Couldn't match type `[a0]' with `a -> t0'
     Expected type: (a -> t0) -> [a] -> [a]
       Actual type: [a0] -> [a0]
     In the return type of a call of `take'
     Probable cause: `take' is applied to too many arguments
     In the expression: take 5
+    In a stmt of a list comprehension: then take 5 by x
index 27fbf92..bba1390 100644 (file)
@@ -1,10 +1,10 @@
 
 tcfail198.hs:6:36:
-    Couldn't match type `a' with `a1'
-      `a' is a rigid type variable bound by
-          the inferred type of f3 :: [a] -> [a] at tcfail198.hs:6:1
+    Couldn't match expected type `a1' with actual type `a'
       `a1' is a rigid type variable bound by
            an expression type signature: a1 at tcfail198.hs:6:36
+      `a' is a rigid type variable bound by
+          the inferred type of f3 :: [a] -> [a] at tcfail198.hs:6:1
     In the expression: x :: a
     In the second argument of `(++)', namely `[x :: a]'
     In the expression: xs ++ [x :: a]
index 23dd026..f45b899 100644 (file)
@@ -1,15 +1,15 @@
-\r
-tcfail201.hs:18:28:\r
-    Couldn't match type `a' with `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:16:1\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:18:28:
+    Couldn't match expected type `a' with actual type `HsDoc id0'
+      `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:16:1
+    In the pattern: DocParagraph hsDoc
+    In a case alternative:
+        (DocParagraph hsDoc) -> z DocParagraph `k` hsDoc
+    In the expression:
+      case hsDoc of {
+        DocEmpty -> z DocEmpty
+        (DocParagraph hsDoc) -> z DocParagraph `k` hsDoc }
index a256bc3..95b0eba 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE TupleSections, UnboxedTuples #-}
-module Main where
+module ShouldCompile where
 
 a :: Bool -> (Int, Bool)
 a = ( , True)
@@ -18,5 +18,3 @@ e = (#1, #)
 
 f :: a -> (#a, Bool#)
 f = (#True || False, #)
-
-main = return ()
\ No newline at end of file
index f469475..76b5c7e 100644 (file)
@@ -1,48 +1,47 @@
-\r
-tcfail206.hs:5:5:\r
-    Couldn't match expected type `Int' with actual type `Bool'\r
-    Expected type: Bool -> (Int, Bool)\r
-      Actual type: Bool -> (Bool, t0)\r
-    In the expression: (, True)\r
-    In an equation for `a': a = (, True)\r
-\r
-tcfail206.hs:8:5:\r
-    Couldn't match expected type `Bool -> (Int, Bool)'\r
-                with actual type `(t0, Int)'\r
-    Expected type: Int -> Bool -> (Int, Bool)\r
-      Actual type: Int -> (t0, Int)\r
-    In the expression: (1,)\r
-    In an equation for `b': b = (1,)\r
-\r
-tcfail206.hs:11:5:\r
-    Couldn't match type `a' with `Bool'\r
-      `a' is a rigid type variable bound by\r
-          the type signature for c :: a -> (a, Bool) at tcfail206.hs:11:1\r
-    Expected type: a -> (a, Bool)\r
-      Actual type: a -> (a, a)\r
-    In the expression: (True || False,)\r
-    In an equation for `c': c = (True || False,)\r
-\r
-tcfail206.hs:14:5:\r
-    Couldn't match expected type `Int' with actual type `Bool'\r
-    Expected type: Bool -> (# Int, Bool #)\r
-      Actual type: Bool -> (# Bool, t0 #)\r
-    In the expression: (# , True #)\r
-    In an equation for `d': d = (# , True #)\r
-\r
-tcfail206.hs:17:5:\r
-    Couldn't match expected type `Bool -> (# Int, Bool #)'\r
-                with actual type `(# t0, Int #)'\r
-    Expected type: Int -> Bool -> (# Int, Bool #)\r
-      Actual type: Int -> (# t0, Int #)\r
-    In the expression: (# 1, #)\r
-    In an equation for `e': e = (# 1, #)\r
-\r
-tcfail206.hs:20:5:\r
-    Couldn't match type `a' with `Bool'\r
-      `a' is a rigid type variable bound by\r
-          the type signature for f :: a -> (# a, Bool #) at tcfail206.hs:20:1\r
-    Expected type: a -> (# a, Bool #)\r
-      Actual type: a -> (# a, a #)\r
-    In the expression: (# True || False, #)\r
-    In an equation for `f': f = (# True || False, #)\r
+
+tcfail206.hs:5:5:
+    Couldn't match type `Bool' with `Int'
+    Expected type: Bool -> (Int, Bool)
+      Actual type: Bool -> (Bool, Bool)
+    In the expression: (, True)
+    In an equation for `a': a = (, True)
+
+tcfail206.hs:8:5:
+    Couldn't match type `(Integer, Int)' with `Bool -> (Int, Bool)'
+    Expected type: Int -> Bool -> (Int, Bool)
+      Actual type: Int -> (Integer, Int)
+    In the expression: (1,)
+    In an equation for `b': b = (1,)
+
+tcfail206.hs:11:5:
+    Couldn't match type `a' with `Bool'
+      `a' is a rigid type variable bound by
+          the type signature for c :: a -> (a, Bool) at tcfail206.hs:11:1
+    Expected type: a -> (a, Bool)
+      Actual type: a -> (a, a)
+    In the expression: (True || False,)
+    In an equation for `c': c = (True || False,)
+
+tcfail206.hs:14:5:
+    Couldn't match type `Bool' with `Int'
+    Expected type: Bool -> (# Int, Bool #)
+      Actual type: Bool -> (# Bool, Bool #)
+    In the expression: (# , True #)
+    In an equation for `d': d = (# , True #)
+
+tcfail206.hs:17:5:
+    Couldn't match type `(# Integer, Int #)'
+                  with `Bool -> (# Int, Bool #)'
+    Expected type: Int -> Bool -> (# Int, Bool #)
+      Actual type: Int -> (# Integer, Int #)
+    In the expression: (# 1, #)
+    In an equation for `e': e = (# 1, #)
+
+tcfail206.hs:20:5:
+    Couldn't match type `a' with `Bool'
+      `a' is a rigid type variable bound by
+          the type signature for f :: a -> (# a, Bool #) at tcfail206.hs:20:1
+    Expected type: a -> (# a, Bool #)
+      Actual type: a -> (# a, a #)
+    In the expression: (# True || False, #)
+    In an equation for `f': f = (# True || False, #)
index 307b404..3e96a09 100644 (file)
@@ -1,7 +1,7 @@
 
 tcfail207.hs:5:7:
     Couldn't match expected type `[Int] -> [Int]'
-                with actual type `[a0]'
+                with actual type `[a1]'
     In the return type of a call of `take'
     Probable cause: `take' is applied to too many arguments
     In the expression: take x []
diff --git a/testsuite/tests/typecheck/should_run/Defer01.hs b/testsuite/tests/typecheck/should_run/Defer01.hs
new file mode 100755 (executable)
index 0000000..368db98
--- /dev/null
@@ -0,0 +1,53 @@
+-- Test -fdefer-type-errors
+-- Should compile and run
+
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE GADTs #-}
+{-# OPTIONS_GHC -fdefer-type-errors #-}
+
+module Main where
+
+t5624 :: IO ()
+t5624 = putStr "Hello World" >> putStr ','
+
+a :: Int
+a = 'p'
+
+data B = B
+b :: B -> Bool
+b x = x == x
+
+data C a where
+  C1 :: C Int
+  C2 :: Bool -> C Bool
+
+c :: C Int -> Bool
+c (C2 x) = True
+
+d :: a -> a
+d = 1
+
+e = 'p'
+f = e 'q'
+
+h :: a -> (Char,Char) 
+h x = (x,'c')
+
+data T a where 
+  K  :: a -> T a
+
+i a = seq (not (K a)) ()
+
+class MyClass a where myOp :: a -> String
+
+j = myOp 23 -- Two errors, should not combine them
+
+k :: (Int ~ Bool) => Int -> Bool
+k x = x
+
+l :: IO ()
+l = putChar >> putChar 'p'
+
+
+main :: IO ()
+main = print "No errors!"
diff --git a/testsuite/tests/typecheck/should_run/Defer01.stdout b/testsuite/tests/typecheck/should_run/Defer01.stdout
new file mode 100644 (file)
index 0000000..19c3777
--- /dev/null
@@ -0,0 +1 @@
+"No errors!"
old mode 100644 (file)
new mode 100755 (executable)
index aacdc7d..d13b317
@@ -11,6 +11,7 @@ test('tcrun002', only_compiler_types(['ghc']), compile_and_run, [''])
 test('tcrun003', normal, compile_and_run, [''])
 test('tcrun004', normal, compile_and_run, [''])
 test('tcrun005', normal, compile_and_run, [''])
+test('Defer01', normal, compile_and_run, [''])
 
 # -----------------------------------------------------------------------------
 # Skip everything else if fast is on
@@ -84,4 +85,4 @@ test('T3500a', normal, compile_and_run, [''])
 test('T3500b', normal, compile_and_run, [''])
 test('T4809', reqlib('mtl'), compile_and_run, [''])
 test('T2722', normal, compile_and_run, [''])
-test('mc17', normal, compile_and_run, [''])
+test('mc17', normal, compile_and_run, [''])
\ No newline at end of file
index f78141a..dbdebf7 100644 (file)
@@ -23,7 +23,7 @@ h = (# ,1, #)
 
 
 unchanged :: a -> (# Int #)
-unchanged _binding = (# #) 1
+unchanged _binding = (# 1 #)
 
 
 main = do