Wibbles to error messages and tests, following ambiguity-check changes
authorSimon Peyton Jones <simonpj@microsoft.com>
Tue, 8 Jan 2013 08:30:05 +0000 (08:30 +0000)
committerSimon Peyton Jones <simonpj@microsoft.com>
Tue, 8 Jan 2013 08:30:05 +0000 (08:30 +0000)
59 files changed:
testsuite/tests/deriving/should_fail/T3101.hs
testsuite/tests/deriving/should_fail/T5287.hs
testsuite/tests/deriving/should_fail/T5287.stderr
testsuite/tests/driver/T4437.hs
testsuite/tests/ghci/scripts/Defer02.stderr
testsuite/tests/indexed-types/should_compile/GADT12.hs
testsuite/tests/indexed-types/should_compile/GADT5.hs
testsuite/tests/indexed-types/should_compile/Simple19.hs
testsuite/tests/indexed-types/should_compile/T1981.hs
testsuite/tests/indexed-types/should_compile/T3208b.stderr
testsuite/tests/indexed-types/should_compile/T4981-V1.hs
testsuite/tests/indexed-types/should_compile/T4981-V2.hs
testsuite/tests/indexed-types/should_compile/T4981-V3.hs
testsuite/tests/indexed-types/should_fail/NoMatchErr.stderr
testsuite/tests/indexed-types/should_fail/Overlap10.hs
testsuite/tests/indexed-types/should_fail/Overlap10.stderr
testsuite/tests/indexed-types/should_fail/Overlap11.hs
testsuite/tests/indexed-types/should_fail/Overlap11.stderr
testsuite/tests/indexed-types/should_fail/SimpleFail16.stderr
testsuite/tests/indexed-types/should_fail/T1897b.stderr
testsuite/tests/indexed-types/should_fail/T1900.stderr
testsuite/tests/indexed-types/should_fail/T2544.stderr
testsuite/tests/indexed-types/should_fail/T2627b.stderr
testsuite/tests/indexed-types/should_fail/T2693.hs
testsuite/tests/indexed-types/should_fail/T2693.stderr
testsuite/tests/indexed-types/should_fail/T4099.hs
testsuite/tests/indexed-types/should_fail/T4099.stderr
testsuite/tests/indexed-types/should_fail/T4485.stderr
testsuite/tests/indexed-types/should_fail/T5934.hs
testsuite/tests/indexed-types/should_fail/T5934.stderr
testsuite/tests/indexed-types/should_fail/T6123.stderr
testsuite/tests/polykinds/T5770.hs
testsuite/tests/polykinds/T6020.hs
testsuite/tests/polykinds/T7090.hs
testsuite/tests/rebindable/rebindable6.stderr
testsuite/tests/simplCore/should_compile/T7360.hs
testsuite/tests/simplCore/should_compile/T7360.stderr
testsuite/tests/typecheck/should_compile/holes2.stderr
testsuite/tests/typecheck/should_compile/tc168.stderr
testsuite/tests/typecheck/should_fail/FrozenErrorTests.hs
testsuite/tests/typecheck/should_fail/FrozenErrorTests.stderr
testsuite/tests/typecheck/should_fail/T1897a.stderr
testsuite/tests/typecheck/should_fail/T5236.stderr
testsuite/tests/typecheck/should_fail/T5300.stderr
testsuite/tests/typecheck/should_fail/T5858.stderr
testsuite/tests/typecheck/should_fail/all.T
testsuite/tests/typecheck/should_fail/tcfail008.stderr
testsuite/tests/typecheck/should_fail/tcfail040.stderr
testsuite/tests/typecheck/should_fail/tcfail043.stderr
testsuite/tests/typecheck/should_fail/tcfail072.stderr
testsuite/tests/typecheck/should_fail/tcfail080.stderr
testsuite/tests/typecheck/should_fail/tcfail083.stderr
testsuite/tests/typecheck/should_fail/tcfail097.stderr
testsuite/tests/typecheck/should_fail/tcfail098.stderr
testsuite/tests/typecheck/should_fail/tcfail128.stderr
testsuite/tests/typecheck/should_fail/tcfail133.stderr
testsuite/tests/typecheck/should_fail/tcfail142.stderr
testsuite/tests/typecheck/should_fail/tcfail181.stderr
testsuite/tests/typecheck/should_run/tcrun035.stderr

index 134694a..f13b2f0 100644 (file)
@@ -5,5 +5,5 @@ module T3101 where
 
 type family F a :: *
 
-data Boom = Boom (forall a. F a)
+data Boom = Boom (forall a. a -> F a)
   deriving Show
index cb1259c..6495b62 100644 (file)
@@ -2,8 +2,13 @@
 module Bug where
 class A a oops
 data D d = D d
+
 instance A a oops => Read (D a)
+-- Actually this instance is ambiguous 
+-- and is now rightly rejected
+
 data E e = E (D e) deriving Read
+
 instance A Int Bool
 
 
index d74166e..9de62ef 100644 (file)
@@ -1,12 +1,10 @@
-
-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)
-    Note: there is a potential instance available:
-      instance A Int Bool -- Defined at T5287.hs:7:10
-    Possible fix:
-      use a standalone 'deriving instance' declaration,
-        so you can specify the instance context yourself
-    When deriving the instance for (Read (E e))
+\r
+T5287.hs:6:10:\r
+    Could not deduce (A a oops0)\r
+      arising from the ambiguity check for an instance declaration\r
+    from the context (A a oops)\r
+      bound by an instance declaration: A a oops => Read (D a)\r
+      at T5287.hs:6:10-31\r
+    The type variable `oops0' is ambiguous\r
+    In the ambiguity check for: forall a oops. A a oops => Read (D a)\r
+    In the instance declaration for `Read (D a)'\r
index 4b1b110..f51707a 100644 (file)
@@ -31,6 +31,7 @@ check title expected got
 
 expectedGhcOnlyExtensions :: [String]
 expectedGhcOnlyExtensions = [
+                             "AlloAmbiguousTypes",
                              "RelaxedLayout",
                              "AlternativeLayoutRule",
                              "AlternativeLayoutRuleTransitional",
index db02b16..b0937a7 100644 (file)
-
-../../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 `=='
-    In the expression: x == x
-    In an equation for `b': b x = x == x
-
-../../typecheck/should_run/Defer01.hs:25:4: Warning:
-    Couldn't match type `Int' with `Bool'
-    Inaccessible code in
-      a pattern with constructor
-        C2 :: Bool -> C Bool,
-      in an equation for `c'
-    In the pattern: C2 x
-    In an equation for `c': c (C2 x) = True
-
-../../typecheck/should_run/Defer01.hs:28:5: Warning:
-    No instance for (Num (a -> a)) arising from the literal `1'
-    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'
-    Relevant bindings include
-      f :: t (bound at ../../typecheck/should_run/Defer01.hs:31:1)
-    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 `Char' with actual type `a'
-      `a' is a rigid type variable bound by
-          the type signature for h :: a -> (Char, Char)
-          at ../../typecheck/should_run/Defer01.hs:33:6
-    Relevant bindings include
-      h :: a -> (Char, Char)
-        (bound at ../../typecheck/should_run/Defer01.hs:34:1)
-      x :: a (bound at ../../typecheck/should_run/Defer01.hs:34:3)
-    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'
-    Relevant bindings include
-      i :: a -> () (bound at ../../typecheck/should_run/Defer01.hs:39:1)
-      a :: a (bound at ../../typecheck/should_run/Defer01.hs:39:3)
-    In the return type of a call of `K'
-    In the first argument of `not', namely `(K a)'
-    In the expression: (not (K a))
-
-../../typecheck/should_run/Defer01.hs:43:5: Warning:
-    No instance for (MyClass a1) arising from a use of `myOp'
-    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)
-    Note: there are several potential instances:
-      instance Num Double -- Defined in `GHC.Float'
-      instance Num Float -- Defined in `GHC.Float'
-      instance Integral a => Num (GHC.Real.Ratio a)
-        -- Defined in `GHC.Real'
-      ...plus three others
-    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:45:6: Warning:
-    Couldn't match type `Int' with `Bool'
-    Inaccessible code in
-      the type signature for k :: Int ~ Bool => Int -> Bool
-
-../../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'
-*** Exception: ../../typecheck/should_run/Defer01.hs:11:40:
-    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 ','
-(deferred type error)
-*** Exception: ../../typecheck/should_run/Defer01.hs:14:5:
-    Couldn't match expected type `Int' with actual type `Char'
-    In the expression: 'p'
-    In an equation for `a': a = 'p'
-(deferred type error)
-*** Exception: ../../typecheck/should_run/Defer01.hs:18:9:
-    No instance for (Eq B) arising from a use of `=='
-    In the expression: x == x
-    In an equation for `b': b x = x == x
-(deferred type error)
-
-<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))'
-*** Exception: ../../typecheck/should_run/Defer01.hs:28:5:
-    No instance for (Num (a -> a)) arising from the literal `1'
-    In the expression: 1
-    In an equation for `d': d = 1
-(deferred type error)
-*** Exception: ../../typecheck/should_run/Defer01.hs:31:5:
-    Couldn't match expected type `Char -> t' with actual type `Char'
-    Relevant bindings include
-      f :: t (bound at ../../typecheck/should_run/Defer01.hs:31:1)
-    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'
-(deferred type error)
-*** Exception: ../../typecheck/should_run/Defer01.hs:34:8:
-    Couldn't match expected type `Char' with actual type `a'
-      `a' is a rigid type variable bound by
-          the type signature for h :: a -> (Char, Char)
-          at ../../typecheck/should_run/Defer01.hs:33:6
-    Relevant bindings include
-      h :: a -> (Char, Char)
-        (bound at ../../typecheck/should_run/Defer01.hs:34:1)
-      x :: a (bound at ../../typecheck/should_run/Defer01.hs:34:3)
-    In the expression: x
-    In the expression: (x, 'c')
-    In an equation for `h': h x = (x, 'c')
-(deferred type error)
-*** Exception: ../../typecheck/should_run/Defer01.hs:39:17:
-    Couldn't match expected type `Bool' with actual type `T a'
-    Relevant bindings include
-      i :: a -> () (bound at ../../typecheck/should_run/Defer01.hs:39:1)
-      a :: a (bound at ../../typecheck/should_run/Defer01.hs:39:3)
-    In the return type of a call of `K'
-    In the first argument of `not', namely `(K a)'
-    In the expression: (not (K a))
-(deferred type error)
-*** Exception: ../../typecheck/should_run/Defer01.hs:43:5:
-    No instance for (MyClass a1) arising from a use of `myOp'
-    In the expression: myOp 23
-    In an equation for `j': j = myOp 23
-(deferred type error)
-
-<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)
-*** Exception: ../../typecheck/should_run/Defer01.hs:49:5:
-    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'
-(deferred type error)
+\r
+..\..\typecheck\should_run\Defer01.hs:11:40: Warning:\r
+    Couldn't match type `Char' with `[Char]'\r
+    Expected type: String\r
+      Actual type: Char\r
+    In the first argument of `putStr', namely ','\r
+    In the second argument of `(>>)', namely putStr ','\r
+    In the expression: putStr "Hello World" >> putStr ','\r
+\r
+..\..\typecheck\should_run\Defer01.hs:14:5: Warning:\r
+    Couldn't match expected type `Int' with actual type `Char'\r
+    In the expression: 'p'\r
+    In an equation for `a': a = 'p'\r
+\r
+..\..\typecheck\should_run\Defer01.hs:18:9: Warning:\r
+    No instance for (Eq B) arising from a use of `=='\r
+    In the expression: x == x\r
+    In an equation for `b': b x = x == x\r
+\r
+..\..\typecheck\should_run\Defer01.hs:25:4: Warning:\r
+    Couldn't match type `Int' with `Bool'\r
+    Inaccessible code in\r
+      a pattern with constructor\r
+        C2 :: Bool -> C Bool,\r
+      in an equation for `c'\r
+    In the pattern: C2 x\r
+    In an equation for `c': c (C2 x) = True\r
+\r
+..\..\typecheck\should_run\Defer01.hs:28:5: Warning:\r
+    No instance for (Num (a -> a)) arising from the literal `1'\r
+    In the expression: 1\r
+    In an equation for `d': d = 1\r
+\r
+..\..\typecheck\should_run\Defer01.hs:31:5: Warning:\r
+    Couldn't match expected type `Char -> t' with actual type `Char'\r
+    Relevant bindings include\r
+      f :: t (bound at ..\..\typecheck\should_run\Defer01.hs:31:1)\r
+    The function `e' is applied to one argument,\r
+    but its type `Char' has none\r
+    In the expression: e 'q'\r
+    In an equation for `f': f = e 'q'\r
+\r
+..\..\typecheck\should_run\Defer01.hs:34:8: Warning:\r
+    Couldn't match expected type `Char' with actual type `a'\r
+      `a' is a rigid type variable bound by\r
+          the type signature for h :: a -> (Char, Char)\r
+          at ..\..\typecheck\should_run\Defer01.hs:33:6\r
+    Relevant bindings include\r
+      h :: a -> (Char, Char)\r
+        (bound at ..\..\typecheck\should_run\Defer01.hs:34:1)\r
+      x :: a (bound at ..\..\typecheck\should_run\Defer01.hs:34:3)\r
+    In the expression: x\r
+    In the expression: (x, 'c')\r
+    In an equation for `h': h x = (x, 'c')\r
+\r
+..\..\typecheck\should_run\Defer01.hs:39:17: Warning:\r
+    Couldn't match expected type `Bool' with actual type `T a'\r
+    Relevant bindings include\r
+      i :: a -> () (bound at ..\..\typecheck\should_run\Defer01.hs:39:1)\r
+      a :: a (bound at ..\..\typecheck\should_run\Defer01.hs:39:3)\r
+    In the return type of a call of `K'\r
+    In the first argument of `not', namely `(K a)'\r
+    In the expression: (not (K a))\r
+\r
+..\..\typecheck\should_run\Defer01.hs:43:5: Warning:\r
+    No instance for (MyClass a1) arising from a use of `myOp'\r
+    In the expression: myOp 23\r
+    In an equation for `j': j = myOp 23\r
+\r
+..\..\typecheck\should_run\Defer01.hs:43:10: Warning:\r
+    No instance for (Num a1) arising from the literal `23'\r
+    The type variable `a1' is ambiguous\r
+    Note: there are several potential instances:\r
+      instance Num Double -- Defined in `GHC.Float'\r
+      instance Num Float -- Defined in `GHC.Float'\r
+      instance Integral a => Num (GHC.Real.Ratio a)\r
+        -- Defined in `GHC.Real'\r
+      ...plus three others\r
+    In the first argument of `myOp', namely `23'\r
+    In the expression: myOp 23\r
+    In an equation for `j': j = myOp 23\r
+\r
+..\..\typecheck\should_run\Defer01.hs:45:6: Warning:\r
+    Couldn't match type `Int' with `Bool'\r
+    Inaccessible code in\r
+      the type signature for k :: Int ~ Bool => Int -> Bool\r
+    In the ambiguity check for: Int ~ Bool => Int -> Bool\r
+    In the type signature for `k': k :: Int ~ Bool => Int -> Bool\r
+\r
+..\..\typecheck\should_run\Defer01.hs:45:6: Warning:\r
+    Couldn't match type `Int' with `Bool'\r
+    Inaccessible code in\r
+      the type signature for k :: Int ~ Bool => Int -> Bool\r
+\r
+..\..\typecheck\should_run\Defer01.hs:46:7: Warning:\r
+    Couldn't match expected type `Bool' with actual type `Int'\r
+    In the expression: x\r
+    In an equation for `k': k x = x\r
+\r
+..\..\typecheck\should_run\Defer01.hs:49:5: Warning:\r
+    Couldn't match expected type `IO a0'\r
+                with actual type `Char -> IO ()'\r
+    In the first argument of `(>>)', namely `putChar'\r
+    In the expression: putChar >> putChar 'p'\r
+    In an equation for `l': l = putChar >> putChar 'p'\r
+*** Exception: ..\..\typecheck\should_run\Defer01.hs:11:40:\r
+    Couldn't match type `Char' with `[Char]'\r
+    Expected type: String\r
+      Actual type: Char\r
+    In the first argument of `putStr', namely ','\r
+    In the second argument of `(>>)', namely putStr ','\r
+    In the expression: putStr "Hello World" >> putStr ','\r
+(deferred type error)\r
+*** Exception: ..\..\typecheck\should_run\Defer01.hs:14:5:\r
+    Couldn't match expected type `Int' with actual type `Char'\r
+    In the expression: 'p'\r
+    In an equation for `a': a = 'p'\r
+(deferred type error)\r
+*** Exception: ..\..\typecheck\should_run\Defer01.hs:18:9:\r
+    No instance for (Eq B) arising from a use of `=='\r
+    In the expression: x == x\r
+    In an equation for `b': b x = x == x\r
+(deferred type error)\r
+\r
+<interactive>:8:11:\r
+    Couldn't match type `Bool' with `Int'\r
+    Expected type: C Int\r
+      Actual type: C Bool\r
+    In the return type of a call of `C2'\r
+    In the first argument of `c', namely `(C2 True)'\r
+    In the first argument of `print', namely `(c (C2 True))'\r
+*** Exception: ..\..\typecheck\should_run\Defer01.hs:28:5:\r
+    No instance for (Num (a -> a)) arising from the literal `1'\r
+    In the expression: 1\r
+    In an equation for `d': d = 1\r
+(deferred type error)\r
+*** Exception: ..\..\typecheck\should_run\Defer01.hs:31:5:\r
+    Couldn't match expected type `Char -> t' with actual type `Char'\r
+    Relevant bindings include\r
+      f :: t (bound at ..\..\typecheck\should_run\Defer01.hs:31:1)\r
+    The function `e' is applied to one argument,\r
+    but its type `Char' has none\r
+    In the expression: e 'q'\r
+    In an equation for `f': f = e 'q'\r
+(deferred type error)\r
+*** Exception: ..\..\typecheck\should_run\Defer01.hs:34:8:\r
+    Couldn't match expected type `Char' with actual type `a'\r
+      `a' is a rigid type variable bound by\r
+          the type signature for h :: a -> (Char, Char)\r
+          at ..\..\typecheck\should_run\Defer01.hs:33:6\r
+    Relevant bindings include\r
+      h :: a -> (Char, Char)\r
+        (bound at ..\..\typecheck\should_run\Defer01.hs:34:1)\r
+      x :: a (bound at ..\..\typecheck\should_run\Defer01.hs:34:3)\r
+    In the expression: x\r
+    In the expression: (x, 'c')\r
+    In an equation for `h': h x = (x, 'c')\r
+(deferred type error)\r
+*** Exception: ..\..\typecheck\should_run\Defer01.hs:39:17:\r
+    Couldn't match expected type `Bool' with actual type `T a'\r
+    Relevant bindings include\r
+      i :: a -> () (bound at ..\..\typecheck\should_run\Defer01.hs:39:1)\r
+      a :: a (bound at ..\..\typecheck\should_run\Defer01.hs:39:3)\r
+    In the return type of a call of `K'\r
+    In the first argument of `not', namely `(K a)'\r
+    In the expression: (not (K a))\r
+(deferred type error)\r
+*** Exception: ..\..\typecheck\should_run\Defer01.hs:43:5:\r
+    No instance for (MyClass a1) arising from a use of `myOp'\r
+    In the expression: myOp 23\r
+    In an equation for `j': j = myOp 23\r
+(deferred type error)\r
+\r
+<interactive>:14:8:\r
+    Couldn't match expected type `Bool' with actual type `Int'\r
+    In the first argument of `print', namely `(k 2)'\r
+    In the expression: print (k 2)\r
+    In an equation for `it': it = print (k 2)\r
+*** Exception: ..\..\typecheck\should_run\Defer01.hs:49:5:\r
+    Couldn't match expected type `IO a0'\r
+                with actual type `Char -> IO ()'\r
+    In the first argument of `(>>)', namely `putChar'\r
+    In the expression: putChar >> putChar 'p'\r
+    In an equation for `l': l = putChar >> putChar 'p'\r
+(deferred type error)\r
index 4eb5124..89362f3 100644 (file)
@@ -22,17 +22,17 @@ data Type a where
 
 data Expr :: * -> * -> * {- tu a -} where
     Const :: Type a -> a -> Expr tu (TU tu a)
-    Var2  :: String -> TU tu (Type a) -> Expr tu (TU tu a)
+    Var2  :: a -> TU tu (Type a) -> Expr tu (TU tu a)
 
 bug1 :: Expr Typed Bool -> ()
 bug1 (Const TypeBool False) = ()
 
 bug2a :: Expr Typed Bool -> ()
-bug2a (Var2 "x" (TypeBool :: Type Bool)) = ()
+bug2a (Var2 x (TypeBool :: Type Bool)) = ()
 
 bug2c :: Expr Typed Bool -> ()
-bug2c (Var2 "x" TypeBool) = ()
+bug2c (Var2 x TypeBool) = ()
 
 bug2b :: Expr Typed (TU Typed Bool) -> ()
-bug2b (Var2 "x" TypeBool) = ()
+bug2b (Var2 x TypeBool) = ()
 
index 69a6481..44b9656 100644 (file)
@@ -9,6 +9,6 @@ data T a where
 
 type family F a
 
-bar :: T (F a) -> ()
-bar T = ()
+bar :: a -> T (F a) -> ()
+bar T = ()
 
index d738b0b..8df1fd4 100644 (file)
@@ -6,5 +6,5 @@ module ShouldCompile where
 
 type family Element c :: *
 
-f :: Element x
-f = undefined
+f :: x -> Element x
+f = undefined
index 658821e..906fdaf 100644 (file)
@@ -4,5 +4,5 @@ module ShouldCompile where
 
 type family T a
 
-f :: T a -> Int
-f x = x `seq` 3
+f :: a -> T a -> Int
+f x = x `seq` 3
index 0d8a459..5eee19a 100644 (file)
@@ -7,7 +7,6 @@ T3208b.hs:15:10:
       at T3208b.hs:14:9-56\r
     NB: `STerm' is a type function, and may not be injective\r
     The type variable `o0' is ambiguous\r
-    Possible fix: add a type signature that fixes these type variable(s)\r
     Expected type: STerm o0\r
       Actual type: OTerm o0\r
     Relevant bindings include\r
@@ -23,7 +22,6 @@ T3208b.hs:15:15:
                  fce' :: (OTerm a ~ STerm a, OBJECT a, SUBST a) => a -> c\r
       at T3208b.hs:14:9-56\r
     The type variable `o0' is ambiguous\r
-    Possible fix: add a type signature that fixes these type variable(s)\r
     Relevant bindings include\r
       fce' :: a -> c (bound at T3208b.hs:15:1)\r
       f :: a (bound at T3208b.hs:15:6)\r
index 14f675c..6290287 100644 (file)
@@ -30,5 +30,5 @@ joinPatches = id
 \r
 cleverNamedResolve :: (Conflict (OnPrim p)\r
                       ,PrimOf (OnPrim p) ~ WithName (PrimOf p))\r
-                   => FL (OnPrim p) -> WithName (PrimOf p)\r
-cleverNamedResolve = resolveConflicts . joinPatches\r
+                   => p -> FL (OnPrim p) -> WithName (PrimOf p)\r
+cleverNamedResolve = resolveConflicts . joinPatches\r
index d18d67e..716f161 100644 (file)
@@ -27,5 +27,5 @@ joinPatches = id
 \r
 cleverNamedResolve :: (Conflict (OnPrim p)\r
                       ,PrimOf (OnPrim p) ~ WithName (PrimOf p))\r
-                   => FL (OnPrim p) -> WithName (PrimOf p)\r
-cleverNamedResolve = resolveConflicts . joinPatches\r
+                   => p -> FL (OnPrim p) -> WithName (PrimOf p)\r
+cleverNamedResolve = resolveConflicts . joinPatches\r
index 9e0eda5..fe810f2 100644 (file)
@@ -27,5 +27,18 @@ joinPatches = id
 \r
 cleverNamedResolve :: (Conflict (OnPrim p)\r
                       ,PrimOf (OnPrim p) ~ WithName (PrimOf p))\r
-                   => FL (OnPrim p) -> WithName (PrimOf p)\r
-cleverNamedResolve = resolveConflicts . joinPatches\r
+                   => p -> FL (OnPrim p) -> WithName (PrimOf p)\r
+cleverNamedResolve x = resolveConflicts . joinPatches\r
+-- I added the parameter 'x' to make the signature unambiguous\r
+-- I don't think that ambiguity is essential to the original problem\r
+\r
+{-\r
+resolveConflicts :: q -> PrimOf q\r
+ (w) FL (OnPrim p) ~ q\r
+ (w) WithName (PrimOf p) ~ PrimOf q\r
+==>\r
+ (w) PrimOf (OnPrim p) ~ PrimOf (FL (OnPrim p))\r
+==>\r
+ (w) PrimOf (OnPrim p) ~ PrimOf (OnPrim p)\r
+\r
+-}
\ No newline at end of file
index b8a45c3..0176ffe 100644 (file)
@@ -1,16 +1,13 @@
-
-NoMatchErr.hs:20:5:
-    Could not deduce (Memo d0 ~ Memo d)
-    from the context (Fun d)
-      bound by the type signature for f :: Fun d => Memo d a -> Memo d a
-      at NoMatchErr.hs:19:7-37
-    NB: `Memo' is a type function, and may not be injective
-    The type variable `d0' is ambiguous
-    Possible fix: add a type signature that fixes these type variable(s)
-    Expected type: (d0 -> a) -> Memo d a
-      Actual type: (d0 -> a) -> Memo d0 a
-    Relevant bindings include
-      f :: Memo d a -> Memo d a (bound at NoMatchErr.hs:20:1)
-    In the first argument of `(.)', namely `abst'
-    In the expression: abst . appl
-    In an equation for `f': f = abst . appl
+\r
+NoMatchErr.hs:19:7:\r
+    Could not deduce (Memo d0 ~ Memo d)\r
+    from the context (Fun d)\r
+      bound by the type signature for f :: Fun d => Memo d a -> Memo d a\r
+      at NoMatchErr.hs:19:7-37\r
+    NB: `Memo' is a type function, and may not be injective\r
+    The type variable `d0' is ambiguous\r
+    Expected type: Memo d a -> Memo d a\r
+      Actual type: Memo d0 a -> Memo d0 a\r
+    In the ambiguity check for:\r
+      forall d a. Fun d => Memo d a -> Memo d a\r
+    In the type signature for `f': f :: Fun d => Memo d a -> Memo d a\r
index 25fca9a..07a13e0 100644 (file)
@@ -7,8 +7,8 @@ type instance where
   F a a = Int
   F a b = b
 
-g :: F a Bool
-g = False
+g :: a -> F a Bool
+g = False
 
 
 
index c8f68ba..63fa4d9 100644 (file)
@@ -1,7 +1,8 @@
-
-Overlap10.hs:11:5:
-    Couldn't match expected type `F a Bool' with actual type `Bool'
-    Relevant bindings include
-      g :: F a Bool (bound at Overlap10.hs:11:1)
-    In the expression: False
-    In an equation for `g': g = False
+\r
+Overlap10.hs:11:7:\r
+    Couldn't match expected type `F a Bool' with actual type `Bool'\r
+    Relevant bindings include\r
+      g :: a -> F a Bool (bound at Overlap10.hs:11:1)\r
+      x :: a (bound at Overlap10.hs:11:3)\r
+    In the expression: False\r
+    In an equation for `g': g x = False\r
index f103759..1498d59 100644 (file)
@@ -7,8 +7,8 @@ type instance where
   F a a = Int
   F a b = b
 
-g :: F a Int
-g = (5 :: Int)
+g :: a -> F a Int
+g = (5 :: Int)
 
 
 
index 0d657da..929ce34 100644 (file)
@@ -1,6 +1,8 @@
-
-Overlap11.hs:11:6:
-    Couldn't match expected type `F a Int' with actual type `Int'
-    Relevant bindings include g :: F a Int (bound at Overlap11.hs:11:1)
-    In the expression: (5 :: Int)
-    In an equation for `g': g = (5 :: Int)
+\r
+Overlap11.hs:11:8:\r
+    Couldn't match expected type `F a Int' with actual type `Int'\r
+    Relevant bindings include\r
+      g :: a -> F a Int (bound at Overlap11.hs:11:1)\r
+      x :: a (bound at Overlap11.hs:11:3)\r
+    In the expression: (5 :: Int)\r
+    In an equation for `g': g x = (5 :: Int)\r
index 4ccdbc3..3ad3cc7 100644 (file)
@@ -1,12 +1,9 @@
-
-SimpleFail16.hs:10:12:
-    Couldn't match expected type `p0 a0' with actual type `F ()'
-    The type variables `p0', `a0' are ambiguous
-    Possible cause: the monomorphism restriction applied to: `bar'
-    Probable fix: give these definition(s) an explicit type signature
-                  or use -XNoMonomorphismRestriction
-    Relevant bindings include
-      bar :: p0 a0 (bound at SimpleFail16.hs:10:1)
-    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
+    Relevant bindings include\r
+      bar :: p0 a0 (bound at SimpleFail16.hs:10:1)\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 7311270..32bb3cf 100644 (file)
@@ -1,15 +1,14 @@
-
-T1897b.hs:16:1:
-    Could not deduce (Depend a0 ~ Depend a)
-    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
-    The type variable `a0' is ambiguous
-    Possible fix: add a type signature that fixes these type variable(s)
-    Expected type: [Depend a] -> Bool
-      Actual type: [Depend a0] -> Bool
-    When checking that `isValid'
-      has the inferred type `forall a. Bug a => [Depend a] -> Bool'
-    Probable cause: the inferred type is ambiguous
+\r
+T1897b.hs:16:1:\r
+    Could not deduce (Depend a0 ~ Depend a)\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
+    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 93b566d..6d7eb62 100644 (file)
@@ -1,21 +1,13 @@
-
-T1900.hs:11:12:
-    No instance for (Num ()) arising from a use of `+'
-    In the expression: (+ 1)
-    In an equation for `trans': trans = (+ 1)
-    In the instance declaration for `Bug Int'
-
-T1900.hs:14:16:
-    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:13:10-36
-    NB: `Depend' is a type function, and may not be injective
-    The type variable `s0' is ambiguous
-    Possible fix: add a type signature that fixes these type variable(s)
-    Relevant bindings include
-      check :: Depend s -> Bool (bound at T1900.hs:14:1)
-      d :: Depend s (bound at T1900.hs:14:7)
-    In the return type of a call of `trans'
-    In the second argument of `(==)', namely `trans d'
-    In the expression: d == trans d
+\r
+T1900.hs:13:10:\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:13:10-36\r
+    NB: `Depend' is a type function, and may not be injective\r
+    The type variable `s0' is ambiguous\r
+    Expected type: Depend s -> Bool\r
+      Actual type: Depend s0 -> Bool\r
+    In the ambiguity check for: forall s. Bug s => Depend s -> Bool\r
+    In the type signature for `check':\r
+      check :: Bug s => Depend s -> Bool\r
index bd81672..fae7cbf 100644 (file)
@@ -1,30 +1,28 @@
-
-T2544.hs:15:18:
-    Could not deduce (IxMap i0 ~ IxMap l)
-    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 `i0' is ambiguous
-    Possible fix: add a type signature that fixes these type variable(s)
-    Expected type: IxMap l [Int]
-      Actual type: IxMap i0 [Int]
-    Relevant bindings include
-      empty :: IxMap (l :|: r) [Int] (bound at T2544.hs:15:4)
-    In the first argument of `BiApp', namely `empty'
-    In the expression: BiApp empty empty
-    In an equation for `empty': empty = BiApp empty empty
-
-T2544.hs:15:24:
-    Could not deduce (IxMap i1 ~ IxMap r)
-    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 r [Int]
-      Actual type: IxMap i1 [Int]
-    Relevant bindings include
-      empty :: IxMap (l :|: r) [Int] (bound at T2544.hs:15:4)
-    In the second argument of `BiApp', namely `empty'
-    In the expression: BiApp empty empty
-    In an equation for `empty': empty = BiApp empty empty
+\r
+T2544.hs:15:18:\r
+    Could not deduce (IxMap i0 ~ IxMap l)\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
+    The type variable `i0' is ambiguous\r
+    Expected type: IxMap l [Int]\r
+      Actual type: IxMap i0 [Int]\r
+    Relevant bindings include\r
+      empty :: IxMap (l :|: r) [Int] (bound at T2544.hs:15:4)\r
+    In the first argument of `BiApp', namely `empty'\r
+    In the expression: BiApp empty empty\r
+    In an equation for `empty': empty = BiApp empty empty\r
+\r
+T2544.hs:15:24:\r
+    Could not deduce (IxMap i1 ~ IxMap r)\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
+    The type variable `i1' is ambiguous\r
+    Expected type: IxMap r [Int]\r
+      Actual type: IxMap i1 [Int]\r
+    Relevant bindings include\r
+      empty :: IxMap (l :|: r) [Int] (bound at T2544.hs:15:4)\r
+    In the second argument of `BiApp', namely `empty'\r
+    In the expression: BiApp empty empty\r
+    In an equation for `empty': empty = BiApp empty empty\r
index acf77ab..871d455 100644 (file)
@@ -1,9 +1,8 @@
-
-T2627b.hs:20:24:
-    Occurs check: cannot construct the infinite type:
-      a0 ~ Dual (Dual a0)
-    The type variable `a0' is ambiguous
-    Possible fix: add a type signature that fixes these type variable(s)
-    In the expression: conn undefined undefined
-    In an equation for `conn':
-        conn (Rd k) (Wr a r) = conn undefined undefined
+\r
+T2627b.hs:20:24:\r
+    Occurs check: cannot construct the infinite type:\r
+      a0 ~ Dual (Dual a0)\r
+    The type variable `a0' is ambiguous\r
+    In the expression: conn undefined undefined\r
+    In an equation for `conn':\r
+        conn (Rd k) (Wr a r) = conn undefined undefined\r
index e986652..d60293a 100644 (file)
@@ -1,4 +1,5 @@
-{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE AllowAmbiguousTypes, TypeFamilies #-}
+-- Type of x is ambiguous
 
 module T2693 where
 
index b02edd1..4427018 100644 (file)
@@ -1,9 +1,8 @@
 \r
-T2693.hs:10:7:\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
-    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
@@ -15,28 +14,25 @@ T2693.hs:10:7:
                  let n = ...;\r
                  return () }\r
 \r
-T2693.hs:18:15:\r
+T2693.hs:19:15:\r
     Couldn't match expected type `(a2, b0)' with actual type `TFn a3'\r
     The type variables `a2', `b0', `a3' are ambiguous\r
-    Possible fix: add a type signature that fixes these type variable(s)\r
-    Relevant bindings include n :: a2 (bound at T2693.hs:18:7)\r
+    Relevant bindings include n :: a2 (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
     In the expression: fst x + snd x\r
 \r
-T2693.hs:18:23:\r
+T2693.hs:19:23:\r
     Couldn't match expected type `(a4, a2)' with actual type `TFn a5'\r
     The type variables `a2', `a4', `a5' are ambiguous\r
-    Possible fix: add a type signature that fixes these type variable(s)\r
-    Relevant bindings include n :: a2 (bound at T2693.hs:18:7)\r
+    Relevant bindings include n :: a2 (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
     In the expression: fst x + snd x\r
 \r
-T2693.hs:28:20:\r
+T2693.hs:29:20:\r
     Couldn't match type `TFn a0' with `PVR a1'\r
     The type variables `a0', `a1' are ambiguous\r
-    Possible fix: add a type signature that fixes these type variable(s)\r
     Expected type: () -> Maybe (PVR a1)\r
       Actual type: () -> Maybe (TFn a0)\r
     In the first argument of `mapM', namely `g'\r
index 1ca3c7a..e0c4117 100644 (file)
@@ -4,11 +4,11 @@ module T4099 where
 
 type family T a
 
-foo :: T a -> Int
+foo :: a -> T a -> Int
 foo x = error "urk"
 
-bar1 :: T b -> Int
-bar1 x = foo x
+bar1 :: b -> T b -> Int
+bar1 a x = foo (error "urk") x
 
-bar2 :: Maybe b -> Int
-bar2 x = foo x
+bar2 :: b -> Maybe b -> Int
+bar2 a x = foo (error "urk") x
index 74410ec..60e3795 100644 (file)
@@ -1,23 +1,23 @@
-
-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)
-    Relevant bindings include
-      bar1 :: T b -> Int (bound at T4099.hs:11:1)
-      x :: T b (bound at T4099.hs:11:6)
-    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)
-    Relevant bindings include
-      bar2 :: Maybe b -> Int (bound at T4099.hs:14:1)
-      x :: Maybe b (bound at T4099.hs:14:6)
-    In the first argument of `foo', namely `x'
-    In the expression: foo x
-    In an equation for `bar2': bar2 x = foo x
+\r
+T4099.hs:11:30:\r
+    Couldn't match expected type `T a0' with actual type `T b'\r
+    NB: `T' is a type function, and may not be injective\r
+    The type variable `a0' is ambiguous\r
+    Relevant bindings include\r
+      bar1 :: b -> T b -> Int (bound at T4099.hs:11:1)\r
+      a :: b (bound at T4099.hs:11:6)\r
+      x :: T b (bound at T4099.hs:11:8)\r
+    In the second argument of `foo', namely `x'\r
+    In the expression: foo (error "urk") x\r
+    In an equation for `bar1': bar1 a x = foo (error "urk") x\r
+\r
+T4099.hs:14:30:\r
+    Couldn't match expected type `T a1' with actual type `Maybe b'\r
+    The type variable `a1' is ambiguous\r
+    Relevant bindings include\r
+      bar2 :: b -> Maybe b -> Int (bound at T4099.hs:14:1)\r
+      a :: b (bound at T4099.hs:14:6)\r
+      x :: Maybe b (bound at T4099.hs:14:8)\r
+    In the second argument of `foo', namely `x'\r
+    In the expression: foo (error "urk") x\r
+    In an equation for `bar2': bar2 a x = foo (error "urk") x\r
index d07eedc..3588869 100644 (file)
@@ -1,31 +1,30 @@
-
-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")
-
-T4485.hs:47:26:
-    No instance for (XMLGen m0) arising from a use of `genElement'
-    The type variable `m0' is ambiguous
-    Possible fix: add a type signature that fixes these type variable(s)
-    Note: there is a potential instance available:
-      instance [overlap ok] XMLGen (IdentityT m)
-        -- Defined at T4485.hs:36:10
-    In the second argument of `($)', namely `(genElement "foo")'
-    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) arising from a use of `genElement'\r
+    The type variable `m0' is ambiguous\r
+    Note: there is a potential instance available:\r
+      instance [overlap ok] XMLGen (IdentityT m)\r
+        -- Defined at T4485.hs:36:10\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 2af0b97..892340e 100644 (file)
@@ -1,4 +1,6 @@
-{-# LANGUAGE RankNTypes, TypeFamilies, KindSignatures #-}
+{-# LANGUAGE AllowAmbiguousTypes, RankNTypes, TypeFamilies, KindSignatures #-}
+
+-- The type of 'run' is actually ambiguous
 
 module T5934 where
 import Control.Monad.ST
index 387dde4..8925899 100644 (file)
@@ -1,5 +1,5 @@
 \r
-T5934.hs:10:7:\r
+T5934.hs:12:7:\r
     Cannot instantiate unification variable `a0'\r
     with a type involving foralls: (forall s. GenST s) -> Int\r
       Perhaps you want -XImpredicativeTypes\r
index 4f7f691..cf8eedd 100644 (file)
@@ -1,11 +1,7 @@
-
-T6123.hs:10:14:
-    Occurs check: cannot construct the infinite type: a0 ~ Id a0
-    The type variable `a0' is ambiguous
-    Possible cause: the monomorphism restriction applied to:
-      `cundefined'
-    Probable fix: give these definition(s) an explicit type signature
-                  or use -XNoMonomorphismRestriction
-    Relevant bindings include cundefined :: a0 (bound at T6123.hs:10:1)
-    In the expression: cid undefined
-    In an equation for `cundefined': cundefined = cid undefined
+\r
+T6123.hs:10:14:\r
+    Occurs check: cannot construct the infinite type: a0 ~ Id a0\r
+    The type variable `a0' is ambiguous\r
+    Relevant bindings include cundefined :: a0 (bound at T6123.hs:10:1)\r
+    In the expression: cid undefined\r
+    In an equation for `cundefined': cundefined = cid undefined\r
index 132a153..96e75d9 100644 (file)
@@ -11,11 +11,11 @@ convert = convert
 type family Foo a 
 type instance Foo Int = Bool
 
-barT5770 :: forall a b c dummya. (b -> c) -> ((Foo a) -> c)
-barT5770 f = (convert f :: (Foo a) -> c)
+barT5770 :: forall a b c dummya. (b -> c) -> Foo a -> a
+barT5770 f = (convert f :: Foo a -> a)
 
-barT5769 :: forall b a. b -> (Foo a)
-barT5769 f = (convert f :: (Foo a))
+barT5769 :: forall b a. b -> (a, Foo a)
+barT5769 f = (convert f :: (a, Foo a))
 
-barT5768 :: forall b a. b -> (Foo a)
-barT5768 f = (convert f :: (Foo a))
+barT5768 :: forall a b. b -> (a, Foo a)
+barT5768 f = (convert f :: (a, Foo a))
index f981239..a044efe 100644 (file)
@@ -7,9 +7,15 @@ module T6020 where
 class Id (a :: k) (b :: k) | a -> b\r
 instance Id a a\r
 \r
-class Test (x :: a) (y :: a) | x -> y\r
-instance (Id x y, Id y z) => Test x z\r
+f :: Id x y => x -> y\r
+f = f\r
 \r
-test :: Test True True => ()\r
-test = ()\r
+--class Test (x :: a) (y :: a) | x -> y\r
+--instance (Id x y, Id y z) => Test x z\r
+\r
+-- (Id x0 y0, Id y0 z0, x~x0, z~z0)\r
+-- (Id x y0, Id y0 z, y0~z, y0~y)\r
+\r
+--test :: Test True True => ()\r
+--test = ()\r
 \r
index 855633b..2364b0c 100644 (file)
@@ -21,6 +21,8 @@ type family (a :: Nat) :==: (b :: Nat) :: Bool
 boolToProp :: (a :==: b) ~ True => Dict (a ~ b)
 boolToProp = undefined
 
-foo :: forall n. (Succ n :==: Plus n One) ~ True => ()
+data T (n :: Nat) = MkT
+
+foo :: forall n. (Succ n :==: Plus n One) ~ True => T n
 foo = case (boolToProp :: Dict (Succ n ~ Plus n One)) of
-           Dict -> ()
+           Dict -> MkT
index 5130968..a12cef0 100644 (file)
@@ -1,70 +1,67 @@
-
-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)
-    Relevant bindings include
-      test_do :: IO a -> IO (Maybe b) -> IO b
-        (bound at rebindable6.hs:104:9)
-      f :: IO a (bound at rebindable6.hs:104:17)
-      g :: IO (Maybe b) (bound at rebindable6.hs:104:19)
-    Note: there is a potential instance available:
-      instance HasSeq (IO a -> IO b -> IO b)
-        -- Defined at rebindable6.hs:52:18
-    In a stmt of a 'do' block: f
-    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
-    The type variables `t0', `t1' are ambiguous
-    Possible fix: add a type signature that fixes these type variable(s)
-    Relevant bindings include
-      test_do :: IO a -> IO (Maybe b) -> IO b
-        (bound at rebindable6.hs:104:9)
-      g :: IO (Maybe b) (bound at rebindable6.hs:104:19)
-    Note: there is a potential instance available:
-      instance HasBind (IO a -> (a -> IO b) -> IO b)
-        -- Defined at rebindable6.hs:47:18
-    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: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)
-    Relevant bindings include
-      test_do :: IO a -> IO (Maybe b) -> IO b
-        (bound at rebindable6.hs:104:9)
-      g :: IO (Maybe b) (bound at rebindable6.hs:104:19)
-      b :: b (bound at rebindable6.hs:107:23)
-    Note: there is a potential instance available:
-      instance HasReturn (a -> IO a) -- Defined at rebindable6.hs:42:18
-    In a stmt of a 'do' block: return b
-    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 }
+\r
+rebindable6.hs:106:17:\r
+    No instance for (HasSeq (IO a -> t0 -> IO b))\r
+      arising from a do statement\r
+    The type variable `t0' is ambiguous\r
+    Relevant bindings include\r
+      test_do :: IO a -> IO (Maybe b) -> IO b\r
+        (bound at rebindable6.hs:104:9)\r
+      f :: IO a (bound at rebindable6.hs:104:17)\r
+      g :: IO (Maybe b) (bound at rebindable6.hs:104:19)\r
+    Note: there is a potential instance available:\r
+      instance HasSeq (IO a -> IO b -> IO b)\r
+        -- Defined at rebindable6.hs:52:18\r
+    In a stmt of a 'do' block: f\r
+    In the expression:\r
+      do { f;\r
+           Just (b :: b) <- g;\r
+           return b }\r
+    In an equation for `test_do':\r
+        test_do f g\r
+          = do { f;\r
+                 Just (b :: b) <- g;\r
+                 return b }\r
+\r
+rebindable6.hs:107:17:\r
+    No instance for (HasBind (IO (Maybe b) -> (Maybe b -> t1) -> t0))\r
+      arising from a do statement\r
+    The type variables `t0', `t1' are ambiguous\r
+    Relevant bindings include\r
+      test_do :: IO a -> IO (Maybe b) -> IO b\r
+        (bound at rebindable6.hs:104:9)\r
+      g :: IO (Maybe b) (bound at rebindable6.hs:104:19)\r
+    Note: there is a potential instance available:\r
+      instance HasBind (IO a -> (a -> IO b) -> IO b)\r
+        -- Defined at rebindable6.hs:47:18\r
+    In a stmt of a 'do' block: Just (b :: b) <- g\r
+    In the expression:\r
+      do { f;\r
+           Just (b :: b) <- g;\r
+           return b }\r
+    In an equation for `test_do':\r
+        test_do f g\r
+          = do { f;\r
+                 Just (b :: b) <- g;\r
+                 return b }\r
+\r
+rebindable6.hs:108:17:\r
+    No instance for (HasReturn (b -> t1))\r
+      arising from a use of `return'\r
+    The type variable `t1' is ambiguous\r
+    Relevant bindings include\r
+      test_do :: IO a -> IO (Maybe b) -> IO b\r
+        (bound at rebindable6.hs:104:9)\r
+      g :: IO (Maybe b) (bound at rebindable6.hs:104:19)\r
+      b :: b (bound at rebindable6.hs:107:23)\r
+    Note: there is a potential instance available:\r
+      instance HasReturn (a -> IO a) -- Defined at rebindable6.hs:42:18\r
+    In a stmt of a 'do' block: return b\r
+    In the expression:\r
+      do { f;\r
+           Just (b :: b) <- g;\r
+           return b }\r
+    In an equation for `test_do':\r
+        test_do f g\r
+          = do { f;\r
+                 Just (b :: b) <- g;\r
+                 return b }\r
index b877da6..99b7a7a 100644 (file)
@@ -6,11 +6,14 @@ module T7360 where
 data Foo = Foo1 | Foo2 | Foo3 !Int
     
 fun1 :: Foo -> ()
+{-# NOINLINE fun1 #-}
 fun1 x = case x of
                Foo1 -> ()
                Foo2 -> ()
                Foo3 {} -> ()
 
-fun2 x = case x of
+fun2 x = (fun1 Foo1,  -- Keep -ddump-simpl output 
+                      -- in a predicatable order
+         case x of
           [] -> length x
-          (_:_) -> length x
+          (_:_) -> length x)
index 5cc46cb..895a411 100644 (file)
@@ -1,47 +1,50 @@
-
-==================== Tidy Core ====================
-Result size of Tidy Core = {terms: 20, types: 17, coercions: 0}
-
-T7360.$WFoo3 [InlPrag=INLINE] :: GHC.Types.Int -> T7360.Foo
-[GblId[DataConWrapper],
- Arity=1,
- Caf=NoCafRefs,
- Str=DmdType S,
- Unf=Unf{Src=InlineStable, TopLvl=True, Arity=1, Value=True,
-         ConLike=True, WorkFree=True, Expandable=True,
-         Guidance=ALWAYS_IF(unsat_ok=False,boring_ok=False)
-         Tmpl= \ (dt [Occ=Once] :: GHC.Types.Int) ->
-                 case dt of dt { __DEFAULT -> T7360.Foo3 dt }}]
-T7360.$WFoo3 =
-  \ (dt [Occ=Once] :: GHC.Types.Int) ->
-    case dt of dt { __DEFAULT -> T7360.Foo3 dt }
-
-T7360.fun1 :: T7360.Foo -> ()
-[GblId,
- Arity=1,
- Caf=NoCafRefs,
- Str=DmdType S,
- Unf=Unf{Src=<vanilla>, TopLvl=True, Arity=1, Value=True,
-         ConLike=True, WorkFree=True, Expandable=True,
-         Guidance=ALWAYS_IF(unsat_ok=True,boring_ok=True)}]
-T7360.fun1 =
-  \ (x :: T7360.Foo) -> case x of _ { __DEFAULT -> GHC.Tuple.() }
-
-T7360.fun2 :: forall a. [a] -> GHC.Types.Int
-[GblId,
- Arity=1,
- Caf=NoCafRefs,
- Str=DmdType Sm,
- Unf=Unf{Src=InlineStable, TopLvl=True, Arity=1, Value=True,
-         ConLike=True, WorkFree=True, Expandable=True,
-         Guidance=ALWAYS_IF(unsat_ok=True,boring_ok=False)
-         Tmpl= \ (@ a) (x [Occ=Once] :: [a]) ->
-                 case GHC.List.$wlen @ a x 0 of ww { __DEFAULT ->
-                 GHC.Types.I# ww
-                 }}]
-T7360.fun2 =
-  \ (@ a) (x :: [a]) ->
-    case GHC.List.$wlen @ a x 0 of ww { __DEFAULT -> GHC.Types.I# ww }
-
-
-
+\r
+==================== Tidy Core ====================\r
+Result size of Tidy Core = {terms: 25, types: 22, coercions: 0}\r
+\r
+T7360.$WFoo3 [InlPrag=INLINE] :: GHC.Types.Int -> T7360.Foo\r
+[GblId[DataConWrapper],\r
+ Arity=1,\r
+ Caf=NoCafRefs,\r
+ Str=DmdType S,\r
+ Unf=Unf{Src=InlineStable, TopLvl=True, Arity=1, Value=True,\r
+         ConLike=True, WorkFree=True, Expandable=True,\r
+         Guidance=ALWAYS_IF(unsat_ok=False,boring_ok=False)\r
+         Tmpl= \ (dt [Occ=Once] :: GHC.Types.Int) ->\r
+                 case dt of dt { __DEFAULT -> T7360.Foo3 dt }}]\r
+T7360.$WFoo3 =\r
+  \ (dt [Occ=Once] :: GHC.Types.Int) ->\r
+    case dt of dt { __DEFAULT -> T7360.Foo3 dt }\r
+\r
+T7360.fun1 [InlPrag=NOINLINE] :: T7360.Foo -> ()\r
+[GblId, Arity=1, Caf=NoCafRefs, Str=DmdType S]\r
+T7360.fun1 =\r
+  \ (x :: T7360.Foo) -> case x of _ { __DEFAULT -> GHC.Tuple.() }\r
+\r
+T7360.fun3 :: ()\r
+[GblId,\r
+ Str=DmdType,\r
+ Unf=Unf{Src=<vanilla>, TopLvl=True, Arity=0, Value=False,\r
+         ConLike=False, WorkFree=False, Expandable=False,\r
+         Guidance=IF_ARGS [] 20 0}]\r
+T7360.fun3 = T7360.fun1 T7360.Foo1\r
+\r
+T7360.fun2 :: forall a. [a] -> ((), GHC.Types.Int)\r
+[GblId,\r
+ Arity=1,\r
+ Str=DmdType Lm,\r
+ Unf=Unf{Src=InlineStable, TopLvl=True, Arity=1, Value=True,\r
+         ConLike=True, WorkFree=True, Expandable=True,\r
+         Guidance=ALWAYS_IF(unsat_ok=True,boring_ok=False)\r
+         Tmpl= \ (@ a) (x [Occ=Once] :: [a]) ->\r
+                 (T7360.fun3,\r
+                  case GHC.List.$wlen @ a x 0 of ww { __DEFAULT ->\r
+                  GHC.Types.I# ww\r
+                  })}]\r
+T7360.fun2 =\r
+  \ (@ a) (x :: [a]) ->\r
+    (T7360.fun3,\r
+     case GHC.List.$wlen @ a x 0 of ww { __DEFAULT -> GHC.Types.I# ww })\r
+\r
+\r
+\r
index 433b5a0..1360426 100644 (file)
@@ -1,20 +1,19 @@
-
-holes2.hs:7:5: Warning:
-    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)
-    Note: there are several potential instances:
-      instance Show Double -- Defined in `GHC.Float'
-      instance Show Float -- Defined in `GHC.Float'
-      instance (Integral a, Show a) => Show (GHC.Real.Ratio a)
-        -- Defined in `GHC.Real'
-      ...plus 23 others
-    In the expression: show _
-    In an equation for `f': f = show _
-
-holes2.hs:7:10: Warning:
-    Found hole `_' with type a0
-    Where: `a0' is an ambiguous type variable
-    In the first argument of `show', namely `_'
-    In the expression: show _
-    In an equation for `f': f = show _
+\r
+holes2.hs:7:5: Warning:\r
+    No instance for (Show a0) arising from a use of `show'\r
+    The type variable `a0' is ambiguous\r
+    Note: there are several potential instances:\r
+      instance Show Double -- Defined in `GHC.Float'\r
+      instance Show Float -- Defined in `GHC.Float'\r
+      instance (Integral a, Show a) => Show (GHC.Real.Ratio a)\r
+        -- Defined in `GHC.Real'\r
+      ...plus 23 others\r
+    In the expression: show _\r
+    In an equation for `f': f = show _\r
+\r
+holes2.hs:7:10: Warning:\r
+    Found hole `_' with type a0\r
+    Where: `a0' is an ambiguous type variable\r
+    In the first argument of `show', namely `_'\r
+    In the expression: show _\r
+    In an equation for `f': f = show _\r
index 8c0c813..96fa5a0 100644 (file)
@@ -1,12 +1,11 @@
-
-tc168.hs:17:1:
-    Could not deduce (C a1 (a, b0))
-      arising from the ambiguity check for `g'
-    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)
-    When checking that `g'
-      has the inferred type `forall a b a1. C a1 (a, b) => a1 -> a'
-    Probable cause: the inferred type is ambiguous
+\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'\r
+      has the inferred type `forall a b a1. C a1 (a, b) => a1 -> a'\r
+    Probable cause: the inferred type is ambiguous\r
index 479087b..390333c 100644 (file)
@@ -6,10 +6,6 @@ data T a where
   MkT :: a -> T a 
   MkT3 :: forall a. (a ~ Bool) => T a 
 
--- Occurs checks in givens
-foo :: forall a. (a ~ T a) => a -> a 
-foo x = x 
-
 -- Mismatches in givens 
 bloh :: T Int -> () 
 bloh x = case x of 
index 0e2ec6c..5a36d7d 100644 (file)
@@ -1,61 +1,53 @@
-
-FrozenErrorTests.hs:10:8:
-    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:10:15
-    Inaccessible code in
-      the type signature for foo :: a ~ T a => a -> a
-
-FrozenErrorTests.hs:16: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:30:9:
-    Occurs check: cannot construct the infinite type: a ~ [a]
-    Expected type: [a]
-      Actual type: F a Bool
-    Relevant bindings include
-      test1 :: a (bound at FrozenErrorTests.hs:30:1)
-    In the expression: goo1 False undefined
-    In an equation for `test1': test1 = goo1 False undefined
-
-FrozenErrorTests.hs:33: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:34: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:49:15:
-    Couldn't match type `T2 c c' with `M (T2 (T2 c c) c)'
-    Expected type: T2 (M (T2 (T2 c c) c)) (T2 (T2 c c) c)
-      Actual type: F (T2 (T2 c c) c) Bool
-    Relevant bindings include
-      test4 :: T2 (T2 c c) c (bound at FrozenErrorTests.hs:49:1)
-    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:50:9:
-    Couldn't match type `T2 c c' with `M (T2 (T2 c c) c)'
-    Expected type: T2 (M (T2 (T2 c c) c)) (T2 (T2 c c) c)
-      Actual type: F (T2 (T2 c c) c) Bool
-    Relevant bindings include
-      test5 :: T2 (T2 c c) c (bound at FrozenErrorTests.hs:50:1)
-    In the expression: goo3 False (goo4 undefined)
-    In an equation for `test5': test5 = goo3 False (goo4 undefined)
+\r
+FrozenErrorTests.hs:12: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:26:9:\r
+    Occurs check: cannot construct the infinite type: a ~ [a]\r
+    Expected type: [a]\r
+      Actual type: F a Bool\r
+    Relevant bindings include\r
+      test1 :: a (bound at FrozenErrorTests.hs:26:1)\r
+    In the expression: goo1 False undefined\r
+    In an equation for `test1': test1 = goo1 False undefined\r
+\r
+FrozenErrorTests.hs:29:15:\r
+    Couldn't match type `Int' with `[Int]'\r
+    Expected type: [[Int]]\r
+      Actual type: F [Int] Bool\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:30:9:\r
+    Couldn't match type `Int' with `[Int]'\r
+    Expected type: [[Int]]\r
+      Actual type: F [Int] Bool\r
+    In the expression: goo1 False (goo2 undefined)\r
+    In an equation for `test3': test3 = goo1 False (goo2 undefined)\r
+\r
+FrozenErrorTests.hs:45:15:\r
+    Couldn't match type `T2 c c' with `M (T2 (T2 c c) c)'\r
+    Expected type: T2 (M (T2 (T2 c c) c)) (T2 (T2 c c) c)\r
+      Actual type: F (T2 (T2 c c) c) Bool\r
+    Relevant bindings include\r
+      test4 :: T2 (T2 c c) c (bound at FrozenErrorTests.hs:45:1)\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:46:9:\r
+    Couldn't match type `T2 c c' with `M (T2 (T2 c c) c)'\r
+    Expected type: T2 (M (T2 (T2 c c) c)) (T2 (T2 c c) c)\r
+      Actual type: F (T2 (T2 c c) c) Bool\r
+    Relevant bindings include\r
+      test5 :: T2 (T2 c c) c (bound at FrozenErrorTests.hs:46:1)\r
+    In the expression: goo3 False (goo4 undefined)\r
+    In an equation for `test5': test5 = goo3 False (goo4 undefined)\r
index 6e5ee1c..eb12048 100644 (file)
@@ -1,12 +1,11 @@
-
-T1897a.hs:9:1:
-    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
+\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'\r
+      has the inferred type `forall a b. Wob a b => b -> [b]'\r
+    Probable cause: the inferred type is ambiguous\r
index a2da439..74e4606 100644 (file)
@@ -1,10 +1,12 @@
-
-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
+\r
+T5236.hs:13:9:\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,\r
+        arising from the type signature for loop :: Id A B => Bool\r
+        at T5236.hs:13:9-22\r
+    In the ambiguity check for: Id A B => Bool\r
+    In the type signature for `loop': loop :: Id A B => Bool\r
index 728655f..749bd22 100644 (file)
@@ -1,16 +1,32 @@
-
-T5300.hs:15:9:
-    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:14:7-69
-    The type variable `c0' is ambiguous
-    Possible fix: add a type signature that fixes these type variable(s)
-    Relevant bindings include
-      f2 :: a1 -> StateT (T b2) m a2 (bound at T5300.hs:15:1)
-      fm :: a1 (bound at T5300.hs:15:4)
-    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
+\r
+T5300.hs:11:7:\r
+    Could not deduce (C1 a b c0)\r
+      arising from the ambiguity check for `f1'\r
+    from the context (Monad m, C1 a b c)\r
+      bound by the type signature for\r
+                 f1 :: (Monad m, C1 a b c) => a -> StateT (T b) m a\r
+      at T5300.hs:11:7-50\r
+    The type variable `c0' is ambiguous\r
+    In the ambiguity check for:\r
+      forall a b (m :: * -> *) c.\r
+      (Monad m, C1 a b c) =>\r
+      a -> StateT (T b) m a\r
+    In the type signature for `f1':\r
+      f1 :: (Monad m, C1 a b c) => a -> StateT (T b) m a\r
+\r
+T5300.hs:14:7:\r
+    Could not deduce (C1 a1 b1 c10)\r
+      arising from the ambiguity check for `f2'\r
+    from the context (Monad m, C1 a1 b1 c1, C2 a2 b2 c2)\r
+      bound by the type signature for\r
+                 f2 :: (Monad m, C1 a1 b1 c1, C2 a2 b2 c2) =>\r
+                       a1 -> StateT (T b2) m a2\r
+      at T5300.hs:14:7-69\r
+    The type variable `c10' is ambiguous\r
+    In the ambiguity check for:\r
+      forall a1 b2 (m :: * -> *) a2 b1 c1 c2.\r
+      (Monad m, C1 a1 b1 c1, C2 a2 b2 c2) =>\r
+      a1 -> StateT (T b2) m a2\r
+    In the type signature for `f2':\r
+      f2 :: (Monad m, C1 a1 b1 c1, C2 a2 b2 c2) =>\r
+            a1 -> StateT (T b2) m a2\r
index 0ce0d5d..0ecd766 100644 (file)
@@ -1,11 +1,10 @@
-
-T5858.hs:11:7:
-    No instance for (InferOverloaded ([a0], [a1]))
-      arising from a use of `infer'
-    The type variables `a0', `a1' are ambiguous
-    Possible fix: add a type signature that fixes these type variable(s)
-    Note: there is a potential instance available:
-      instance t1 ~ String => InferOverloaded (t1, t1)
-        -- Defined at T5858.hs:8:10
-    In the expression: infer ([], [])
-    In an equation for `foo': foo = infer ([], [])
+\r
+T5858.hs:11:7:\r
+    No instance for (InferOverloaded ([a0], [a1]))\r
+      arising from a use of `infer'\r
+    The type variables `a0', `a1' are ambiguous\r
+    Note: there is a potential instance available:\r
+      instance t1 ~ String => InferOverloaded (t1, t1)\r
+        -- Defined at T5858.hs:8:10\r
+    In the expression: infer ([], [])\r
+    In an equation for `foo': foo = infer ([], [])\r
index 0dc39af..bbf6eb6 100644 (file)
@@ -82,7 +82,7 @@ test('tcfail094', normal, compile_fail, [''])
 test('tcfail095', only_compiler_types(['ghc']), compile_fail, [''])
 test('tcfail096', normal, compile_fail, [''])
 test('tcfail097', normal, compile_fail, [''])
-test('tcfail098', normal, compile, [''])
+test('tcfail098', normal, compile_fail, [''])
 test('tcfail099', normal, compile_fail, [''])
 test('tcfail100', normal, compile_fail, [''])
 test('tcfail101', normal, compile_fail, [''])
index c0791f2..7abed93 100644 (file)
@@ -1,23 +1,20 @@
-
-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: `o'
-    Probable fix: give these definition(s) an explicit type signature
-                  or use -XNoMonomorphismRestriction
-    Relevant bindings include o :: [a0] (bound at tcfail008.hs:3:1)
-    Note: there are several potential instances:
-      instance Num Double -- Defined in `GHC.Float'
-      instance Num Float -- Defined in `GHC.Float'
-      instance Integral a => Num (GHC.Real.Ratio a)
-        -- Defined in `GHC.Real'
-      ...plus three others
-    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'
-    In the second argument of `(:)', namely `2'
-    In the expression: 1 : 2
-    In an equation for `o': o = 1 : 2
+\r
+tcfail008.hs:3:5:\r
+    No instance for (Num a0) arising from the literal `1'\r
+    The type variable `a0' is ambiguous\r
+    Relevant bindings include o :: [a0] (bound at tcfail008.hs:3:1)\r
+    Note: there are several potential instances:\r
+      instance Num Double -- Defined in `GHC.Float'\r
+      instance Num Float -- Defined in `GHC.Float'\r
+      instance Integral a => Num (GHC.Real.Ratio a)\r
+        -- Defined in `GHC.Real'\r
+      ...plus three others\r
+    In the first argument of `(:)', namely `1'\r
+    In the expression: 1 : 2\r
+    In an equation for `o': o = 1 : 2\r
+\r
+tcfail008.hs:3:7:\r
+    No instance for (Num [a0]) arising from the literal `2'\r
+    In the second argument of `(:)', namely `2'\r
+    In the expression: 1 : 2\r
+    In an equation for `o': o = 1 : 2\r
index 8ee305f..003cb9f 100644 (file)
@@ -1,10 +1,9 @@
-
-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)
-    Note: there is a potential instance available:
-      instance ORD (a -> b) -- Defined at tcfail040.hs:17:10
-    In the first argument of `(===)', namely `(<<)'
-    In the expression: (<<) === (<<)
-    In an equation for `f': f = (<<) === (<<)
+\r
+tcfail040.hs:19:5:\r
+    No instance for (ORD a0) arising from a use of `<<'\r
+    The type variable `a0' is ambiguous\r
+    Note: there is a potential instance available:\r
+      instance ORD (a -> b) -- Defined at tcfail040.hs:17:10\r
+    In the first argument of `(===)', namely `(<<)'\r
+    In the expression: (<<) === (<<)\r
+    In an equation for `f': f = (<<) === (<<)\r
index 6067500..ef4e999 100644 (file)
@@ -1,46 +1,40 @@
-
-tcfail043.hs:38:17:
-    No instance for (Ord_ a0) arising from a use of `gt'
-    The type variable `a0' is ambiguous
-    Possible cause: the monomorphism restriction applied to: `search'
-    Probable fix: give these definition(s) an explicit type signature
-                  or use -XNoMonomorphismRestriction
-    Relevant bindings include
-      search :: a0 -> [a0] -> Bool (bound at tcfail043.hs:37:1)
-      a :: a0 (bound at tcfail043.hs:38:6)
-      bs :: [a0] (bound at tcfail043.hs:38:8)
-    Note: there is a potential instance available:
-      instance Ord_ Int -- Defined at tcfail043.hs:34:10
-    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)
-
-tcfail043.hs:40:25:
-    No instance for (Eq_ a0) arising from a use of `eq'
-    The type variable `a0' is ambiguous
-    Possible cause: the monomorphism restriction applied to: `search'
-    Probable fix: give these definition(s) an explicit type signature
-                  or use -XNoMonomorphismRestriction
-    Relevant bindings include
-      search :: a0 -> [a0] -> Bool (bound at tcfail043.hs:37:1)
-      a :: a0 (bound at tcfail043.hs:38:6)
-      bs :: [a0] (bound at tcfail043.hs:38:8)
-    Note: there are several potential instances:
-      instance Eq_ a => Eq_ [a] -- Defined at tcfail043.hs:23:10
-      instance Eq_ Int -- Defined at tcfail043.hs:20:10
-    In the expression: eq a (hd bs)
-    In the expression: if eq a (hd bs) then True else search a (tl bs)
-    In the expression:
-      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) arising from a use of `gt'\r
+    The type variable `a0' is ambiguous\r
+    Relevant bindings include\r
+      search :: a0 -> [a0] -> Bool (bound at tcfail043.hs:37:1)\r
+      a :: a0 (bound at tcfail043.hs:38:6)\r
+      bs :: [a0] (bound at tcfail043.hs:38:8)\r
+    Note: there is a potential instance available:\r
+      instance Ord_ Int -- Defined at tcfail043.hs:34:10\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) arising from a use of `eq'\r
+    The type variable `a0' is ambiguous\r
+    Relevant bindings include\r
+      search :: a0 -> [a0] -> Bool (bound at tcfail043.hs:37:1)\r
+      a :: a0 (bound at tcfail043.hs:38:6)\r
+      bs :: [a0] (bound at tcfail043.hs:38:8)\r
+    Note: there are several potential instances:\r
+      instance Eq_ a => Eq_ [a] -- Defined at tcfail043.hs:23:10\r
+      instance Eq_ Int -- Defined at tcfail043.hs:20:10\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 087d12b..a71b0ef 100644 (file)
@@ -1,17 +1,16 @@
-
-tcfail072.hs:23:13:
-    Could not deduce (Ord q0) arising from a use of `g'
-    from the context (Ord p, Ord q)
-      bound by the type signature for
-                 g :: (Ord p, Ord q) => AB p q -> Bool
-      at tcfail072.hs:22:6-38
-    The type variable `q0' is ambiguous
-    Possible fix: add a type signature that fixes these type variable(s)
-    Note: there are several potential instances:
-      instance Integral a => Ord (GHC.Real.Ratio a)
-        -- Defined in `GHC.Real'
-      instance Ord () -- Defined in `GHC.Classes'
-      instance (Ord a, Ord b) => Ord (a, b) -- Defined in `GHC.Classes'
-      ...plus 22 others
-    In the expression: g A
-    In an equation for `g': g (B _ _) = g A
+\r
+tcfail072.hs:23:13:\r
+    Could not deduce (Ord q0) arising from a use of `g'\r
+    from the context (Ord p, Ord q)\r
+      bound by the type signature for\r
+                 g :: (Ord p, Ord q) => AB p q -> Bool\r
+      at tcfail072.hs:22:6-38\r
+    The type variable `q0' is ambiguous\r
+    Note: there are several potential instances:\r
+      instance Integral a => Ord (GHC.Real.Ratio a)\r
+        -- Defined in `GHC.Real'\r
+      instance Ord () -- Defined in `GHC.Classes'\r
+      instance (Ord a, Ord b) => Ord (a, b) -- Defined in `GHC.Classes'\r
+      ...plus 22 others\r
+    In the expression: g A\r
+    In an equation for `g': g (B _ _) = g A\r
index 5200786..31ad546 100644 (file)
@@ -1,14 +1,13 @@
-
-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
+\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'\r
+      has the inferred type `forall (c :: * -> *) a.\r
+                             Collection c a =>\r
+                             a -> Bool'\r
+    Probable cause: the inferred type is ambiguous\r
index 589d2c9..07717e0 100644 (file)
@@ -1,21 +1,20 @@
-
-tcfail083.hs:8:39:
-    Constructor `Bar' does not have field `baz'
-    In the pattern: Bar {flag = f, baz = b}
-    In the pattern: State {bar = Bar {flag = f, baz = b}}
-    In an equation for `display':
-        display (State {bar = Bar {flag = f, baz = b}}) = print (f, b)
-
-tcfail083.hs:8:53:
-    No instance for (Show t0) arising from a use of `print'
-    The type variable `t0' is ambiguous
-    Possible fix: add a type signature that fixes these type variable(s)
-    Relevant bindings include b :: t0 (bound at tcfail083.hs:8:45)
-    Note: there are several potential instances:
-      instance Show Bar -- Defined at tcfail083.hs:3:43
-      instance Show Double -- Defined in `GHC.Float'
-      instance Show Float -- Defined in `GHC.Float'
-      ...plus 24 others
-    In the expression: print (f, b)
-    In an equation for `display':
-        display (State {bar = Bar {flag = f, baz = b}}) = print (f, b)
+\r
+tcfail083.hs:8:39:\r
+    Constructor `Bar' does not have field `baz'\r
+    In the pattern: Bar {flag = f, baz = b}\r
+    In the pattern: State {bar = Bar {flag = f, baz = b}}\r
+    In an equation for `display':\r
+        display (State {bar = Bar {flag = f, baz = b}}) = print (f, b)\r
+\r
+tcfail083.hs:8:53:\r
+    No instance for (Show t0) arising from a use of `print'\r
+    The type variable `t0' is ambiguous\r
+    Relevant bindings include b :: t0 (bound at tcfail083.hs:8:45)\r
+    Note: there are several potential instances:\r
+      instance Show Bar -- Defined at tcfail083.hs:3:43\r
+      instance Show Double -- Defined in `GHC.Float'\r
+      instance Show Float -- Defined in `GHC.Float'\r
+      ...plus 24 others\r
+    In the expression: print (f, b)\r
+    In an equation for `display':\r
+        display (State {bar = Bar {flag = f, baz = b}}) = print (f, b)\r
index 2fabae4..e7dadd4 100644 (file)
@@ -1,6 +1,9 @@
-
-tcfail097.hs:5:6:
-    Ambiguous constraint `Eq a'
-      At least one of the forall'd type variables mentioned by the constraint
-      must be reachable from the type after the '=>'
-    In the type signature for `f': f :: Eq a => Int -> Int
+\r
+tcfail097.hs:5:6:\r
+    Could not deduce (Eq a0) arising from the ambiguity check for `f'\r
+    from the context (Eq a)\r
+      bound by the type signature for f :: Eq a => Int -> Int\r
+      at tcfail097.hs:5:6-23\r
+    The type variable `a0' is ambiguous\r
+    In the ambiguity check for: forall a. Eq a => Int -> Int\r
+    In the type signature for `f': f :: Eq a => Int -> Int\r
index e69de29..8853e69 100644 (file)
@@ -0,0 +1,10 @@
+\r
+tcfail098.hs:12:10:\r
+    Could not deduce (Bar a0)\r
+      arising from the ambiguity check for an instance declaration\r
+    from the context (Bar a)\r
+      bound by an instance declaration: Bar a => Bar Bool\r
+      at tcfail098.hs:12:10-26\r
+    The type variable `a0' is ambiguous\r
+    In the ambiguity check for: forall a. Bar a => Bar Bool\r
+    In the instance declaration for `Bar Bool'\r
index 265b783..9a1564f 100644 (file)
@@ -1,22 +1,21 @@
-
-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)
-    Note: there is a potential instance available:
-      instance Data.Array.Base.MArray GHC.IOArray.IOArray e IO
-        -- Defined in `Data.Array.Base'
-    In a stmt of a 'do' block: v <- thaw tmp
-    In the expression:
-      do { let sL = ...
-               dim = length sL
-               ....;
-           v <- thaw tmp;
-           return () }
-    In an equation for `main':
-        main
-          = do { let sL = ...
-                     ....;
-                 v <- thaw tmp;
-                 return () }
+\r
+tcfail128.hs:18:16:\r
+    No instance for (Data.Array.Base.MArray b0 FlatVector IO)\r
+      arising from a use of `thaw'\r
+    The type variable `b0' is ambiguous\r
+    Note: there is a potential instance available:\r
+      instance Data.Array.Base.MArray GHC.IOArray.IOArray e IO\r
+        -- Defined in `Data.Array.Base'\r
+    In a stmt of a 'do' block: v <- thaw tmp\r
+    In the expression:\r
+      do { let sL = ...\r
+               dim = length sL\r
+               ....;\r
+           v <- thaw tmp;\r
+           return () }\r
+    In an equation for `main':\r
+        main\r
+          = do { let sL = ...\r
+                     ....;\r
+                 v <- thaw tmp;\r
+                 return () }\r
index b18a27f..4a7c564 100644 (file)
@@ -5,7 +5,6 @@ tcfail133.hs:2:61: Warning:
 tcfail133.hs:68:7:\r
     No instance for (Show s0) arising from a use of `show'\r
     The type variable `s0' is ambiguous\r
-    Possible fix: add a type signature that fixes these type variable(s)\r
     Note: there are several potential instances:\r
       instance Show Zero -- Defined at tcfail133.hs:8:29\r
       instance Show One -- Defined at tcfail133.hs:9:28\r
index 635a670..e0ec8f4 100644 (file)
@@ -1,7 +1,10 @@
-
-tcfail142.hs:21:12:
-    No instance for (Bar a0 r0)
-      arising from a use of `bar'
-    In the first argument of `foo', namely `bar'
-    In the expression: foo bar
-    In an equation for `test': test = foo bar
+\r
+tcfail142.hs:18:8:\r
+    Could not deduce (Bar a0 r)\r
+      arising from the ambiguity check for `bar'\r
+    from the context (Bar a r)\r
+      bound by the type signature for bar :: Bar a r => r -> ()\r
+      at tcfail142.hs:18:8-25\r
+    The type variable `a0' is ambiguous\r
+    In the ambiguity check for: forall r a. Bar a r => r -> ()\r
+    In the type signature for `bar': bar :: Bar a r => r -> ()\r
index 690cbe7..d6e622c 100644 (file)
@@ -1,17 +1,15 @@
-
-tcfail181.hs:17:9:
-    Could not deduce (Monad m0) arising from a use of `foo'
-    from the context (Monad m)
-      bound by the inferred type of
-               wog :: Monad m => t -> Something (m Bool) e
-      at tcfail181.hs:17:1-30
-    The type variable `m0' is ambiguous
-    Possible fix: add a type signature that fixes these type variable(s)
-    Note: there are several potential instances:
-      instance Monad ((->) r) -- Defined in `GHC.Base'
-      instance Monad IO -- Defined in `GHC.Base'
-      instance Monad [] -- Defined in `GHC.Base'
-    In the expression: foo
-    In the expression: foo {bar = return True}
-    In an equation for `wog': wog x = foo {bar = return True}
-
+\r
+tcfail181.hs:17:9:\r
+    Could not deduce (Monad m0) arising from a use of `foo'\r
+    from the context (Monad m)\r
+      bound by the inferred type of\r
+               wog :: Monad m => t -> Something (m Bool) e\r
+      at tcfail181.hs:17:1-30\r
+    The type variable `m0' is ambiguous\r
+    Note: there are several potential instances:\r
+      instance Monad ((->) r) -- Defined in `GHC.Base'\r
+      instance Monad IO -- Defined in `GHC.Base'\r
+      instance Monad [] -- Defined in `GHC.Base'\r
+    In the expression: foo\r
+    In the expression: foo {bar = return True}\r
+    In an equation for `wog': wog x = foo {bar = return True}\r
index 8c795ce..f0fc2d5 100644 (file)
@@ -1,10 +1,11 @@
-
-tcrun035.hs:13:12:
-    Couldn't match type `forall (m :: * -> *). Monad m => m a'
-                  with `IO a'
-    Expected type: (forall (m :: * -> *). Monad m => m a) -> IO a
-      Actual type: (forall (m :: * -> *). Monad m => m a)
-                   -> forall (m :: * -> *). Monad m => m a
-    In the second argument of `(.)', namely `id'
-    In the expression: id . id
-    In an equation for `foo': foo = id . id
+\r
+tcrun035.hs:13:7:\r
+    Couldn't match type `IO a'\r
+                  with `forall (m :: * -> *). Monad m => m a'\r
+    Expected type: (forall (m :: * -> *). Monad m => m a) -> IO a\r
+      Actual type: IO a -> IO a\r
+    Relevant bindings include\r
+      foo :: (forall (m :: * -> *). Monad m => m a) -> IO a\r
+        (bound at tcrun035.hs:13:1)\r
+    In the expression: id . id\r
+    In an equation for `foo': foo = id . id\r