Testsuite: remove Windows CR again.. [skip ci]
authorThomas Miedema <thomasmiedema@gmail.com>
Sat, 18 Jun 2016 20:05:51 +0000 (22:05 +0200)
committerThomas Miedema <thomasmiedema@gmail.com>
Mon, 20 Jun 2016 14:22:07 +0000 (16:22 +0200)
44 files changed:
testsuite/tests/patsyn/should_fail/T11010.stderr
testsuite/tests/patsyn/should_fail/T11039.stderr
testsuite/tests/patsyn/should_fail/T11667.stderr
testsuite/tests/typecheck/should_compile/ExPatFail.stderr
testsuite/tests/typecheck/should_compile/FD1.stderr
testsuite/tests/typecheck/should_compile/FD2.stderr
testsuite/tests/typecheck/should_compile/FD3.stderr
testsuite/tests/typecheck/should_compile/T10072.stderr
testsuite/tests/typecheck/should_compile/T10632.stderr
testsuite/tests/typecheck/should_compile/T11339.stderr
testsuite/tests/typecheck/should_compile/T2494.stderr
testsuite/tests/typecheck/should_compile/T9834.stderr
testsuite/tests/typecheck/should_compile/T9939.stderr
testsuite/tests/typecheck/should_compile/holes.stderr
testsuite/tests/typecheck/should_compile/holes3.stderr
testsuite/tests/typecheck/should_fail/T10285.stderr
testsuite/tests/typecheck/should_fail/T10534.stderr
testsuite/tests/typecheck/should_fail/T10715.stderr
testsuite/tests/typecheck/should_fail/T11347.stderr
testsuite/tests/typecheck/should_fail/T1899.stderr
testsuite/tests/typecheck/should_fail/T2714.stderr
testsuite/tests/typecheck/should_fail/T3102.stderr
testsuite/tests/typecheck/should_fail/T5691.stderr
testsuite/tests/typecheck/should_fail/T7264.stderr
testsuite/tests/typecheck/should_fail/T7748a.stderr
testsuite/tests/typecheck/should_fail/T7869.stderr
testsuite/tests/typecheck/should_fail/T8450.stderr
testsuite/tests/typecheck/should_fail/mc19.stderr
testsuite/tests/typecheck/should_fail/mc21.stderr
testsuite/tests/typecheck/should_fail/mc22.stderr
testsuite/tests/typecheck/should_fail/tcfail032.stderr
testsuite/tests/typecheck/should_fail/tcfail065.stderr
testsuite/tests/typecheck/should_fail/tcfail068.stderr
testsuite/tests/typecheck/should_fail/tcfail076.stderr
testsuite/tests/typecheck/should_fail/tcfail103.stderr
testsuite/tests/typecheck/should_fail/tcfail131.stderr
testsuite/tests/typecheck/should_fail/tcfail153.stderr
testsuite/tests/typecheck/should_fail/tcfail174.stderr
testsuite/tests/typecheck/should_fail/tcfail175.stderr
testsuite/tests/typecheck/should_fail/tcfail179.stderr
testsuite/tests/typecheck/should_fail/tcfail191.stderr
testsuite/tests/typecheck/should_fail/tcfail193.stderr
testsuite/tests/typecheck/should_fail/tcfail198.stderr
testsuite/tests/typecheck/should_fail/tcfail206.stderr

index 1bd83c8..b09140c 100644 (file)
@@ -1,14 +1,14 @@
-\r
-T11010.hs:9:36: error:\r
-    • Couldn't match type ‘a1’ with ‘Int’\r
-      ‘a1’ is a rigid type variable bound by\r
-        a pattern with constructor:\r
-          Fun :: forall b a. String -> (a -> b) -> Expr a -> Expr b,\r
-        in a pattern synonym declaration\r
-        at T11010.hs:9:26-36\r
-      Expected type: a -> b\r
-        Actual type: a1 -> b\r
-    • In the declaration for pattern synonym ‘IntFun’\r
-    • Relevant bindings include\r
-        x :: Expr a1 (bound at T11010.hs:9:36)\r
-        f :: a1 -> b (bound at T11010.hs:9:34)\r
+
+T11010.hs:9:36: error:
+    • Couldn't match type ‘a1’ with ‘Int’
+      ‘a1’ is a rigid type variable bound by
+        a pattern with constructor:
+          Fun :: forall b a. String -> (a -> b) -> Expr a -> Expr b,
+        in a pattern synonym declaration
+        at T11010.hs:9:26-36
+      Expected type: a -> b
+        Actual type: a1 -> b
+    • In the declaration for pattern synonym ‘IntFun’
+    • Relevant bindings include
+        x :: Expr a1 (bound at T11010.hs:9:36)
+        f :: a1 -> b (bound at T11010.hs:9:34)
index 15a56e0..4783bc9 100644 (file)
@@ -1,9 +1,9 @@
-\r
-T11039.hs:8:15: error:\r
-    • Couldn't match type ‘f’ with ‘A’\r
-      ‘f’ is a rigid type variable bound by\r
-        the signature for pattern synonym ‘Q’ at T11039.hs:7:14-38\r
-      Expected type: f a\r
-        Actual type: A a\r
-    • In the pattern: A a\r
-      In the declaration for pattern synonym ‘Q’\r
+
+T11039.hs:8:15: error:
+    • Couldn't match type ‘f’ with ‘A’
+      ‘f’ is a rigid type variable bound by
+        the signature for pattern synonym ‘Q’ at T11039.hs:7:14-38
+      Expected type: f a
+        Actual type: A a
+    • In the pattern: A a
+      In the declaration for pattern synonym ‘Q’
index 0407d00..fdd4477 100644 (file)
@@ -1,41 +1,41 @@
-\r
-T11667.hs:12:22: error:\r
-    • Could not deduce (Num a) arising from the literal ‘42’\r
-      from the context: Eq a\r
-        bound by the signature for pattern synonym ‘Pat1’\r
-        at T11667.hs:12:9-12\r
-      Possible fix:\r
-        add (Num a) to the "required" context of\r
-          the signature for pattern synonym ‘Pat1’\r
-    • In the pattern: 42\r
-      In the pattern: Just 42\r
-      In the declaration for pattern synonym ‘Pat1’\r
-\r
-T11667.hs:18:28: error:\r
-    • Couldn't match type ‘b’ with ‘Bool’\r
-        arising from the "provided" constraints claimed by\r
-          the signature of ‘Pat2’\r
-      ‘b’ is a rigid type variable bound by\r
-        the signature for pattern synonym ‘Pat2’ at T11667.hs:17:17-50\r
-    • In the declaration for pattern synonym ‘Pat2’\r
-    • Relevant bindings include y :: b (bound at T11667.hs:18:21)\r
-\r
-T11667.hs:24:24: error:\r
-    • No instance for (Show a)\r
-        arising from the "provided" constraints claimed by\r
-          the signature of ‘Pat3’\r
-      In other words, a successful match on the pattern\r
-        Just x\r
-      does not provide the constraint (Show a)\r
-    • In the declaration for pattern synonym ‘Pat3’\r
-\r
-T11667.hs:31:16: error:\r
-    • Could not deduce (Num a) arising from a use of ‘MkS’\r
-      from the context: (Eq a, Show a)\r
-        bound by the signature for pattern synonym ‘Pat4’\r
-        at T11667.hs:31:1-21\r
-      Possible fix:\r
-        add (Num a) to the "required" context of\r
-          the signature for pattern synonym ‘Pat4’\r
-    • In the expression: MkS 42\r
-      In an equation for ‘Pat4’: Pat4 = MkS 42\r
+
+T11667.hs:12:22: error:
+    • Could not deduce (Num a) arising from the literal ‘42’
+      from the context: Eq a
+        bound by the signature for pattern synonym ‘Pat1’
+        at T11667.hs:12:9-12
+      Possible fix:
+        add (Num a) to the "required" context of
+          the signature for pattern synonym ‘Pat1’
+    • In the pattern: 42
+      In the pattern: Just 42
+      In the declaration for pattern synonym ‘Pat1’
+
+T11667.hs:18:28: error:
+    • Couldn't match type ‘b’ with ‘Bool’
+        arising from the "provided" constraints claimed by
+          the signature of ‘Pat2’
+      ‘b’ is a rigid type variable bound by
+        the signature for pattern synonym ‘Pat2’ at T11667.hs:17:17-50
+    • In the declaration for pattern synonym ‘Pat2’
+    • Relevant bindings include y :: b (bound at T11667.hs:18:21)
+
+T11667.hs:24:24: error:
+    • No instance for (Show a)
+        arising from the "provided" constraints claimed by
+          the signature of ‘Pat3’
+      In other words, a successful match on the pattern
+        Just x
+      does not provide the constraint (Show a)
+    • In the declaration for pattern synonym ‘Pat3’
+
+T11667.hs:31:16: error:
+    • Could not deduce (Num a) arising from a use of ‘MkS’
+      from the context: (Eq a, Show a)
+        bound by the signature for pattern synonym ‘Pat4’
+        at T11667.hs:31:1-21
+      Possible fix:
+        add (Num a) to the "required" context of
+          the signature for pattern synonym ‘Pat4’
+    • In the expression: MkS 42
+      In an equation for ‘Pat4’: Pat4 = MkS 42
index afae403..696bff7 100644 (file)
@@ -1,14 +1,14 @@
-\r
-ExPatFail.hs:12:15: error:\r
-    • Couldn't match expected type ‘t’ with actual type ‘a’\r
-        because type variable ‘a’ would escape its scope\r
-      This (rigid, skolem) type variable is bound by\r
-        a pattern with constructor:\r
-          MkT :: forall a. Integral a => a -> Int -> T,\r
-        in a pattern binding\r
-        at ExPatFail.hs:12:11-17\r
-    • In the pattern: MkT y _\r
-      In a pattern binding: MkT y _ = x\r
-      In the expression: let MkT y _ = x in y\r
-    • Relevant bindings include\r
-        f :: T -> t (bound at ExPatFail.hs:12:1)\r
+
+ExPatFail.hs:12:15: error:
+    • Couldn't match expected type ‘t’ with actual type ‘a’
+        because type variable ‘a’ would escape its scope
+      This (rigid, skolem) type variable is bound by
+        a pattern with constructor:
+          MkT :: forall a. Integral a => a -> Int -> T,
+        in a pattern binding
+        at ExPatFail.hs:12:11-17
+    • In the pattern: MkT y _
+      In a pattern binding: MkT y _ = x
+      In the expression: let MkT y _ = x in y
+    • Relevant bindings include
+        f :: T -> t (bound at ExPatFail.hs:12:1)
index 9223b8e..380be21 100644 (file)
@@ -1,10 +1,10 @@
-\r
-FD1.hs:16:1: error:\r
-    • Couldn't match expected type ‘a’ with actual type ‘Int -> Int’\r
-      ‘a’ is a rigid type variable bound by\r
-        the type signature for:\r
-          plus :: forall a. E a (Int -> Int) => Int -> a\r
-        at FD1.hs:15:1-38\r
-    • The equation(s) for ‘plus’ have two arguments,\r
-      but its type ‘Int -> a’ has only one\r
-    • Relevant bindings include plus :: Int -> a (bound at FD1.hs:16:1)\r
+
+FD1.hs:16:1: error:
+    • Couldn't match expected type ‘a’ with actual type ‘Int -> Int’
+      ‘a’ is a rigid type variable bound by
+        the type signature for:
+          plus :: forall a. E a (Int -> Int) => Int -> a
+        at FD1.hs:15:1-38
+    • The equation(s) for ‘plus’ have two arguments,
+      but its type ‘Int -> a’ has only one
+    • Relevant bindings include plus :: Int -> a (bound at FD1.hs:16:1)
index 98de9d7..323d10f 100644 (file)
@@ -1,20 +1,20 @@
-\r
-FD2.hs:26:36: error:\r
-    • Couldn't match expected type ‘e’ with actual type ‘e1’\r
-      ‘e1’ is a rigid type variable bound by\r
-        the type signature for:\r
-          mf :: forall e1. Elem a e1 => e1 -> Maybe e1 -> Maybe e1\r
-        at FD2.hs:24:12-54\r
-      ‘e’ is a rigid type variable bound by\r
-        the type signature for:\r
-          foldr1 :: forall e. Elem a e => (e -> e -> e) -> a -> e\r
-        at FD2.hs:21:13-47\r
-    • In the first argument of ‘f’, namely ‘x’\r
-      In the first argument of ‘Just’, namely ‘(f x y)’\r
-      In the expression: Just (f x y)\r
-    • Relevant bindings include\r
-        y :: e1 (bound at FD2.hs:26:23)\r
-        x :: e1 (bound at FD2.hs:26:15)\r
-        mf :: e1 -> Maybe e1 -> Maybe e1 (bound at FD2.hs:25:12)\r
-        f :: e -> e -> e (bound at FD2.hs:22:10)\r
-        foldr1 :: (e -> e -> e) -> a -> e (bound at FD2.hs:22:3)\r
+
+FD2.hs:26:36: error:
+    • Couldn't match expected type ‘e’ with actual type ‘e1’
+      ‘e1’ is a rigid type variable bound by
+        the type signature for:
+          mf :: forall e1. Elem a e1 => e1 -> Maybe e1 -> Maybe e1
+        at FD2.hs:24:12-54
+      ‘e’ is a rigid type variable bound by
+        the type signature for:
+          foldr1 :: forall e. Elem a e => (e -> e -> e) -> a -> e
+        at FD2.hs:21:13-47
+    • In the first argument of ‘f’, namely ‘x’
+      In the first argument of ‘Just’, namely ‘(f x y)’
+      In the expression: Just (f x y)
+    • Relevant bindings include
+        y :: e1 (bound at FD2.hs:26:23)
+        x :: e1 (bound at FD2.hs:26:15)
+        mf :: e1 -> Maybe e1 -> Maybe e1 (bound at FD2.hs:25:12)
+        f :: e -> e -> e (bound at FD2.hs:22:10)
+        foldr1 :: (e -> e -> e) -> a -> e (bound at FD2.hs:22:3)
index 19f819f..d7ac728 100644 (file)
@@ -1,15 +1,15 @@
-\r
-FD3.hs:15:15: error:\r
-    • Couldn't match type ‘a’ with ‘(String, a)’\r
-        arising from a functional dependency between:\r
-          constraint ‘MkA (String, a) a’ arising from a use of ‘mkA’\r
-          instance ‘MkA a1 a1’ at FD3.hs:12:10-16\r
-      ‘a’ is a rigid type variable bound by\r
-        the type signature for:\r
-          translate :: forall a. (String, a) -> A a\r
-        at FD3.hs:14:1-31\r
-    • In the expression: mkA a\r
-      In an equation for ‘translate’: translate a = mkA a\r
-    • Relevant bindings include\r
-        a :: (String, a) (bound at FD3.hs:15:11)\r
-        translate :: (String, a) -> A a (bound at FD3.hs:15:1)\r
+
+FD3.hs:15:15: error:
+    • Couldn't match type ‘a’ with ‘(String, a)’
+        arising from a functional dependency between:
+          constraint ‘MkA (String, a) a’ arising from a use of ‘mkA’
+          instance ‘MkA a1 a1’ at FD3.hs:12:10-16
+      ‘a’ is a rigid type variable bound by
+        the type signature for:
+          translate :: forall a. (String, a) -> A a
+        at FD3.hs:14:1-31
+    • In the expression: mkA a
+      In an equation for ‘translate’: translate a = mkA a
+    • Relevant bindings include
+        a :: (String, a) (bound at FD3.hs:15:11)
+        translate :: (String, a) -> A a (bound at FD3.hs:15:1)
index 7686581..848c915 100644 (file)
@@ -1,8 +1,8 @@
-\r
-T10072.hs:3:31: error:\r
-    • Found type wildcard ‘_’ standing for ‘b’\r
-      Where: ‘b’ is a rigid type variable bound by\r
-               the RULE "map/empty" at T10072.hs:3:1-47\r
-      To use the inferred type, enable PartialTypeSignatures\r
-    • In a RULE for ‘f’: a -> _\r
-      When checking the transformation rule "map/empty"\r
+
+T10072.hs:3:31: error:
+    • Found type wildcard ‘_’ standing for ‘b’
+      Where: ‘b’ is a rigid type variable bound by
+               the RULE "map/empty" at T10072.hs:3:1-47
+      To use the inferred type, enable PartialTypeSignatures
+    • In a RULE for ‘f’: a -> _
+      When checking the transformation rule "map/empty"
index 45fd33c..c3d112f 100644 (file)
@@ -1,5 +1,5 @@
-\r
-T10632.hs:3:1: warning: [-Wredundant-constraints (in -Wall)]\r
-    • Redundant constraint: ?file1::String\r
-    • In the type signature for:\r
-           f :: (?file1::String) => IO ()\r
+
+T10632.hs:3:1: warning: [-Wredundant-constraints (in -Wall)]
+    • Redundant constraint: ?file1::String
+    • In the type signature for:
+           f :: (?file1::String) => IO ()
index b43c45f..7fd5001 100644 (file)
@@ -1,15 +1,15 @@
-\r
-T11339.hs:15:5: error:\r
-    • Overloaded signature conflicts with monomorphism restriction\r
-        t :: forall (f :: * -> *). Applicative f => (a -> f b) -> f t\r
-    • In an equation for ‘failing’:\r
-          failing left right afb s\r
-            = case pins t of {\r
-                [] -> right afb s\r
-                _ -> t afb }\r
-            where\r
-                t :: Applicative f => (a -> f b) -> f t\r
-                Bazaar {getBazaar = t} = left sell s\r
-                sell :: a -> Bazaar a b b\r
-                sell w = Bazaar ($ w)\r
-                ....\r
+
+T11339.hs:15:5: error:
+    • Overloaded signature conflicts with monomorphism restriction
+        t :: forall (f :: * -> *). Applicative f => (a -> f b) -> f t
+    • In an equation for ‘failing’:
+          failing left right afb s
+            = case pins t of {
+                [] -> right afb s
+                _ -> t afb }
+            where
+                t :: Applicative f => (a -> f b) -> f t
+                Bazaar {getBazaar = t} = left sell s
+                sell :: a -> Bazaar a b b
+                sell w = Bazaar ($ w)
+                ....
index 93c46fc..48b2221 100644 (file)
@@ -1,36 +1,36 @@
-\r
-T2494.hs:15:14: error:\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-62\r
-      ‘a’ is a rigid type variable bound by\r
-        the RULE "foo/foo" at T2494.hs:13:16-62\r
-      Expected type: Maybe (m a) -> Maybe (m a)\r
-        Actual type: Maybe (m b) -> Maybe (m b)\r
-    • In the first argument of ‘foo’, namely ‘g’\r
-      In the second argument of ‘foo’, namely ‘(foo g x)’\r
-      In the expression: foo f (foo g x)\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
-\r
-T2494.hs:15:30: error:\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-62\r
-      ‘a’ is a rigid type variable bound by\r
-        the RULE "foo/foo" at T2494.hs:13:16-62\r
-      Expected type: Maybe (m b) -> Maybe (m a)\r
-        Actual type: Maybe (m b) -> Maybe (m b)\r
-    • In the second argument of ‘(.)’, namely ‘g’\r
-      In the first argument of ‘foo’, namely ‘(f . g)’\r
-      In the expression: foo (f . g) x\r
-    • 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
+
+T2494.hs:15:14: error:
+    • Couldn't match type ‘b’ with ‘a’
+      ‘b’ is a rigid type variable bound by
+        the RULE "foo/foo" at T2494.hs:14:16-62
+      ‘a’ is a rigid type variable bound by
+        the RULE "foo/foo" at T2494.hs:13:16-62
+      Expected type: Maybe (m a) -> Maybe (m a)
+        Actual type: Maybe (m b) -> Maybe (m b)
+    • In the first argument of ‘foo’, namely ‘g’
+      In the second argument of ‘foo’, namely ‘(foo g x)’
+      In the expression: foo f (foo g x)
+    • 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)
+
+T2494.hs:15:30: error:
+    • Couldn't match type ‘b’ with ‘a’
+      ‘b’ is a rigid type variable bound by
+        the RULE "foo/foo" at T2494.hs:14:16-62
+      ‘a’ is a rigid type variable bound by
+        the RULE "foo/foo" at T2494.hs:13:16-62
+      Expected type: Maybe (m b) -> Maybe (m a)
+        Actual type: Maybe (m b) -> Maybe (m b)
+    • In the second argument of ‘(.)’, namely ‘g’
+      In the first argument of ‘foo’, namely ‘(f . g)’
+      In the expression: foo (f . g) x
+    • 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)
index 75392ea..8fb1db7 100644 (file)
@@ -1,46 +1,46 @@
-\r
-T9834.hs:23:10: warning: [-Wdeferred-type-errors (in -Wdefault)]\r
-    • Couldn't match type ‘p’ with ‘(->) (p a0)’\r
-      ‘p’ is a rigid type variable bound by\r
-        the class declaration for ‘ApplicativeFix’ at T9834.hs:21:39\r
-      Expected type: (forall (q :: * -> *).\r
-                      Applicative q =>\r
-                      Comp p q a -> Comp p q a)\r
-                     -> p a\r
-        Actual type: (forall (q :: * -> *).\r
-                      Applicative q =>\r
-                      Nat (Comp p q) (Comp p q))\r
-                     -> p a0 -> p a0\r
-    • In the expression: wrapIdComp\r
-      In an equation for ‘afix’: afix = wrapIdComp\r
-    • Relevant bindings include\r
-        afix :: (forall (q :: * -> *).\r
-                 Applicative q =>\r
-                 Comp p q a -> Comp p q a)\r
-                -> p a\r
-          (bound at T9834.hs:23:3)\r
-\r
-T9834.hs:23:10: warning: [-Wdeferred-type-errors (in -Wdefault)]\r
-    • Couldn't match type ‘a’ with ‘a1’\r
-      ‘a’ is a rigid type variable bound by\r
-        the type signature for:\r
-          afix :: forall a.\r
-                  (forall (q :: * -> *). Applicative q => Comp p q a -> Comp p q a)\r
-                  -> p a\r
-        at T9834.hs:22:11-74\r
-      ‘a1’ is a rigid type variable bound by\r
-        a type expected by the context:\r
-          forall (q :: * -> *) a1.\r
-          Applicative q =>\r
-          Comp p q a1 -> Comp p q a1\r
-        at T9834.hs:23:10-19\r
-      Expected type: Comp p q a1 -> Comp p q a1\r
-        Actual type: Comp p q a -> Comp p q a\r
-    • In the expression: wrapIdComp\r
-      In an equation for ‘afix’: afix = wrapIdComp\r
-    • Relevant bindings include\r
-        afix :: (forall (q :: * -> *).\r
-                 Applicative q =>\r
-                 Comp p q a -> Comp p q a)\r
-                -> p a\r
-          (bound at T9834.hs:23:3)\r
+
+T9834.hs:23:10: warning: [-Wdeferred-type-errors (in -Wdefault)]
+    • Couldn't match type ‘p’ with ‘(->) (p a0)’
+      ‘p’ is a rigid type variable bound by
+        the class declaration for ‘ApplicativeFix’ at T9834.hs:21:39
+      Expected type: (forall (q :: * -> *).
+                      Applicative q =>
+                      Comp p q a -> Comp p q a)
+                     -> p a
+        Actual type: (forall (q :: * -> *).
+                      Applicative q =>
+                      Nat (Comp p q) (Comp p q))
+                     -> p a0 -> p a0
+    • In the expression: wrapIdComp
+      In an equation for ‘afix’: afix = wrapIdComp
+    • Relevant bindings include
+        afix :: (forall (q :: * -> *).
+                 Applicative q =>
+                 Comp p q a -> Comp p q a)
+                -> p a
+          (bound at T9834.hs:23:3)
+
+T9834.hs:23:10: warning: [-Wdeferred-type-errors (in -Wdefault)]
+    • Couldn't match type ‘a’ with ‘a1’
+      ‘a’ is a rigid type variable bound by
+        the type signature for:
+          afix :: forall a.
+                  (forall (q :: * -> *). Applicative q => Comp p q a -> Comp p q a)
+                  -> p a
+        at T9834.hs:22:11-74
+      ‘a1’ is a rigid type variable bound by
+        a type expected by the context:
+          forall (q :: * -> *) a1.
+          Applicative q =>
+          Comp p q a1 -> Comp p q a1
+        at T9834.hs:23:10-19
+      Expected type: Comp p q a1 -> Comp p q a1
+        Actual type: Comp p q a -> Comp p q a
+    • In the expression: wrapIdComp
+      In an equation for ‘afix’: afix = wrapIdComp
+    • Relevant bindings include
+        afix :: (forall (q :: * -> *).
+                 Applicative q =>
+                 Comp p q a -> Comp p q a)
+                -> p a
+          (bound at T9834.hs:23:3)
index 5e227b2..d10c510 100644 (file)
@@ -1,20 +1,20 @@
-\r
-T9939.hs:5:1: warning: [-Wredundant-constraints (in -Wall)]\r
-    • Redundant constraint: Eq a\r
-    • In the type signature for:\r
-           f1 :: (Eq a, Ord a) => a -> a -> Bool\r
-\r
-T9939.hs:9:1: warning: [-Wredundant-constraints (in -Wall)]\r
-    • Redundant constraint: Eq a\r
-    • In the type signature for:\r
-           f2 :: (Eq a, Ord a) => a -> a -> Bool\r
-\r
-T9939.hs:13:1: warning: [-Wredundant-constraints (in -Wall)]\r
-    • Redundant constraint: Eq b\r
-    • In the type signature for:\r
-           f3 :: (Eq a, a ~ b, Eq b) => a -> b -> Bool\r
-\r
-T9939.hs:20:1: warning: [-Wredundant-constraints (in -Wall)]\r
-    • Redundant constraint: Eq a\r
-    • In the type signature for:\r
-           f4 :: (Eq a, Eq b) => a -> b -> Equal a b -> Bool\r
+
+T9939.hs:5:1: warning: [-Wredundant-constraints (in -Wall)]
+    • Redundant constraint: Eq a
+    • In the type signature for:
+           f1 :: (Eq a, Ord a) => a -> a -> Bool
+
+T9939.hs:9:1: warning: [-Wredundant-constraints (in -Wall)]
+    • Redundant constraint: Eq a
+    • In the type signature for:
+           f2 :: (Eq a, Ord a) => a -> a -> Bool
+
+T9939.hs:13:1: warning: [-Wredundant-constraints (in -Wall)]
+    • Redundant constraint: Eq b
+    • In the type signature for:
+           f3 :: (Eq a, a ~ b, Eq b) => a -> b -> Bool
+
+T9939.hs:20:1: warning: [-Wredundant-constraints (in -Wall)]
+    • Redundant constraint: Eq a
+    • In the type signature for:
+           f4 :: (Eq a, Eq b) => a -> b -> Equal a b -> Bool
index 6bb1177..aadc844 100644 (file)
@@ -1,33 +1,33 @@
-\r
-holes.hs:3:5: warning: [-Wtyped-holes (in -Wdefault)]\r
-    • Found hole: _ :: t\r
-      Where: ‘t’ is a rigid type variable bound by\r
-               the inferred type of f :: t at holes.hs:3:1-5\r
-    • In the expression: _\r
-      In an equation for ‘f’: f = _\r
-    • Relevant bindings include f :: t (bound at holes.hs:3:1)\r
-\r
-holes.hs:6:7: warning: [-Wtyped-holes (in -Wdefault)]\r
-    • Found hole: _ :: Char\r
-    • In the expression: _\r
-      In an equation for ‘g’: g x = _\r
-    • Relevant bindings include\r
-        x :: Int (bound at holes.hs:6:3)\r
-        g :: Int -> Char (bound at holes.hs:6:1)\r
-\r
-holes.hs:8:5: warning: [-Wtyped-holes (in -Wdefault)]\r
-    • Found hole: _ :: [Char]\r
-    • In the first argument of ‘(++)’, namely ‘_’\r
-      In the expression: _ ++ "a"\r
-      In an equation for ‘h’: h = _ ++ "a"\r
-    • Relevant bindings include h :: [Char] (bound at holes.hs:8:1)\r
-\r
-holes.hs:11:15: warning: [-Wtyped-holes (in -Wdefault)]\r
-    • Found hole: _ :: b0\r
-      Where: ‘b0’ is an ambiguous type variable\r
-    • In the second argument of ‘const’, namely ‘_’\r
-      In the expression: const y _\r
-      In an equation for ‘z’: z y = const y _\r
-    • Relevant bindings include\r
-        y :: [a] (bound at holes.hs:11:3)\r
-        z :: [a] -> [a] (bound at holes.hs:11:1)\r
+
+holes.hs:3:5: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: t
+      Where: ‘t’ is a rigid type variable bound by
+               the inferred type of f :: t at holes.hs:3:1-5
+    • In the expression: _
+      In an equation for ‘f’: f = _
+    • Relevant bindings include f :: t (bound at holes.hs:3:1)
+
+holes.hs:6:7: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Char
+    • In the expression: _
+      In an equation for ‘g’: g x = _
+    • Relevant bindings include
+        x :: Int (bound at holes.hs:6:3)
+        g :: Int -> Char (bound at holes.hs:6:1)
+
+holes.hs:8:5: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: [Char]
+    • In the first argument of ‘(++)’, namely ‘_’
+      In the expression: _ ++ "a"
+      In an equation for ‘h’: h = _ ++ "a"
+    • Relevant bindings include h :: [Char] (bound at holes.hs:8:1)
+
+holes.hs:11:15: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: b0
+      Where: ‘b0’ is an ambiguous type variable
+    • In the second argument of ‘const’, namely ‘_’
+      In the expression: const y _
+      In an equation for ‘z’: z y = const y _
+    • Relevant bindings include
+        y :: [a] (bound at holes.hs:11:3)
+        z :: [a] -> [a] (bound at holes.hs:11:1)
index 7edaed8..3a3fd57 100644 (file)
@@ -1,36 +1,36 @@
-\r
-holes3.hs:3:5: error:\r
-    • Found hole: _ :: t\r
-      Where: ‘t’ is a rigid type variable bound by\r
-               the inferred type of f :: t at holes3.hs:3:1-5\r
-    • In the expression: _\r
-      In an equation for ‘f’: f = _\r
-    • Relevant bindings include f :: t (bound at holes3.hs:3:1)\r
-\r
-holes3.hs:6:7: error:\r
-    • Found hole: _gr :: Char\r
-      Or perhaps ‘_gr’ is mis-spelled, or not in scope\r
-    • In the expression: _gr\r
-      In an equation for ‘g’: g x = _gr\r
-    • Relevant bindings include\r
-        x :: Int (bound at holes3.hs:6:3)\r
-        g :: Int -> Char (bound at holes3.hs:6:1)\r
-\r
-holes3.hs:8:5: error:\r
-    • Found hole: _aa :: [Char]\r
-      Or perhaps ‘_aa’ is mis-spelled, or not in scope\r
-    • In the first argument of ‘(++)’, namely ‘_aa’\r
-      In the expression: _aa ++ "a"\r
-      In an equation for ‘h’: h = _aa ++ "a"\r
-    • Relevant bindings include h :: [Char] (bound at holes3.hs:8:1)\r
-\r
-holes3.hs:11:15: error:\r
-    • Found hole: _x :: b0\r
-      Where: ‘b0’ is an ambiguous type variable\r
-      Or perhaps ‘_x’ is mis-spelled, or not in scope\r
-    • In the second argument of ‘const’, namely ‘_x’\r
-      In the expression: const y _x\r
-      In an equation for ‘z’: z y = const y _x\r
-    • Relevant bindings include\r
-        y :: [a] (bound at holes3.hs:11:3)\r
-        z :: [a] -> [a] (bound at holes3.hs:11:1)\r
+
+holes3.hs:3:5: error:
+    • Found hole: _ :: t
+      Where: ‘t’ is a rigid type variable bound by
+               the inferred type of f :: t at holes3.hs:3:1-5
+    • In the expression: _
+      In an equation for ‘f’: f = _
+    • Relevant bindings include f :: t (bound at holes3.hs:3:1)
+
+holes3.hs:6:7: error:
+    • Found hole: _gr :: Char
+      Or perhaps ‘_gr’ is mis-spelled, or not in scope
+    • In the expression: _gr
+      In an equation for ‘g’: g x = _gr
+    • Relevant bindings include
+        x :: Int (bound at holes3.hs:6:3)
+        g :: Int -> Char (bound at holes3.hs:6:1)
+
+holes3.hs:8:5: error:
+    • Found hole: _aa :: [Char]
+      Or perhaps ‘_aa’ is mis-spelled, or not in scope
+    • In the first argument of ‘(++)’, namely ‘_aa’
+      In the expression: _aa ++ "a"
+      In an equation for ‘h’: h = _aa ++ "a"
+    • Relevant bindings include h :: [Char] (bound at holes3.hs:8:1)
+
+holes3.hs:11:15: error:
+    • Found hole: _x :: b0
+      Where: ‘b0’ is an ambiguous type variable
+      Or perhaps ‘_x’ is mis-spelled, or not in scope
+    • In the second argument of ‘const’, namely ‘_x’
+      In the expression: const y _x
+      In an equation for ‘z’: z y = const y _x
+    • Relevant bindings include
+        y :: [a] (bound at holes3.hs:11:3)
+        z :: [a] -> [a] (bound at holes3.hs:11:1)
index a8e5b01..99edf39 100644 (file)
@@ -1,22 +1,22 @@
-\r
-T10285.hs:8:17: error:\r
-    • Could not deduce: Coercible a b arising from a use of ‘coerce’\r
-      from the context: Coercible (N a) (N b)\r
-        bound by a pattern with constructor:\r
-                   Coercion :: forall k (a :: k) (b :: k).\r
-                               Coercible a b =>\r
-                               Coercion a b,\r
-                 in an equation for ‘oops’\r
-        at T10285.hs:8:6-13\r
-      ‘a’ is a rigid type variable bound by\r
-        the type signature for:\r
-          oops :: forall a b. Coercion (N a) (N b) -> a -> b\r
-        at T10285.hs:7:1-38\r
-      ‘b’ is a rigid type variable bound by\r
-        the type signature for:\r
-          oops :: forall a b. Coercion (N a) (N b) -> a -> b\r
-        at T10285.hs:7:1-38\r
-    • In the expression: coerce\r
-      In an equation for ‘oops’: oops Coercion = coerce\r
-    • Relevant bindings include\r
-        oops :: Coercion (N a) (N b) -> a -> b (bound at T10285.hs:8:1)\r
+
+T10285.hs:8:17: error:
+    • Could not deduce: Coercible a b arising from a use of ‘coerce’
+      from the context: Coercible (N a) (N b)
+        bound by a pattern with constructor:
+                   Coercion :: forall k (a :: k) (b :: k).
+                               Coercible a b =>
+                               Coercion a b,
+                 in an equation for ‘oops’
+        at T10285.hs:8:6-13
+      ‘a’ is a rigid type variable bound by
+        the type signature for:
+          oops :: forall a b. Coercion (N a) (N b) -> a -> b
+        at T10285.hs:7:1-38
+      ‘b’ is a rigid type variable bound by
+        the type signature for:
+          oops :: forall a b. Coercion (N a) (N b) -> a -> b
+        at T10285.hs:7:1-38
+    • In the expression: coerce
+      In an equation for ‘oops’: oops Coercion = coerce
+    • Relevant bindings include
+        oops :: Coercion (N a) (N b) -> a -> b (bound at T10285.hs:8:1)
index 5ba1c89..ef42727 100644 (file)
@@ -1,19 +1,19 @@
-\r
-T10534a.hs:10:9: error:\r
-    • Could not deduce: Coercible a b arising from a use of ‘coerce’\r
-      from the context: Coercible (DF a) (DF b)\r
-        bound by the type signature for:\r
-                   silly :: Coercible (DF a) (DF b) => a -> b\r
-        at T10534a.hs:9:1-42\r
-      ‘a’ is a rigid type variable bound by\r
-        the type signature for:\r
-          silly :: forall a b. Coercible (DF a) (DF b) => a -> b\r
-        at T10534a.hs:9:1-42\r
-      ‘b’ is a rigid type variable bound by\r
-        the type signature for:\r
-          silly :: forall a b. Coercible (DF a) (DF b) => a -> b\r
-        at T10534a.hs:9:1-42\r
-    • In the expression: coerce\r
-      In an equation for ‘silly’: silly = coerce\r
-    • Relevant bindings include\r
-        silly :: a -> b (bound at T10534a.hs:10:1)\r
+
+T10534a.hs:10:9: error:
+    • Could not deduce: Coercible a b arising from a use of ‘coerce’
+      from the context: Coercible (DF a) (DF b)
+        bound by the type signature for:
+                   silly :: Coercible (DF a) (DF b) => a -> b
+        at T10534a.hs:9:1-42
+      ‘a’ is a rigid type variable bound by
+        the type signature for:
+          silly :: forall a b. Coercible (DF a) (DF b) => a -> b
+        at T10534a.hs:9:1-42
+      ‘b’ is a rigid type variable bound by
+        the type signature for:
+          silly :: forall a b. Coercible (DF a) (DF b) => a -> b
+        at T10534a.hs:9:1-42
+    • In the expression: coerce
+      In an equation for ‘silly’: silly = coerce
+    • Relevant bindings include
+        silly :: a -> b (bound at T10534a.hs:10:1)
index 9b98acb..19bc1b9 100644 (file)
@@ -1,13 +1,13 @@
-\r
-T10715.hs:9:13: error:\r
-    • Couldn't match representation of type ‘a’ with that of ‘X a’\r
-      ‘a’ is a rigid type variable bound by\r
-        the type signature for:\r
-          doCoerce :: forall a. Coercible a (X a) => a -> X a\r
-        at T10715.hs:9:13-41\r
-      Inaccessible code in\r
-        the type signature for:\r
-          doCoerce :: Coercible a (X a) => a -> X a\r
-    • In the ambiguity check for ‘doCoerce’\r
-      To defer the ambiguity check to use sites, enable AllowAmbiguousTypes\r
-      In the type signature: doCoerce :: Coercible a (X a) => a -> X a\r
+
+T10715.hs:9:13: error:
+    • Couldn't match representation of type ‘a’ with that of ‘X a’
+      ‘a’ is a rigid type variable bound by
+        the type signature for:
+          doCoerce :: forall a. Coercible a (X a) => a -> X a
+        at T10715.hs:9:13-41
+      Inaccessible code in
+        the type signature for:
+          doCoerce :: Coercible a (X a) => a -> X a
+    • In the ambiguity check for ‘doCoerce’
+      To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
+      In the type signature: doCoerce :: Coercible a (X a) => a -> X a
index 5406106..5f1e7ad 100644 (file)
@@ -1,11 +1,11 @@
-\r
-T11347.hs:6:41: error:\r
-    • Couldn't match representation of type ‘a’ with that of ‘b’\r
-        arising from the coercion of the method ‘unsafe’\r
-          from type ‘Id1 a -> Discern (Id1 a) b’\r
-            to type ‘Id2 a -> Discern (Id2 a) b’\r
-      ‘a’ is a rigid type variable bound by\r
-        the deriving clause for ‘UnsafeCast b (Id2 a)’ at T11347.hs:6:41-52\r
-      ‘b’ is a rigid type variable bound by\r
-        the deriving clause for ‘UnsafeCast b (Id2 a)’ at T11347.hs:6:41-52\r
-    • When deriving the instance for (UnsafeCast b (Id2 a))\r
+
+T11347.hs:6:41: error:
+    • Couldn't match representation of type ‘a’ with that of ‘b’
+        arising from the coercion of the method ‘unsafe’
+          from type ‘Id1 a -> Discern (Id1 a) b’
+            to type ‘Id2 a -> Discern (Id2 a) b’
+      ‘a’ is a rigid type variable bound by
+        the deriving clause for ‘UnsafeCast b (Id2 a)’ at T11347.hs:6:41-52
+      ‘b’ is a rigid type variable bound by
+        the deriving clause for ‘UnsafeCast b (Id2 a)’ at T11347.hs:6:41-52
+    • When deriving the instance for (UnsafeCast b (Id2 a))
index c88ae9a..9fe7102 100644 (file)
@@ -1,15 +1,15 @@
-\r
-T1899.hs:14:36: error:\r
-    • Couldn't match type ‘a’ with ‘Proposition a0’\r
-      ‘a’ is a rigid type variable bound by\r
-        the type signature for:\r
-          transRHS :: forall a. [a] -> Int -> Constraint a\r
-        at T1899.hs:9:2-39\r
-      Expected type: [Proposition a0]\r
-        Actual type: [a]\r
-    • In the first argument of ‘Auxiliary’, namely ‘varSet’\r
-      In the first argument of ‘Prop’, namely ‘(Auxiliary varSet)’\r
-      In the expression: Prop (Auxiliary varSet)\r
-    • Relevant bindings include\r
-        varSet :: [a] (bound at T1899.hs:10:11)\r
-        transRHS :: [a] -> Int -> Constraint a (bound at T1899.hs:10:2)\r
+
+T1899.hs:14:36: error:
+    • Couldn't match type ‘a’ with ‘Proposition a0’
+      ‘a’ is a rigid type variable bound by
+        the type signature for:
+          transRHS :: forall a. [a] -> Int -> Constraint a
+        at T1899.hs:9:2-39
+      Expected type: [Proposition a0]
+        Actual type: [a]
+    • In the first argument of ‘Auxiliary’, namely ‘varSet’
+      In the first argument of ‘Prop’, namely ‘(Auxiliary varSet)’
+      In the expression: Prop (Auxiliary varSet)
+    • Relevant bindings include
+        varSet :: [a] (bound at T1899.hs:10:11)
+        transRHS :: [a] -> Int -> Constraint a (bound at T1899.hs:10:2)
index f60855d..c016586 100644 (file)
@@ -1,13 +1,13 @@
-\r
-T2714.hs:8:5: error:\r
-    • Couldn't match type ‘a’ with ‘f0 b’\r
-      ‘a’ is a rigid type variable bound by\r
-        the type signature for:\r
-          f :: forall a b. ((a -> b) -> b) -> forall c. c -> a\r
-        at T2714.hs:7:1-42\r
-      Expected type: ((a -> b) -> b) -> c -> a\r
-        Actual type: ((a -> b) -> b) -> f0 (a -> b) -> f0 b\r
-    • In the expression: ffmap\r
-      In an equation for ‘f’: f = ffmap\r
-    • Relevant bindings include\r
-        f :: ((a -> b) -> b) -> forall c. c -> a (bound at T2714.hs:8:1)\r
+
+T2714.hs:8:5: error:
+    • Couldn't match type ‘a’ with ‘f0 b’
+      ‘a’ is a rigid type variable bound by
+        the type signature for:
+          f :: forall a b. ((a -> b) -> b) -> forall c. c -> a
+        at T2714.hs:7:1-42
+      Expected type: ((a -> b) -> b) -> c -> a
+        Actual type: ((a -> b) -> b) -> f0 (a -> b) -> f0 b
+    • In the expression: ffmap
+      In an equation for ‘f’: f = ffmap
+    • Relevant bindings include
+        f :: ((a -> b) -> b) -> forall c. c -> a (bound at T2714.hs:8:1)
index 6ff8d1c..66979dd 100644 (file)
@@ -1,12 +1,12 @@
-\r
-T3102.hs:11:12: error:\r
-    • Couldn't match type ‘a’ with ‘(?p::Int) => a0’\r
-      ‘a’ is a rigid type variable bound by\r
-        a type expected by the context:\r
-          forall a. a -> String\r
-        at T3102.hs:11:10-12\r
-      Expected type: a -> String\r
-        Actual type: ((?p::Int) => a0) -> String\r
-    • In the first argument of ‘f’, namely ‘t’\r
-      In the expression: f t\r
-      In an equation for ‘result’: result = f t\r
+
+T3102.hs:11:12: error:
+    • Couldn't match type ‘a’ with ‘(?p::Int) => a0’
+      ‘a’ is a rigid type variable bound by
+        a type expected by the context:
+          forall a. a -> String
+        at T3102.hs:11:10-12
+      Expected type: a -> String
+        Actual type: ((?p::Int) => a0) -> String
+    • In the first argument of ‘f’, namely ‘t’
+      In the expression: f t
+      In an equation for ‘result’: result = f t
index 585dcdf..9d4e587 100644 (file)
@@ -1,19 +1,19 @@
-\r
-T5691.hs:15:24: error:\r
-    • Couldn't match type ‘p’ with ‘PrintRuleInterp’\r
-      Expected type: PrintRuleInterp a\r
-        Actual type: p a\r
-    • In the first argument of ‘printRule_’, namely ‘f’\r
-      In the second argument of ‘($)’, namely ‘printRule_ f’\r
-      In the expression: MkPRI $ printRule_ f\r
-    • Relevant bindings include f :: p a (bound at T5691.hs:14:9)\r
-\r
-T5691.hs:24:10: error:\r
-    • No instance for (Alternative RecDecParser)\r
-        arising from the superclasses of an instance declaration\r
-    • In the instance declaration for ‘MonadPlus RecDecParser’\r
-\r
-T5691.hs:24:10: error:\r
-    • No instance for (Monad RecDecParser)\r
-        arising from the superclasses of an instance declaration\r
-    • In the instance declaration for ‘MonadPlus RecDecParser’\r
+
+T5691.hs:15:24: error:
+    • Couldn't match type ‘p’ with ‘PrintRuleInterp’
+      Expected type: PrintRuleInterp a
+        Actual type: p a
+    • In the first argument of ‘printRule_’, namely ‘f’
+      In the second argument of ‘($)’, namely ‘printRule_ f’
+      In the expression: MkPRI $ printRule_ f
+    • Relevant bindings include f :: p a (bound at T5691.hs:14:9)
+
+T5691.hs:24:10: error:
+    • No instance for (Alternative RecDecParser)
+        arising from the superclasses of an instance declaration
+    • In the instance declaration for ‘MonadPlus RecDecParser’
+
+T5691.hs:24:10: error:
+    • No instance for (Monad RecDecParser)
+        arising from the superclasses of an instance declaration
+    • In the instance declaration for ‘MonadPlus RecDecParser’
index 57d3699..71c99c5 100644 (file)
@@ -1,13 +1,13 @@
-\r
-T7264.hs:13:19: error:\r
-    • Couldn't match type ‘a’ with ‘forall r. r -> String’\r
-      ‘a’ is a rigid type variable bound by\r
-        the inferred type of mkFoo2 :: a -> Maybe Foo at T7264.hs:13:1-32\r
-      Expected type: a -> Foo\r
-        Actual type: (forall r. r -> String) -> Foo\r
-    • In the first argument of ‘mmap’, namely ‘Foo’\r
-      In the expression: mmap Foo (Just val)\r
-      In an equation for ‘mkFoo2’: mkFoo2 val = mmap Foo (Just val)\r
-    • Relevant bindings include\r
-        val :: a (bound at T7264.hs:13:8)\r
-        mkFoo2 :: a -> Maybe Foo (bound at T7264.hs:13:1)\r
+
+T7264.hs:13:19: error:
+    • Couldn't match type ‘a’ with ‘forall r. r -> String’
+      ‘a’ is a rigid type variable bound by
+        the inferred type of mkFoo2 :: a -> Maybe Foo at T7264.hs:13:1-32
+      Expected type: a -> Foo
+        Actual type: (forall r. r -> String) -> Foo
+    • In the first argument of ‘mmap’, namely ‘Foo’
+      In the expression: mmap Foo (Just val)
+      In an equation for ‘mkFoo2’: mkFoo2 val = mmap Foo (Just val)
+    • Relevant bindings include
+        val :: a (bound at T7264.hs:13:8)
+        mkFoo2 :: a -> Maybe Foo (bound at T7264.hs:13:1)
index d63f406..17d60cc 100644 (file)
@@ -1,20 +1,20 @@
-\r
-T7748a.hs:16:24: error:\r
-    • Couldn't match expected type ‘a’\r
-                  with actual type ‘Maybe (Maybe (r -> ()))’\r
-      ‘a’ is a rigid type variable bound by\r
-        the type signature for:\r
-          test :: forall a r. a -> r -> ()\r
-        at T7748a.hs:11:1-20\r
-    • In the pattern: Just (Just p)\r
-      In a case alternative: Just (Just p) -> p\r
-      In the expression:\r
-        case zd of {\r
-          Nothing -> const ()\r
-          Just Nothing -> const ()\r
-          Just (Just p) -> p }\r
-    • Relevant bindings include\r
-        g :: r -> () (bound at T7748a.hs:13:16)\r
-        f :: r -> () (bound at T7748a.hs:13:8)\r
-        zd :: a (bound at T7748a.hs:12:6)\r
-        test :: a -> r -> () (bound at T7748a.hs:12:1)\r
+
+T7748a.hs:16:24: error:
+    • Couldn't match expected type ‘a’
+                  with actual type ‘Maybe (Maybe (r -> ()))’
+      ‘a’ is a rigid type variable bound by
+        the type signature for:
+          test :: forall a r. a -> r -> ()
+        at T7748a.hs:11:1-20
+    • In the pattern: Just (Just p)
+      In a case alternative: Just (Just p) -> p
+      In the expression:
+        case zd of {
+          Nothing -> const ()
+          Just Nothing -> const ()
+          Just (Just p) -> p }
+    • Relevant bindings include
+        g :: r -> () (bound at T7748a.hs:13:16)
+        f :: r -> () (bound at T7748a.hs:13:8)
+        zd :: a (bound at T7748a.hs:12:6)
+        test :: a -> r -> () (bound at T7748a.hs:12:1)
index 95dc5a9..00ea8e7 100644 (file)
@@ -1,14 +1,14 @@
-\r
-T7869.hs:3:12: error:\r
-    • Couldn't match type ‘b’ with ‘b1’\r
-        because type variable ‘b1’ would escape its scope\r
-      This (rigid, skolem) type variable is bound by\r
-        an expression type signature:\r
-          [a1] -> b1\r
-        at T7869.hs:3:20-27\r
-      Expected type: [a1] -> b1\r
-        Actual type: [a] -> b\r
-    • In the expression: f x\r
-      In the expression: (\ x -> f x) :: [a] -> b\r
-      In an equation for ‘f’: f = (\ x -> f x) :: [a] -> b\r
-    • Relevant bindings include f :: [a] -> b (bound at T7869.hs:3:1)\r
+
+T7869.hs:3:12: error:
+    • Couldn't match type ‘b’ with ‘b1’
+        because type variable ‘b1’ would escape its scope
+      This (rigid, skolem) type variable is bound by
+        an expression type signature:
+          [a1] -> b1
+        at T7869.hs:3:20-27
+      Expected type: [a1] -> b1
+        Actual type: [a] -> b
+    • In the expression: f x
+      In the expression: (\ x -> f x) :: [a] -> b
+      In an equation for ‘f’: f = (\ x -> f x) :: [a] -> b
+    • Relevant bindings include f :: [a] -> b (bound at T7869.hs:3:1)
index c5a751d..8ba84a7 100644 (file)
@@ -1,11 +1,11 @@
-\r
-T8450.hs:8:7: error:\r
-    • Couldn't match expected type ‘a’ with actual type ‘()’\r
-      ‘a’ is a rigid type variable bound by\r
-        the type signature for:\r
-          run :: forall a. a\r
-        at T8450.hs:7:1-18\r
-    • In the expression: runEffect $ (undefined :: Either a ())\r
-      In an equation for ‘run’:\r
-          run = runEffect $ (undefined :: Either a ())\r
-    • Relevant bindings include run :: a (bound at T8450.hs:8:1)\r
+
+T8450.hs:8:7: error:
+    • Couldn't match expected type ‘a’ with actual type ‘()’
+      ‘a’ is a rigid type variable bound by
+        the type signature for:
+          run :: forall a. a
+        at T8450.hs:7:1-18
+    • In the expression: runEffect $ (undefined :: Either a ())
+      In an equation for ‘run’:
+          run = runEffect $ (undefined :: Either a ())
+    • Relevant bindings include run :: a (bound at T8450.hs:8:1)
index 4b00eea..cffb7f6 100644 (file)
@@ -1,12 +1,12 @@
-\r
-mc19.hs:10:31: error:\r
-    • Couldn't match type ‘a’ with ‘[a]’\r
-      ‘a’ is a rigid type variable bound by\r
-        a type expected by the context:\r
-          forall a. [a] -> [a]\r
-        at mc19.hs:10:10-35\r
-      Expected type: [a] -> [a]\r
-        Actual type: [a] -> [[a]]\r
-    • In the expression: inits\r
-      In a stmt of a monad comprehension: then inits\r
-      In the expression: [x | x <- [3, 2, 1], then inits]\r
+
+mc19.hs:10:31: error:
+    • Couldn't match type ‘a’ with ‘[a]’
+      ‘a’ is a rigid type variable bound by
+        a type expected by the context:
+          forall a. [a] -> [a]
+        at mc19.hs:10:10-35
+      Expected type: [a] -> [a]
+        Actual type: [a] -> [[a]]
+    • In the expression: inits
+      In a stmt of a monad comprehension: then inits
+      In the expression: [x | x <- [3, 2, 1], then inits]
index d650f0e..9cffcfb 100644 (file)
@@ -1,13 +1,13 @@
-\r
-mc21.hs:12:26: error:\r
-    • Couldn't match type ‘a’ with ‘[a]’\r
-      ‘a’ is a rigid type variable bound by\r
-        a type expected by the context:\r
-          forall a. [a] -> [[a]]\r
-        at mc21.hs:(11,9)-(12,31)\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
-      In the expression:\r
-        [GHC.List.length x | x <- [Gnorf, Brain], then group using take 5]\r
+
+mc21.hs:12:26: error:
+    • Couldn't match type ‘a’ with ‘[a]’
+      ‘a’ is a rigid type variable bound by
+        a type expected by the context:
+          forall a. [a] -> [[a]]
+        at mc21.hs:(11,9)-(12,31)
+      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
+      In the expression:
+        [GHC.List.length x | x <- [Gnorf, Brain], then group using take 5]
index a394859..ec82baf 100644 (file)
@@ -1,15 +1,15 @@
-\r
-mc22.hs:10:26: error:\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:\r
-          forall a. [a] -> [t a]\r
-        at mc22.hs:(9,9)-(10,31)\r
-      Expected type: [a] -> [t a]\r
-        Actual type: [t a] -> [t a]\r
-    • In the expression: take 5\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
-    • Relevant bindings include\r
-        foo :: [t [Char]] (bound at mc22.hs:8:1)\r
+
+mc22.hs:10:26: error:
+    • Couldn't match type ‘a’ with ‘t a’
+      ‘a’ is a rigid type variable bound by
+        a type expected by the context:
+          forall a. [a] -> [t a]
+        at mc22.hs:(9,9)-(10,31)
+      Expected type: [a] -> [t a]
+        Actual type: [t a] -> [t a]
+    • In the expression: take 5
+      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]
+    • Relevant bindings include
+        foo :: [t [Char]] (bound at mc22.hs:8:1)
index b576a1e..583e6e3 100644 (file)
@@ -1,13 +1,13 @@
-\r
-tcfail032.hs:14:8: error:\r
-    • Couldn't match expected type ‘a1 -> Int’ with actual type ‘t’\r
-        because type variable ‘a1’ would escape its scope\r
-      This (rigid, skolem) type variable is bound by\r
-        an expression type signature:\r
-          Eq a1 => a1 -> Int\r
-        at tcfail032.hs:14:13-30\r
-    • In the expression: (x :: (Eq a) => a -> Int)\r
-      In an equation for ‘f’: f x = (x :: (Eq a) => a -> Int)\r
-    • Relevant bindings include\r
-        x :: t (bound at tcfail032.hs:14:3)\r
-        f :: t -> forall a. Eq a => a -> Int (bound at tcfail032.hs:14:1)\r
+
+tcfail032.hs:14:8: error:
+    • Couldn't match expected type ‘a1 -> Int’ with actual type ‘t’
+        because type variable ‘a1’ would escape its scope
+      This (rigid, skolem) type variable is bound by
+        an expression type signature:
+          Eq a1 => a1 -> Int
+        at tcfail032.hs:14:13-30
+    • In the expression: (x :: (Eq a) => a -> Int)
+      In an equation for ‘f’: f x = (x :: (Eq a) => a -> Int)
+    • Relevant bindings include
+        x :: t (bound at tcfail032.hs:14:3)
+        f :: t -> forall a. Eq a => a -> Int (bound at tcfail032.hs:14:1)
index e381969..c1f3283 100644 (file)
@@ -1,17 +1,17 @@
-\r
-tcfail065.hs:29:18: error:\r
-    • Couldn't match type ‘x1’ with ‘x’\r
-      ‘x1’ is a rigid type variable bound by\r
-        the type signature for:\r
-          setX :: forall x1. x1 -> X x -> X x\r
-        at tcfail065.hs:29:3-6\r
-      ‘x’ is a rigid type variable bound by\r
-        the instance declaration at tcfail065.hs:28:10-19\r
-      Expected type: X x\r
-        Actual type: X x1\r
-    • In the expression: X x\r
-      In an equation for ‘setX’: setX x (X _) = X x\r
-      In the instance declaration for ‘HasX (X x)’\r
-    • Relevant bindings include\r
-        x :: x1 (bound at tcfail065.hs:29:8)\r
-        setX :: x1 -> X x -> X x (bound at tcfail065.hs:29:3)\r
+
+tcfail065.hs:29:18: error:
+    • Couldn't match type ‘x1’ with ‘x’
+      ‘x1’ is a rigid type variable bound by
+        the type signature for:
+          setX :: forall x1. x1 -> X x -> X x
+        at tcfail065.hs:29:3-6
+      ‘x’ is a rigid type variable bound by
+        the instance declaration at tcfail065.hs:28:10-19
+      Expected type: X x
+        Actual type: X x1
+    • In the expression: X x
+      In an equation for ‘setX’: setX x (X _) = X x
+      In the instance declaration for ‘HasX (X x)’
+    • Relevant bindings include
+        x :: x1 (bound at tcfail065.hs:29:8)
+        setX :: x1 -> X x -> X x (bound at tcfail065.hs:29:3)
index 66e7f09..bb3f9dd 100644 (file)
-\r
-tcfail068.hs:14:9: error:\r
-    • Couldn't match type ‘s1’ with ‘s’\r
-      ‘s1’ is a rigid type variable bound by\r
-        a type expected by the context:\r
-          forall s1. GHC.ST.ST s1 (IndTree s a)\r
-        at tcfail068.hs:(13,9)-(14,31)\r
-      ‘s’ is a rigid type variable bound by\r
-        the type signature for:\r
-          itgen :: forall a s.\r
-                   Constructed a =>\r
-                   (Int, Int) -> a -> IndTree s a\r
-        at tcfail068.hs:11:1-55\r
-      Expected type: GHC.ST.ST s1 (IndTree s a)\r
-        Actual type: GHC.ST.ST s1 (STArray s1 (Int, Int) a)\r
-    • In the first argument of ‘runST’, namely\r
-        ‘(newSTArray ((1, 1), n) x)’\r
-      In the expression: runST (newSTArray ((1, 1), n) x)\r
-      In an equation for ‘itgen’:\r
-          itgen n x = runST (newSTArray ((1, 1), n) x)\r
-    • Relevant bindings include\r
-        itgen :: (Int, Int) -> a -> IndTree s a\r
-          (bound at tcfail068.hs:12:1)\r
-\r
-tcfail068.hs:19:9: error:\r
-    • Couldn't match type ‘s’ with ‘s1’\r
-      ‘s’ is a rigid type variable bound by\r
-        the type signature for:\r
-          itiap :: forall a s.\r
-                   Constructed a =>\r
-                   (Int, Int) -> (a -> a) -> IndTree s a -> IndTree s a\r
-        at tcfail068.hs:16:1-75\r
-      ‘s1’ is a rigid type variable bound by\r
-        a type expected by the context:\r
-          forall s1. GHC.ST.ST s1 (IndTree s a)\r
-        at tcfail068.hs:(18,9)-(21,19)\r
-      Expected type: GHC.ST.ST s1 (IndTree s a)\r
-        Actual type: GHC.ST.ST s (IndTree s a)\r
-    • In the first argument of ‘runST’, namely\r
-        ‘(readSTArray arr i\r
-          >>= \ val -> writeSTArray arr i (f val) >> return arr)’\r
-      In the expression:\r
-        runST\r
-          (readSTArray arr i\r
-           >>= \ val -> writeSTArray arr i (f val) >> return arr)\r
-      In an equation for ‘itiap’:\r
-          itiap i f arr\r
-            = runST\r
-                (readSTArray arr i\r
-                 >>= \ val -> writeSTArray arr i (f val) >> return arr)\r
-    • Relevant bindings include\r
-        arr :: IndTree s a (bound at tcfail068.hs:17:11)\r
-        itiap :: (Int, Int) -> (a -> a) -> IndTree s a -> IndTree s a\r
-          (bound at tcfail068.hs:17:1)\r
-\r
-tcfail068.hs:24:36: error:\r
-    • Couldn't match type ‘s’ with ‘s1’\r
-      ‘s’ is a rigid type variable bound by\r
-        the type signature for:\r
-          itrap :: forall a s.\r
-                   Constructed a =>\r
-                   ((Int, Int), (Int, Int)) -> (a -> a) -> IndTree s a -> IndTree s a\r
-        at tcfail068.hs:23:1-87\r
-      ‘s1’ is a rigid type variable bound by\r
-        a type expected by the context:\r
-          forall s1. GHC.ST.ST s1 (IndTree s a)\r
-        at tcfail068.hs:24:29-46\r
-      Expected type: GHC.ST.ST s1 (IndTree s a)\r
-        Actual type: GHC.ST.ST s (IndTree s a)\r
-    • In the first argument of ‘runST’, namely ‘(itrap' i k)’\r
-      In the expression: runST (itrap' i k)\r
-      In an equation for ‘itrap’:\r
-          itrap ((i, k), (j, l)) f arr\r
-            = runST (itrap' i k)\r
-            where\r
-                itrap' i k\r
-                  = if k > l then return arr else (itrapsnd i k >> itrap' i (k + 1))\r
-                itrapsnd i k\r
-                  = if i > j then\r
-                        return arr\r
-                    else\r
-                        (readSTArray arr (i, k) >>= \ val -> ...)\r
-    • Relevant bindings include\r
-        itrap' :: Int -> Int -> GHC.ST.ST s (IndTree s a)\r
-          (bound at tcfail068.hs:26:9)\r
-        itrapsnd :: Int -> Int -> GHC.ST.ST s (IndTree s a)\r
-          (bound at tcfail068.hs:29:9)\r
-        arr :: IndTree s a (bound at tcfail068.hs:24:23)\r
-        itrap :: ((Int, Int), (Int, Int))\r
-                 -> (a -> a) -> IndTree s a -> IndTree s a\r
-          (bound at tcfail068.hs:24:1)\r
-\r
-tcfail068.hs:36:46: error:\r
-    • Couldn't match type ‘s’ with ‘s1’\r
-      ‘s’ is a rigid type variable bound by\r
-        the type signature for:\r
-          itrapstate :: forall b a c s.\r
-                        Constructed b =>\r
-                        ((Int, Int), (Int, Int))\r
-                        -> (a -> b -> (a, b))\r
-                        -> ((Int, Int) -> c -> a)\r
-                        -> (a -> c)\r
-                        -> c\r
-                        -> IndTree s b\r
-                        -> (c, IndTree s b)\r
-        at tcfail068.hs:(34,1)-(35,62)\r
-      ‘s1’ is a rigid type variable bound by\r
-        a type expected by the context:\r
-          forall s1. GHC.ST.ST s1 (c, IndTree s b)\r
-        at tcfail068.hs:36:40-63\r
-      Expected type: GHC.ST.ST s1 (c, IndTree s b)\r
-        Actual type: GHC.ST.ST s (c, IndTree s b)\r
-    • In the first argument of ‘runST’, namely ‘(itrapstate' i k s)’\r
-      In the expression: runST (itrapstate' i k s)\r
-      In an equation for ‘itrapstate’:\r
-          itrapstate ((i, k), (j, l)) f c d s arr\r
-            = runST (itrapstate' i k s)\r
-            where\r
-                itrapstate' i k s\r
-                  = if k > l then\r
-                        return (s, arr)\r
-                    else\r
-                        (itrapstatesnd i k s >>= \ (s, arr) -> ...)\r
-                itrapstatesnd i k s\r
-                  = if i > j then\r
-                        return (s, arr)\r
-                    else\r
-                        (readSTArray arr (i, k) >>= \ val -> ...)\r
-    • Relevant bindings include\r
-        itrapstate' :: Int -> Int -> c -> GHC.ST.ST s (c, IndTree s b)\r
-          (bound at tcfail068.hs:38:9)\r
-        itrapstatesnd :: Int -> Int -> c -> GHC.ST.ST s (c, IndTree s b)\r
-          (bound at tcfail068.hs:41:9)\r
-        arr :: IndTree s b (bound at tcfail068.hs:36:34)\r
-        itrapstate :: ((Int, Int), (Int, Int))\r
-                      -> (a -> b -> (a, b))\r
-                      -> ((Int, Int) -> c -> a)\r
-                      -> (a -> c)\r
-                      -> c\r
-                      -> IndTree s b\r
-                      -> (c, IndTree s b)\r
-          (bound at tcfail068.hs:36:1)\r
+
+tcfail068.hs:14:9: error:
+    • Couldn't match type ‘s1’ with ‘s’
+      ‘s1’ is a rigid type variable bound by
+        a type expected by the context:
+          forall s1. GHC.ST.ST s1 (IndTree s a)
+        at tcfail068.hs:(13,9)-(14,31)
+      ‘s’ is a rigid type variable bound by
+        the type signature for:
+          itgen :: forall a s.
+                   Constructed a =>
+                   (Int, Int) -> a -> IndTree s a
+        at tcfail068.hs:11:1-55
+      Expected type: GHC.ST.ST s1 (IndTree s a)
+        Actual type: GHC.ST.ST s1 (STArray s1 (Int, Int) a)
+    • In the first argument of ‘runST’, namely
+        ‘(newSTArray ((1, 1), n) x)’
+      In the expression: runST (newSTArray ((1, 1), n) x)
+      In an equation for ‘itgen’:
+          itgen n x = runST (newSTArray ((1, 1), n) x)
+    • Relevant bindings include
+        itgen :: (Int, Int) -> a -> IndTree s a
+          (bound at tcfail068.hs:12:1)
+
+tcfail068.hs:19:9: error:
+    • Couldn't match type ‘s’ with ‘s1’
+      ‘s’ is a rigid type variable bound by
+        the type signature for:
+          itiap :: forall a s.
+                   Constructed a =>
+                   (Int, Int) -> (a -> a) -> IndTree s a -> IndTree s a
+        at tcfail068.hs:16:1-75
+      ‘s1’ is a rigid type variable bound by
+        a type expected by the context:
+          forall s1. GHC.ST.ST s1 (IndTree s a)
+        at tcfail068.hs:(18,9)-(21,19)
+      Expected type: GHC.ST.ST s1 (IndTree s a)
+        Actual type: GHC.ST.ST s (IndTree s a)
+    • In the first argument of ‘runST’, namely
+        ‘(readSTArray arr i
+          >>= \ val -> writeSTArray arr i (f val) >> return arr)’
+      In the expression:
+        runST
+          (readSTArray arr i
+           >>= \ val -> writeSTArray arr i (f val) >> return arr)
+      In an equation for ‘itiap’:
+          itiap i f arr
+            = runST
+                (readSTArray arr i
+                 >>= \ val -> writeSTArray arr i (f val) >> return arr)
+    • Relevant bindings include
+        arr :: IndTree s a (bound at tcfail068.hs:17:11)
+        itiap :: (Int, Int) -> (a -> a) -> IndTree s a -> IndTree s a
+          (bound at tcfail068.hs:17:1)
+
+tcfail068.hs:24:36: error:
+    • Couldn't match type ‘s’ with ‘s1’
+      ‘s’ is a rigid type variable bound by
+        the type signature for:
+          itrap :: forall a s.
+                   Constructed a =>
+                   ((Int, Int), (Int, Int)) -> (a -> a) -> IndTree s a -> IndTree s a
+        at tcfail068.hs:23:1-87
+      ‘s1’ is a rigid type variable bound by
+        a type expected by the context:
+          forall s1. GHC.ST.ST s1 (IndTree s a)
+        at tcfail068.hs:24:29-46
+      Expected type: GHC.ST.ST s1 (IndTree s a)
+        Actual type: GHC.ST.ST s (IndTree s a)
+    • In the first argument of ‘runST’, namely ‘(itrap' i k)’
+      In the expression: runST (itrap' i k)
+      In an equation for ‘itrap’:
+          itrap ((i, k), (j, l)) f arr
+            = runST (itrap' i k)
+            where
+                itrap' i k
+                  = if k > l then return arr else (itrapsnd i k >> itrap' i (k + 1))
+                itrapsnd i k
+                  = if i > j then
+                        return arr
+                    else
+                        (readSTArray arr (i, k) >>= \ val -> ...)
+    • Relevant bindings include
+        itrap' :: Int -> Int -> GHC.ST.ST s (IndTree s a)
+          (bound at tcfail068.hs:26:9)
+        itrapsnd :: Int -> Int -> GHC.ST.ST s (IndTree s a)
+          (bound at tcfail068.hs:29:9)
+        arr :: IndTree s a (bound at tcfail068.hs:24:23)
+        itrap :: ((Int, Int), (Int, Int))
+                 -> (a -> a) -> IndTree s a -> IndTree s a
+          (bound at tcfail068.hs:24:1)
+
+tcfail068.hs:36:46: error:
+    • Couldn't match type ‘s’ with ‘s1’
+      ‘s’ is a rigid type variable bound by
+        the type signature for:
+          itrapstate :: forall b a c s.
+                        Constructed b =>
+                        ((Int, Int), (Int, Int))
+                        -> (a -> b -> (a, b))
+                        -> ((Int, Int) -> c -> a)
+                        -> (a -> c)
+                        -> c
+                        -> IndTree s b
+                        -> (c, IndTree s b)
+        at tcfail068.hs:(34,1)-(35,62)
+      ‘s1’ is a rigid type variable bound by
+        a type expected by the context:
+          forall s1. GHC.ST.ST s1 (c, IndTree s b)
+        at tcfail068.hs:36:40-63
+      Expected type: GHC.ST.ST s1 (c, IndTree s b)
+        Actual type: GHC.ST.ST s (c, IndTree s b)
+    • In the first argument of ‘runST’, namely ‘(itrapstate' i k s)’
+      In the expression: runST (itrapstate' i k s)
+      In an equation for ‘itrapstate’:
+          itrapstate ((i, k), (j, l)) f c d s arr
+            = runST (itrapstate' i k s)
+            where
+                itrapstate' i k s
+                  = if k > l then
+                        return (s, arr)
+                    else
+                        (itrapstatesnd i k s >>= \ (s, arr) -> ...)
+                itrapstatesnd i k s
+                  = if i > j then
+                        return (s, arr)
+                    else
+                        (readSTArray arr (i, k) >>= \ val -> ...)
+    • Relevant bindings include
+        itrapstate' :: Int -> Int -> c -> GHC.ST.ST s (c, IndTree s b)
+          (bound at tcfail068.hs:38:9)
+        itrapstatesnd :: Int -> Int -> c -> GHC.ST.ST s (c, IndTree s b)
+          (bound at tcfail068.hs:41:9)
+        arr :: IndTree s b (bound at tcfail068.hs:36:34)
+        itrapstate :: ((Int, Int), (Int, Int))
+                      -> (a -> b -> (a, b))
+                      -> ((Int, Int) -> c -> a)
+                      -> (a -> c)
+                      -> c
+                      -> IndTree s b
+                      -> (c, IndTree s b)
+          (bound at tcfail068.hs:36:1)
index bee39a2..546715a 100644 (file)
@@ -1,19 +1,19 @@
-\r
-tcfail076.hs:18:82: error:\r
-    • Couldn't match type ‘res’ with ‘res1’\r
-      ‘res’ is a rigid type variable bound by\r
-        a type expected by the context:\r
-          forall res. (a -> m res) -> m res\r
-        at tcfail076.hs:18:28-96\r
-      ‘res1’ is a rigid type variable bound by\r
-        a type expected by the context:\r
-          forall res1. (b -> m res1) -> m res1\r
-        at tcfail076.hs:18:64-88\r
-      Expected type: m res1\r
-        Actual type: m res\r
-    • In the expression: cont a\r
-      In the first argument of ‘KContT’, namely ‘(\ cont' -> cont a)’\r
-      In the expression: KContT (\ cont' -> cont a)\r
-    • Relevant bindings include\r
-        cont' :: b -> m res1 (bound at tcfail076.hs:18:73)\r
-        cont :: a -> m res (bound at tcfail076.hs:18:37)\r
+
+tcfail076.hs:18:82: error:
+    • Couldn't match type ‘res’ with ‘res1’
+      ‘res’ is a rigid type variable bound by
+        a type expected by the context:
+          forall res. (a -> m res) -> m res
+        at tcfail076.hs:18:28-96
+      ‘res1’ is a rigid type variable bound by
+        a type expected by the context:
+          forall res1. (b -> m res1) -> m res1
+        at tcfail076.hs:18:64-88
+      Expected type: m res1
+        Actual type: m res
+    • In the expression: cont a
+      In the first argument of ‘KContT’, namely ‘(\ cont' -> cont a)’
+      In the expression: KContT (\ cont' -> cont a)
+    • Relevant bindings include
+        cont' :: b -> m res1 (bound at tcfail076.hs:18:73)
+        cont :: a -> m res (bound at tcfail076.hs:18:37)
index 59635a3..dd4d074 100644 (file)
@@ -1,24 +1,24 @@
-\r
-tcfail103.hs:15:13: error:\r
-    • Couldn't match type ‘t’ with ‘s’\r
-      ‘t’ is a rigid type variable bound by\r
-        the type signature for:\r
-          f :: forall t. ST t Int\r
-        at tcfail103.hs:10:1-12\r
-      ‘s’ is a rigid type variable bound by\r
-        the type signature for:\r
-          g :: forall s. ST s Int\r
-        at tcfail103.hs:13:9-21\r
-      Expected type: ST s Int\r
-        Actual type: ST t Int\r
-    • In the expression: readSTRef v\r
-      In an equation for ‘g’: g = readSTRef v\r
-      In the expression:\r
-        do { v <- newSTRef 5;\r
-             let g :: ST s Int\r
-                 g = readSTRef v;\r
-             g }\r
-    • Relevant bindings include\r
-        g :: ST s Int (bound at tcfail103.hs:15:9)\r
-        v :: STRef t Int (bound at tcfail103.hs:12:5)\r
-        f :: ST t Int (bound at tcfail103.hs:11:1)\r
+
+tcfail103.hs:15:13: error:
+    • Couldn't match type ‘t’ with ‘s’
+      ‘t’ is a rigid type variable bound by
+        the type signature for:
+          f :: forall t. ST t Int
+        at tcfail103.hs:10:1-12
+      ‘s’ is a rigid type variable bound by
+        the type signature for:
+          g :: forall s. ST s Int
+        at tcfail103.hs:13:9-21
+      Expected type: ST s Int
+        Actual type: ST t Int
+    • In the expression: readSTRef v
+      In an equation for ‘g’: g = readSTRef v
+      In the expression:
+        do { v <- newSTRef 5;
+             let g :: ST s Int
+                 g = readSTRef v;
+             g }
+    • Relevant bindings include
+        g :: ST s Int (bound at tcfail103.hs:15:9)
+        v :: STRef t Int (bound at tcfail103.hs:12:5)
+        f :: ST t Int (bound at tcfail103.hs:11:1)
index e9920ea..04fa000 100644 (file)
@@ -1,13 +1,13 @@
-\r
-tcfail131.hs:7:11: error:\r
-    • Couldn't match expected type ‘Integer’ with actual type ‘b’\r
-      ‘b’ is a rigid type variable bound by\r
-        the type signature for:\r
-          g :: forall b. Num b => b -> b\r
-        at tcfail131.hs:6:3-22\r
-    • In the first argument of ‘f’, namely ‘x’\r
-      In the expression: f x x\r
-      In an equation for ‘g’: g x = f x x\r
-    • Relevant bindings include\r
-        x :: b (bound at tcfail131.hs:7:5)\r
-        g :: b -> b (bound at tcfail131.hs:7:3)\r
+
+tcfail131.hs:7:11: error:
+    • Couldn't match expected type ‘Integer’ with actual type ‘b’
+      ‘b’ is a rigid type variable bound by
+        the type signature for:
+          g :: forall b. Num b => b -> b
+        at tcfail131.hs:6:3-22
+    • In the first argument of ‘f’, namely ‘x’
+      In the expression: f x x
+      In an equation for ‘g’: g x = f x x
+    • Relevant bindings include
+        x :: b (bound at tcfail131.hs:7:5)
+        g :: b -> b (bound at tcfail131.hs:7:3)
index e80add6..4faca8f 100644 (file)
@@ -1,17 +1,17 @@
-\r
-tcfail153.hs:6:9: error:\r
-    • Couldn't match expected type ‘Bool’ with actual type ‘a’\r
-      ‘a’ is a rigid type variable bound by\r
-        the type signature for:\r
-          f :: forall a. a -> [a]\r
-        at tcfail153.hs:5:1-13\r
-    • In the first argument of ‘g’, namely ‘x’\r
-      In the expression: g x\r
-      In an equation for ‘f’:\r
-          f x\r
-            = g x\r
-            where\r
-                g y = if y then [] else [...]\r
-    • Relevant bindings include\r
-        x :: a (bound at tcfail153.hs:6:3)\r
-        f :: a -> [a] (bound at tcfail153.hs:6:1)\r
+
+tcfail153.hs:6:9: error:
+    • Couldn't match expected type ‘Bool’ with actual type ‘a’
+      ‘a’ is a rigid type variable bound by
+        the type signature for:
+          f :: forall a. a -> [a]
+        at tcfail153.hs:5:1-13
+    • In the first argument of ‘g’, namely ‘x’
+      In the expression: g x
+      In an equation for ‘f’:
+          f x
+            = g x
+            where
+                g y = if y then [] else [...]
+    • Relevant bindings include
+        x :: a (bound at tcfail153.hs:6:3)
+        f :: a -> [a] (bound at tcfail153.hs:6:1)
index 66a057b..653daaf 100644 (file)
@@ -1,30 +1,30 @@
-\r
-tcfail174.hs:14:14: error:\r
-    • Couldn't match type ‘a’ with ‘a1’\r
-        because type variable ‘a1’ would escape its scope\r
-      This (rigid, skolem) type variable is bound by\r
-        the type a1 -> a1\r
-        at tcfail174.hs:14:1-14\r
-      Expected type: Capture (forall x. x -> a)\r
-        Actual type: Capture (forall a. a -> a)\r
-    • In the first argument of ‘Capture’, namely ‘g’\r
-      In the expression: Capture g\r
-      In an equation for ‘h1’: h1 = Capture g\r
-    • Relevant bindings include\r
-        h1 :: Capture a (bound at tcfail174.hs:14:1)\r
-\r
-tcfail174.hs:17:14: error:\r
-    • Couldn't match type ‘a’ with ‘b’\r
-      ‘a’ is a rigid type variable bound by\r
-        the type a -> a at tcfail174.hs:1:1\r
-      ‘b’ is a rigid type variable bound by\r
-        the type signature for:\r
-          h2 :: forall b. Capture b\r
-        at tcfail174.hs:16:1-15\r
-      Expected type: Capture (forall x. x -> b)\r
-        Actual type: Capture (forall a. a -> a)\r
-    • In the first argument of ‘Capture’, namely ‘g’\r
-      In the expression: Capture g\r
-      In an equation for ‘h2’: h2 = Capture g\r
-    • Relevant bindings include\r
-        h2 :: Capture b (bound at tcfail174.hs:17:1)\r
+
+tcfail174.hs:14:14: error:
+    • Couldn't match type ‘a’ with ‘a1’
+        because type variable ‘a1’ would escape its scope
+      This (rigid, skolem) type variable is bound by
+        the type a1 -> a1
+        at tcfail174.hs:14:1-14
+      Expected type: Capture (forall x. x -> a)
+        Actual type: Capture (forall a. a -> a)
+    • In the first argument of ‘Capture’, namely ‘g’
+      In the expression: Capture g
+      In an equation for ‘h1’: h1 = Capture g
+    • Relevant bindings include
+        h1 :: Capture a (bound at tcfail174.hs:14:1)
+
+tcfail174.hs:17:14: error:
+    • Couldn't match type ‘a’ with ‘b’
+      ‘a’ is a rigid type variable bound by
+        the type a -> a at tcfail174.hs:1:1
+      ‘b’ is a rigid type variable bound by
+        the type signature for:
+          h2 :: forall b. Capture b
+        at tcfail174.hs:16:1-15
+      Expected type: Capture (forall x. x -> b)
+        Actual type: Capture (forall a. a -> a)
+    • In the first argument of ‘Capture’, namely ‘g’
+      In the expression: Capture g
+      In an equation for ‘h2’: h2 = Capture g
+    • Relevant bindings include
+        h2 :: Capture b (bound at tcfail174.hs:17:1)
index b55203d..6fbb6d4 100644 (file)
@@ -1,12 +1,12 @@
-\r
-tcfail175.hs:11:1: error:\r
-    • Couldn't match expected type ‘a’\r
-                  with actual type ‘String -> String -> String’\r
-      ‘a’ is a rigid type variable bound by\r
-        the type signature for:\r
-          evalRHS :: forall a. Int -> a\r
-        at tcfail175.hs:10:1-19\r
-    • The equation(s) for ‘evalRHS’ have three arguments,\r
-      but its type ‘Int -> a’ has only one\r
-    • Relevant bindings include\r
-        evalRHS :: Int -> a (bound at tcfail175.hs:11:1)\r
+
+tcfail175.hs:11:1: error:
+    • Couldn't match expected type ‘a’
+                  with actual type ‘String -> String -> String’
+      ‘a’ is a rigid type variable bound by
+        the type signature for:
+          evalRHS :: forall a. Int -> a
+        at tcfail175.hs:10:1-19
+    • The equation(s) for ‘evalRHS’ have three arguments,
+      but its type ‘Int -> a’ has only one
+    • Relevant bindings include
+        evalRHS :: Int -> a (bound at tcfail175.hs:11:1)
index cb01a3c..7d16288 100644 (file)
@@ -1,22 +1,22 @@
-\r
-tcfail179.hs:14:41: error:\r
-    • Couldn't match type ‘x’ with ‘s’\r
-      ‘x’ is a rigid type variable bound by\r
-        a pattern with constructor:\r
-          T :: forall s x. (s -> (x -> s) -> (x, s, Int)) -> T s,\r
-        in a case alternative\r
-        at tcfail179.hs:14:14-16\r
-      ‘s’ is a rigid type variable bound by\r
-        the type signature for:\r
-          run :: forall s. T s -> Int\r
-        at tcfail179.hs:12:1-17\r
-      Expected type: x -> s\r
-        Actual type: s -> s\r
-    • In the second argument of ‘g’, namely ‘id’\r
-      In the expression: g x id\r
-      In a pattern binding: (x, _, b) = g x id\r
-    • Relevant bindings include\r
-        x :: s (bound at tcfail179.hs:14:26)\r
-        g :: s -> (x -> s) -> (x, s, Int) (bound at tcfail179.hs:14:16)\r
-        ts :: T s (bound at tcfail179.hs:13:5)\r
-        run :: T s -> Int (bound at tcfail179.hs:13:1)\r
+
+tcfail179.hs:14:41: error:
+    • Couldn't match type ‘x’ with ‘s’
+      ‘x’ is a rigid type variable bound by
+        a pattern with constructor:
+          T :: forall s x. (s -> (x -> s) -> (x, s, Int)) -> T s,
+        in a case alternative
+        at tcfail179.hs:14:14-16
+      ‘s’ is a rigid type variable bound by
+        the type signature for:
+          run :: forall s. T s -> Int
+        at tcfail179.hs:12:1-17
+      Expected type: x -> s
+        Actual type: s -> s
+    • In the second argument of ‘g’, namely ‘id’
+      In the expression: g x id
+      In a pattern binding: (x, _, b) = g x id
+    • Relevant bindings include
+        x :: s (bound at tcfail179.hs:14:26)
+        g :: s -> (x -> s) -> (x, s, Int) (bound at tcfail179.hs:14:16)
+        ts :: T s (bound at tcfail179.hs:13:5)
+        run :: T s -> Int (bound at tcfail179.hs:13:1)
index fe831ae..8eb11f9 100644 (file)
@@ -1,13 +1,13 @@
-\r
-tcfail191.hs:11:26: error:\r
-    • Couldn't match type ‘a’ with ‘[a]’\r
-      ‘a’ is a rigid type variable bound by\r
-        a type expected by the context:\r
-          forall a. [a] -> [[a]]\r
-        at tcfail191.hs:(10,9)-(11,31)\r
-      Expected type: [a] -> [[a]]\r
-        Actual type: [[a]] -> [[a]]\r
-    • In the expression: take 5\r
-      In a stmt of a list comprehension: then group using take 5\r
-      In the expression:\r
-        [() | x <- [Gnorf, Brain], then group using take 5]\r
+
+tcfail191.hs:11:26: error:
+    • Couldn't match type ‘a’ with ‘[a]’
+      ‘a’ is a rigid type variable bound by
+        a type expected by the context:
+          forall a. [a] -> [[a]]
+        at tcfail191.hs:(10,9)-(11,31)
+      Expected type: [a] -> [[a]]
+        Actual type: [[a]] -> [[a]]
+    • In the expression: take 5
+      In a stmt of a list comprehension: then group using take 5
+      In the expression:
+        [() | x <- [Gnorf, Brain], then group using take 5]
index 0e24649..6259dfc 100644 (file)
@@ -1,12 +1,12 @@
-\r
-tcfail193.hs:10:31: error:\r
-    • Couldn't match type ‘a’ with ‘[a]’\r
-      ‘a’ is a rigid type variable bound by\r
-        a type expected by the context:\r
-          forall a. [a] -> [a]\r
-        at tcfail193.hs:10:10-35\r
-      Expected type: [a] -> [a]\r
-        Actual type: [a] -> [[a]]\r
-    • In the expression: inits\r
-      In a stmt of a list comprehension: then inits\r
-      In the expression: [x | x <- [3, 2, 1], then inits]\r
+
+tcfail193.hs:10:31: error:
+    • Couldn't match type ‘a’ with ‘[a]’
+      ‘a’ is a rigid type variable bound by
+        a type expected by the context:
+          forall a. [a] -> [a]
+        at tcfail193.hs:10:10-35
+      Expected type: [a] -> [a]
+        Actual type: [a] -> [[a]]
+    • In the expression: inits
+      In a stmt of a list comprehension: then inits
+      In the expression: [x | x <- [3, 2, 1], then inits]
index f073b5e..373c570 100644 (file)
@@ -1,15 +1,15 @@
-\r
-tcfail198.hs:6:36: error:\r
-    • Couldn't match expected type ‘a1’ with actual type ‘a’\r
-        because type variable ‘a1’ would escape its scope\r
-      This (rigid, skolem) type variable is bound by\r
-        an expression type signature:\r
-          a1\r
-        at tcfail198.hs:6:41\r
-    • In the expression: x :: a\r
-      In the second argument of ‘(++)’, namely ‘[x :: a]’\r
-      In the expression: xs ++ [x :: a]\r
-    • Relevant bindings include\r
-        xs :: [a] (bound at tcfail198.hs:6:21)\r
-        x :: a (bound at tcfail198.hs:6:19)\r
-        f3 :: [a] -> [a] (bound at tcfail198.hs:6:6)\r
+
+tcfail198.hs:6:36: error:
+    • Couldn't match expected type ‘a1’ with actual type ‘a’
+        because type variable ‘a1’ would escape its scope
+      This (rigid, skolem) type variable is bound by
+        an expression type signature:
+          a1
+        at tcfail198.hs:6:41
+    • In the expression: x :: a
+      In the second argument of ‘(++)’, namely ‘[x :: a]’
+      In the expression: xs ++ [x :: a]
+    • Relevant bindings include
+        xs :: [a] (bound at tcfail198.hs:6:21)
+        x :: a (bound at tcfail198.hs:6:19)
+        f3 :: [a] -> [a] (bound at tcfail198.hs:6:6)
index 3eb7bfc..51fbbb3 100644 (file)
@@ -1,55 +1,55 @@
-\r
-tcfail206.hs:5:5: error:\r
-    • Couldn't match type ‘Bool’ with ‘Int’\r
-      Expected type: Bool -> (Int, Bool)\r
-        Actual type: Int -> (Int, Bool)\r
-    • In the expression: (, True)\r
-      In an equation for ‘a’: a = (, True)\r
-\r
-tcfail206.hs:8:5: error:\r
-    • Couldn't match type ‘(Integer, Int)’ with ‘Bool -> (Int, Bool)’\r
-      Expected type: Int -> Bool -> (Int, Bool)\r
-        Actual type: Int -> (Integer, Int)\r
-    • In the expression: (1,)\r
-      In an equation for ‘b’: b = (1,)\r
-\r
-tcfail206.hs:11:5: error:\r
-    • Couldn't match type ‘a’ with ‘Bool’\r
-      ‘a’ is a rigid type variable bound by\r
-        the type signature for:\r
-          c :: forall a. a -> (a, Bool)\r
-        at tcfail206.hs:10:1-19\r
-      Expected type: a -> (a, Bool)\r
-        Actual type: Bool -> (a, Bool)\r
-    • In the expression: (True || False,)\r
-      In an equation for ‘c’: c = (True || False,)\r
-    • Relevant bindings include\r
-        c :: a -> (a, Bool) (bound at tcfail206.hs:11:1)\r
-\r
-tcfail206.hs:14:5: error:\r
-    • Couldn't match type ‘Bool’ with ‘Int’\r
-      Expected type: Bool -> (# Int, Bool #)\r
-        Actual type: Int -> (# Int, Bool #)\r
-    • In the expression: (# , True #)\r
-      In an equation for ‘d’: d = (# , True #)\r
-\r
-tcfail206.hs:17:5: error:\r
-    • Couldn't match type ‘(# Integer, Int #)’\r
-                     with ‘Bool -> (# Int, Bool #)’\r
-      Expected type: Int -> Bool -> (# Int, Bool #)\r
-        Actual type: Int -> (# Integer, Int #)\r
-    • In the expression: (# 1, #)\r
-      In an equation for ‘e’: e = (# 1, #)\r
-\r
-tcfail206.hs:20:5: error:\r
-    • Couldn't match type ‘a’ with ‘Bool’\r
-      ‘a’ is a rigid type variable bound by\r
-        the type signature for:\r
-          f :: forall a. a -> (# a, Bool #)\r
-        at tcfail206.hs:19:1-21\r
-      Expected type: a -> (# a, Bool #)\r
-        Actual type: Bool -> (# a, Bool #)\r
-    • In the expression: (# True || False, #)\r
-      In an equation for ‘f’: f = (# True || False, #)\r
-    • Relevant bindings include\r
-        f :: a -> (# a, Bool #) (bound at tcfail206.hs:20:1)\r
+
+tcfail206.hs:5:5: error:
+    • Couldn't match type ‘Bool’ with ‘Int’
+      Expected type: Bool -> (Int, Bool)
+        Actual type: Int -> (Int, Bool)
+    • In the expression: (, True)
+      In an equation for ‘a’: a = (, True)
+
+tcfail206.hs:8:5: error:
+    • Couldn't match type ‘(Integer, Int)’ with ‘Bool -> (Int, Bool)’
+      Expected type: Int -> Bool -> (Int, Bool)
+        Actual type: Int -> (Integer, Int)
+    • In the expression: (1,)
+      In an equation for ‘b’: b = (1,)
+
+tcfail206.hs:11:5: error:
+    • Couldn't match type ‘a’ with ‘Bool’
+      ‘a’ is a rigid type variable bound by
+        the type signature for:
+          c :: forall a. a -> (a, Bool)
+        at tcfail206.hs:10:1-19
+      Expected type: a -> (a, Bool)
+        Actual type: Bool -> (a, Bool)
+    • In the expression: (True || False,)
+      In an equation for ‘c’: c = (True || False,)
+    • Relevant bindings include
+        c :: a -> (a, Bool) (bound at tcfail206.hs:11:1)
+
+tcfail206.hs:14:5: error:
+    • Couldn't match type ‘Bool’ with ‘Int’
+      Expected type: Bool -> (# Int, Bool #)
+        Actual type: Int -> (# Int, Bool #)
+    • In the expression: (# , True #)
+      In an equation for ‘d’: d = (# , True #)
+
+tcfail206.hs:17:5: error:
+    • Couldn't match type ‘(# Integer, Int #)’
+                     with ‘Bool -> (# Int, Bool #)’
+      Expected type: Int -> Bool -> (# Int, Bool #)
+        Actual type: Int -> (# Integer, Int #)
+    • In the expression: (# 1, #)
+      In an equation for ‘e’: e = (# 1, #)
+
+tcfail206.hs:20:5: error:
+    • Couldn't match type ‘a’ with ‘Bool’
+      ‘a’ is a rigid type variable bound by
+        the type signature for:
+          f :: forall a. a -> (# a, Bool #)
+        at tcfail206.hs:19:1-21
+      Expected type: a -> (# a, Bool #)
+        Actual type: Bool -> (# a, Bool #)
+    • In the expression: (# True || False, #)
+      In an equation for ‘f’: f = (# True || False, #)
+    • Relevant bindings include
+        f :: a -> (# a, Bool #) (bound at tcfail206.hs:20:1)