Wibbles (usually improvements) to error messages
authorSimon Peyton Jones <simonpj@microsoft.com>
Fri, 21 Nov 2014 11:33:16 +0000 (11:33 +0000)
committerSimon Peyton Jones <simonpj@microsoft.com>
Fri, 21 Nov 2014 11:36:25 +0000 (11:36 +0000)
45 files changed:
testsuite/tests/deriving/should_fail/T5287.stderr
testsuite/tests/ghci/scripts/Defer02.stderr
testsuite/tests/ghci/scripts/ghci012.stdout
testsuite/tests/indexed-types/should_compile/Simple14.hs
testsuite/tests/indexed-types/should_compile/Simple14.stderr
testsuite/tests/indexed-types/should_fail/NoMatchErr.stderr
testsuite/tests/indexed-types/should_fail/T1897b.stderr
testsuite/tests/indexed-types/should_fail/T1900.stderr
testsuite/tests/indexed-types/should_fail/T2693.stderr
testsuite/tests/indexed-types/should_fail/T4093a.stderr
testsuite/tests/indexed-types/should_fail/T9036.stderr
testsuite/tests/indexed-types/should_fail/T9171.stderr
testsuite/tests/parser/should_fail/T7848.stderr
testsuite/tests/perf/compiler/T5837.stderr
testsuite/tests/typecheck/should_compile/T2494.stderr
testsuite/tests/typecheck/should_compile/T3692.hs
testsuite/tests/typecheck/should_compile/T9708.stderr
testsuite/tests/typecheck/should_compile/tc168.stderr
testsuite/tests/typecheck/should_compile/tc211.hs
testsuite/tests/typecheck/should_compile/tc211.stderr
testsuite/tests/typecheck/should_fail/ContextStack2.stderr
testsuite/tests/typecheck/should_fail/T1897a.stderr
testsuite/tests/typecheck/should_fail/T2414.stderr
testsuite/tests/typecheck/should_fail/T2534.stderr
testsuite/tests/typecheck/should_fail/T3592.stderr
testsuite/tests/typecheck/should_fail/T3613.stderr
testsuite/tests/typecheck/should_fail/T5236.stderr
testsuite/tests/typecheck/should_fail/T5300.stderr
testsuite/tests/typecheck/should_fail/T5691.stderr
testsuite/tests/typecheck/should_fail/T6069.stderr
testsuite/tests/typecheck/should_fail/T7279.stderr
testsuite/tests/typecheck/should_fail/T8392a.stderr
testsuite/tests/typecheck/should_fail/T8883.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/tcfail080.stderr
testsuite/tests/typecheck/should_fail/tcfail097.stderr
testsuite/tests/typecheck/should_fail/tcfail098.stderr
testsuite/tests/typecheck/should_fail/tcfail142.stderr
testsuite/tests/typecheck/should_fail/tcfail174.stderr
testsuite/tests/typecheck/should_fail/tcfail189.stderr
testsuite/tests/typecheck/should_fail/tcfail191.stderr

index 764c422..0c068e0 100644 (file)
@@ -1,11 +1,11 @@
 
 T5287.hs:6:10:
     Could not deduce (A a oops0)
-      arising from the ambiguity check for an instance declaration
     from the context (A a oops)
       bound by an instance declaration: A a oops => Read (D a)
       at T5287.hs:6:10-31
     The type variable ‘oops0’ is ambiguous
-    In the ambiguity check for: forall a oops. A a oops => Read (D a)
+    In the ambiguity check for an instance declaration:
+      forall a oops. A a oops => Read (D a)
     To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
     In the instance declaration for ‘Read (D a)’
index 4f58b02..669d271 100644 (file)
     Couldn't match type ‘Int’ with ‘Bool’
     Inaccessible code in
       the type signature for k :: (Int ~ Bool) => Int -> Bool
-    In the ambiguity check for: (Int ~ Bool) => Int -> Bool
+    In the ambiguity check for the type signature for ‘k’:
+      k :: (Int ~ Bool) => Int -> Bool
     To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
     In the type signature for ‘k’: k :: (Int ~ Bool) => Int -> Bool
 
 ../../typecheck/should_run/Defer01.hs:45:6: Warning:
     Couldn't match expected type ‘Bool’ with actual type ‘Int’
-    In the ambiguity check for: (Int ~ Bool) => Int -> Bool
+    In the ambiguity check for the type signature for ‘k’:
+      k :: (Int ~ Bool) => Int -> Bool
     To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
     In the type signature for ‘k’: k :: (Int ~ Bool) => Int -> Bool
 
index 407ef45..d19785b 100644 (file)
@@ -1 +1 @@
-($$$) :: [b -> c] -> [b] -> [c]        -- Defined at <interactive>:2:8
+($$$) :: [a -> c] -> [a] -> [c]        -- Defined at <interactive>:2:8
index dfffbc7..b8e002b 100644 (file)
@@ -4,6 +4,7 @@ module Simple14 where
 
 data EQ_ x y = EQ_
 
+-- Nov 2014: actually eqE has an ambiguous type
 eqE :: EQ_ x y -> (x~y => EQ_ z z) -> p
 eqE = error "eqE"
 
index 3dbf213..1e430d5 100644 (file)
@@ -1,18 +1,17 @@
 
-Simple14.hs:17:19:
-    Couldn't match type ‘z0’ with ‘m
+Simple14.hs:8:8:
+    Couldn't match type ‘z0’ with ‘z
       ‘z0’ is untouchable
-        inside the constraints (Maybe m ~ Maybe n)
-        bound by a type expected by the context:
-                   (Maybe m ~ Maybe n) => EQ_ z0 z0
-        at Simple14.hs:17:12-33
-      ‘m’ is a rigid type variable bound by
-          the type signature for foo :: EQ_ (Maybe m) (Maybe n)
-          at Simple14.hs:16:15
+        inside the constraints (x ~ y)
+        bound by the type signature for eqE :: (x ~ y) => EQ_ z0 z0
+        at Simple14.hs:8:8-39
+      ‘z’ is a rigid type variable bound by
+          the type signature for eqE :: EQ_ x y -> ((x ~ y) => EQ_ z z) -> p
+          at Simple14.hs:8:8
     Expected type: EQ_ z0 z0
-      Actual type: EQ_ m n
-    Relevant bindings include
-      foo :: EQ_ (Maybe m) (Maybe n) (bound at Simple14.hs:17:1)
-    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))
+      Actual type: EQ_ z z
+    In the ambiguity check for the type signature for ‘eqE’:
+      eqE :: forall x y z p. EQ_ x y -> ((x ~ y) => EQ_ z z) -> p
+    To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
+    In the type signature for ‘eqE’:
+      eqE :: EQ_ x y -> (x ~ y => EQ_ z z) -> p
index f825fd2..5a0443b 100644 (file)
@@ -1,11 +1,11 @@
 
 NoMatchErr.hs:19:7:
-    Couldn't match type ‘Memo d’ with ‘Memo d0
+    Couldn't match type ‘Memo d0’ with ‘Memo d
     NB: ‘Memo’ is a type function, and may not be injective
     The type variable ‘d0’ is ambiguous
     Expected type: Memo d a -> Memo d a
       Actual type: Memo d0 a -> Memo d0 a
-    In the ambiguity check for:
-      forall d a. Fun d => Memo d a -> Memo d a
+    In the ambiguity check for the type signature for ‘f’:
+      f :: forall d a. Fun d => Memo d a -> Memo d a
     To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
     In the type signature for ‘f’: f :: (Fun d) => Memo d a -> Memo d a
index 936aa26..c6d318f 100644 (file)
@@ -1,6 +1,6 @@
 
 T1897b.hs:16:1:
-    Couldn't match type ‘Depend a’ with ‘Depend a0
+    Couldn't match type ‘Depend a0’ with ‘Depend a
     NB: ‘Depend’ is a type function, and may not be injective
     The type variable ‘a0’ is ambiguous
     Expected type: t (Depend a) -> Bool
index 73fe381..0d02a52 100644 (file)
@@ -5,7 +5,8 @@ T1900.hs:13:10:
     The type variable ‘s0’ is ambiguous
     Expected type: Depend s -> Bool
       Actual type: Depend s0 -> Bool
-    In the ambiguity check for: forall s. Bug s => Depend s -> Bool
+    In the ambiguity check for the type signature for ‘check’:
+      check :: forall s. Bug s => Depend s -> Bool
     To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
     In the type signature for ‘check’:
       check :: (Bug s) => Depend s -> Bool
index 0c6ea15..8fdb998 100644 (file)
@@ -1,38 +1,38 @@
-\r
-T2693.hs:11: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
-    When checking that ‘x’ has the inferred type\r
-      x :: 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
-\r
-T2693.hs:19:15:\r
-    Couldn't match expected type ‘(a5, b0)’ with actual type ‘TFn a2’\r
-    The type variables ‘b0’, ‘a2’, ‘a5’ are ambiguous\r
-    Relevant bindings include n :: a5 (bound at T2693.hs:19:7)\r
-    In the first argument of ‘fst’, namely ‘x’\r
-    In the first argument of ‘(+)’, namely ‘fst x’\r
-\r
-T2693.hs:19:23:\r
-    Couldn't match expected type ‘(a3, a5)’ with actual type ‘TFn a4’\r
-    The type variables ‘a3’, ‘a4’, ‘a5’ are ambiguous\r
-    Relevant bindings include n :: a5 (bound at T2693.hs:19:7)\r
-    In the first argument of ‘snd’, namely ‘x’\r
-    In the second argument of ‘(+)’, namely ‘snd x’\r
-\r
-T2693.hs:29:20:\r
-    Couldn't match type ‘TFn a0’ with ‘PVR a1’\r
-    The type variables ‘a0’, ‘a1’ are ambiguous\r
-    Expected type: () -> Maybe (PVR a1)\r
-      Actual type: () -> Maybe (TFn a0)\r
-    In the first argument of ‘mapM’, namely ‘g’\r
-    In a stmt of a 'do' block: pvs <- mapM g undefined\r
+
+T2693.hs:11:7:
+    Couldn't match expected type ‘TFn a’ with actual type ‘TFn a0’
+    NB: ‘TFn’ is a type function, and may not be injective
+    The type variable ‘a0’ is ambiguous
+    When checking that ‘x’ has the inferred type
+      x :: 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:19:15:
+    Couldn't match expected type ‘(a2, b0)’ with actual type ‘TFn a3’
+    The type variables ‘a2’, ‘b0’, ‘a3’ are ambiguous
+    Relevant bindings include n :: a2 (bound at T2693.hs:19:7)
+    In the first argument of ‘fst’, namely ‘x’
+    In the first argument of ‘(+)’, namely ‘fst x’
+
+T2693.hs:19:23:
+    Couldn't match expected type ‘(a4, a2)’ with actual type ‘TFn a5’
+    The type variables ‘a2’, ‘a4’, ‘a5’ are ambiguous
+    Relevant bindings include n :: a2 (bound at T2693.hs:19:7)
+    In the first argument of ‘snd’, namely ‘x’
+    In the second argument of ‘(+)’, namely ‘snd x’
+
+T2693.hs:29:20:
+    Couldn't match type ‘TFn a0’ with ‘PVR a1’
+    The type variables ‘a0’, ‘a1’ are ambiguous
+    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
index 076041b..9918821 100644 (file)
@@ -5,7 +5,8 @@ T4093a.hs:7:9:
       bound by the type signature for hang :: (Foo e ~ Maybe e) => Foo e
       at T4093a.hs:7:9-34
     The type variable ‘e0’ is ambiguous
-    In the ambiguity check for: forall e. (Foo e ~ Maybe e) => Foo e
+    In the ambiguity check for the type signature for ‘hang’:
+      hang :: forall e. (Foo e ~ Maybe e) => Foo e
     To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
     In the type signature for ‘hang’:
       hang :: (Foo e ~ Maybe e) => Foo e
index 3a6e38e..499e6b4 100644 (file)
@@ -1,12 +1,13 @@
 
 T9036.hs:17:17:
-    Couldn't match type ‘Curried t [t]’ with ‘Curried t0 [t0]
-    NB: ‘Curried’ is a type function, and may not be injective
+    Couldn't match type ‘GetMonad t0’ with ‘GetMonad t
+    NB: ‘GetMonad’ is a type function, and may not be injective
     The type variable ‘t0’ is ambiguous
     Expected type: Maybe (GetMonad t after) -> Curried t [t]
       Actual type: Maybe (GetMonad t0 after) -> Curried t0 [t0]
-    In the ambiguity check for:
-      forall t after. Maybe (GetMonad t after) -> Curried t [t]
+    In the ambiguity check for the type signature for ‘simpleLogger’:
+      simpleLogger :: forall t after.
+                      Maybe (GetMonad t after) -> Curried t [t]
     To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
     In the type signature for ‘simpleLogger’:
       simpleLogger :: Maybe (GetMonad t after) -> t `Curried` [t]
index fe49925..28c1a23 100644 (file)
@@ -1,22 +1,22 @@
-\r
-T9171.hs:10:1:\r
-    Couldn't match expected type ‘GetParam Base (GetParam Base Int)’\r
-                with actual type ‘GetParam Base (GetParam Base Int)’\r
-    NB: ‘GetParam’ is a type function, and may not be injective\r
-    The kind variable ‘k0’ is ambiguous\r
-    Use -fprint-explicit-kinds to see the kind arguments\r
-    When checking that ‘foo’ has the inferred type\r
-      foo :: forall (k :: BOX). GetParam Base (GetParam Base Int)\r
-    Probable cause: the inferred type is ambiguous\r
-\r
-T9171.hs:10:20:\r
-    Couldn't match expected type ‘GetParam Base (GetParam Base Int)’\r
-                with actual type ‘GetParam Base (GetParam Base Int)’\r
-    NB: ‘GetParam’ is a type function, and may not be injective\r
-    The kind variable ‘k0’ is ambiguous\r
-    Use -fprint-explicit-kinds to see the kind arguments\r
-    In the ambiguity check for:\r
-      forall (k :: BOX). GetParam Base (GetParam Base Int)\r
-    To defer the ambiguity check to use sites, enable AllowAmbiguousTypes\r
-    In an expression type signature: GetParam Base (GetParam Base Int)\r
-    In the expression: undefined :: GetParam Base (GetParam Base Int)\r
+
+T9171.hs:10:1:
+    Couldn't match expected type ‘GetParam Base (GetParam Base Int)’
+                with actual type ‘GetParam Base (GetParam Base Int)’
+    NB: ‘GetParam’ is a type function, and may not be injective
+    The kind variable ‘k0’ is ambiguous
+    Use -fprint-explicit-kinds to see the kind arguments
+    When checking that ‘foo’ has the inferred type
+      foo :: forall (k :: BOX). GetParam Base (GetParam Base Int)
+    Probable cause: the inferred type is ambiguous
+
+T9171.hs:10:20:
+    Couldn't match expected type ‘GetParam Base (GetParam Base Int)’
+                with actual type ‘GetParam Base (GetParam Base Int)’
+    NB: ‘GetParam’ is a type function, and may not be injective
+    The kind variable ‘k0’ is ambiguous
+    Use -fprint-explicit-kinds to see the kind arguments
+    In the ambiguity check for an expression type signature:
+      forall (k :: BOX). GetParam Base (GetParam Base Int)
+    To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
+    In an expression type signature: GetParam Base (GetParam Base Int)
+    In the expression: undefined :: GetParam Base (GetParam Base Int)
index 1cbf5f4..202c66c 100644 (file)
@@ -1,12 +1,39 @@
 
+T7848.hs:6:57:
+    Occurs check: cannot construct the infinite type:
+      t2 ~ t0 -> t -> t1 -> A -> A -> A -> A -> t2
+    Relevant bindings include
+      y :: forall t3. t3 -> t -> t1 -> A -> A -> A -> A -> t2
+        (bound at T7848.hs:8:9)
+      (&) :: t -> t1 -> A -> A -> A -> A -> t2 (bound at T7848.hs:11:9)
+      z :: t1 (bound at T7848.hs:6:12)
+      (&) :: t1 (bound at T7848.hs:6:8)
+      (+) :: t (bound at T7848.hs:6:3)
+      x :: t -> t1 -> A -> A -> A -> A -> t2 (bound at T7848.hs:6:1)
+    In the expression: y
+    In an equation for ‘x’:
+        x (+) ((&)@z) ((:&&) a b) (c :&& d) (e `A` f) (A g h)
+          = y
+          where
+              infixl 3 `y`
+              y _ = (&)
+              {-# INLINE (&) #-}
+              {-# SPECIALIZE (&) :: a #-}
+              (&) = x
+
 T7848.hs:10:9:
-    Couldn't match expected type ‘forall a. a’
-                with actual type ‘t -> t1 -> A -> A -> A -> A -> t2’
+    Couldn't match type ‘a’ with ‘t -> t1 -> A -> A -> A -> A -> t2’
+      ‘a’ is a rigid type variable bound by
+          the type signature for (&) :: a at T7848.hs:10:9
+    Expected type: forall a. a
+      Actual type: t -> t1 -> A -> A -> A -> A -> t2
     Relevant bindings include
       z :: t1 (bound at T7848.hs:6:12)
       (&) :: t1 (bound at T7848.hs:6:8)
       (+) :: t (bound at T7848.hs:6:3)
       x :: t -> t1 -> A -> A -> A -> A -> t2 (bound at T7848.hs:6:1)
+    When checking that: t -> t1 -> A -> A -> A -> A -> t2
+      is more polymorphic than: forall a. a
     In the SPECIALISE pragma {-# SPECIALIZE (&) :: a #-}
     In an equation for ‘x’:
         x (+) ((&)@z) ((:&&) a b) (c :&& d) (e `A` f) (A g h)
index 193bff1..f3ee82c 100644 (file)
@@ -157,5 +157,6 @@ T5837.hs:8:6:
                                                                                                                                                            (TF
                                                                                                                                                               (TF
                                                                                                                                                                  Int)))))))))))))))))))))))))))))))))))))))))))))))))))
-    In the ambiguity check for: forall a. (a ~ TF (a, Int)) => Int
+    In the ambiguity check for the type signature for ‘t’:
+      t :: forall a. (a ~ TF (a, Int)) => Int
     In the type signature for ‘t’: t :: (a ~ TF (a, Int)) => Int
index dee00ab..0346e62 100644 (file)
@@ -1,34 +1,34 @@
-\r
-T2494.hs:15:14:\r
-    Couldn't match type ‘b’ with ‘a’\r
-      ‘b’ is a rigid type variable bound by\r
-          the RULE "foo/foo" at T2494.hs:14:16\r
-      ‘a’ is a rigid type variable bound by\r
-          the RULE "foo/foo" at T2494.hs:13:16\r
-    Expected type: Maybe (m a) -> Maybe (m a)\r
-      Actual type: Maybe (m b) -> Maybe (m b)\r
-    Relevant bindings include\r
-      f :: forall (m :: * -> *). Monad m => Maybe (m a) -> Maybe (m a)\r
-        (bound at T2494.hs:13:11)\r
-      g :: forall (m :: * -> *). Monad m => Maybe (m b) -> Maybe (m b)\r
-        (bound at T2494.hs:14:11)\r
-      x :: Maybe a (bound at T2494.hs:14:65)\r
-    In the first argument of ‘foo’, namely ‘g’\r
-    In the second argument of ‘foo’, namely ‘(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:16\r
-      ‘a’ is a rigid type variable bound by\r
-          the RULE "foo/foo" at T2494.hs:13:16\r
-    Expected type: Maybe (m a) -> Maybe (m a)\r
-      Actual type: Maybe (m b) -> Maybe (m b)\r
-    Relevant bindings include\r
-      f :: forall (m :: * -> *). Monad m => Maybe (m a) -> Maybe (m a)\r
-        (bound at T2494.hs:13:11)\r
-      g :: forall (m :: * -> *). Monad m => Maybe (m b) -> Maybe (m b)\r
-        (bound at T2494.hs:14:11)\r
-      x :: Maybe a (bound at T2494.hs:14:65)\r
-    In the second argument of ‘(.)’, namely ‘g’\r
-    In the first argument of ‘foo’, namely ‘(f . g)’\r
+
+T2494.hs:15:14:
+    Couldn't match type ‘b’ with ‘a’
+      ‘b’ is a rigid type variable bound by
+          the RULE "foo/foo" at T2494.hs:14:16
+      ‘a’ is a rigid type variable bound by
+          the RULE "foo/foo" at T2494.hs:13:16
+    Expected type: Maybe (m a) -> Maybe (m a)
+      Actual type: Maybe (m b) -> Maybe (m b)
+    Relevant bindings include
+      f :: forall (m :: * -> *). Monad m => Maybe (m a) -> Maybe (m a)
+        (bound at T2494.hs:13:11)
+      g :: forall (m :: * -> *). Monad m => Maybe (m b) -> Maybe (m b)
+        (bound at T2494.hs:14:11)
+      x :: Maybe a (bound at T2494.hs:14:65)
+    In the first argument of ‘foo’, namely ‘g’
+    In the second argument of ‘foo’, namely ‘(foo g x)’
+
+T2494.hs:15:30:
+    Couldn't match type ‘b’ with ‘a’
+      ‘b’ is a rigid type variable bound by
+          the RULE "foo/foo" at T2494.hs:14:16
+      ‘a’ is a rigid type variable bound by
+          the RULE "foo/foo" at T2494.hs:13:16
+    Expected type: Maybe (m a) -> Maybe (m a)
+      Actual type: Maybe (m b) -> Maybe (m b)
+    Relevant bindings include
+      f :: forall (m :: * -> *). Monad m => Maybe (m a) -> Maybe (m a)
+        (bound at T2494.hs:13:11)
+      g :: forall (m :: * -> *). Monad m => Maybe (m b) -> Maybe (m b)
+        (bound at T2494.hs:14:11)
+      x :: Maybe a (bound at T2494.hs:14:65)
+    In the second argument of ‘(.)’, namely ‘g’
+    In the first argument of ‘foo’, namely ‘(f . g)’
index b10e184..9fccb0a 100644 (file)
@@ -7,4 +7,4 @@ type Foo a b = () -> (Bar a => a)
 class Bar a where {}\r
 \r
 foo :: Foo a b\r
-foo = id (undefined :: Foo a b)\r
+foo = id (undefined :: Foo p q)\r
index fca5df7..fb8a6a7 100644 (file)
@@ -1,17 +1,17 @@
-\r
-T9708.hs:9:8:\r
-    Could not deduce (SomeFun x ~ SomeFun y)\r
-    from the context (x <= y, y <= x)\r
-      bound by the type signature for\r
-                 ti7 :: (x <= y, y <= x) => Proxy (SomeFun x) -> Proxy y -> ()\r
-      at T9708.hs:9:8-61\r
-    NB: ‘SomeFun’ is a type function, and may not be injective\r
-    Expected type: Proxy (SomeFun x) -> Proxy y -> ()\r
-      Actual type: Proxy (SomeFun y) -> Proxy y -> ()\r
-    In the ambiguity check for:\r
-      forall (x :: Nat) (y :: Nat).\r
-      (x <= y, y <= x) =>\r
-      Proxy (SomeFun x) -> Proxy y -> ()\r
-    To defer the ambiguity check to use sites, enable AllowAmbiguousTypes\r
-    In the type signature for ‘ti7’:\r
-      ti7 :: (x <= y, y <= x) => Proxy (SomeFun x) -> Proxy y -> ()\r
+
+T9708.hs:9:8:
+    Could not deduce (SomeFun y ~ SomeFun x)
+    from the context (x <= y, y <= x)
+      bound by the type signature for
+                 ti7 :: (x <= y, y <= x) => Proxy (SomeFun x) -> Proxy y -> ()
+      at T9708.hs:9:8-61
+    NB: ‘SomeFun’ is a type function, and may not be injective
+    Expected type: Proxy (SomeFun x) -> Proxy y -> ()
+      Actual type: Proxy (SomeFun y) -> Proxy y -> ()
+    In the ambiguity check for the type signature for ‘ti7’:
+      ti7 :: forall (x :: Nat) (y :: Nat).
+             (x <= y, y <= x) =>
+             Proxy (SomeFun x) -> Proxy y -> ()
+    To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
+    In the type signature for ‘ti7’:
+      ti7 :: (x <= y, y <= x) => Proxy (SomeFun x) -> Proxy y -> ()
index b46cdd0..16df4a4 100644 (file)
@@ -1,11 +1,10 @@
-\r
-tc168.hs:17:1:\r
-    Could not deduce (C a1 (a, b0))\r
-      arising from the ambiguity check for ‘g’\r
-    from the context (C a1 (a, b))\r
-      bound by the inferred type for ‘g’: C a1 (a, b) => a1 -> a\r
-      at tc168.hs:17:1-16\r
-    The type variable ‘b0’ is ambiguous\r
-    When checking that ‘g’ has the inferred type\r
-      g :: forall a b a1. C a1 (a, b) => a1 -> a\r
-    Probable cause: the inferred type is ambiguous\r
+
+tc168.hs:17:1:
+    Could not deduce (C a1 (a, b0))
+    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
+    When checking that ‘g’ has the inferred type
+      g :: forall a b a1. C a1 (a, b) => a1 -> a
+    Probable cause: the inferred type is ambiguous
index 5bd5c34..8f273ba 100644 (file)
@@ -1,5 +1,8 @@
 {-# OPTIONS_GHC -XImpredicativeTypes -fno-warn-deprecated-flags -XScopedTypeVariables -XGADTs #-}
 
+-- Nov 2014: impredicative types are very dodgy so I am
+--           FAR from confident that these tests give the right errors
+
 -- Here are a bunch of tests for impredicative polymorphism
 -- mainly written by Dimitrios
 
index 533155a..34a35f1 100644 (file)
@@ -1,25 +1,61 @@
-\r
-tc211.hs:15:22:\r
-    Couldn't match type ‘forall a1. a1 -> a1’ with ‘a -> a’\r
-    Expected type: [a -> a]\r
-      Actual type: [forall a. a -> a]\r
-    In the first argument of ‘head’, namely ‘foo’\r
-    In the first argument of ‘(:) ::\r
-                                (forall a. a -> a)\r
-                                -> [forall a. a -> a] -> [forall a. a -> a]’, namely\r
-      ‘(head foo)’\r
-\r
-tc211.hs:70:9:\r
-    Couldn't match type ‘forall a2. a2 -> a2’ with ‘a1 -> a1’\r
-    Expected type: List (forall a. a -> a)\r
-                   -> (forall a. a -> a) -> a1 -> a1\r
-      Actual type: List (forall a. a -> a)\r
-                   -> (forall a. a -> a) -> forall a. a -> a\r
-    In the expression:\r
-        foo2 ::\r
-          List (forall a. a -> a) -> (forall a. a -> a) -> (forall a. a -> a)\r
-    In the expression:\r
-      (foo2 ::\r
-         List (forall a. a -> a)\r
-         -> (forall a. a -> a) -> (forall a. a -> a))\r
-        xs1 (\ x -> x)\r
+
+tc211.hs:17:8:
+    Couldn't match expected type ‘forall a. a -> a’
+                with actual type ‘a2 -> a2’
+    In the expression:
+        (:) ::
+          (forall a. a -> a) -> [forall a. a -> a] -> [forall a. a -> a]
+    In the expression:
+      ((:) ::
+         (forall a. a -> a) -> [forall a. a -> a] -> [forall a. a -> a])
+        (head foo) foo
+
+tc211.hs:18:22:
+    Couldn't match type ‘forall a3. a3 -> a3’ 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)’
+
+tc211.hs:59:18:
+    Couldn't match expected type ‘forall a. a -> a’
+                with actual type ‘a1 -> a1’
+    In the expression:
+        Cons ::
+          (forall a. a -> a)
+          -> List (forall a. a -> a) -> List (forall a. a -> a)
+    In an equation for ‘cons’:
+        cons
+          = Cons ::
+              (forall a. a -> a)
+              -> List (forall a. a -> a) -> List (forall a. a -> a)
+
+tc211.hs:65:8:
+    Couldn't match expected type ‘forall a. a -> a’
+                with actual type ‘a0 -> a0’
+    In the expression:
+        Cons ::
+          (forall a. a -> a)
+          -> List (forall a. a -> a) -> List (forall a. a -> a)
+    In the expression:
+      (Cons ::
+         (forall a. a -> a)
+         -> List (forall a. a -> a) -> List (forall a. a -> a))
+        (\ x -> x) Nil
+
+tc211.hs:73:9:
+    Couldn't match type ‘forall a4. a4 -> a4’ with ‘a3 -> a3’
+    Expected type: List (forall a. a -> a)
+                   -> (forall a. a -> a) -> a3 -> a3
+      Actual type: List (a3 -> a3) -> (a3 -> a3) -> a3 -> a3
+    In the expression:
+        foo2 ::
+          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))
+        xs1 (\ x -> x)
index fbbd598..90e7285 100644 (file)
@@ -5,5 +5,6 @@ ContextStack2.hs:8:6:
       TF (TF (TF (TF (TF (TF (TF (TF (TF (TF a)))))))))
       ~ (TF (TF (TF (TF (TF (TF (TF (TF (TF (TF (TF a)))))))))),
          TF (TF (TF (TF (TF (TF (TF (TF (TF (TF (TF Int)))))))))))
-    In the ambiguity check for: forall a. (a ~ TF (a, Int)) => Int
+    In the ambiguity check for the type signature for ‘t’:
+      t :: forall a. (a ~ TF (a, Int)) => Int
     In the type signature for ‘t’: t :: (a ~ TF (a, Int)) => Int
index 58f1a2d..e0f76ee 100644 (file)
@@ -1,11 +1,10 @@
-\r
-T1897a.hs:9:1:\r
-    Could not deduce (Wob a0 b)\r
-      arising from the ambiguity check for ‘foo’\r
-    from the context (Wob a b)\r
-      bound by the inferred type for ‘foo’: Wob a b => b -> [b]\r
-      at T1897a.hs:9:1-24\r
-    The type variable ‘a0’ is ambiguous\r
-    When checking that ‘foo’ has the inferred type\r
-      foo :: forall a b. Wob a b => b -> [b]\r
-    Probable cause: the inferred type is ambiguous\r
+
+T1897a.hs:9:1:
+    Could not deduce (Wob a0 b)
+    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
+    When checking that ‘foo’ has the inferred type
+      foo :: forall a b. Wob a b => b -> [b]
+    Probable cause: the inferred type is ambiguous
index 7c43103..0f797da 100644 (file)
@@ -2,6 +2,6 @@
 T2414.hs:9:13:
     Occurs check: cannot construct the infinite type: b0 ~ (Bool, b0)
     Expected type: b0 -> Maybe (Bool, b0)
-      Actual type: b0 -> Maybe b0
+      Actual type: (Bool, b0) -> Maybe (Bool, b0)
     In the first argument of ‘unfoldr’, namely ‘Just’
     In the expression: unfoldr Just
index 7a0aa3a..157521f 100644 (file)
@@ -1,8 +1,8 @@
 
-T2534.hs:3:19:
-    Couldn't match expected type ‘a -> a -> b’ with actual type ‘[t0]’
-    Relevant bindings include
-      foo :: a -> a -> b (bound at T2534.hs:3:1)
-    In the second argument of ‘foldr’, namely ‘[]’
+T2534.hs:3:13:
+    Couldn't match type ‘[b]’ with ‘a0 -> [b]’
+    Expected type: [a0] -> [b] -> [b]
+      Actual type: [a0] -> (a0 -> [b]) -> [b]
+    Relevant bindings include foo :: [b] (bound at T2534.hs:3:1)
+    In the first argument of ‘foldr’, namely ‘(>>=)’
     In the expression: foldr (>>=) [] []
-    In an equation for ‘foo’: foo = foldr (>>=) [] []
index a7f0f28..05ea89a 100644 (file)
@@ -1,6 +1,9 @@
 
 T3592.hs:8:5:
-    No instance for (Show (T a)) arising from a use of ‘show’
+    No instance for (Show a) arising from a use of ‘show’
+    Possible fix:
+      add (Show a) to the context of
+        the type signature for f :: T a -> String
     In the expression: show
     In an equation for ‘f’: f = show
 
index f230fc4..f7fa6d4 100644 (file)
@@ -7,9 +7,7 @@ T3613.hs:14:20:
     In the first argument of ‘fooThen’, namely ‘(bar >> undefined)’
 
 T3613.hs:17:24:
-    Couldn't match type ‘IO’ with ‘Maybe’
-    Expected type: Maybe ()
-      Actual type: IO ()
+    Couldn't match expected type ‘Maybe a0’ with actual type ‘IO ()’
     In a stmt of a 'do' block: bar
     In the first argument of ‘fooThen’, namely
       ‘(do { bar;
index e1e136a..7b5830c 100644 (file)
@@ -1,10 +1,11 @@
-\r
-T5236.hs:13:9:\r
-    Couldn't match type ‘B’ with ‘A’\r
-    arising from a functional dependency between:\r
-      constraint ‘Id A B’\r
-        arising from the type signature for loop :: Id A B => Bool\r
-      instance ‘Id B B’ at T5236.hs:11:10-15\r
-    In the ambiguity check for: Id A B => Bool\r
-    To defer the ambiguity check to use sites, enable AllowAmbiguousTypes\r
-    In the type signature for ‘loop’: loop :: Id A B => Bool\r
+
+T5236.hs:13:9:
+    Couldn't match type ‘B’ with ‘A’
+    arising from a functional dependency between:
+      constraint ‘Id A B’
+        arising from the type signature for loop :: Id A B => Bool
+      instance ‘Id B B’ at T5236.hs:11:10-15
+    In the ambiguity check for the type signature for ‘loop’:
+      loop :: Id A B => Bool
+    To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
+    In the type signature for ‘loop’: loop :: Id A B => Bool
index 912cd19..14e069a 100644 (file)
@@ -1,33 +1,31 @@
 
 T5300.hs:11:7:
     Could not deduce (C1 a b c0)
-      arising from the ambiguity check for ‘f1’
     from the context (Monad m, C1 a b c)
       bound by the type signature for
                  f1 :: (Monad m, C1 a b c) => a -> StateT (T b) m a
       at T5300.hs:11:7-50
     The type variable ‘c0’ is ambiguous
-    In the ambiguity check for:
-      forall a b (m :: * -> *) c.
-      (Monad m, C1 a b c) =>
-      a -> StateT (T b) m a
+    In the ambiguity check for the type signature for ‘f1’:
+      f1 :: forall a b (m :: * -> *) c.
+            (Monad m, C1 a b c) =>
+            a -> StateT (T b) m a
     To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
     In the type signature for ‘f1’:
       f1 :: (Monad m, C1 a b c) => a -> StateT (T b) m a
 
 T5300.hs:14:7:
     Could not deduce (C2 a2 b2 c20)
-      arising from the ambiguity check for ‘f2’
     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:14:7-69
     The type variable ‘c20’ is ambiguous
-    In the ambiguity check for:
-      forall a1 b2 (m :: * -> *) a2 b1 c1 c2.
-      (Monad m, C1 a1 b1 c1, C2 a2 b2 c2) =>
-      a1 -> StateT (T b2) m a2
+    In the ambiguity check for the type signature for ‘f2’:
+      f2 :: forall a1 b2 (m :: * -> *) a2 b1 c1 c2.
+            (Monad m, C1 a1 b1 c1, C2 a2 b2 c2) =>
+            a1 -> StateT (T b2) m a2
     To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
     In the type signature for ‘f2’:
       f2 :: (Monad m, C1 a1 b1 c1, C2 a2 b2 c2) =>
index 674ffc7..e4151c1 100644 (file)
@@ -1,11 +1,12 @@
 
 T5691.hs:14:9:
     Couldn't match type ‘p’ with ‘PrintRuleInterp’
-    Expected type: PrintRuleInterp a
-      Actual type: p a
+    Expected type: p a
+      Actual type: PrintRuleInterp a
+    When checking that the pattern signature: p a
+      fits the type of its context: PrintRuleInterp a
     In the pattern: f :: p a
     In an equation for ‘test’: test (f :: p a) = MkPRI $ printRule_ f
-    In the instance declaration for ‘Test PrintRuleInterp’
 
 T5691.hs:15:24:
     Couldn't match type ‘p’ with ‘PrintRuleInterp’
index 81b1552..eff2e8b 100644 (file)
@@ -1,21 +1,21 @@
 
 T6069.hs:13:15:
-    Couldn't match type ‘ST s0 Int’ with ‘forall s. ST s b0’
-    Expected type: ST s0 Int -> b0
-      Actual type: (forall s. ST s b0) -> b0
+    Couldn't match type ‘ST s0 Int’ with ‘forall s. ST s a0’
+    Expected type: ST s0 Int -> a0
+      Actual type: (forall s. ST s a0) -> a0
     In the second argument of ‘(.)’, namely ‘runST’
     In the expression: print . runST
 
 T6069.hs:14:15:
-    Couldn't match type ‘ST s1 Int’ with ‘forall s. ST s b1’
-    Expected type: ST s1 Int -> b1
-      Actual type: (forall s. ST s b1) -> b1
+    Couldn't match type ‘ST s1 Int’ with ‘forall s. ST s a1’
+    Expected type: ST s1 Int -> a1
+      Actual type: (forall s. ST s a1) -> a1
     In the second argument of ‘(.)’, namely ‘runST’
     In the expression: (print . runST)
 
 T6069.hs:15:16:
-    Couldn't match type ‘ST s2 Int’ with ‘forall s. ST s b2’
-    Expected type: ST s2 Int -> b2
-      Actual type: (forall s. ST s b2) -> b2
+    Couldn't match type ‘ST s2 Int’ with ‘forall s. ST s a2’
+    Expected type: ST s2 Int -> a2
+      Actual type: (forall s. ST s a2) -> a2
     In the second argument of ‘(.)’, namely ‘runST’
     In the first argument of ‘($)’, namely ‘(print . runST)’
index df0328c..10acbbe 100644 (file)
@@ -1,11 +1,11 @@
 
 T7279.hs:6:10:
     Could not deduce (Show b0)
-      arising from the ambiguity check for an instance declaration
     from the context (Eq a, Show b)
       bound by an instance declaration: (Eq a, Show b) => Eq (T a)
       at T7279.hs:6:10-35
     The type variable ‘b0’ is ambiguous
-    In the ambiguity check for: forall a b. (Eq a, Show b) => Eq (T a)
+    In the ambiguity check for an instance declaration:
+      forall a b. (Eq a, Show b) => Eq (T a)
     To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
     In the instance declaration for ‘Eq (T a)’
index 9be12a5..a51cc83 100644 (file)
@@ -3,5 +3,6 @@ T8392a.hs:6:8:
     Couldn't match type ‘Int’ with ‘Bool’
     Inaccessible code in
       the type signature for foo :: (Int ~ Bool) => a -> a
-    In the ambiguity check for: forall a. (Int ~ Bool) => a -> a
+    In the ambiguity check for the type signature for ‘foo’:
+      foo :: forall a. (Int ~ Bool) => a -> a
     In the type signature for ‘foo’: foo :: (Int ~ Bool) => a -> a
index 28730ae..27b4d94 100644 (file)
@@ -3,6 +3,6 @@ T8883.hs:20:1:
     Non type-variable argument in the constraint: Functor (PF a)
     (Use FlexibleContexts to permit this)
     When checking that ‘fold’ has the inferred type
-      fold :: forall a b.
+      fold :: forall b a.
               (Functor (PF a), Regular a) =>
               (PF a b -> b) -> a -> b
index e3a8b88..0e72729 100644 (file)
@@ -1,9 +1,9 @@
-\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 expression: take 5\r
-    In a stmt of a monad comprehension: then group using 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 expression: take 5
+    In a stmt of a monad comprehension: then group using take 5
index 104bcff..ebae89e 100644 (file)
@@ -1,21 +1,21 @@
-\r
-mc22.hs:10:9:\r
-    No instance for (Functor t) arising from a use of ‘fmap’\r
-    Possible fix:\r
-      add (Functor t) to the context of\r
-        a type expected by the context: (a -> b) -> t a -> t b\r
-        or the inferred type of foo :: [t [Char]]\r
-    In the expression: fmap\r
-    In a stmt of a monad comprehension: then group using take 5\r
-    In the expression:\r
-      [x + 1 | x <- ["Hello", "World"], then group using take 5]\r
-\r
-mc22.hs:10:26:\r
-    Couldn't match type ‘a’ with ‘t a’\r
-      ‘a’ is a rigid type variable bound by\r
-          a type expected by the context: [a] -> [t a] at mc22.hs:10:9\r
-    Expected type: [a] -> [t a]\r
-      Actual type: [a] -> [a]\r
-    Relevant bindings include foo :: [t [Char]] (bound at mc22.hs:8:1)\r
-    In the expression: take 5\r
-    In a stmt of a monad comprehension: then group using take 5\r
+
+mc22.hs:10:9:
+    No instance for (Functor t) arising from a use of ‘fmap’
+    Possible fix:
+      add (Functor t) to the context of
+        a type expected by the context: (a -> b) -> t a -> t b
+        or the inferred type of foo :: [t [Char]]
+    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 ‘t a’
+      ‘a’ is a rigid type variable bound by
+          a type expected by the context: [a] -> [t a] at mc22.hs:10:9
+    Expected type: [a] -> [t a]
+      Actual type: [t a] -> [t a]
+    Relevant bindings include foo :: [t [Char]] (bound at mc22.hs:8:1)
+    In the expression: take 5
+    In a stmt of a monad comprehension: then group using take 5
index cdb1080..9f4a467 100644 (file)
@@ -1,9 +1,9 @@
 
 mc23.hs:9:29:
-    Couldn't match type ‘[a0]’ with ‘a -> b
-    Expected type: (a -> b) -> [a] -> t a
+    Couldn't match type ‘[a0]’ with ‘[a] -> m a
+    Expected type: (a -> b) -> [a] -> m a
       Actual type: [a0] -> [a0]
-    Relevant bindings include z :: t b (bound at mc23.hs:9:1)
+    Relevant bindings include z :: m b (bound at mc23.hs:9:1)
     Possible 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 495693c..3260edb 100644 (file)
@@ -1,8 +1,9 @@
-\r
-mc24.hs:10:31:\r
-    Couldn't match type ‘[a0]’ with ‘a -> Integer’\r
-    Expected type: (a -> Integer) -> [a] -> t [a]\r
-      Actual type: [a0] -> [a0]\r
-    Possible cause: ‘take’ is applied to too many arguments\r
-    In the expression: take 2\r
-    In a stmt of a monad comprehension: then group by x using take 2\r
+
+mc24.hs:10:31:
+    Couldn't match type ‘[a0]’ with ‘[a] -> m [a]’
+    Expected type: (a -> Integer) -> [a] -> m [a]
+      Actual type: [a0] -> [a0]
+    Relevant bindings include foo :: m Int (bound at mc24.hs:8:1)
+    Possible 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 e145af4..fb136bc 100644 (file)
@@ -1,18 +1,18 @@
-\r
-mc25.hs:9:24:\r
-    No instance for (Functor t1) arising from a use of ‘fmap’\r
-    Possible fix:\r
-      add (Functor t1) to the context of\r
-        a type expected by the context: (a -> b) -> t1 a -> t1 b\r
-        or the inferred type of z :: [t1 t]\r
-    In the expression: fmap\r
-    In a stmt of a monad comprehension: then group by x using take\r
-    In the expression: [x | x <- [1 .. 10], then group by x using take]\r
-\r
-mc25.hs:9:46:\r
-    Couldn't match type ‘Int’ with ‘a -> t’\r
-    Expected type: (a -> t) -> [a] -> [t1 a]\r
-      Actual type: Int -> [a] -> [a]\r
-    Relevant bindings include z :: [t1 t] (bound at mc25.hs:9:1)\r
-    In the expression: take\r
-    In a stmt of a monad comprehension: then group by x using take\r
+
+mc25.hs:9:24:
+    No instance for (Functor t1) arising from a use of ‘fmap’
+    Possible fix:
+      add (Functor t1) to the context of
+        a type expected by the context: (a -> b) -> t1 a -> t1 b
+        or the inferred type of z :: [t1 t]
+    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 type ‘a -> t’ with ‘Int’
+    Expected type: (a -> t) -> [a] -> [t1 a]
+      Actual type: Int -> [t1 a] -> [t1 a]
+    Relevant bindings include z :: [t1 t] (bound at mc25.hs:9:1)
+    In the expression: take
+    In a stmt of a monad comprehension: then group by x using take
index 4e02b3e..fcd974d 100644 (file)
@@ -1,11 +1,10 @@
-\r
-tcfail080.hs:27:1:\r
-    Could not deduce (Collection c0 a)\r
-      arising from the ambiguity check for ‘q’\r
-    from the context (Collection c a)\r
-      bound by the inferred type for ‘q’: Collection c a => a -> Bool\r
-      at tcfail080.hs:27:1-27\r
-    The type variable ‘c0’ is ambiguous\r
-    When checking that ‘q’ has the inferred type\r
-      q :: forall (c :: * -> *) a. Collection c a => a -> Bool\r
-    Probable cause: the inferred type is ambiguous\r
+
+tcfail080.hs:27:1:
+    Could not deduce (Collection c0 a)
+    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
+    When checking that ‘q’ has the inferred type
+      q :: forall (c :: * -> *) a. Collection c a => a -> Bool
+    Probable cause: the inferred type is ambiguous
index cbd5612..8219724 100644 (file)
@@ -1,10 +1,11 @@
 
 tcfail097.hs:5:6:
-    Could not deduce (Eq a0) arising from the ambiguity check for ‘f’
+    Could not deduce (Eq a0)
     from the context (Eq a)
       bound by the type signature for f :: Eq a => Int -> Int
       at tcfail097.hs:5:6-23
     The type variable ‘a0’ is ambiguous
-    In the ambiguity check for: forall a. Eq a => Int -> Int
+    In the ambiguity check for the type signature for ‘f’:
+      f :: forall a. Eq a => Int -> Int
     To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
     In the type signature for ‘f’: f :: Eq a => Int -> Int
index 94ade75..8ac2960 100644 (file)
@@ -1,11 +1,11 @@
 
 tcfail098.hs:12:10:
     Could not deduce (Bar a0)
-      arising from the ambiguity check for an instance declaration
     from the context (Bar a)
       bound by an instance declaration: Bar a => Bar Bool
       at tcfail098.hs:12:10-26
     The type variable ‘a0’ is ambiguous
-    In the ambiguity check for: forall a. Bar a => Bar Bool
+    In the ambiguity check for an instance declaration:
+      forall a. Bar a => Bar Bool
     To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
     In the instance declaration for ‘Bar Bool’
index e2338eb..fecb2f3 100644 (file)
@@ -1,11 +1,11 @@
 
 tcfail142.hs:18:8:
     Could not deduce (Bar a0 r)
-      arising from the ambiguity check for ‘bar’
     from the context (Bar a r)
       bound by the type signature for bar :: Bar a r => r -> ()
       at tcfail142.hs:18:8-25
     The type variable ‘a0’ is ambiguous
-    In the ambiguity check for: forall r a. Bar a r => r -> ()
+    In the ambiguity check for the type signature for ‘bar’:
+      bar :: forall r a. Bar a r => r -> ()
     To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
     In the type signature for ‘bar’: bar :: Bar a r => r -> ()
index f48d153..577c36e 100644 (file)
@@ -10,7 +10,7 @@ tcfail174.hs:13:14:
       because type variable ‘a1’ would escape its scope
     This (rigid, skolem) type variable is bound by
       the type forall a2. a2 -> a2
-      at tcfail174.hs:13:14
+      at tcfail174.hs:13:1-14
     Expected type: Capture (forall x. x -> a)
       Actual type: Capture (forall a. a -> a)
     Relevant bindings include
@@ -21,7 +21,7 @@ tcfail174.hs:13:14:
 tcfail174.hs:16:14:
     Couldn't match type ‘a’ with ‘b’
       ‘a’ is a rigid type variable bound by
-          the type forall a1. a1 -> a1 at tcfail174.hs:16:14
+          the type forall a1. a1 -> a1 at tcfail174.hs:1:1
       ‘b’ is a rigid type variable bound by
           the type signature for h2 :: Capture b at tcfail174.hs:15:7
     Expected type: Capture (forall x. x -> b)
index 6bd08a2..380b014 100644 (file)
@@ -1,8 +1,8 @@
-\r
-tcfail189.hs:10:31:\r
-    Couldn't match type ‘[a0]’ with ‘a -> Integer’\r
-    Expected type: (a -> Integer) -> [a] -> [[a]]\r
-      Actual type: [a0] -> [a0]\r
-    Possible cause: ‘take’ is applied to too many arguments\r
-    In the expression: take 2\r
-    In a stmt of a list comprehension: then group by x using take 2\r
+
+tcfail189.hs:10:31:
+    Couldn't match type ‘[a0]’ with ‘[a] -> [[a]]’
+    Expected type: (a -> Integer) -> [a] -> [[a]]
+      Actual type: [a0] -> [a0]
+    Possible 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 c766699..2158927 100644 (file)
@@ -4,6 +4,6 @@ tcfail191.hs:11:26:
       ‘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]
+      Actual type: [[a]] -> [[a]]
     In the expression: take 5
     In a stmt of a list comprehension: then group using take 5