Modify a couple of error messages slightly
authorSimon Peyton Jones <simonpj@microsoft.com>
Sat, 3 Jan 2015 23:27:21 +0000 (23:27 +0000)
committerSimon Peyton Jones <simonpj@microsoft.com>
Tue, 6 Jan 2015 14:18:44 +0000 (14:18 +0000)
In particular
  In the type signature for:
     f :: Int -> Int
I added the colon

Also reword the "maybe you haven't applied a function to enough arguments?"
suggestion to make grammatical sense.

These tiny changes affect a lot of error messages.

86 files changed:
compiler/typecheck/TcErrors.hs
compiler/typecheck/TcRnTypes.hs
testsuite/tests/annotations/should_fail/annfail08.stderr
testsuite/tests/arrows/should_fail/T5380.stderr
testsuite/tests/deriving/should_fail/drvfail007.stderr
testsuite/tests/driver/T2182.stderr
testsuite/tests/gadt/T3169.stderr
testsuite/tests/gadt/T3651.stderr
testsuite/tests/gadt/T7293.stderr
testsuite/tests/gadt/T7294.stderr
testsuite/tests/gadt/T7558.stderr
testsuite/tests/gadt/gadt-escape1.stderr
testsuite/tests/gadt/gadt13.stderr
testsuite/tests/gadt/gadt21.stderr
testsuite/tests/gadt/gadt7.stderr
testsuite/tests/gadt/rw.stderr
testsuite/tests/ghci.debugger/scripts/break003.stderr
testsuite/tests/ghci/scripts/Defer02.stderr
testsuite/tests/ghci/scripts/T2182ghci.stderr
testsuite/tests/indexed-types/should_compile/PushedInAsGivens.stderr
testsuite/tests/indexed-types/should_compile/Simple14.stderr
testsuite/tests/indexed-types/should_compile/T3208b.stderr
testsuite/tests/indexed-types/should_fail/GADTwrong1.stderr
testsuite/tests/indexed-types/should_fail/Overlap6.stderr
testsuite/tests/indexed-types/should_fail/SimpleFail5a.stderr
testsuite/tests/indexed-types/should_fail/T2664.stderr
testsuite/tests/indexed-types/should_fail/T3330a.stderr
testsuite/tests/indexed-types/should_fail/T3440.stderr
testsuite/tests/indexed-types/should_fail/T4093a.stderr
testsuite/tests/indexed-types/should_fail/T4093b.stderr
testsuite/tests/indexed-types/should_fail/T4174.stderr
testsuite/tests/indexed-types/should_fail/T4272.stderr
testsuite/tests/indexed-types/should_fail/T7194.stderr
testsuite/tests/indexed-types/should_fail/T7786.stderr
testsuite/tests/indexed-types/should_fail/T9662.stderr
testsuite/tests/parser/should_fail/T7848.stderr
testsuite/tests/partial-sigs/should_fail/AnnotatedConstraint.stderr
testsuite/tests/partial-sigs/should_fail/NamedWildcardsNotEnabled.stderr
testsuite/tests/polykinds/T7230.stderr
testsuite/tests/polykinds/T7438.stderr
testsuite/tests/polykinds/T8566.stderr
testsuite/tests/rebindable/rebindable6.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/T7220a.stderr
testsuite/tests/typecheck/should_compile/T9834.stderr
testsuite/tests/typecheck/should_compile/tc141.stderr
testsuite/tests/typecheck/should_fail/FDsFromGivens.stderr
testsuite/tests/typecheck/should_fail/FailDueToGivenOverlapping.stderr
testsuite/tests/typecheck/should_fail/FrozenErrorTests.stderr
testsuite/tests/typecheck/should_fail/IPFail.stderr
testsuite/tests/typecheck/should_fail/T1899.stderr
testsuite/tests/typecheck/should_fail/T2714.stderr
testsuite/tests/typecheck/should_fail/T2846b.stderr
testsuite/tests/typecheck/should_fail/T3592.stderr
testsuite/tests/typecheck/should_fail/T5236.stderr
testsuite/tests/typecheck/should_fail/T5300.stderr
testsuite/tests/typecheck/should_fail/T7453.stderr
testsuite/tests/typecheck/should_fail/T7748a.stderr
testsuite/tests/typecheck/should_fail/T8392a.stderr
testsuite/tests/typecheck/should_fail/T8450.stderr
testsuite/tests/typecheck/should_fail/T9109.stderr
testsuite/tests/typecheck/should_fail/TcStaticPointersFail02.stderr
testsuite/tests/typecheck/should_fail/mc22.stderr
testsuite/tests/typecheck/should_fail/tcfail034.stderr
testsuite/tests/typecheck/should_fail/tcfail065.stderr
testsuite/tests/typecheck/should_fail/tcfail067.stderr
testsuite/tests/typecheck/should_fail/tcfail068.stderr
testsuite/tests/typecheck/should_fail/tcfail072.stderr
testsuite/tests/typecheck/should_fail/tcfail097.stderr
testsuite/tests/typecheck/should_fail/tcfail099.stderr
testsuite/tests/typecheck/should_fail/tcfail102.stderr
testsuite/tests/typecheck/should_fail/tcfail103.stderr
testsuite/tests/typecheck/should_fail/tcfail125.stderr
testsuite/tests/typecheck/should_fail/tcfail131.stderr
testsuite/tests/typecheck/should_fail/tcfail142.stderr
testsuite/tests/typecheck/should_fail/tcfail153.stderr
testsuite/tests/typecheck/should_fail/tcfail167.stderr
testsuite/tests/typecheck/should_fail/tcfail171.stderr
testsuite/tests/typecheck/should_fail/tcfail174.stderr
testsuite/tests/typecheck/should_fail/tcfail175.stderr
testsuite/tests/typecheck/should_fail/tcfail179.stderr
testsuite/tests/typecheck/should_fail/tcfail201.stderr
testsuite/tests/typecheck/should_fail/tcfail206.stderr
testsuite/tests/typecheck/should_fail/tcfail208.stderr

index 9a47276..44fbadb 100644 (file)
@@ -1252,7 +1252,7 @@ mk_dict_err ctxt (ct, (matches, unifiers, safe_haskell))
       = ptext (sLit "No instance for")
         <+> pprParendType pred
         $$ if type_has_arrow pred
       = ptext (sLit "No instance for")
         <+> pprParendType pred
         $$ if type_has_arrow pred
-            then nest 2 $ ptext (sLit "(maybe you haven't applied enough arguments to a function?)")
+            then nest 2 $ ptext (sLit "(maybe you haven't applied a function to enough arguments?)")
             else empty
 
       | otherwise
             else empty
 
       | otherwise
index 583bc97..5b77ebe 100644 (file)
@@ -1932,35 +1932,21 @@ instance Outputable SkolemInfo where
 
 pprSkolInfo :: SkolemInfo -> SDoc
 -- Complete the sentence "is a rigid type variable bound by..."
 
 pprSkolInfo :: SkolemInfo -> SDoc
 -- Complete the sentence "is a rigid type variable bound by..."
-pprSkolInfo (SigSkol (FunSigCtxt f) ty)
-                            = hang (ptext (sLit "the type signature for"))
-                                 2 (pprPrefixOcc f <+> dcolon <+> ppr ty)
-pprSkolInfo (SigSkol cx ty) = hang (pprUserTypeCtxt cx <> colon)
-                                 2 (ppr ty)
-pprSkolInfo (IPSkol ips)    = ptext (sLit "the implicit-parameter binding") <> plural ips <+> ptext (sLit "for")
-                              <+> pprWithCommas ppr ips
-pprSkolInfo (ClsSkol cls)   = ptext (sLit "the class declaration for") <+> quotes (ppr cls)
-pprSkolInfo InstSkol        = ptext (sLit "the instance declaration")
-pprSkolInfo DataSkol        = ptext (sLit "the data type declaration")
-pprSkolInfo FamInstSkol     = ptext (sLit "the family instance declaration")
-pprSkolInfo BracketSkol     = ptext (sLit "a Template Haskell bracket")
-pprSkolInfo (RuleSkol name) = ptext (sLit "the RULE") <+> doubleQuotes (ftext name)
-pprSkolInfo ArrowSkol       = ptext (sLit "the arrow form")
-pprSkolInfo (PatSkol cl mc) = case cl of
-    RealDataCon dc -> sep [ ptext (sLit "a pattern with constructor")
-                          , nest 2 $ ppr dc <+> dcolon
-                            <+> pprType (dataConUserType dc) <> comma
-                            -- pprType prints forall's regardless of -fprint-explict-foralls
-                            -- which is what we want here, since we might be saying
-                            -- type variable 't' is bound by ...
-                          , ptext (sLit "in") <+> pprMatchContext mc ]
-    PatSynCon ps -> sep [ ptext (sLit "a pattern with pattern synonym")
-                        , nest 2 $ ppr ps <+> dcolon
-                          <+> pprType (patSynType ps) <> comma
-                        , ptext (sLit "in") <+> pprMatchContext mc ]
-pprSkolInfo (InferSkol ids) = sep [ ptext (sLit "the inferred type of")
-                                  , vcat [ ppr name <+> dcolon <+> ppr ty
-                                         | (name,ty) <- ids ]]
+pprSkolInfo (SigSkol ctxt ty) = pprSigSkolInfo ctxt ty
+pprSkolInfo (IPSkol ips)      = ptext (sLit "the implicit-parameter binding") <> plural ips <+> ptext (sLit "for")
+                                <+> pprWithCommas ppr ips
+pprSkolInfo (ClsSkol cls)     = ptext (sLit "the class declaration for") <+> quotes (ppr cls)
+pprSkolInfo InstSkol          = ptext (sLit "the instance declaration")
+pprSkolInfo DataSkol          = ptext (sLit "a data type declaration")
+pprSkolInfo FamInstSkol       = ptext (sLit "a family instance declaration")
+pprSkolInfo BracketSkol       = ptext (sLit "a Template Haskell bracket")
+pprSkolInfo (RuleSkol name)   = ptext (sLit "the RULE") <+> doubleQuotes (ftext name)
+pprSkolInfo ArrowSkol         = ptext (sLit "an arrow form")
+pprSkolInfo (PatSkol cl mc)   = sep [ pprPatSkolInfo cl
+                                    , ptext (sLit "in") <+> pprMatchContext mc ]
+pprSkolInfo (InferSkol ids)   = sep [ ptext (sLit "the inferred type of")
+                                    , vcat [ ppr name <+> dcolon <+> ppr ty
+                                           | (name,ty) <- ids ]]
 pprSkolInfo (UnifyForAllSkol tvs ty) = ptext (sLit "the type") <+> ppr (mkForAllTys tvs ty)
 
 -- UnkSkol
 pprSkolInfo (UnifyForAllSkol tvs ty) = ptext (sLit "the type") <+> ppr (mkForAllTys tvs ty)
 
 -- UnkSkol
@@ -1968,6 +1954,30 @@ pprSkolInfo (UnifyForAllSkol tvs ty) = ptext (sLit "the type") <+> ppr (mkForAll
 -- For Insts, these cases should not happen
 pprSkolInfo UnkSkol = WARN( True, text "pprSkolInfo: UnkSkol" ) ptext (sLit "UnkSkol")
 
 -- For Insts, these cases should not happen
 pprSkolInfo UnkSkol = WARN( True, text "pprSkolInfo: UnkSkol" ) ptext (sLit "UnkSkol")
 
+pprSigSkolInfo :: UserTypeCtxt -> Type -> SDoc
+pprSigSkolInfo ctxt ty
+  = case ctxt of
+       FunSigCtxt f _ -> pp_sig f
+       _              -> hang (pprUserTypeCtxt ctxt <> colon)
+                            2 (ppr ty)
+  where
+    pp_sig f = sep [ ptext (sLit "the type signature for:")
+                   , pprPrefixOcc f <+> dcolon <+> ppr ty ]
+
+pprPatSkolInfo :: ConLike -> SDoc
+pprPatSkolInfo (RealDataCon dc)
+  = sep [ ptext (sLit "a pattern with constructor:")
+        , nest 2 $ ppr dc <+> dcolon
+          <+> pprType (dataConUserType dc) <> comma ]
+          -- pprType prints forall's regardless of -fprint-explict-foralls
+          -- which is what we want here, since we might be saying
+          -- type variable 't' is bound by ...
+
+pprPatSkolInfo (PatSynCon ps)
+  = sep [ ptext (sLit "a pattern with pattern synonym:")
+        , nest 2 $ ppr ps <+> dcolon
+                   <+> pprType (patSynType ps) <> comma ]
+
 {-
 ************************************************************************
 *                                                                      *
 {-
 ************************************************************************
 *                                                                      *
index 0449033..1c6f9f6 100644 (file)
@@ -1,12 +1,12 @@
-
-annfail08.hs:9:1:
-    No instance for (Data.Data.Data (a0 -> a0))
-      (maybe you haven't applied enough arguments to a function?)
-      arising from an annotation
-    In the annotation: {-# ANN f (id + 1) #-}
-
-annfail08.hs:9:15:
-    No instance for (Num (a0 -> a0))
-      (maybe you haven't applied enough arguments to a function?)
-      arising from a use of ‘+’
-    In the annotation: {-# ANN f (id + 1) #-}
+\r
+annfail08.hs:9:1:\r
+    No instance for (Data.Data.Data (a0 -> a0))\r
+      (maybe you haven't applied a function to enough arguments?)\r
+      arising from an annotation\r
+    In the annotation: {-# ANN f (id + 1) #-}\r
+\r
+annfail08.hs:9:15:\r
+    No instance for (Num (a0 -> a0))\r
+      (maybe you haven't applied a function to enough arguments?)\r
+      arising from a use of ‘+’\r
+    In the annotation: {-# ANN f (id + 1) #-}\r
index 1f8d451..bff48f5 100644 (file)
@@ -2,8 +2,8 @@
 T5380.hs:7:27:
     Couldn't match expected type ‘Bool’ with actual type ‘not_bool’
       ‘not_bool’ is a rigid type variable bound by
 T5380.hs:7:27:
     Couldn't match expected type ‘Bool’ with actual type ‘not_bool’
       ‘not_bool’ is a rigid type variable bound by
-                 the type signature for
-                   testB :: not_bool -> (() -> ()) -> () -> not_unit
+                 the type signature for:
+                 testB :: not_bool -> (() -> ()) -> () -> not_unit
                  at T5380.hs:6:10
     Relevant bindings include
       b :: not_bool (bound at T5380.hs:7:7)
                  at T5380.hs:6:10
     Relevant bindings include
       b :: not_bool (bound at T5380.hs:7:7)
@@ -15,8 +15,8 @@ T5380.hs:7:27:
 T5380.hs:7:34:
     Couldn't match type ‘not_unit’ with ‘()’
       ‘not_unit’ is a rigid type variable bound by
 T5380.hs:7:34:
     Couldn't match type ‘not_unit’ with ‘()’
       ‘not_unit’ is a rigid type variable bound by
-                 the type signature for
-                   testB :: not_bool -> (() -> ()) -> () -> not_unit
+                 the type signature for:
+                 testB :: not_bool -> (() -> ()) -> () -> not_unit
                  at T5380.hs:6:10
     Expected type: () -> not_unit
       Actual type: () -> ()
                  at T5380.hs:6:10
     Expected type: () -> not_unit
       Actual type: () -> ()
index 91cf8bf..ad43243 100644 (file)
@@ -1,9 +1,9 @@
-
-drvfail007.hs:4:38:
-    No instance for (Eq (Int -> Int))
-      (maybe you haven't applied enough arguments to a function?)
-      arising from the first field of ‘Foo’ (type ‘Int -> Int’)
-    Possible fix:
-      use a standalone 'deriving instance' declaration,
-        so you can specify the instance context yourself
-    When deriving the instance for (Eq Foo)
+\r
+drvfail007.hs:4:38:\r
+    No instance for (Eq (Int -> Int))\r
+      (maybe you haven't applied a function to enough arguments?)\r
+      arising from the first field of ‘Foo’ (type ‘Int -> Int’)\r
+    Possible fix:\r
+      use a standalone 'deriving instance' declaration,\r
+        so you can specify the instance context yourself\r
+    When deriving the instance for (Eq Foo)\r
index b8d9e8b..d88f6c0 100644 (file)
@@ -1,28 +1,28 @@
-
-T2182.hs:5:5:
-    No instance for (Show (t1 -> t1))
-      (maybe you haven't applied enough arguments to a function?)
-      arising from a use of ‘show’
-    In the expression: show (\ x -> x)
-    In an equation for ‘y’: y = show (\ x -> x)
-
-T2182.hs:6:15:
-    No instance for (Eq (t0 -> t0))
-      (maybe you haven't applied enough arguments to a function?)
-      arising from a use of ‘==’
-    In the expression: (\ x -> x) == (\ y -> y)
-    In an equation for ‘z’: z = (\ x -> x) == (\ y -> y)
-
-T2182.hs:5:5:
-    No instance for (Show (t1 -> t1))
-      (maybe you haven't applied enough arguments to a function?)
-      arising from a use of ‘show’
-    In the expression: show (\ x -> x)
-    In an equation for ‘y’: y = show (\ x -> x)
-
-T2182.hs:6:15:
-    No instance for (Eq (t0 -> t0))
-      (maybe you haven't applied enough arguments to a function?)
-      arising from a use of ‘==’
-    In the expression: (\ x -> x) == (\ y -> y)
-    In an equation for ‘z’: z = (\ x -> x) == (\ y -> y)
+\r
+T2182.hs:5:5:\r
+    No instance for (Show (t1 -> t1))\r
+      (maybe you haven't applied a function to enough arguments?)\r
+      arising from a use of ‘show’\r
+    In the expression: show (\ x -> x)\r
+    In an equation for ‘y’: y = show (\ x -> x)\r
+\r
+T2182.hs:6:15:\r
+    No instance for (Eq (t0 -> t0))\r
+      (maybe you haven't applied a function to enough arguments?)\r
+      arising from a use of ‘==’\r
+    In the expression: (\ x -> x) == (\ y -> y)\r
+    In an equation for ‘z’: z = (\ x -> x) == (\ y -> y)\r
+\r
+T2182.hs:5:5:\r
+    No instance for (Show (t1 -> t1))\r
+      (maybe you haven't applied a function to enough arguments?)\r
+      arising from a use of ‘show’\r
+    In the expression: show (\ x -> x)\r
+    In an equation for ‘y’: y = show (\ x -> x)\r
+\r
+T2182.hs:6:15:\r
+    No instance for (Eq (t0 -> t0))\r
+      (maybe you haven't applied a function to enough arguments?)\r
+      arising from a use of ‘==’\r
+    In the expression: (\ x -> x) == (\ y -> y)\r
+    In an equation for ‘z’: z = (\ x -> x) == (\ y -> y)\r
index a646a56..3e4a950 100644 (file)
@@ -2,8 +2,8 @@
 T3169.hs:13:22:
     Couldn't match type ‘elt’ with ‘Map b elt’
       ‘elt’ is a rigid type variable bound by
 T3169.hs:13:22:
     Couldn't match type ‘elt’ with ‘Map b elt’
       ‘elt’ is a rigid type variable bound by
-            the type signature for
-              lookup :: (a, b) -> Map (a, b) elt -> Maybe elt
+            the type signature for:
+            lookup :: (a, b) -> Map (a, b) elt -> Maybe elt
             at T3169.hs:12:3
     Expected type: Map a (Map b elt)
       Actual type: Map (a, b) elt
             at T3169.hs:12:3
     Expected type: Map a (Map b elt)
       Actual type: Map (a, b) elt
index e9230a4..db723c8 100644 (file)
@@ -2,20 +2,20 @@
 T3651.hs:11:11:\r
     Couldn't match type ‘Bool’ with ‘()’\r
     Inaccessible code in\r
 T3651.hs:11:11:\r
     Couldn't match type ‘Bool’ with ‘()’\r
     Inaccessible code in\r
-      a pattern with constructor U :: Z (), in an equation for ‘unsafe1’\r
+      a pattern with constructor: U :: Z (), in an equation for ‘unsafe1’\r
     In the pattern: U\r
     In an equation for ‘unsafe1’: unsafe1 B U = ()\r
 \r
 T3651.hs:14:11:\r
     Couldn't match type ‘Bool’ with ‘()’\r
     Inaccessible code in\r
     In the pattern: U\r
     In an equation for ‘unsafe1’: unsafe1 B U = ()\r
 \r
 T3651.hs:14:11:\r
     Couldn't match type ‘Bool’ with ‘()’\r
     Inaccessible code in\r
-      a pattern with constructor U :: Z (), in an equation for ‘unsafe2’\r
+      a pattern with constructor: U :: Z (), in an equation for ‘unsafe2’\r
     In the pattern: U\r
     In an equation for ‘unsafe2’: unsafe2 B U = ()\r
 \r
 T3651.hs:17:11:\r
     Couldn't match type ‘Bool’ with ‘()’\r
     Inaccessible code in\r
     In the pattern: U\r
     In an equation for ‘unsafe2’: unsafe2 B U = ()\r
 \r
 T3651.hs:17:11:\r
     Couldn't match type ‘Bool’ with ‘()’\r
     Inaccessible code in\r
-      a pattern with constructor U :: Z (), in an equation for ‘unsafe3’\r
+      a pattern with constructor: U :: Z (), in an equation for ‘unsafe3’\r
     In the pattern: U\r
     In an equation for ‘unsafe3’: unsafe3 B U = True\r
     In the pattern: U\r
     In an equation for ‘unsafe3’: unsafe3 B U = True\r
index 3e5d9dd..35c02d5 100644 (file)
@@ -1,9 +1,8 @@
-
-T7293.hs:24:5:
-    Couldn't match type ‘'True’ with ‘'False’
-    Inaccessible code in
-      a pattern with constructor
-        Nil :: forall a. Vec a 'Zero,
-      in an equation for ‘nth’
-    In the pattern: Nil
-    In an equation for ‘nth’: nth Nil _ = undefined
+\r
+T7293.hs:24:5:\r
+    Couldn't match type ‘'True’ with ‘'False’\r
+    Inaccessible code in\r
+      a pattern with constructor: Nil :: forall a. Vec a 'Zero,\r
+      in an equation for ‘nth’\r
+    In the pattern: Nil\r
+    In an equation for ‘nth’: nth Nil _ = undefined\r
index b5e4e56..b4379b1 100644 (file)
@@ -1,9 +1,8 @@
-
-T7294.hs:25:5: Warning:
-    Couldn't match type ‘'True’ with ‘'False’
-    Inaccessible code in
-      a pattern with constructor
-        Nil :: forall a. Vec a 'Zero,
-      in an equation for ‘nth’
-    In the pattern: Nil
-    In an equation for ‘nth’: nth Nil _ = undefined
+\r
+T7294.hs:25:5: Warning:\r
+    Couldn't match type ‘'True’ with ‘'False’\r
+    Inaccessible code in\r
+      a pattern with constructor: Nil :: forall a. Vec a 'Zero,\r
+      in an equation for ‘nth’\r
+    In the pattern: Nil\r
+    In an equation for ‘nth’: nth Nil _ = undefined\r
index 054c41f..4929982 100644 (file)
@@ -1,13 +1,13 @@
-
-T7558.hs:8:4:
-    Couldn't match type ‘a’ with ‘Maybe a’
-      ‘a’ is a rigid type variable bound by
-          the type signature for f :: T a a -> Bool at T7558.hs:7:6
-    Inaccessible code in
-      a pattern with constructor
-        MkT :: forall a b. (a ~ Maybe b) => a -> Maybe b -> T a b,
-      in an equation for ‘f’
-    Relevant bindings include
-      f :: T a a -> Bool (bound at T7558.hs:8:1)
-    In the pattern: MkT x y
-    In an equation for ‘f’: f (MkT x y) = [x, y] `seq` True
+\r
+T7558.hs:8:4:\r
+    Couldn't match type ‘a’ with ‘Maybe a’\r
+      ‘a’ is a rigid type variable bound by\r
+          the type signature for: f :: T a a -> Bool at T7558.hs:7:6\r
+    Inaccessible code in\r
+      a pattern with constructor:\r
+        MkT :: forall a b. (a ~ Maybe b) => a -> Maybe b -> T a b,\r
+      in an equation for ‘f’\r
+    Relevant bindings include\r
+      f :: T a a -> Bool (bound at T7558.hs:8:1)\r
+    In the pattern: MkT x y\r
+    In an equation for ‘f’: f (MkT x y) = [x, y] `seq` True\r
index 35d1bf4..a98e273 100644 (file)
@@ -1,18 +1,17 @@
-
-gadt-escape1.hs:19:58:
-    Couldn't match type ‘t’ with ‘ExpGADT Int’
-      ‘t’ is untouchable
-        inside the constraints (t1 ~ Int)
-        bound by a pattern with constructor
-                   ExpInt :: Int -> ExpGADT Int,
-                 in a case alternative
-        at gadt-escape1.hs:19:43-50
-      ‘t’ is a rigid type variable bound by
-          the inferred type of weird1 :: t at gadt-escape1.hs:19:1
-    Possible fix: add a type signature for ‘weird1’
-    Expected type: t
-      Actual type: ExpGADT t1
-    Relevant bindings include
-      weird1 :: t (bound at gadt-escape1.hs:19:1)
-    In the expression: a
-    In a case alternative: Hidden (ExpInt _) a -> a
+\r
+gadt-escape1.hs:19:58:\r
+    Couldn't match type ‘t’ with ‘ExpGADT Int’\r
+      ‘t’ is untouchable\r
+        inside the constraints (t1 ~ Int)\r
+        bound by a pattern with constructor: ExpInt :: Int -> ExpGADT Int,\r
+                 in a case alternative\r
+        at gadt-escape1.hs:19:43-50\r
+      ‘t’ is a rigid type variable bound by\r
+          the inferred type of weird1 :: t at gadt-escape1.hs:19:1\r
+    Possible fix: add a type signature for ‘weird1’\r
+    Expected type: t\r
+      Actual type: ExpGADT t1\r
+    Relevant bindings include\r
+      weird1 :: t (bound at gadt-escape1.hs:19:1)\r
+    In the expression: a\r
+    In a case alternative: Hidden (ExpInt _) a -> a\r
index 563492d..c8b7259 100644 (file)
@@ -1,17 +1,16 @@
-
-gadt13.hs:15:13:
-    Couldn't match expected type ‘t’
-                with actual type ‘String -> [Char]’
-      ‘t’ is untouchable
-        inside the constraints (t1 ~ Int)
-        bound by a pattern with constructor
-                   I :: Int -> Term Int,
-                 in an equation for ‘shw’
-        at gadt13.hs:15:6-8
-      ‘t’ is a rigid type variable bound by
-          the inferred type of shw :: Term t1 -> t at gadt13.hs:15:1
-    Possible fix: add a type signature for ‘shw’
-    Relevant bindings include
-      shw :: Term t1 -> t (bound at gadt13.hs:15:1)
-    In the expression: ("I " ++) . shows t
-    In an equation for ‘shw’: shw (I t) = ("I " ++) . shows t
+\r
+gadt13.hs:15:13:\r
+    Couldn't match expected type ‘t’\r
+                with actual type ‘String -> [Char]’\r
+      ‘t’ is untouchable\r
+        inside the constraints (t1 ~ Int)\r
+        bound by a pattern with constructor: I :: Int -> Term Int,\r
+                 in an equation for ‘shw’\r
+        at gadt13.hs:15:6-8\r
+      ‘t’ is a rigid type variable bound by\r
+          the inferred type of shw :: Term t1 -> t at gadt13.hs:15:1\r
+    Possible fix: add a type signature for ‘shw’\r
+    Relevant bindings include\r
+      shw :: Term t1 -> t (bound at gadt13.hs:15:1)\r
+    In the expression: ("I " ++) . shows t\r
+    In an equation for ‘shw’: shw (I t) = ("I " ++) . shows t\r
index 9b29cba..878abe2 100644 (file)
@@ -2,7 +2,7 @@
 gadt21.hs:21:60:\r
     Could not deduce (Ord a1) arising from a use of ‘f’\r
     from the context (a ~ Set a1)\r
 gadt21.hs:21:60:\r
     Could not deduce (Ord a1) arising from a use of ‘f’\r
     from the context (a ~ Set a1)\r
-      bound by a pattern with constructor\r
+      bound by a pattern with constructor:\r
                  TypeSet :: forall a. Type a -> Type (Set a),\r
                in an equation for ‘withOrdDynExpr’\r
       at gadt21.hs:21:35-43\r
                  TypeSet :: forall a. Type a -> Type (Set a),\r
                in an equation for ‘withOrdDynExpr’\r
       at gadt21.hs:21:35-43\r
index 3fb4a6a..2721e99 100644 (file)
@@ -1,20 +1,19 @@
-
-gadt7.hs:16:38:
-    Couldn't match expected type ‘t’ with actual type ‘t1’
-      ‘t1’ is untouchable
-        inside the constraints (t2 ~ Int)
-        bound by a pattern with constructor
-                   K :: T Int,
-                 in a case alternative
-        at gadt7.hs:16:33
-      ‘t1’ is a rigid type variable bound by
-           the inferred type of i1b :: T t2 -> t1 -> t at gadt7.hs:16:1
-      ‘t’ is a rigid type variable bound by
-          the inferred type of i1b :: T t2 -> t1 -> t at gadt7.hs:16:1
-    Possible fix: add a type signature for ‘i1b’
-    Relevant bindings include
-      y1 :: t1 (bound at gadt7.hs:16:16)
-      y :: t1 (bound at gadt7.hs:16:7)
-      i1b :: T t2 -> t1 -> t (bound at gadt7.hs:16:1)
-    In the expression: y1
-    In a case alternative: K -> y1
+\r
+gadt7.hs:16:38:\r
+    Couldn't match expected type ‘t’ with actual type ‘t1’\r
+      ‘t1’ is untouchable\r
+        inside the constraints (t2 ~ Int)\r
+        bound by a pattern with constructor: K :: T Int,\r
+                 in a case alternative\r
+        at gadt7.hs:16:33\r
+      ‘t1’ is a rigid type variable bound by\r
+           the inferred type of i1b :: T t2 -> t1 -> t at gadt7.hs:16:1\r
+      ‘t’ is a rigid type variable bound by\r
+          the inferred type of i1b :: T t2 -> t1 -> t at gadt7.hs:16:1\r
+    Possible fix: add a type signature for ‘i1b’\r
+    Relevant bindings include\r
+      y1 :: t1 (bound at gadt7.hs:16:16)\r
+      y :: t1 (bound at gadt7.hs:16:7)\r
+      i1b :: T t2 -> t1 -> t (bound at gadt7.hs:16:1)\r
+    In the expression: y1\r
+    In a case alternative: K -> y1\r
index 82b1986..8b02f5c 100644 (file)
@@ -2,7 +2,7 @@
 rw.hs:14:47:
     Couldn't match expected type ‘a’ with actual type ‘Int’
       ‘a’ is a rigid type variable bound by
 rw.hs:14:47:
     Couldn't match expected type ‘a’ with actual type ‘Int’
       ‘a’ is a rigid type variable bound by
-          the type signature for writeInt :: T a -> IORef a -> IO ()
+          the type signature for: writeInt :: T a -> IORef a -> IO ()
           at rw.hs:12:12
     Relevant bindings include
       ref :: IORef a (bound at rw.hs:13:12)
           at rw.hs:12:12
     Relevant bindings include
       ref :: IORef a (bound at rw.hs:13:12)
@@ -15,7 +15,7 @@ rw.hs:14:47:
 rw.hs:19:51:
     Couldn't match type ‘a’ with ‘Bool’
       ‘a’ is a rigid type variable bound by
 rw.hs:19:51:
     Couldn't match type ‘a’ with ‘Bool’
       ‘a’ is a rigid type variable bound by
-          the type signature for readBool :: T a -> IORef a -> IO ()
+          the type signature for: readBool :: T a -> IORef a -> IO ()
           at rw.hs:16:12
     Expected type: a -> Bool
       Actual type: Bool -> Bool
           at rw.hs:16:12
     Expected type: a -> Bool
       Actual type: Bool -> Bool
index 7a9c08e..fee6366 100644 (file)
@@ -1,6 +1,6 @@
-
-<interactive>:5:1:
-    No instance for (Show (t -> t1))
-      (maybe you haven't applied enough arguments to a function?)
-      arising from a use of ‘print’
-    In a stmt of an interactive GHCi command: print it
+\r
+<interactive>:5:1:\r
+    No instance for (Show (t -> t1))\r
+      (maybe you haven't applied a function to enough arguments?)\r
+      arising from a use of ‘print’\r
+    In a stmt of an interactive GHCi command: print it\r
index 669d271..69e098a 100644 (file)
 ../../typecheck/should_run/Defer01.hs:25:4: Warning:
     Couldn't match type ‘Int’ with ‘Bool’
     Inaccessible code in
 ../../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,
+      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))
       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))
-      (maybe you haven't applied enough arguments to a function?)
+      (maybe you haven't applied a function to enough arguments?)
       arising from the literal ‘1’
     In the expression: 1
     In an equation for ‘d’: d = 1
       arising from the literal ‘1’
     In the expression: 1
     In an equation for ‘d’: d = 1
@@ -45,7 +44,7 @@
 ../../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
 ../../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)
+          the type signature for: h :: a -> (Char, Char)
           at ../../typecheck/should_run/Defer01.hs:33:6
     Relevant bindings include
       x :: a (bound at ../../typecheck/should_run/Defer01.hs:34:3)
           at ../../typecheck/should_run/Defer01.hs:33:6
     Relevant bindings include
       x :: a (bound at ../../typecheck/should_run/Defer01.hs:34:3)
@@ -82,7 +81,7 @@
 ../../typecheck/should_run/Defer01.hs:45:6: Warning:
     Couldn't match type ‘Int’ with ‘Bool’
     Inaccessible code in
 ../../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
+      the type signature for: k :: (Int ~ Bool) => Int -> Bool
     In the ambiguity check for the type signature for ‘k’:
       k :: (Int ~ Bool) => Int -> Bool
     To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
     In the ambiguity check for the type signature for ‘k’:
       k :: (Int ~ Bool) => Int -> Bool
     To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
@@ -98,7 +97,7 @@
 ../../typecheck/should_run/Defer01.hs:45:6: Warning:
     Couldn't match type ‘Int’ with ‘Bool’
     Inaccessible code in
 ../../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
+      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’
 
 ../../typecheck/should_run/Defer01.hs:46:7: Warning:
     Couldn't match expected type ‘Bool’ with actual type ‘Int’
     In the first argument of ‘print’, namely ‘(c (C2 True))’
 *** Exception: ../../typecheck/should_run/Defer01.hs:28:5:
     No instance for (Num (a -> a))
     In the first argument of ‘print’, namely ‘(c (C2 True))’
 *** Exception: ../../typecheck/should_run/Defer01.hs:28:5:
     No instance for (Num (a -> a))
-      (maybe you haven't applied enough arguments to a function?)
+      (maybe you haven't applied a function to enough arguments?)
       arising from the literal ‘1’
     In the expression: 1
     In an equation for ‘d’: d = 1
       arising from the literal ‘1’
     In the expression: 1
     In an equation for ‘d’: d = 1
 *** 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
 *** 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)
+          the type signature for: h :: a -> (Char, Char)
           at ../../typecheck/should_run/Defer01.hs:33:6
     Relevant bindings include
       x :: a (bound at ../../typecheck/should_run/Defer01.hs:34:3)
           at ../../typecheck/should_run/Defer01.hs:33:6
     Relevant bindings include
       x :: a (bound at ../../typecheck/should_run/Defer01.hs:34:3)
index 82fbb31..6a6eebd 100644 (file)
@@ -1,30 +1,30 @@
-
-<interactive>:3:1:
-    No instance for (Show (t0 -> t0))
-      (maybe you haven't applied enough arguments to a function?)
-      arising from a use of ‘print’
-    In a stmt of an interactive GHCi command: print it
-
-<interactive>:11:1:
-    No instance for (Show (t0 -> t0))
-      (maybe you haven't applied enough arguments to a function?)
-      arising from a use of ‘print’
-    In a stmt of an interactive GHCi command: print it
-
-<interactive>:20:1:
-    No instance for (Show (t0 -> t0))
-      (maybe you haven't applied enough arguments to a function?)
-      arising from a use of ‘print’
-    In a stmt of an interactive GHCi command: print it
-
-<interactive>:29:1:
-    No instance for (Show (t0 -> t0))
-      (maybe you haven't applied enough arguments to a function?)
-      arising from a use of ‘print’
-    In a stmt of an interactive GHCi command: print it
-
-<interactive>:50:1:
-    No instance for (Show (t0 -> t0))
-      (maybe you haven't applied enough arguments to a function?)
-      arising from a use of ‘print’
-    In a stmt of an interactive GHCi command: print it
+\r
+<interactive>:3:1:\r
+    No instance for (Show (t0 -> t0))\r
+      (maybe you haven't applied a function to enough arguments?)\r
+      arising from a use of ‘print’\r
+    In a stmt of an interactive GHCi command: print it\r
+\r
+<interactive>:11:1:\r
+    No instance for (Show (t0 -> t0))\r
+      (maybe you haven't applied a function to enough arguments?)\r
+      arising from a use of ‘print’\r
+    In a stmt of an interactive GHCi command: print it\r
+\r
+<interactive>:20:1:\r
+    No instance for (Show (t0 -> t0))\r
+      (maybe you haven't applied a function to enough arguments?)\r
+      arising from a use of ‘print’\r
+    In a stmt of an interactive GHCi command: print it\r
+\r
+<interactive>:29:1:\r
+    No instance for (Show (t0 -> t0))\r
+      (maybe you haven't applied a function to enough arguments?)\r
+      arising from a use of ‘print’\r
+    In a stmt of an interactive GHCi command: print it\r
+\r
+<interactive>:50:1:\r
+    No instance for (Show (t0 -> t0))\r
+      (maybe you haven't applied a function to enough arguments?)\r
+      arising from a use of ‘print’\r
+    In a stmt of an interactive GHCi command: print it\r
index 8d14f3f..b76aef8 100644 (file)
@@ -3,7 +3,7 @@ PushedInAsGivens.hs:10:31:
     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
     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
-      the type signature for foo :: (F Int ~ [a1]) => a1 -> Int
+      the type signature for: foo :: (F Int ~ [a1]) => a1 -> Int
       at PushedInAsGivens.hs:9:20-44
     Relevant bindings include
       x :: a1 (bound at PushedInAsGivens.hs:10:17)
       at PushedInAsGivens.hs:9:20-44
     Relevant bindings include
       x :: a1 (bound at PushedInAsGivens.hs:10:17)
index 1e430d5..d3531ac 100644 (file)
@@ -3,10 +3,10 @@ Simple14.hs:8:8:
     Couldn't match type ‘z0’ with ‘z’
       ‘z0’ is untouchable
         inside the constraints (x ~ y)
     Couldn't match type ‘z0’ with ‘z’
       ‘z0’ is untouchable
         inside the constraints (x ~ y)
-        bound by the type signature for eqE :: (x ~ y) => EQ_ z0 z0
+        bound by the type signature for: eqE :: (x ~ y) => EQ_ z0 z0
         at Simple14.hs:8:8-39
       ‘z’ is a rigid type variable bound by
         at Simple14.hs:8:8-39
       ‘z’ is a rigid type variable bound by
-          the type signature for eqE :: EQ_ x y -> ((x ~ y) => EQ_ z z) -> p
+          the type signature for: eqE :: EQ_ x y -> ((x ~ y) => EQ_ z z) -> p
           at Simple14.hs:8:8
     Expected type: EQ_ z0 z0
       Actual type: EQ_ z z
           at Simple14.hs:8:8
     Expected type: EQ_ z0 z0
       Actual type: EQ_ z z
index 5ee40a7..b476088 100644 (file)
@@ -2,8 +2,8 @@
 T3208b.hs:15:10:
     Could not deduce (STerm o0 ~ OTerm o0)
     from the context (OTerm a ~ STerm a, OBJECT a, SUBST a)
 T3208b.hs:15:10:
     Could not deduce (STerm o0 ~ OTerm o0)
     from the context (OTerm a ~ STerm a, OBJECT a, SUBST a)
-      bound by the type signature for
-                 fce' :: (OTerm a ~ STerm a, OBJECT a, SUBST a) => a -> c
+      bound by the type signature for:
+               fce' :: (OTerm a ~ STerm a, OBJECT a, SUBST a) => a -> c
       at T3208b.hs:14:9-56
     The type variable ‘o0’ is ambiguous
     In the expression: fce (apply f)
       at T3208b.hs:14:9-56
     The type variable ‘o0’ is ambiguous
     In the expression: fce (apply f)
@@ -12,8 +12,8 @@ T3208b.hs:15:10:
 T3208b.hs:15:15:
     Could not deduce (OTerm o0 ~ OTerm a)
     from the context (OTerm a ~ STerm a, OBJECT a, SUBST a)
 T3208b.hs:15:15:
     Could not deduce (OTerm o0 ~ OTerm a)
     from the context (OTerm a ~ STerm a, OBJECT a, SUBST a)
-      bound by the type signature for
-                 fce' :: (OTerm a ~ STerm a, OBJECT a, SUBST a) => a -> c
+      bound by the type signature for:
+               fce' :: (OTerm a ~ STerm a, OBJECT a, SUBST a) => a -> c
       at T3208b.hs:14:9-56
     NB: ‘OTerm’ is a type function, and may not be injective
     The type variable ‘o0’ is ambiguous
       at T3208b.hs:14:9-56
     NB: ‘OTerm’ is a type function, and may not be injective
     The type variable ‘o0’ is ambiguous
index c49049b..2f2d3bf 100644 (file)
@@ -1,15 +1,14 @@
-
-GADTwrong1.hs:12:21:
-    Couldn't match expected type ‘b’ with actual type ‘c’
-      ‘c’ is a rigid type variable bound by
-          a pattern with constructor
-            T :: forall c. c -> T (Const c),
-          in a case alternative
-          at GADTwrong1.hs:12:14
-      ‘b’ is a rigid type variable bound by
-          the type signature for coerce :: a -> b at GADTwrong1.hs:10:20
-    Relevant bindings include
-      y :: c (bound at GADTwrong1.hs:12:16)
-      coerce :: a -> b (bound at GADTwrong1.hs:11:1)
-    In the expression: y
-    In a case alternative: T y -> y
+\r
+GADTwrong1.hs:12:21:\r
+    Couldn't match expected type ‘b’ with actual type ‘c’\r
+      ‘c’ is a rigid type variable bound by\r
+          a pattern with constructor: T :: forall c. c -> T (Const c),\r
+          in a case alternative\r
+          at GADTwrong1.hs:12:14\r
+      ‘b’ is a rigid type variable bound by\r
+          the type signature for: coerce :: a -> b at GADTwrong1.hs:10:20\r
+    Relevant bindings include\r
+      y :: c (bound at GADTwrong1.hs:12:16)\r
+      coerce :: a -> b (bound at GADTwrong1.hs:11:1)\r
+    In the expression: y\r
+    In a case alternative: T y -> y\r
index 209e2af..1b406e4 100644 (file)
@@ -1,13 +1,13 @@
-\r
-Overlap6.hs:15:7:\r
-    Couldn't match type ‘x’ with ‘And x 'True’\r
-      ‘x’ is a rigid type variable bound by\r
-          the type signature for g :: Proxy x -> Proxy (And x 'True)\r
-          at Overlap6.hs:14:6\r
-    Expected type: Proxy (And x 'True)\r
-      Actual type: Proxy x\r
-    Relevant bindings include\r
-      x :: Proxy x (bound at Overlap6.hs:15:3)\r
-      g :: Proxy x -> Proxy (And x 'True) (bound at Overlap6.hs:15:1)\r
-    In the expression: x\r
-    In an equation for ‘g’: g x = x\r
+
+Overlap6.hs:15:7:
+    Couldn't match type ‘x’ with ‘And x 'True’
+      ‘x’ is a rigid type variable bound by
+          the type signature for: g :: Proxy x -> Proxy (And x 'True)
+          at Overlap6.hs:14:6
+    Expected type: Proxy (And x 'True)
+      Actual type: Proxy x
+    Relevant bindings include
+      x :: Proxy x (bound at Overlap6.hs:15:3)
+      g :: Proxy x -> Proxy (And x 'True) (bound at Overlap6.hs:15:1)
+    In the expression: x
+    In an equation for ‘g’: g x = x
index dc88c87..09df4c2 100644 (file)
@@ -2,7 +2,7 @@
 SimpleFail5a.hs:31:11:
     Couldn't match type ‘a’ with ‘Int’
       ‘a’ is a rigid type variable bound by
 SimpleFail5a.hs:31:11:
     Couldn't match type ‘a’ with ‘Int’
       ‘a’ is a rigid type variable bound by
-          the type signature for bar3wrong :: S3 a -> a
+          the type signature for: bar3wrong :: S3 a -> a
           at SimpleFail5a.hs:30:14
     Expected type: S3 a
       Actual type: S3 Int
           at SimpleFail5a.hs:30:14
     Expected type: S3 a
       Actual type: S3 Int
index 169c43d..8d000ca 100644 (file)
@@ -1,21 +1,21 @@
-
-T2664.hs:31:52:
-    Could not deduce (a ~ b)
-    from the context ((a :*: b) ~ Dual c, c ~ Dual (a :*: b))
-      bound by the type signature for
-                 newPChan :: ((a :*: b) ~ Dual c, c ~ Dual (a :*: b)) =>
-                             IO (PChan (a :*: b), PChan c)
-      at T2664.hs:23:5-12
-      ‘a’ is a rigid type variable bound by
-          the instance declaration at T2664.hs:22:10
-      ‘b’ is a rigid type variable bound by
-          the instance declaration at T2664.hs:22:10
-    Expected type: Dual (Dual a)
-      Actual type: b
-    Relevant bindings include
-      v :: MVar (Either (PChan a) (PChan b)) (bound at T2664.hs:24:9)
-      newPChan :: IO (PChan (a :*: b), PChan c) (bound at T2664.hs:23:5)
-    In the third argument of ‘pchoose’, namely ‘newPChan’
-    In the first argument of ‘E’, namely ‘(pchoose Right v newPChan)’
-    In the expression:
-      E (pchoose Right v newPChan) (pchoose Left v newPChan)
+\r
+T2664.hs:31:52:\r
+    Could not deduce (a ~ b)\r
+    from the context ((a :*: b) ~ Dual c, c ~ Dual (a :*: b))\r
+      bound by the type signature for:\r
+               newPChan :: ((a :*: b) ~ Dual c, c ~ Dual (a :*: b)) =>\r
+                           IO (PChan (a :*: b), PChan c)\r
+      at T2664.hs:23:5-12\r
+      ‘a’ is a rigid type variable bound by\r
+          the instance declaration at T2664.hs:22:10\r
+      ‘b’ is a rigid type variable bound by\r
+          the instance declaration at T2664.hs:22:10\r
+    Expected type: Dual (Dual a)\r
+      Actual type: b\r
+    Relevant bindings include\r
+      v :: MVar (Either (PChan a) (PChan b)) (bound at T2664.hs:24:9)\r
+      newPChan :: IO (PChan (a :*: b), PChan c) (bound at T2664.hs:23:5)\r
+    In the third argument of ‘pchoose’, namely ‘newPChan’\r
+    In the first argument of ‘E’, namely ‘(pchoose Right v newPChan)’\r
+    In the expression:\r
+      E (pchoose Right v newPChan) (pchoose Left v newPChan)\r
index 4596f9b..9adb5ad 100644 (file)
@@ -2,7 +2,7 @@
 T3330a.hs:19:34:
     Couldn't match type ‘s’ with ‘(->) (s0 ix0 -> ix1)’
       ‘s’ is a rigid type variable bound by
 T3330a.hs:19:34:
     Couldn't match type ‘s’ with ‘(->) (s0 ix0 -> ix1)’
       ‘s’ is a rigid type variable bound by
-          the type signature for children :: s ix -> PF s r ix -> [AnyF s]
+          the type signature for: children :: s ix -> PF s r ix -> [AnyF s]
           at T3330a.hs:18:13
     Expected type: (s0 ix0 -> ix1)
                    -> r ix1 -> Writer [AnyF s] (r'0 ix1)
           at T3330a.hs:18:13
     Expected type: (s0 ix0 -> ix1)
                    -> r ix1 -> Writer [AnyF s] (r'0 ix1)
@@ -17,7 +17,7 @@ T3330a.hs:19:34:
 T3330a.hs:19:34:
     Couldn't match type ‘ix’ with ‘r ix1 -> Writer [AnyF s] (r'0 ix1)’
       ‘ix’ is a rigid type variable bound by
 T3330a.hs:19:34:
     Couldn't match type ‘ix’ with ‘r ix1 -> Writer [AnyF s] (r'0 ix1)’
       ‘ix’ is a rigid type variable bound by
-           the type signature for children :: s ix -> PF s r ix -> [AnyF s]
+           the type signature for: children :: s ix -> PF s r ix -> [AnyF s]
            at T3330a.hs:18:13
     Expected type: (s0 ix0 -> ix1)
                    -> r ix1 -> Writer [AnyF s] (r'0 ix1)
            at T3330a.hs:18:13
     Expected type: (s0 ix0 -> ix1)
                    -> r ix1 -> Writer [AnyF s] (r'0 ix1)
@@ -32,7 +32,7 @@ T3330a.hs:19:34:
 T3330a.hs:19:44:
     Couldn't match type ‘ix’ with ‘r0 ix0 -> Writer [AnyF s0] (r0 ix0)’
       ‘ix’ is a rigid type variable bound by
 T3330a.hs:19:44:
     Couldn't match type ‘ix’ with ‘r0 ix0 -> Writer [AnyF s0] (r0 ix0)’
       ‘ix’ is a rigid type variable bound by
-           the type signature for children :: s ix -> PF s r ix -> [AnyF s]
+           the type signature for: children :: s ix -> PF s r ix -> [AnyF s]
            at T3330a.hs:18:13
     Expected type: PF s r (r0 ix0 -> Writer [AnyF s0] (r0 ix0))
       Actual type: PF s r ix
            at T3330a.hs:18:13
     Expected type: PF s r (r0 ix0 -> Writer [AnyF s0] (r0 ix0))
       Actual type: PF s r ix
index 5e8c7b4..1234d75 100644 (file)
@@ -1,22 +1,22 @@
-
-T3440.hs:11:22:
-    Could not deduce (a1 ~ a)
-    from the context (Fam a ~ Fam a1)
-      bound by a pattern with constructor
-                 GADT :: forall a. a -> Fam a -> GADT (Fam a),
-               in an equation for ‘unwrap’
-      at T3440.hs:11:9-16
-      ‘a1’ is a rigid type variable bound by
-           a pattern with constructor
-             GADT :: forall a. a -> Fam a -> GADT (Fam a),
-           in an equation for ‘unwrap’
-           at T3440.hs:11:9
-      ‘a’ is a rigid type variable bound by
-          the type signature for unwrap :: GADT (Fam a) -> (a, Fam a)
-          at T3440.hs:10:11
-    Relevant bindings include
-      y :: Fam a1 (bound at T3440.hs:11:16)
-      x :: a1 (bound at T3440.hs:11:14)
-      unwrap :: GADT (Fam a) -> (a, Fam a) (bound at T3440.hs:11:1)
-    In the expression: x
-    In the expression: (x, y)
+\r
+T3440.hs:11:22:\r
+    Could not deduce (a1 ~ a)\r
+    from the context (Fam a ~ Fam a1)\r
+      bound by a pattern with constructor:\r
+                 GADT :: forall a. a -> Fam a -> GADT (Fam a),\r
+               in an equation for ‘unwrap’\r
+      at T3440.hs:11:9-16\r
+      ‘a1’ is a rigid type variable bound by\r
+           a pattern with constructor:\r
+             GADT :: forall a. a -> Fam a -> GADT (Fam a),\r
+           in an equation for ‘unwrap’\r
+           at T3440.hs:11:9\r
+      ‘a’ is a rigid type variable bound by\r
+          the type signature for: unwrap :: GADT (Fam a) -> (a, Fam a)\r
+          at T3440.hs:10:11\r
+    Relevant bindings include\r
+      y :: Fam a1 (bound at T3440.hs:11:16)\r
+      x :: a1 (bound at T3440.hs:11:14)\r
+      unwrap :: GADT (Fam a) -> (a, Fam a) (bound at T3440.hs:11:1)\r
+    In the expression: x\r
+    In the expression: (x, y)\r
index a2d4415..1fa4905 100644 (file)
@@ -2,7 +2,7 @@
 T4093a.hs:7:9:\r
     Could not deduce (Foo e0 ~ Maybe e)\r
     from the context (Foo e ~ Maybe e)\r
 T4093a.hs:7:9:\r
     Could not deduce (Foo e0 ~ Maybe e)\r
     from the context (Foo e ~ Maybe e)\r
-      bound by the type signature for hang :: (Foo e ~ Maybe e) => Foo e\r
+      bound by the type signature for: hang :: (Foo e ~ Maybe e) => Foo e\r
       at T4093a.hs:7:9-34\r
     The type variable ‘e0’ is ambiguous\r
     Expected type: Foo e\r
       at T4093a.hs:7:9-34\r
     The type variable ‘e0’ is ambiguous\r
     Expected type: Foo e\r
index 7fedfa6..9d749d1 100644 (file)
@@ -3,16 +3,16 @@ T4093b.hs:31:13:
     Could not deduce (e ~ C)
     from the context (EitherCO e (A C O n) (A O O n) ~ A e O n,
                       EitherCO x (A C C n) (A C O n) ~ A C x n)
     Could not deduce (e ~ C)
     from the context (EitherCO e (A C O n) (A O O n) ~ A e O n,
                       EitherCO x (A C C n) (A C O n) ~ A C x n)
-      bound by the type signature for
-                 blockToNodeList :: (EitherCO e (A C O n) (A O O n) ~ A e O n,
-                                     EitherCO x (A C C n) (A C O n) ~ A C x n) =>
-                                    Block n e x -> A e x n
+      bound by the type signature for:
+               blockToNodeList :: (EitherCO e (A C O n) (A O O n) ~ A e O n,
+                                   EitherCO x (A C C n) (A C O n) ~ A C x n) =>
+                                  Block n e x -> A e x n
       at T4093b.hs:(20,3)-(22,26)
       ‘e’ is a rigid type variable bound by
       at T4093b.hs:(20,3)-(22,26)
       ‘e’ is a rigid type variable bound by
-          the type signature for
-            blockToNodeList :: (EitherCO e (A C O n) (A O O n) ~ A e O n,
-                                EitherCO x (A C C n) (A C O n) ~ A C x n) =>
-                               Block n e x -> A e x n
+          the type signature for:
+          blockToNodeList :: (EitherCO e (A C O n) (A O O n) ~ A e O n,
+                              EitherCO x (A C C n) (A C O n) ~ A C x n) =>
+                             Block n e x -> A e x n
           at T4093b.hs:20:12
     Expected type: EitherCO e (A C O n) (A O O n)
       Actual type: (MaybeC C (n C O), MaybeC O (n O C))
           at T4093b.hs:20:12
     Expected type: EitherCO e (A C O n) (A O O n)
       Actual type: (MaybeC C (n C O), MaybeC O (n O C))
index 6b5ada2..cc4a7ae 100644 (file)
@@ -2,8 +2,8 @@
 T4174.hs:42:12:
     Couldn't match type ‘a’ with ‘SmStep’
       ‘a’ is a rigid type variable bound by
 T4174.hs:42:12:
     Couldn't match type ‘a’ with ‘SmStep’
       ‘a’ is a rigid type variable bound by
-          the type signature for
-            testcase :: Monad m => m (Field (Way (GHC6'8 minor) n t p) a b)
+          the type signature for:
+          testcase :: Monad m => m (Field (Way (GHC6'8 minor) n t p) a b)
           at T4174.hs:41:13
     Expected type: m (Field (Way (GHC6'8 minor) n t p) a b)
       Actual type: m (Field (WayOf m) SmStep RtsSpinLock)
           at T4174.hs:41:13
     Expected type: m (Field (Way (GHC6'8 minor) n t p) a b)
       Actual type: m (Field (WayOf m) SmStep RtsSpinLock)
@@ -16,8 +16,8 @@ T4174.hs:42:12:
 T4174.hs:42:12:
     Couldn't match type ‘b’ with ‘RtsSpinLock’
       ‘b’ is a rigid type variable bound by
 T4174.hs:42:12:
     Couldn't match type ‘b’ with ‘RtsSpinLock’
       ‘b’ is a rigid type variable bound by
-          the type signature for
-            testcase :: Monad m => m (Field (Way (GHC6'8 minor) n t p) a b)
+          the type signature for:
+          testcase :: Monad m => m (Field (Way (GHC6'8 minor) n t p) a b)
           at T4174.hs:41:13
     Expected type: m (Field (Way (GHC6'8 minor) n t p) a b)
       Actual type: m (Field (WayOf m) SmStep RtsSpinLock)
           at T4174.hs:41:13
     Expected type: m (Field (Way (GHC6'8 minor) n t p) a b)
       Actual type: m (Field (WayOf m) SmStep RtsSpinLock)
index 1000b9a..74e36f7 100644 (file)
@@ -2,7 +2,7 @@
 T4272.hs:15:26:
     Couldn't match type ‘a’ with ‘TermFamily a a’
       ‘a’ is a rigid type variable bound by
 T4272.hs:15:26:
     Couldn't match type ‘a’ with ‘TermFamily a a’
       ‘a’ is a rigid type variable bound by
-          the type signature for laws :: TermLike a => TermFamily a a -> b
+          the type signature for: laws :: TermLike a => TermFamily a a -> b
           at T4272.hs:14:16
     Expected type: TermFamily a (TermFamily a a)
       Actual type: TermFamily a a
           at T4272.hs:14:16
     Expected type: TermFamily a (TermFamily a a)
       Actual type: TermFamily a a
index dece4fb..12df18b 100644 (file)
@@ -3,7 +3,7 @@ T7194.hs:18:35:
     Couldn't match expected type ‘b0’ with actual type ‘F a’
       because type variable ‘a’ would escape its scope
     This (rigid, skolem) type variable is bound by
     Couldn't match expected type ‘b0’ with actual type ‘F a’
       because type variable ‘a’ would escape its scope
     This (rigid, skolem) type variable is bound by
-      the type signature for g :: C (F a) => a -> Int
+      the type signature for: g :: C (F a) => a -> Int
       at T7194.hs:17:23-41
     Relevant bindings include
       y :: a (bound at T7194.hs:18:20)
       at T7194.hs:17:23-41
     Relevant bindings include
       y :: a (bound at T7194.hs:18:20)
index b081ed6..4ce52b4 100644 (file)
@@ -1,13 +1,12 @@
-
-T7786.hs:86:22:
-    Couldn't match type ‘xxx’ with ‘'Empty’
-    Inaccessible code in
-      a pattern with constructor
-        Nil :: forall (k :: BOX). Sing 'Empty,
-      in a pattern binding in
-           'do' block
-    In the pattern: Nil
-    In the pattern: Nil :: Sing xxx
-    In a stmt of a 'do' block:
-      Nil :: Sing xxx <- return
-                           (buryUnder (dbKeys sub) k Nil `intersectPaths` dbKeys db)
+\r
+T7786.hs:86:22:\r
+    Couldn't match type ‘xxx’ with ‘'Empty’\r
+    Inaccessible code in\r
+      a pattern with constructor: Nil :: forall (k :: BOX). Sing 'Empty,\r
+      in a pattern binding in\r
+           'do' block\r
+    In the pattern: Nil\r
+    In the pattern: Nil :: Sing xxx\r
+    In a stmt of a 'do' block:\r
+      Nil :: Sing xxx <- return\r
+                           (buryUnder (dbKeys sub) k Nil `intersectPaths` dbKeys db)\r
index 3e84e4a..3093abb 100644 (file)
@@ -2,14 +2,14 @@
 T9662.hs:49:7:
     Couldn't match type ‘k’ with ‘n’
       ‘k’ is a rigid type variable bound by
 T9662.hs:49:7:
     Couldn't match type ‘k’ with ‘n’
       ‘k’ is a rigid type variable bound by
-          the type signature for
-            test :: Shape (((sh :. k) :. m) :. n)
-                    -> Shape (((sh :. m) :. n) :. k)
+          the type signature for:
+          test :: Shape (((sh :. k) :. m) :. n)
+                  -> Shape (((sh :. m) :. n) :. k)
           at T9662.hs:44:9
       ‘n’ is a rigid type variable bound by
           at T9662.hs:44:9
       ‘n’ is a rigid type variable bound by
-          the type signature for
-            test :: Shape (((sh :. k) :. m) :. n)
-                    -> Shape (((sh :. m) :. n) :. k)
+          the type signature for:
+          test :: Shape (((sh :. k) :. m) :. n)
+                  -> Shape (((sh :. m) :. n) :. k)
           at T9662.hs:44:9
     Expected type: Exp (((sh :. m) :. n) :. k)
                    -> Exp (((sh :. k) :. m) :. n)
           at T9662.hs:44:9
     Expected type: Exp (((sh :. m) :. n) :. k)
                    -> Exp (((sh :. k) :. m) :. n)
@@ -30,14 +30,14 @@ T9662.hs:49:7:
 T9662.hs:49:7:
     Couldn't match type ‘m’ with ‘k’
       ‘m’ is a rigid type variable bound by
 T9662.hs:49:7:
     Couldn't match type ‘m’ with ‘k’
       ‘m’ is a rigid type variable bound by
-          the type signature for
-            test :: Shape (((sh :. k) :. m) :. n)
-                    -> Shape (((sh :. m) :. n) :. k)
+          the type signature for:
+          test :: Shape (((sh :. k) :. m) :. n)
+                  -> Shape (((sh :. m) :. n) :. k)
           at T9662.hs:44:9
       ‘k’ is a rigid type variable bound by
           at T9662.hs:44:9
       ‘k’ is a rigid type variable bound by
-          the type signature for
-            test :: Shape (((sh :. k) :. m) :. n)
-                    -> Shape (((sh :. m) :. n) :. k)
+          the type signature for:
+          test :: Shape (((sh :. k) :. m) :. n)
+                  -> Shape (((sh :. m) :. n) :. k)
           at T9662.hs:44:9
     Expected type: Exp (((sh :. m) :. n) :. k)
                    -> Exp (((sh :. k) :. m) :. n)
           at T9662.hs:44:9
     Expected type: Exp (((sh :. m) :. n) :. k)
                    -> Exp (((sh :. k) :. m) :. n)
@@ -58,14 +58,14 @@ T9662.hs:49:7:
 T9662.hs:49:7:
     Couldn't match type ‘n’ with ‘m’
       ‘n’ is a rigid type variable bound by
 T9662.hs:49:7:
     Couldn't match type ‘n’ with ‘m’
       ‘n’ is a rigid type variable bound by
-          the type signature for
-            test :: Shape (((sh :. k) :. m) :. n)
-                    -> Shape (((sh :. m) :. n) :. k)
+          the type signature for:
+          test :: Shape (((sh :. k) :. m) :. n)
+                  -> Shape (((sh :. m) :. n) :. k)
           at T9662.hs:44:9
       ‘m’ is a rigid type variable bound by
           at T9662.hs:44:9
       ‘m’ is a rigid type variable bound by
-          the type signature for
-            test :: Shape (((sh :. k) :. m) :. n)
-                    -> Shape (((sh :. m) :. n) :. k)
+          the type signature for:
+          test :: Shape (((sh :. k) :. m) :. n)
+                  -> Shape (((sh :. m) :. n) :. k)
           at T9662.hs:44:9
     Expected type: Exp (((sh :. m) :. n) :. k)
                    -> Exp (((sh :. k) :. m) :. n)
           at T9662.hs:44:9
     Expected type: Exp (((sh :. m) :. n) :. k)
                    -> Exp (((sh :. k) :. m) :. n)
index 202c66c..179ff4f 100644 (file)
@@ -1,46 +1,46 @@
-
-T7848.hs:6:57:
-    Occurs check: cannot construct the infinite type:
-      t2 ~ t0 -> t -> t1 -> A -> A -> A -> A -> t2
-    Relevant bindings include
-      y :: forall t3. t3 -> t -> t1 -> A -> A -> A -> A -> t2
-        (bound at T7848.hs:8:9)
-      (&) :: t -> t1 -> A -> A -> A -> A -> t2 (bound at T7848.hs:11:9)
-      z :: t1 (bound at T7848.hs:6:12)
-      (&) :: t1 (bound at T7848.hs:6:8)
-      (+) :: t (bound at T7848.hs:6:3)
-      x :: t -> t1 -> A -> A -> A -> A -> t2 (bound at T7848.hs:6:1)
-    In the expression: y
-    In an equation for ‘x’:
-        x (+) ((&)@z) ((:&&) a b) (c :&& d) (e `A` f) (A g h)
-          = y
-          where
-              infixl 3 `y`
-              y _ = (&)
-              {-# INLINE (&) #-}
-              {-# SPECIALIZE (&) :: a #-}
-              (&) = x
-
-T7848.hs:10:9:
-    Couldn't match type ‘a’ with ‘t -> t1 -> A -> A -> A -> A -> t2’
-      ‘a’ is a rigid type variable bound by
-          the type signature for (&) :: a at T7848.hs:10:9
-    Expected type: forall a. a
-      Actual type: t -> t1 -> A -> A -> A -> A -> t2
-    Relevant bindings include
-      z :: t1 (bound at T7848.hs:6:12)
-      (&) :: t1 (bound at T7848.hs:6:8)
-      (+) :: t (bound at T7848.hs:6:3)
-      x :: t -> t1 -> A -> A -> A -> A -> t2 (bound at T7848.hs:6:1)
-    When checking that: t -> t1 -> A -> A -> A -> A -> t2
-      is more polymorphic than: forall a. a
-    In the SPECIALISE pragma {-# SPECIALIZE (&) :: a #-}
-    In an equation for ‘x’:
-        x (+) ((&)@z) ((:&&) a b) (c :&& d) (e `A` f) (A g h)
-          = y
-          where
-              infixl 3 `y`
-              y _ = (&)
-              {-# INLINE (&) #-}
-              {-# SPECIALIZE (&) :: a #-}
-              (&) = x
+\r
+T7848.hs:6:57:\r
+    Occurs check: cannot construct the infinite type:\r
+      t2 ~ t0 -> t -> t1 -> A -> A -> A -> A -> t2\r
+    Relevant bindings include\r
+      y :: forall t3. t3 -> t -> t1 -> A -> A -> A -> A -> t2\r
+        (bound at T7848.hs:8:9)\r
+      (&) :: t -> t1 -> A -> A -> A -> A -> t2 (bound at T7848.hs:11:9)\r
+      z :: t1 (bound at T7848.hs:6:12)\r
+      (&) :: t1 (bound at T7848.hs:6:8)\r
+      (+) :: t (bound at T7848.hs:6:3)\r
+      x :: t -> t1 -> A -> A -> A -> A -> t2 (bound at T7848.hs:6:1)\r
+    In the expression: y\r
+    In an equation for ‘x’:\r
+        x (+) ((&)@z) ((:&&) a b) (c :&& d) (e `A` f) (A g h)\r
+          = y\r
+          where\r
+              infixl 3 `y`\r
+              y _ = (&)\r
+              {-# INLINE (&) #-}\r
+              {-# SPECIALIZE (&) :: a #-}\r
+              (&) = x\r
+\r
+T7848.hs:10:9:\r
+    Couldn't match type ‘a’ with ‘t -> t1 -> A -> A -> A -> A -> t2’\r
+      ‘a’ is a rigid type variable bound by\r
+          the type signature for: (&) :: a at T7848.hs:10:9\r
+    Expected type: forall a. a\r
+      Actual type: t -> t1 -> A -> A -> A -> A -> t2\r
+    Relevant bindings include\r
+      z :: t1 (bound at T7848.hs:6:12)\r
+      (&) :: t1 (bound at T7848.hs:6:8)\r
+      (+) :: t (bound at T7848.hs:6:3)\r
+      x :: t -> t1 -> A -> A -> A -> A -> t2 (bound at T7848.hs:6:1)\r
+    When checking that: t -> t1 -> A -> A -> A -> A -> t2\r
+      is more polymorphic than: forall a. a\r
+    In the SPECIALISE pragma {-# SPECIALIZE (&) :: a #-}\r
+    In an equation for ‘x’:\r
+        x (+) ((&)@z) ((:&&) a b) (c :&& d) (e `A` f) (A g h)\r
+          = y\r
+          where\r
+              infixl 3 `y`\r
+              y _ = (&)\r
+              {-# INLINE (&) #-}\r
+              {-# SPECIALIZE (&) :: a #-}\r
+              (&) = x\r
index 5211cda..ef66e75 100644 (file)
@@ -1,7 +1,7 @@
-
-AnnotatedConstraint.hs:7:8:
-    No instance for (Eq (a0 -> a0))
-      (maybe you haven't applied enough arguments to a function?)
-      arising from a use of ‘foo’
-    In the expression: foo id
-    In an equation for ‘test’: test = foo id
+\r
+AnnotatedConstraint.hs:7:8:\r
+    No instance for (Eq (a0 -> a0))\r
+      (maybe you haven't applied a function to enough arguments?)\r
+      arising from a use of ‘foo’\r
+    In the expression: foo id\r
+    In an equation for ‘test’: test = foo id\r
index 7c61bf6..a8c4bc5 100644 (file)
@@ -1,21 +1,21 @@
-
-NamedWildcardsNotEnabled.hs:4:9:
-    Couldn't match expected type ‘_b’ with actual type ‘Bool’
-      ‘_b’ is a rigid type variable bound by
-           the type signature for foo :: _a -> _b
-           at NamedWildcardsNotEnabled.hs:3:8
-    Relevant bindings include
-      foo :: _a -> _b (bound at NamedWildcardsNotEnabled.hs:4:1)
-    In the expression: not x
-    In an equation for ‘foo’: foo x = not x
-
-NamedWildcardsNotEnabled.hs:4:13:
-    Couldn't match expected type ‘Bool’ with actual type ‘_a’
-      ‘_a’ is a rigid type variable bound by
-           the type signature for foo :: _a -> _b
-           at NamedWildcardsNotEnabled.hs:3:8
-    Relevant bindings include
-      x :: _a (bound at NamedWildcardsNotEnabled.hs:4:5)
-      foo :: _a -> _b (bound at NamedWildcardsNotEnabled.hs:4:1)
-    In the first argument of ‘not’, namely ‘x’
-    In the expression: not x
+\r
+NamedWildcardsNotEnabled.hs:4:9:\r
+    Couldn't match expected type ‘_b’ with actual type ‘Bool’\r
+      ‘_b’ is a rigid type variable bound by\r
+           the type signature for: foo :: _a -> _b\r
+           at NamedWildcardsNotEnabled.hs:3:8\r
+    Relevant bindings include\r
+      foo :: _a -> _b (bound at NamedWildcardsNotEnabled.hs:4:1)\r
+    In the expression: not x\r
+    In an equation for ‘foo’: foo x = not x\r
+\r
+NamedWildcardsNotEnabled.hs:4:13:\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: foo :: _a -> _b\r
+           at NamedWildcardsNotEnabled.hs:3:8\r
+    Relevant bindings include\r
+      x :: _a (bound at NamedWildcardsNotEnabled.hs:4:5)\r
+      foo :: _a -> _b (bound at NamedWildcardsNotEnabled.hs:4:1)\r
+    In the first argument of ‘not’, namely ‘x’\r
+    In the expression: not x\r
index 9ec952a..b6af606 100644 (file)
@@ -1,28 +1,28 @@
-
-T7230.hs:48:32:
-    Could not deduce ((x :<<= x1) ~ 'True)
-    from the context (Increasing xs ~ 'True)
-      bound by the type signature for
-                 crash :: (Increasing xs ~ 'True) =>
-                          SList xs -> SBool (Increasing xs)
-      at T7230.hs:47:10-68
-    or from (xs ~ (x : xs1))
-      bound by a pattern with constructor
-                 SCons :: forall (k :: BOX) (x :: k) (xs :: [k]).
-                          Sing x -> Sing xs -> Sing (x : xs),
-               in an equation for ‘crash’
-      at T7230.hs:48:8-27
-    or from (xs1 ~ (x1 : xs2))
-      bound by a pattern with constructor
-                 SCons :: forall (k :: BOX) (x :: k) (xs :: [k]).
-                          Sing x -> Sing xs -> Sing (x : xs),
-               in an equation for ‘crash’
-      at T7230.hs:48:17-26
-    Expected type: SBool (Increasing xs)
-      Actual type: SBool (x :<<= x1)
-    Relevant bindings include
-      y :: Sing x1 (bound at T7230.hs:48:23)
-      x :: Sing x (bound at T7230.hs:48:14)
-    In the expression: x %:<<= y
-    In an equation for ‘crash’:
-        crash (SCons x (SCons y xs)) = x %:<<= y
+\r
+T7230.hs:48:32:\r
+    Could not deduce ((x :<<= x1) ~ 'True)\r
+    from the context (Increasing xs ~ 'True)\r
+      bound by the type signature for:\r
+               crash :: (Increasing xs ~ 'True) =>\r
+                        SList xs -> SBool (Increasing xs)\r
+      at T7230.hs:47:10-68\r
+    or from (xs ~ (x : xs1))\r
+      bound by a pattern with constructor:\r
+                 SCons :: forall (k :: BOX) (x :: k) (xs :: [k]).\r
+                          Sing x -> Sing xs -> Sing (x : xs),\r
+               in an equation for ‘crash’\r
+      at T7230.hs:48:8-27\r
+    or from (xs1 ~ (x1 : xs2))\r
+      bound by a pattern with constructor:\r
+                 SCons :: forall (k :: BOX) (x :: k) (xs :: [k]).\r
+                          Sing x -> Sing xs -> Sing (x : xs),\r
+               in an equation for ‘crash’\r
+      at T7230.hs:48:17-26\r
+    Expected type: SBool (Increasing xs)\r
+      Actual type: SBool (x :<<= x1)\r
+    Relevant bindings include\r
+      y :: Sing x1 (bound at T7230.hs:48:23)\r
+      x :: Sing x (bound at T7230.hs:48:14)\r
+    In the expression: x %:<<= y\r
+    In an equation for ‘crash’:\r
+        crash (SCons x (SCons y xs)) = x %:<<= y\r
index 4616576..d280deb 100644 (file)
@@ -1,19 +1,19 @@
-
-T7438.hs:6:14:
-    Couldn't match expected type ‘t1’ with actual type ‘t’
-      ‘t’ is untouchable
-        inside the constraints (t2 ~ t3)
-        bound by a pattern with constructor
-                   Nil :: forall (k :: BOX) (b :: k). Thrist b b,
-                 in an equation for ‘go’
-        at T7438.hs:6:4-6
-      ‘t’ is a rigid type variable bound by
-          the inferred type of go :: Thrist t2 t3 -> t -> t1 at T7438.hs:6:1
-      ‘t1’ is a rigid type variable bound by
-           the inferred type of go :: Thrist t2 t3 -> t -> t1 at T7438.hs:6:1
-    Possible fix: add a type signature for ‘go’
-    Relevant bindings include
-      acc :: t (bound at T7438.hs:6:8)
-      go :: Thrist t2 t3 -> t -> t1 (bound at T7438.hs:6:1)
-    In the expression: acc
-    In an equation for ‘go’: go Nil acc = acc
+\r
+T7438.hs:6:14:\r
+    Couldn't match expected type ‘t1’ with actual type ‘t’\r
+      ‘t’ is untouchable\r
+        inside the constraints (t2 ~ t3)\r
+        bound by a pattern with constructor:\r
+                   Nil :: forall (k :: BOX) (b :: k). Thrist b b,\r
+                 in an equation for ‘go’\r
+        at T7438.hs:6:4-6\r
+      ‘t’ is a rigid type variable bound by\r
+          the inferred type of go :: Thrist t2 t3 -> t -> t1 at T7438.hs:6:1\r
+      ‘t1’ is a rigid type variable bound by\r
+           the inferred type of go :: Thrist t2 t3 -> t -> t1 at T7438.hs:6:1\r
+    Possible fix: add a type signature for ‘go’\r
+    Relevant bindings include\r
+      acc :: t (bound at T7438.hs:6:8)\r
+      go :: Thrist t2 t3 -> t -> t1 (bound at T7438.hs:6:1)\r
+    In the expression: acc\r
+    In an equation for ‘go’: go Nil acc = acc\r
index ad0d15e..82c1ded 100644 (file)
@@ -1,19 +1,19 @@
-
-T8566.hs:31:9:
-    Could not deduce (C ('AA (t (I a ps)) as) ps fs0)
-      arising from a use of ‘c’
-    from the context (C ('AA (t (I a ps)) as) ps fs)
-      bound by the instance declaration at T8566.hs:29:10-67
-    or from ('AA t (a : as) ~ 'AA t1 as1)
-      bound by a pattern with constructor
-                 A :: forall (r :: [*]) (k :: BOX) (t :: k) (as :: [U *]).
-                      I ('AA t as) r,
-               in an equation for ‘c’
-      at T8566.hs:31:5
-    The type variable ‘fs0’ is ambiguous
-    Relevant bindings include
-      c :: I ('AA t (a : as)) ps -> I ('AA t (a : as)) ps
-        (bound at T8566.hs:31:3)
-    In the expression: c undefined
-    In an equation for ‘c’: c A = c undefined
-    In the instance declaration for ‘C ('AA t (a : as)) ps fs’
+\r
+T8566.hs:31:9:\r
+    Could not deduce (C ('AA (t (I a ps)) as) ps fs0)\r
+      arising from a use of ‘c’\r
+    from the context (C ('AA (t (I a ps)) as) ps fs)\r
+      bound by the instance declaration at T8566.hs:29:10-67\r
+    or from ('AA t (a : as) ~ 'AA t1 as1)\r
+      bound by a pattern with constructor:\r
+                 A :: forall (r :: [*]) (k :: BOX) (t :: k) (as :: [U *]).\r
+                      I ('AA t as) r,\r
+               in an equation for ‘c’\r
+      at T8566.hs:31:5\r
+    The type variable ‘fs0’ is ambiguous\r
+    Relevant bindings include\r
+      c :: I ('AA t (a : as)) ps -> I ('AA t (a : as)) ps\r
+        (bound at T8566.hs:31:3)\r
+    In the expression: c undefined\r
+    In an equation for ‘c’: c A = c undefined\r
+    In the instance declaration for ‘C ('AA t (a : as)) ps fs’\r
index b9ae820..88cf8ab 100644 (file)
@@ -1,66 +1,66 @@
-
-rebindable6.hs:106:17:
-    No instance for (HasSeq (IO a -> t0 -> IO b))
-      (maybe you haven't applied enough arguments to a function?)
-      arising from a do statement
-    The type variable ‘t0’ is ambiguous
-    Relevant bindings include
-      g :: IO (Maybe b) (bound at rebindable6.hs:104:19)
-      f :: IO a (bound at rebindable6.hs:104:17)
-      test_do :: IO a -> IO (Maybe b) -> IO b
-        (bound at rebindable6.hs:104:9)
-    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 (HasFail ([Prelude.Char] -> t1))
-      (maybe you haven't applied enough arguments to a function?)
-      arising from a do statement
-    The type variable ‘t1’ is ambiguous
-    Note: there is a potential instance available:
-      instance HasFail (String -> IO a)
-        -- Defined at rebindable6.hs:57: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))
-      (maybe you haven't applied enough arguments to a function?)
-      arising from a use of ‘return’
-    The type variable ‘t1’ is ambiguous
-    Relevant bindings include
-      b :: b (bound at rebindable6.hs:107:23)
-      g :: IO (Maybe b) (bound at rebindable6.hs:104:19)
-      test_do :: IO a -> IO (Maybe b) -> IO b
-        (bound at rebindable6.hs:104:9)
-    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
+      (maybe you haven't applied a function to enough arguments?)\r
+      arising from a do statement\r
+    The type variable ‘t0’ is ambiguous\r
+    Relevant bindings include\r
+      g :: IO (Maybe b) (bound at rebindable6.hs:104:19)\r
+      f :: IO a (bound at rebindable6.hs:104:17)\r
+      test_do :: IO a -> IO (Maybe b) -> IO b\r
+        (bound at rebindable6.hs:104:9)\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 (HasFail ([Prelude.Char] -> t1))\r
+      (maybe you haven't applied a function to enough arguments?)\r
+      arising from a do statement\r
+    The type variable ‘t1’ is ambiguous\r
+    Note: there is a potential instance available:\r
+      instance HasFail (String -> IO a)\r
+        -- Defined at rebindable6.hs:57: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
+      (maybe you haven't applied a function to enough arguments?)\r
+      arising from a use of ‘return’\r
+    The type variable ‘t1’ is ambiguous\r
+    Relevant bindings include\r
+      b :: b (bound at rebindable6.hs:107:23)\r
+      g :: IO (Maybe b) (bound at rebindable6.hs:104:19)\r
+      test_do :: IO a -> IO (Maybe b) -> IO b\r
+        (bound at rebindable6.hs:104:9)\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 34ea4bf..2b0ac17 100644 (file)
@@ -1,9 +1,9 @@
-
-FD1.hs:16:1:
-    Couldn't match expected type ‘Int -> Int’ with actual type ‘a’
-      ‘a’ is a rigid type variable bound by
-          the type signature for plus :: E a (Int -> Int) => Int -> a
-          at FD1.hs:15:9
-    Relevant bindings include plus :: Int -> a (bound at FD1.hs:16:1)
-    The equation(s) for ‘plus’ have two arguments,
-    but its type ‘Int -> a’ has only one
+\r
+FD1.hs:16:1:\r
+    Couldn't match expected type ‘Int -> Int’ with actual type ‘a’\r
+      ‘a’ is a rigid type variable bound by\r
+          the type signature for: plus :: E a (Int -> Int) => Int -> a\r
+          at FD1.hs:15:9\r
+    Relevant bindings include plus :: Int -> a (bound at FD1.hs:16:1)\r
+    The equation(s) for ‘plus’ have two arguments,\r
+    but its type ‘Int -> a’ has only one\r
index 9ebfabe..0134d87 100644 (file)
@@ -1,19 +1,19 @@
-
-FD2.hs:26:34:
-    Couldn't match expected type ‘e1’ with actual type ‘e’
-      ‘e’ is a rigid type variable bound by
-          the type signature for
-            foldr1 :: Elem a e => (e -> e -> e) -> a -> e
-          at FD2.hs:21:13
-      ‘e1’ is a rigid type variable bound by
-           the type signature for
-             mf :: Elem a e1 => e1 -> Maybe e1 -> Maybe e1
-           at FD2.hs:24:18
-    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)
-    In the first argument of ‘Just’, namely ‘(f x y)’
-    In the expression: Just (f x y)
+\r
+FD2.hs:26:34:\r
+    Couldn't match expected type ‘e1’ with actual type ‘e’\r
+      ‘e’ is a rigid type variable bound by\r
+          the type signature for:\r
+          foldr1 :: Elem a e => (e -> e -> e) -> a -> e\r
+          at FD2.hs:21:13\r
+      ‘e1’ is a rigid type variable bound by\r
+           the type signature for:\r
+           mf :: Elem a e1 => e1 -> Maybe e1 -> Maybe e1\r
+           at FD2.hs:24:18\r
+    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
+    In the first argument of ‘Just’, namely ‘(f x y)’\r
+    In the expression: Just (f x y)\r
index 0ba6587..3bed15a 100644 (file)
@@ -1,14 +1,14 @@
-
-FD3.hs:15:15:
-    Couldn't match type ‘a’ with ‘(String, a)’
-      ‘a’ is a rigid type variable bound by
-          the type signature for translate :: (String, a) -> A a
-          at FD3.hs:14:14
-    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
-    Relevant bindings include
-      a :: (String, a) (bound at FD3.hs:15:11)
-      translate :: (String, a) -> A a (bound at FD3.hs:15:1)
-    In the expression: mkA a
-    In an equation for ‘translate’: translate a = mkA a
+\r
+FD3.hs:15:15:\r
+    Couldn't match type ‘a’ with ‘(String, a)’\r
+      ‘a’ is a rigid type variable bound by\r
+          the type signature for: translate :: (String, a) -> A a\r
+          at FD3.hs:14:14\r
+    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
+    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
+    In the expression: mkA a\r
+    In an equation for ‘translate’: translate a = mkA a\r
index 4be503d..ef9900e 100644 (file)
@@ -1,14 +1,14 @@
-
-T7220a.hs:17:6:
-    Could not deduce (C a b)
-    from the context (C a0 b, TF b ~ Y)
-      bound by the type signature for f :: (C a0 b, TF b ~ Y) => b
-      at T7220a.hs:17:6-44
-    Possible fix:
-      add (C a b) to the context of
-        the type signature for f :: (C a0 b, TF b ~ Y) => b
-    In the ambiguity check for the type signature for ‘f’:
-      f :: forall a. (forall b. (C a b, TF b ~ Y) => b) -> X
-    To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
-    In the type signature for ‘f’:
-      f :: (forall b. (C a b, TF b ~ Y) => b) -> X
+\r
+T7220a.hs:17:6:\r
+    Could not deduce (C a b)\r
+    from the context (C a0 b, TF b ~ Y)\r
+      bound by the type signature for: f :: (C a0 b, TF b ~ Y) => b\r
+      at T7220a.hs:17:6-44\r
+    Possible fix:\r
+      add (C a b) to the context of\r
+        the type signature for: f :: (C a0 b, TF b ~ Y) => b\r
+    In the ambiguity check for the type signature for ‘f’:\r
+      f :: forall a. (forall b. (C a b, TF b ~ Y) => b) -> X\r
+    To defer the ambiguity check to use sites, enable AllowAmbiguousTypes\r
+    In the type signature for ‘f’:\r
+      f :: (forall b. (C a b, TF b ~ Y) => b) -> X\r
index e4372e5..534d16d 100644 (file)
@@ -1,71 +1,71 @@
-
-T9834.hs:23:10: Warning:
-    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
-    Relevant bindings include
-      afix :: (forall (q :: * -> *).
-               Applicative q =>
-               Comp p q a -> Comp p q a)
-              -> p a
-        (bound at T9834.hs:23:3)
-    In the expression: wrapIdComp
-    In an equation for ‘afix’: afix = wrapIdComp
-
-T9834.hs:23:10: Warning:
-    Couldn't match type ‘a’ with ‘p a0’
-      ‘a’ is a rigid type variable bound by
-          the type signature for
-            afix :: (forall (q :: * -> *).
-                     Applicative q =>
-                     Comp p q a -> Comp p q a)
-                    -> p a
-          at T9834.hs:22:11
-    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
-    Relevant bindings include
-      afix :: (forall (q :: * -> *).
-               Applicative q =>
-               Comp p q a -> Comp p q a)
-              -> p a
-        (bound at T9834.hs:23:3)
-    In the expression: wrapIdComp
-    In an equation for ‘afix’: afix = wrapIdComp
-
-T9834.hs:23:10: Warning:
-    Couldn't match type ‘a’ with ‘a1’
-      ‘a’ is a rigid type variable bound by
-          the type signature for
-            afix :: (forall (q :: * -> *).
-                     Applicative q =>
-                     Comp p q a -> Comp p q a)
-                    -> p a
-          at T9834.hs:22:11
-      ‘a1’ is a rigid type variable bound by
-           a type expected by the context:
-             Applicative q => Comp p q a1 -> Comp p q a1
-           at T9834.hs:23:10
-    Expected type: Comp p q a1 -> Comp p q a1
-      Actual type: Comp p q a -> Comp p q a
-    Relevant bindings include
-      afix :: (forall (q :: * -> *).
-               Applicative q =>
-               Comp p q a -> Comp p q a)
-              -> p a
-        (bound at T9834.hs:23:3)
-    In the expression: wrapIdComp
-    In an equation for ‘afix’: afix = wrapIdComp
+\r
+T9834.hs:23:10: Warning:\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
+    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
+    In the expression: wrapIdComp\r
+    In an equation for ‘afix’: afix = wrapIdComp\r
+\r
+T9834.hs:23:10: Warning:\r
+    Couldn't match type ‘a’ with ‘p a0’\r
+      ‘a’ is a rigid type variable bound by\r
+          the type signature for:\r
+          afix :: (forall (q :: * -> *).\r
+                   Applicative q =>\r
+                   Comp p q a -> Comp p q a)\r
+                  -> p a\r
+          at T9834.hs:22:11\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
+    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
+    In the expression: wrapIdComp\r
+    In an equation for ‘afix’: afix = wrapIdComp\r
+\r
+T9834.hs:23:10: Warning:\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 (q :: * -> *).\r
+                   Applicative q =>\r
+                   Comp p q a -> Comp p q a)\r
+                  -> p a\r
+          at T9834.hs:22:11\r
+      ‘a1’ is a rigid type variable bound by\r
+           a type expected by the context:\r
+             Applicative q => Comp p q a1 -> Comp p q a1\r
+           at T9834.hs:23:10\r
+    Expected type: Comp p q a1 -> Comp p q a1\r
+      Actual type: Comp p q a -> Comp p q a\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
+    In the expression: wrapIdComp\r
+    In an equation for ‘afix’: afix = wrapIdComp\r
index 9279d03..07adbfc 100644 (file)
@@ -36,7 +36,7 @@ tc141.hs:15:18:
     Couldn't match expected type ‘a2’ with actual type ‘t’
       because type variable ‘a2’ would escape its scope
     This (rigid, skolem) type variable is bound by
     Couldn't match expected type ‘a2’ with actual type ‘t’
       because type variable ‘a2’ would escape its scope
     This (rigid, skolem) type variable is bound by
-      the type signature for v :: a2
+      the type signature for: v :: a2
       at tc141.hs:14:19
     Relevant bindings include
       v :: a2 (bound at tc141.hs:15:14)
       at tc141.hs:14:19
     Relevant bindings include
       v :: a2 (bound at tc141.hs:15:14)
index 895cc7d..52e8d8a 100644 (file)
@@ -4,7 +4,7 @@ FDsFromGivens.hs:21:15:
     arising from a functional dependency between constraints:\r
       ‘C Char [a]’ arising from a use of ‘f’ at FDsFromGivens.hs:21:15\r
       ‘C Char Char’\r
     arising from a functional dependency between constraints:\r
       ‘C Char [a]’ arising from a use of ‘f’ at FDsFromGivens.hs:21:15\r
       ‘C Char Char’\r
-        arising from a pattern with constructor\r
+        arising from a pattern with constructor:\r
                        KCC :: C Char Char => () -> KCC,\r
                      in an equation for ‘bar’\r
         at FDsFromGivens.hs:21:6-10\r
                        KCC :: C Char Char => () -> KCC,\r
                      in an equation for ‘bar’\r
         at FDsFromGivens.hs:21:6-10\r
index 5ccc035..f06ee68 100644 (file)
@@ -1,12 +1,12 @@
-
-FailDueToGivenOverlapping.hs:27:9:
-    Overlapping instances for E [t0] arising from a use of ‘eop’
-    Matching givens (or their superclasses):
-      (E [Int])
-        bound by the type signature for bar :: E [Int] => () -> ()
-        at FailDueToGivenOverlapping.hs:26:8-26
-    Matching instances:
-      instance E [a] -- Defined at FailDueToGivenOverlapping.hs:21:10
-    (The choice depends on the instantiation of ‘t0’)
-    In the expression: eop [undefined]
-    In an equation for ‘bar’: bar _ = eop [undefined]
+\r
+FailDueToGivenOverlapping.hs:27:9:\r
+    Overlapping instances for E [t0] arising from a use of ‘eop’\r
+    Matching givens (or their superclasses):\r
+      (E [Int])\r
+        bound by the type signature for: bar :: E [Int] => () -> ()\r
+        at FailDueToGivenOverlapping.hs:26:8-26\r
+    Matching instances:\r
+      instance E [a] -- Defined at FailDueToGivenOverlapping.hs:21:10\r
+    (The choice depends on the instantiation of ‘t0’)\r
+    In the expression: eop [undefined]\r
+    In an equation for ‘bar’: bar _ = eop [undefined]\r
index 1261408..ff39e7e 100644 (file)
@@ -1,53 +1,52 @@
-
-FrozenErrorTests.hs:12: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:26: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:26:1)
-    In the expression: goo1 False undefined
-    In an equation for ‘test1’: test1 = goo1 False undefined
-
-FrozenErrorTests.hs:29: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:30: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:45: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:45: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:46: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:46: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: 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 c617cfb..1af8948 100644 (file)
@@ -1,9 +1,9 @@
-
-IPFail.hs:6:18:
-    Could not deduce (Num Bool) arising from the literal ‘5’
-    from the context (?x::Int)
-      bound by the type signature for f0 :: (?x::Int) => () -> Bool
-      at IPFail.hs:5:7-31
-    In the expression: 5
-    In the expression: let ?x = 5 in ?x
-    In an equation for ‘f0’: f0 () = let ?x = 5 in ?x
+\r
+IPFail.hs:6:18:\r
+    Could not deduce (Num Bool) arising from the literal ‘5’\r
+    from the context (?x::Int)\r
+      bound by the type signature for: f0 :: (?x::Int) => () -> Bool\r
+      at IPFail.hs:5:7-31\r
+    In the expression: 5\r
+    In the expression: let ?x = 5 in ?x\r
+    In an equation for ‘f0’: f0 () = let ?x = 5 in ?x\r
index 324eebb..37e7b23 100644 (file)
@@ -1,13 +1,13 @@
-
-T1899.hs:14:36:
-    Couldn't match type ‘a’ with ‘Proposition a1’
-      ‘a’ is a rigid type variable bound by
-          the type signature for transRHS :: [a] -> Int -> Constraint a
-          at T1899.hs:9:14
-    Expected type: [Proposition a1]
-      Actual type: [a]
-    Relevant bindings include
-      varSet :: [a] (bound at T1899.hs:10:11)
-      transRHS :: [a] -> Int -> Constraint a (bound at T1899.hs:10:2)
-    In the first argument of ‘Auxiliary’, namely ‘varSet’
-    In the first argument of ‘Prop’, namely ‘(Auxiliary varSet)’
+\r
+T1899.hs:14:36:\r
+    Couldn't match type ‘a’ with ‘Proposition a1’\r
+      ‘a’ is a rigid type variable bound by\r
+          the type signature for: transRHS :: [a] -> Int -> Constraint a\r
+          at T1899.hs:9:14\r
+    Expected type: [Proposition a1]\r
+      Actual type: [a]\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
+    In the first argument of ‘Auxiliary’, namely ‘varSet’\r
+    In the first argument of ‘Prop’, namely ‘(Auxiliary varSet)’\r
index df64852..65aa78c 100644 (file)
@@ -1,24 +1,24 @@
-
-T2714.hs:8:5:
-    Couldn't match type ‘a’ with ‘f0 b’
-      ‘a’ is a rigid type variable bound by
-          the type signature for f :: ((a -> b) -> b) -> forall c. c -> a
-          at T2714.hs:7:6
-    Expected type: ((a -> b) -> b) -> c -> a
-      Actual type: ((a -> b) -> b) -> f0 (a -> b) -> f0 b
-    Relevant bindings include
-      f :: ((a -> b) -> b) -> forall c. c -> a (bound at T2714.hs:8:1)
-    In the expression: ffmap
-    In an equation for ‘f’: f = ffmap
-
-T2714.hs:8:5:
-    Couldn't match type ‘c’ with ‘f0 (a -> b)’
-      ‘c’ is a rigid type variable bound by
-          the type signature for f :: ((a -> b) -> b) -> c -> a
-          at T2714.hs:8:1
-    Expected type: ((a -> b) -> b) -> c -> a
-      Actual type: ((a -> b) -> b) -> f0 (a -> b) -> f0 b
-    Relevant bindings include
-      f :: ((a -> b) -> b) -> forall c. c -> a (bound at T2714.hs:8:1)
-    In the expression: ffmap
-    In an equation for ‘f’: f = ffmap
+\r
+T2714.hs:8:5:\r
+    Couldn't match type ‘a’ with ‘f0 b’\r
+      ‘a’ is a rigid type variable bound by\r
+          the type signature for: f :: ((a -> b) -> b) -> forall c. c -> a\r
+          at T2714.hs:7:6\r
+    Expected type: ((a -> b) -> b) -> c -> a\r
+      Actual type: ((a -> b) -> b) -> f0 (a -> b) -> f0 b\r
+    Relevant bindings include\r
+      f :: ((a -> b) -> b) -> forall c. c -> a (bound at T2714.hs:8:1)\r
+    In the expression: ffmap\r
+    In an equation for ‘f’: f = ffmap\r
+\r
+T2714.hs:8:5:\r
+    Couldn't match type ‘c’ with ‘f0 (a -> b)’\r
+      ‘c’ is a rigid type variable bound by\r
+          the type signature for: f :: ((a -> b) -> b) -> c -> a\r
+          at T2714.hs:8:1\r
+    Expected type: ((a -> b) -> b) -> c -> a\r
+      Actual type: ((a -> b) -> b) -> f0 (a -> b) -> f0 b\r
+    Relevant bindings include\r
+      f :: ((a -> b) -> b) -> forall c. c -> a (bound at T2714.hs:8:1)\r
+    In the expression: ffmap\r
+    In an equation for ‘f’: f = ffmap\r
index ccf4f14..3008346 100644 (file)
@@ -1,7 +1,7 @@
-
-T2846b.hs:5:5:
-    No instance for (Show (Num a0 => a0))
-      (maybe you haven't applied enough arguments to a function?)
-      arising from a use of ‘show’
-    In the expression: show ([1, 2, 3] :: [Num a => a])
-    In an equation for ‘f’: f = show ([1, 2, 3] :: [Num a => a])
+\r
+T2846b.hs:5:5:\r
+    No instance for (Show (Num a0 => a0))\r
+      (maybe you haven't applied a function to enough arguments?)\r
+      arising from a use of ‘show’\r
+    In the expression: show ([1, 2, 3] :: [Num a => a])\r
+    In an equation for ‘f’: f = show ([1, 2, 3] :: [Num a => a])\r
index 05ea89a..e55b693 100644 (file)
@@ -1,16 +1,16 @@
-
-T3592.hs:8:5:
-    No instance for (Show a) arising from a use of ‘show’
-    Possible fix:
-      add (Show a) to the context of
-        the type signature for f :: T a -> String
-    In the expression: show
-    In an equation for ‘f’: f = show
-
-T3592.hs:11:7:
-    No instance for (Show a) arising from a use of ‘show’
-    Possible fix:
-      add (Show a) to the context of
-        the type signature for g :: T a -> String
-    In the expression: show x
-    In an equation for ‘g’: g x = show x
+\r
+T3592.hs:8:5:\r
+    No instance for (Show a) arising from a use of ‘show’\r
+    Possible fix:\r
+      add (Show a) to the context of\r
+        the type signature for: f :: T a -> String\r
+    In the expression: show\r
+    In an equation for ‘f’: f = show\r
+\r
+T3592.hs:11:7:\r
+    No instance for (Show a) arising from a use of ‘show’\r
+    Possible fix:\r
+      add (Show a) to the context of\r
+        the type signature for: g :: T a -> String\r
+    In the expression: show x\r
+    In an equation for ‘g’: g x = show x\r
index 7b5830c..c1cbae3 100644 (file)
@@ -1,11 +1,11 @@
-
-T5236.hs:13:9:
-    Couldn't match type ‘B’ with ‘A’
-    arising from a functional dependency between:
-      constraint ‘Id A B’
-        arising from the type signature for loop :: Id A B => Bool
-      instance ‘Id B B’ at T5236.hs:11:10-15
-    In the ambiguity check for the type signature for ‘loop’:
-      loop :: Id A B => Bool
-    To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
-    In the type signature for ‘loop’: loop :: Id A B => Bool
+\r
+T5236.hs:13:9:\r
+    Couldn't match type ‘B’ with ‘A’\r
+    arising from a functional dependency between:\r
+      constraint ‘Id A B’\r
+        arising from the type signature for: loop :: Id A B => Bool\r
+      instance ‘Id B B’ at T5236.hs:11:10-15\r
+    In the ambiguity check for the type signature for ‘loop’:\r
+      loop :: Id A B => Bool\r
+    To defer the ambiguity check to use sites, enable AllowAmbiguousTypes\r
+    In the type signature for ‘loop’: loop :: Id A B => Bool\r
index 14e069a..2adbed4 100644 (file)
@@ -1,32 +1,32 @@
-
-T5300.hs:11:7:
-    Could not deduce (C1 a b c0)
-    from the context (Monad m, C1 a b c)
-      bound by the type signature for
-                 f1 :: (Monad m, C1 a b c) => a -> StateT (T b) m a
-      at T5300.hs:11:7-50
-    The type variable ‘c0’ is ambiguous
-    In the ambiguity check for the type signature for ‘f1’:
-      f1 :: forall a b (m :: * -> *) c.
-            (Monad m, C1 a b c) =>
-            a -> StateT (T b) m a
-    To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
-    In the type signature for ‘f1’:
-      f1 :: (Monad m, C1 a b c) => a -> StateT (T b) m a
-
-T5300.hs:14:7:
-    Could not deduce (C2 a2 b2 c20)
-    from the context (Monad m, C1 a1 b1 c1, C2 a2 b2 c2)
-      bound by the type signature for
-                 f2 :: (Monad m, C1 a1 b1 c1, C2 a2 b2 c2) =>
-                       a1 -> StateT (T b2) m a2
-      at T5300.hs:14:7-69
-    The type variable ‘c20’ is ambiguous
-    In the ambiguity check for the type signature for ‘f2’:
-      f2 :: forall a1 b2 (m :: * -> *) a2 b1 c1 c2.
-            (Monad m, C1 a1 b1 c1, C2 a2 b2 c2) =>
-            a1 -> StateT (T b2) m a2
-    To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
-    In the type signature for ‘f2’:
-      f2 :: (Monad m, C1 a1 b1 c1, C2 a2 b2 c2) =>
-            a1 -> StateT (T b2) m a2
+\r
+T5300.hs:11:7:\r
+    Could not deduce (C1 a b c0)\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 the type signature for ‘f1’:\r
+      f1 :: forall a b (m :: * -> *) c.\r
+            (Monad m, C1 a b c) =>\r
+            a -> StateT (T b) m a\r
+    To defer the ambiguity check to use sites, enable AllowAmbiguousTypes\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 (C2 a2 b2 c20)\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 ‘c20’ is ambiguous\r
+    In the ambiguity check for the type signature for ‘f2’:\r
+      f2 :: 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
+    To defer the ambiguity check to use sites, enable AllowAmbiguousTypes\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 c474460..2b89177 100644 (file)
@@ -1,45 +1,45 @@
-
-T7453.hs:10:30:
-    Couldn't match expected type ‘t1’ with actual type ‘t’
-      because type variable ‘t1’ would escape its scope
-    This (rigid, skolem) type variable is bound by
-      the type signature for z :: Id t1
-      at T7453.hs:8:16-19
-    Relevant bindings include
-      aux :: Id t1 (bound at T7453.hs:10:21)
-      z :: Id t1 (bound at T7453.hs:9:11)
-      v :: t (bound at T7453.hs:7:7)
-      cast1 :: t -> a (bound at T7453.hs:7:1)
-    In the first argument of ‘Id’, namely ‘v’
-    In the expression: Id v
-
-T7453.hs:16:33:
-    Couldn't match expected type ‘t2’ with actual type ‘t’
-      because type variable ‘t2’ would escape its scope
-    This (rigid, skolem) type variable is bound by
-      the type signature for z :: () -> t2
-      at T7453.hs:14:16-22
-    Relevant bindings include
-      aux :: b -> t2 (bound at T7453.hs:16:21)
-      z :: () -> t2 (bound at T7453.hs:15:11)
-      v :: t (bound at T7453.hs:13:7)
-      cast2 :: t -> t1 (bound at T7453.hs:13:1)
-    In the first argument of ‘const’, namely ‘v’
-    In the expression: const v
-
-T7453.hs:21:15:
-    Couldn't match expected type ‘t1’ with actual type ‘a’
-      because type variable ‘t1’ would escape its scope
-    This (rigid, skolem) type variable is bound by
-      the type signature for z :: t1
-      at T7453.hs:20:16
-    Relevant bindings include
-      aux :: forall b. b -> a (bound at T7453.hs:22:21)
-      z :: t1 (bound at T7453.hs:21:11)
-      v :: a (bound at T7453.hs:19:7)
-      cast3 :: a -> t (bound at T7453.hs:19:1)
-    In the expression: v
-    In an equation for ‘z’:
-        z = v
-          where
-              aux = const v
+\r
+T7453.hs:10:30:\r
+    Couldn't match expected type ‘t1’ with actual type ‘t’\r
+      because type variable ‘t1’ would escape its scope\r
+    This (rigid, skolem) type variable is bound by\r
+      the type signature for: z :: Id t1\r
+      at T7453.hs:8:16-19\r
+    Relevant bindings include\r
+      aux :: Id t1 (bound at T7453.hs:10:21)\r
+      z :: Id t1 (bound at T7453.hs:9:11)\r
+      v :: t (bound at T7453.hs:7:7)\r
+      cast1 :: t -> a (bound at T7453.hs:7:1)\r
+    In the first argument of ‘Id’, namely ‘v’\r
+    In the expression: Id v\r
+\r
+T7453.hs:16:33:\r
+    Couldn't match expected type ‘t2’ with actual type ‘t’\r
+      because type variable ‘t2’ would escape its scope\r
+    This (rigid, skolem) type variable is bound by\r
+      the type signature for: z :: () -> t2\r
+      at T7453.hs:14:16-22\r
+    Relevant bindings include\r
+      aux :: b -> t2 (bound at T7453.hs:16:21)\r
+      z :: () -> t2 (bound at T7453.hs:15:11)\r
+      v :: t (bound at T7453.hs:13:7)\r
+      cast2 :: t -> t1 (bound at T7453.hs:13:1)\r
+    In the first argument of ‘const’, namely ‘v’\r
+    In the expression: const v\r
+\r
+T7453.hs:21:15:\r
+    Couldn't match expected type ‘t1’ with actual type ‘a’\r
+      because type variable ‘t1’ would escape its scope\r
+    This (rigid, skolem) type variable is bound by\r
+      the type signature for: z :: t1\r
+      at T7453.hs:20:16\r
+    Relevant bindings include\r
+      aux :: forall b. b -> a (bound at T7453.hs:22:21)\r
+      z :: t1 (bound at T7453.hs:21:11)\r
+      v :: a (bound at T7453.hs:19:7)\r
+      cast3 :: a -> t (bound at T7453.hs:19:1)\r
+    In the expression: v\r
+    In an equation for ‘z’:\r
+        z = v\r
+          where\r
+              aux = const v\r
index 63cff4a..a8e2921 100644 (file)
@@ -1,18 +1,18 @@
-\r
-T7748a.hs:16:24:\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 test :: a -> r -> () at T7748a.hs:11:9\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
-    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
+
+T7748a.hs:16:24:
+    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 :: a -> r -> () at T7748a.hs:11:9
+    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)
+    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 }
index a51cc83..290ae86 100644 (file)
@@ -1,8 +1,8 @@
-
-T8392a.hs:6:8:
-    Couldn't match type ‘Int’ with ‘Bool’
-    Inaccessible code in
-      the type signature for foo :: (Int ~ Bool) => a -> a
-    In the ambiguity check for the type signature for ‘foo’:
-      foo :: forall a. (Int ~ Bool) => a -> a
-    In the type signature for ‘foo’: foo :: (Int ~ Bool) => a -> a
+\r
+T8392a.hs:6:8:\r
+    Couldn't match type ‘Int’ with ‘Bool’\r
+    Inaccessible code in\r
+      the type signature for: foo :: (Int ~ Bool) => a -> a\r
+    In the ambiguity check for the type signature for ‘foo’:\r
+      foo :: forall a. (Int ~ Bool) => a -> a\r
+    In the type signature for ‘foo’: foo :: (Int ~ Bool) => a -> a\r
index 2cc9a6b..1416f2a 100644 (file)
@@ -1,9 +1,9 @@
-\r
-T8450.hs:8:7:\r
-    Couldn't match expected type ‘a’ with actual type ‘()’\r
-      ‘a’ is a rigid type variable bound by\r
-          the type signature for run :: a at T8450.hs:7:15\r
-    Relevant bindings include run :: a (bound at T8450.hs:8:1)\r
-    In the expression: runEffect $ (undefined :: Either a ())\r
-    In an equation for ‘run’:\r
-        run = runEffect $ (undefined :: Either a ())\r
+
+T8450.hs:8:7:
+    Couldn't match expected type ‘a’ with actual type ‘()’
+      ‘a’ is a rigid type variable bound by
+          the type signature for: run :: a at T8450.hs:7:15
+    Relevant bindings include run :: a (bound at T8450.hs:8:1)
+    In the expression: runEffect $ (undefined :: Either a ())
+    In an equation for ‘run’:
+        run = runEffect $ (undefined :: Either a ())
index 5ef2340..3f5236b 100644 (file)
@@ -1,15 +1,14 @@
-
-T9109.hs:8:13:
-    Couldn't match expected type ‘t’ with actual type ‘Bool’
-      ‘t’ is untouchable
-        inside the constraints (t1 ~ Bool)
-        bound by a pattern with constructor
-                   GBool :: G Bool,
-                 in an equation for ‘foo’
-        at T9109.hs:8:5-9
-      ‘t’ is a rigid type variable bound by
-          the inferred type of foo :: G t1 -> t at T9109.hs:8:1
-    Possible fix: add a type signature for ‘foo’
-    Relevant bindings include foo :: G t1 -> t (bound at T9109.hs:8:1)
-    In the expression: True
-    In an equation for ‘foo’: foo GBool = True
+\r
+T9109.hs:8:13:\r
+    Couldn't match expected type ‘t’ with actual type ‘Bool’\r
+      ‘t’ is untouchable\r
+        inside the constraints (t1 ~ Bool)\r
+        bound by a pattern with constructor: GBool :: G Bool,\r
+                 in an equation for ‘foo’\r
+        at T9109.hs:8:5-9\r
+      ‘t’ is a rigid type variable bound by\r
+          the inferred type of foo :: G t1 -> t at T9109.hs:8:1\r
+    Possible fix: add a type signature for ‘foo’\r
+    Relevant bindings include foo :: G t1 -> t (bound at T9109.hs:8:1)\r
+    In the expression: True\r
+    In an equation for ‘foo’: foo GBool = True\r
index f11ec28..ead183c 100644 (file)
@@ -1,14 +1,14 @@
-
-TcStaticPointersFail02.hs:9:6:
-    No instance for (Data.Typeable.Internal.Typeable b)
-      arising from a static form
-    In the expression: static (undefined :: (forall a. a -> a) -> b)
-    In an equation for ‘f1’:
-       f1 = static (undefined :: (forall a. a -> a) -> b)
-
-TcStaticPointersFail02.hs:12:6:
-    No instance for (Data.Typeable.Internal.Typeable Monad)
-      (maybe you haven't applied enough arguments to a function?)
-      arising from a static form
-    In the expression: static return
-    In an equation for ‘f2’: f2 = static return
+\r
+TcStaticPointersFail02.hs:9:6:\r
+    No instance for (Data.Typeable.Internal.Typeable b)\r
+      arising from a static form\r
+    In the expression: static (undefined :: (forall a. a -> a) -> b)\r
+    In an equation for ‘f1’:\r
+        f1 = static (undefined :: (forall a. a -> a) -> b)\r
+\r
+TcStaticPointersFail02.hs:12:6:\r
+    No instance for (Data.Typeable.Internal.Typeable Monad)\r
+      (maybe you haven't applied a function to enough arguments?)\r
+      arising from a static form\r
+    In the expression: static return\r
+    In an equation for ‘f2’: f2 = static return\r
index ebae89e..785bf07 100644 (file)
@@ -1,21 +1,21 @@
-
-mc22.hs:10:9:
-    No instance for (Functor t) arising from a use of ‘fmap’
-    Possible fix:
-      add (Functor t) to the context of
-        a type expected by the context: (a -> b) -> t a -> t b
-        or the inferred type of foo :: [t [Char]]
-    In the expression: fmap
-    In a stmt of a monad comprehension: then group using take 5
-    In the expression:
-      [x + 1 | x <- ["Hello", "World"], then group using take 5]
-
-mc22.hs:10:26:
-    Couldn't match type ‘a’ with ‘t a’
-      ‘a’ is a rigid type variable bound by
-          a type expected by the context: [a] -> [t a] at mc22.hs:10:9
-    Expected type: [a] -> [t a]
-      Actual type: [t a] -> [t a]
-    Relevant bindings include foo :: [t [Char]] (bound at mc22.hs:8:1)
-    In the expression: take 5
-    In a stmt of a monad comprehension: then group using take 5
+\r
+mc22.hs:10:9:\r
+    No instance for (Functor t) arising from a use of ‘fmap’\r
+    Possible fix:\r
+      add (Functor t) to the context of\r
+        a type expected by the context: (a -> b) -> t a -> t b\r
+        or the inferred type of foo :: [t [Char]]\r
+    In the expression: fmap\r
+    In a stmt of a monad comprehension: then group using take 5\r
+    In the expression:\r
+      [x + 1 | x <- ["Hello", "World"], then group using take 5]\r
+\r
+mc22.hs:10:26:\r
+    Couldn't match type ‘a’ with ‘t a’\r
+      ‘a’ is a rigid type variable bound by\r
+          a type expected by the context: [a] -> [t a] at mc22.hs:10:9\r
+    Expected type: [a] -> [t a]\r
+      Actual type: [t a] -> [t a]\r
+    Relevant bindings include foo :: [t [Char]] (bound at mc22.hs:8:1)\r
+    In the expression: take 5\r
+    In a stmt of a monad comprehension: then group using take 5\r
index 9107051..d2abc05 100644 (file)
@@ -1,12 +1,12 @@
-
-tcfail034.hs:17:13:
-    Could not deduce (Integral a) arising from a use of ‘mod’
-    from the context (Num a, Eq a)
-      bound by the type signature for test :: (Num a, Eq a) => a -> Bool
-      at tcfail034.hs:16:7-32
-    Possible fix:
-      add (Integral a) to the context of
-        the type signature for test :: (Num a, Eq a) => a -> Bool
-    In the first argument of ‘(==)’, namely ‘(x `mod` 3)’
-    In the expression: (x `mod` 3) == 0
-    In an equation for ‘test’: test x = (x `mod` 3) == 0
+\r
+tcfail034.hs:17:13:\r
+    Could not deduce (Integral a) arising from a use of ‘mod’\r
+    from the context (Num a, Eq a)\r
+      bound by the type signature for: test :: (Num a, Eq a) => a -> Bool\r
+      at tcfail034.hs:16:7-32\r
+    Possible fix:\r
+      add (Integral a) to the context of\r
+        the type signature for: test :: (Num a, Eq a) => a -> Bool\r
+    In the first argument of ‘(==)’, namely ‘(x `mod` 3)’\r
+    In the expression: (x `mod` 3) == 0\r
+    In an equation for ‘test’: test x = (x `mod` 3) == 0\r
index f912a68..0233841 100644 (file)
@@ -1,13 +1,13 @@
-
-tcfail065.hs:29:20:
-    Couldn't match expected type ‘x’ with actual type ‘x1’
-      ‘x1’ is a rigid type variable bound by
-           the type signature for setX :: x1 -> X x -> X x
-           at tcfail065.hs:29:3
-      ‘x’ is a rigid type variable bound by
-          the instance declaration at tcfail065.hs:28:10
-    Relevant bindings include
-      x :: x1 (bound at tcfail065.hs:29:8)
-      setX :: x1 -> X x -> X x (bound at tcfail065.hs:29:3)
-    In the first argument of ‘X’, namely ‘x’
-    In the expression: X x
+\r
+tcfail065.hs:29:20:\r
+    Couldn't match expected type ‘x’ with actual type ‘x1’\r
+      ‘x1’ is a rigid type variable bound by\r
+           the type signature for: setX :: x1 -> X x -> X x\r
+           at tcfail065.hs:29:3\r
+      ‘x’ is a rigid type variable bound by\r
+          the instance declaration at tcfail065.hs:28:10\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
+    In the first argument of ‘X’, namely ‘x’\r
+    In the expression: X x\r
index fb6d670..bdf479c 100644 (file)
@@ -1,76 +1,76 @@
-
-tcfail067.hs:1:14: Warning:
-    -XDatatypeContexts is deprecated: It was widely considered a misfeature, and has been removed from the Haskell language.
-
-tcfail067.hs:12:16:
-    No instance for (Ord a) arising from a use of ‘SubRange’
-    Possible fix:
-      add (Ord a) to the context of
-        the type signature for subRangeValue :: SubRange a -> a
-    In the pattern: SubRange (lower, upper) value
-    In an equation for ‘subRangeValue’:
-        subRangeValue (SubRange (lower, upper) value) = value
-
-tcfail067.hs:15:11:
-    No instance for (Ord a) arising from a use of ‘SubRange’
-    Possible fix:
-      add (Ord a) to the context of
-        the type signature for subRange :: SubRange a -> (a, a)
-    In the pattern: SubRange r value
-    In an equation for ‘subRange’: subRange (SubRange r value) = r
-
-tcfail067.hs:46:12:
-    Could not deduce (Ord a) arising from a use of ‘SubRange’
-    from the context (Show a)
-      bound by the type signature for
-                 showRange :: Show a => SubRange a -> String
-      at tcfail067.hs:45:14-43
-    Possible fix:
-      add (Ord a) to the context of
-        the type signature for showRange :: Show a => SubRange a -> String
-    In the pattern: SubRange (lower, upper) value
-    In an equation for ‘showRange’:
-        showRange (SubRange (lower, upper) value)
-          = show value ++ " :" ++ show lower ++ ".." ++ show upper
-
-tcfail067.hs:61:12:
-    Could not deduce (Ord a) arising from a use of ‘numSubRangeNegate’
-    from the context (Num a)
-      bound by the instance declaration at tcfail067.hs:60:10-34
-    Possible fix:
-      add (Ord a) to the context of the instance declaration
-    In the expression: numSubRangeNegate
-    In an equation for ‘negate’: negate = numSubRangeNegate
-    In the instance declaration for ‘Num (SubRange a)’
-
-tcfail067.hs:65:19:
-    Could not deduce (Ord a) arising from a use of ‘SubRange’
-    from the context (Num a)
-      bound by the instance declaration at tcfail067.hs:60:10-34
-    Possible fix:
-      add (Ord a) to the context of the instance declaration
-    In the expression:
-      SubRange (fromInteger a, fromInteger a) (fromInteger a)
-    In an equation for ‘fromInteger’:
-        fromInteger a
-          = SubRange (fromInteger a, fromInteger a) (fromInteger a)
-    In the instance declaration for ‘Num (SubRange a)’
-
-tcfail067.hs:74:5:
-    Could not deduce (Ord a) arising from a use of ‘SubRange’
-    from the context (Num a)
-      bound by the type signature for
-                 numSubRangeBinOp :: Num a =>
-                                     (a -> a -> a) -> SubRange a -> SubRange a -> SubRange a
-      at tcfail067.hs:(71,21)-(72,58)
-    Possible fix:
-      add (Ord a) to the context of
-        the type signature for
-          numSubRangeBinOp :: Num a =>
-                              (a -> a -> a) -> SubRange a -> SubRange a -> SubRange a
-    In the expression: SubRange (result, result) result
-    In an equation for ‘numSubRangeBinOp’:
-        numSubRangeBinOp op a b
-          = SubRange (result, result) result
-          where
-              result = (subRangeValue a) `op` (subRangeValue b)
+\r
+tcfail067.hs:1:14: Warning:\r
+    -XDatatypeContexts is deprecated: It was widely considered a misfeature, and has been removed from the Haskell language.\r
+\r
+tcfail067.hs:12:16:\r
+    No instance for (Ord a) arising from a use of ‘SubRange’\r
+    Possible fix:\r
+      add (Ord a) to the context of\r
+        the type signature for: subRangeValue :: SubRange a -> a\r
+    In the pattern: SubRange (lower, upper) value\r
+    In an equation for ‘subRangeValue’:\r
+        subRangeValue (SubRange (lower, upper) value) = value\r
+\r
+tcfail067.hs:15:11:\r
+    No instance for (Ord a) arising from a use of ‘SubRange’\r
+    Possible fix:\r
+      add (Ord a) to the context of\r
+        the type signature for: subRange :: SubRange a -> (a, a)\r
+    In the pattern: SubRange r value\r
+    In an equation for ‘subRange’: subRange (SubRange r value) = r\r
+\r
+tcfail067.hs:46:12:\r
+    Could not deduce (Ord a) arising from a use of ‘SubRange’\r
+    from the context (Show a)\r
+      bound by the type signature for:\r
+               showRange :: Show a => SubRange a -> String\r
+      at tcfail067.hs:45:14-43\r
+    Possible fix:\r
+      add (Ord a) to the context of\r
+        the type signature for: showRange :: Show a => SubRange a -> String\r
+    In the pattern: SubRange (lower, upper) value\r
+    In an equation for ‘showRange’:\r
+        showRange (SubRange (lower, upper) value)\r
+          = show value ++ " :" ++ show lower ++ ".." ++ show upper\r
+\r
+tcfail067.hs:61:12:\r
+    Could not deduce (Ord a) arising from a use of ‘numSubRangeNegate’\r
+    from the context (Num a)\r
+      bound by the instance declaration at tcfail067.hs:60:10-34\r
+    Possible fix:\r
+      add (Ord a) to the context of the instance declaration\r
+    In the expression: numSubRangeNegate\r
+    In an equation for ‘negate’: negate = numSubRangeNegate\r
+    In the instance declaration for ‘Num (SubRange a)’\r
+\r
+tcfail067.hs:65:19:\r
+    Could not deduce (Ord a) arising from a use of ‘SubRange’\r
+    from the context (Num a)\r
+      bound by the instance declaration at tcfail067.hs:60:10-34\r
+    Possible fix:\r
+      add (Ord a) to the context of the instance declaration\r
+    In the expression:\r
+      SubRange (fromInteger a, fromInteger a) (fromInteger a)\r
+    In an equation for ‘fromInteger’:\r
+        fromInteger a\r
+          = SubRange (fromInteger a, fromInteger a) (fromInteger a)\r
+    In the instance declaration for ‘Num (SubRange a)’\r
+\r
+tcfail067.hs:74:5:\r
+    Could not deduce (Ord a) arising from a use of ‘SubRange’\r
+    from the context (Num a)\r
+      bound by the type signature for:\r
+               numSubRangeBinOp :: Num a =>\r
+                                   (a -> a -> a) -> SubRange a -> SubRange a -> SubRange a\r
+      at tcfail067.hs:(71,21)-(72,58)\r
+    Possible fix:\r
+      add (Ord a) to the context of\r
+        the type signature for:\r
+        numSubRangeBinOp :: Num a =>\r
+                            (a -> a -> a) -> SubRange a -> SubRange a -> SubRange a\r
+    In the expression: SubRange (result, result) result\r
+    In an equation for ‘numSubRangeBinOp’:\r
+        numSubRangeBinOp op a b\r
+          = SubRange (result, result) result\r
+          where\r
+              result = (subRangeValue a) `op` (subRangeValue b)\r
index 233c92e..a25e575 100644 (file)
@@ -1,96 +1,96 @@
-
-tcfail068.hs:14:9:
-    Couldn't match type ‘s1’ with ‘s’
-      ‘s1’ is a rigid type variable bound by
-           a type expected by the context: GHC.ST.ST s1 (IndTree s a)
-           at tcfail068.hs:13:9
-      ‘s’ is a rigid type variable bound by
-          the type signature for
-            itgen :: Constructed a => (Int, Int) -> a -> IndTree s a
-          at tcfail068.hs:11:10
-    Expected type: GHC.ST.ST s1 (IndTree s a)
-      Actual type: GHC.ST.ST s1 (STArray s1 (Int, Int) a)
-    Relevant bindings include
-      itgen :: (Int, Int) -> a -> IndTree s a
-        (bound at tcfail068.hs:12:1)
-    In the first argument of ‘runST’, namely
-      ‘(newSTArray ((1, 1), n) x)’
-    In the expression: runST (newSTArray ((1, 1), n) x)
-
-tcfail068.hs:19:21:
-    Couldn't match type ‘s’ with ‘s1’
-      ‘s’ is a rigid type variable bound by
-          the type signature for
-            itiap :: Constructed a =>
-                     (Int, Int) -> (a -> a) -> IndTree s a -> IndTree s a
-          at tcfail068.hs:16:10
-      ‘s1’ is a rigid type variable bound by
-           a type expected by the context: GHC.ST.ST s1 (IndTree s a)
-           at tcfail068.hs:18:9
-    Expected type: STArray s1 (Int, Int) a
-      Actual type: IndTree s a
-    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)
-    In the first argument of ‘readSTArray’, namely ‘arr’
-    In the first argument of ‘(>>=)’, namely ‘readSTArray arr i’
-
-tcfail068.hs:24:36:
-    Couldn't match type ‘s’ with ‘s1’
-      ‘s’ is a rigid type variable bound by
-          the type signature for
-            itrap :: Constructed a =>
-                     ((Int, Int), (Int, Int)) -> (a -> a) -> IndTree s a -> IndTree s a
-          at tcfail068.hs:23:10
-      ‘s1’ is a rigid type variable bound by
-           a type expected by the context: GHC.ST.ST s1 (IndTree s a)
-           at tcfail068.hs:24:29
-    Expected type: GHC.ST.ST s1 (IndTree s a)
-      Actual type: GHC.ST.ST s (IndTree s a)
-    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)
-    In the first argument of ‘runST’, namely ‘(itrap' i k)’
-    In the expression: runST (itrap' i k)
-
-tcfail068.hs:36:46:
-    Couldn't match type ‘s’ with ‘s1’
-      ‘s’ is a rigid type variable bound by
-          the type signature for
-            itrapstate :: Constructed b =>
-                          ((Int, Int), (Int, Int))
-                          -> (a -> b -> (a, b))
-                          -> ((Int, Int) -> c -> a)
-                          -> (a -> c)
-                          -> c
-                          -> IndTree s b
-                          -> (c, IndTree s b)
-          at tcfail068.hs:34:15
-      ‘s1’ is a rigid type variable bound by
-           a type expected by the context: GHC.ST.ST s1 (c, IndTree s b)
-           at tcfail068.hs:36:40
-    Expected type: GHC.ST.ST s1 (c, IndTree s b)
-      Actual type: GHC.ST.ST s (c, IndTree s b)
-    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)
-    In the first argument of ‘runST’, namely ‘(itrapstate' i k s)’
-    In the expression: runST (itrapstate' i k s)
+\r
+tcfail068.hs:14:9:\r
+    Couldn't match type ‘s1’ with ‘s’\r
+      ‘s1’ is a rigid type variable bound by\r
+           a type expected by the context: GHC.ST.ST s1 (IndTree s a)\r
+           at tcfail068.hs:13:9\r
+      ‘s’ is a rigid type variable bound by\r
+          the type signature for:\r
+          itgen :: Constructed a => (Int, Int) -> a -> IndTree s a\r
+          at tcfail068.hs:11:10\r
+    Expected type: GHC.ST.ST s1 (IndTree s a)\r
+      Actual type: GHC.ST.ST s1 (STArray s1 (Int, Int) a)\r
+    Relevant bindings include\r
+      itgen :: (Int, Int) -> a -> IndTree s a\r
+        (bound at tcfail068.hs:12:1)\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
+\r
+tcfail068.hs:19:21:\r
+    Couldn't match type ‘s’ with ‘s1’\r
+      ‘s’ is a rigid type variable bound by\r
+          the type signature for:\r
+          itiap :: Constructed a =>\r
+                   (Int, Int) -> (a -> a) -> IndTree s a -> IndTree s a\r
+          at tcfail068.hs:16:10\r
+      ‘s1’ is a rigid type variable bound by\r
+           a type expected by the context: GHC.ST.ST s1 (IndTree s a)\r
+           at tcfail068.hs:18:9\r
+    Expected type: STArray s1 (Int, Int) a\r
+      Actual type: IndTree s a\r
+    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
+    In the first argument of ‘readSTArray’, namely ‘arr’\r
+    In the first argument of ‘(>>=)’, namely ‘readSTArray arr i’\r
+\r
+tcfail068.hs:24:36:\r
+    Couldn't match type ‘s’ with ‘s1’\r
+      ‘s’ is a rigid type variable bound by\r
+          the type signature for:\r
+          itrap :: Constructed a =>\r
+                   ((Int, Int), (Int, Int)) -> (a -> a) -> IndTree s a -> IndTree s a\r
+          at tcfail068.hs:23:10\r
+      ‘s1’ is a rigid type variable bound by\r
+           a type expected by the context: GHC.ST.ST s1 (IndTree s a)\r
+           at tcfail068.hs:24:29\r
+    Expected type: GHC.ST.ST s1 (IndTree s a)\r
+      Actual type: GHC.ST.ST s (IndTree s a)\r
+    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
+    In the first argument of ‘runST’, namely ‘(itrap' i k)’\r
+    In the expression: runST (itrap' i k)\r
+\r
+tcfail068.hs:36:46:\r
+    Couldn't match type ‘s’ with ‘s1’\r
+      ‘s’ is a rigid type variable bound by\r
+          the type signature for:\r
+          itrapstate :: Constructed b =>\r
+                        ((Int, Int), (Int, Int))\r
+                        -> (a -> b -> (a, b))\r
+                        -> ((Int, Int) -> c -> a)\r
+                        -> (a -> c)\r
+                        -> c\r
+                        -> IndTree s b\r
+                        -> (c, IndTree s b)\r
+          at tcfail068.hs:34:15\r
+      ‘s1’ is a rigid type variable bound by\r
+           a type expected by the context: GHC.ST.ST s1 (c, IndTree s b)\r
+           at tcfail068.hs:36:40\r
+    Expected type: GHC.ST.ST s1 (c, IndTree s b)\r
+      Actual type: GHC.ST.ST s (c, IndTree s b)\r
+    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
+    In the first argument of ‘runST’, namely ‘(itrapstate' i k s)’\r
+    In the expression: runST (itrapstate' i k s)\r
index aeb0e9a..9d88d70 100644 (file)
@@ -2,8 +2,8 @@
 tcfail072.hs:23:13:
     Could not deduce (Ord p0) arising from a use of ‘g’
     from the context (Ord p, Ord q)
 tcfail072.hs:23:13:
     Could not deduce (Ord p0) 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
+      bound by the type signature for:
+               g :: (Ord p, Ord q) => AB p q -> Bool
       at tcfail072.hs:22:6-38
     The type variable ‘p0’ is ambiguous
     Note: there are several potential instances:
       at tcfail072.hs:22:6-38
     The type variable ‘p0’ is ambiguous
     Note: there are several potential instances:
index 8219724..b5be488 100644 (file)
@@ -1,11 +1,11 @@
-
-tcfail097.hs:5:6:
-    Could not deduce (Eq a0)
-    from the context (Eq a)
-      bound by the type signature for f :: Eq a => Int -> Int
-      at tcfail097.hs:5:6-23
-    The type variable ‘a0’ is ambiguous
-    In the ambiguity check for the type signature for ‘f’:
-      f :: forall a. Eq a => Int -> Int
-    To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
-    In the type signature for ‘f’: f :: Eq a => Int -> Int
+\r
+tcfail097.hs:5:6:\r
+    Could not deduce (Eq a0)\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 the type signature for ‘f’:\r
+      f :: forall a. Eq a => Int -> Int\r
+    To defer the ambiguity check to use sites, enable AllowAmbiguousTypes\r
+    In the type signature for ‘f’: f :: Eq a => Int -> Int\r
index 7b1f5bc..cb3008c 100644 (file)
@@ -1,15 +1,14 @@
-
-tcfail099.hs:9:20:
-    Couldn't match expected type ‘a’ with actual type ‘t’
-      because type variable ‘a’ would escape its scope
-    This (rigid, skolem) type variable is bound by
-      a pattern with constructor
-        C :: forall a. (a -> Int) -> DS,
-      in an equation for ‘call’
-      at tcfail099.hs:9:7-9
-    Relevant bindings include
-      arg :: t (bound at tcfail099.hs:9:12)
-      f :: a -> Int (bound at tcfail099.hs:9:9)
-      call :: DS -> t -> Int (bound at tcfail099.hs:9:1)
-    In the first argument of ‘f’, namely ‘arg’
-    In the expression: f arg
+\r
+tcfail099.hs:9:20:\r
+    Couldn't match expected type ‘a’ with actual type ‘t’\r
+      because type variable ‘a’ would escape its scope\r
+    This (rigid, skolem) type variable is bound by\r
+      a pattern with constructor: C :: forall a. (a -> Int) -> DS,\r
+      in an equation for ‘call’\r
+      at tcfail099.hs:9:7-9\r
+    Relevant bindings include\r
+      arg :: t (bound at tcfail099.hs:9:12)\r
+      f :: a -> Int (bound at tcfail099.hs:9:9)\r
+      call :: DS -> t -> Int (bound at tcfail099.hs:9:1)\r
+    In the first argument of ‘f’, namely ‘arg’\r
+    In the expression: f arg\r
index 01a8bba..f32dead 100644 (file)
@@ -1,13 +1,13 @@
-
-tcfail102.hs:1:14: Warning:
-    -XDatatypeContexts is deprecated: It was widely considered a misfeature, and has been removed from the Haskell language.
-
-tcfail102.hs:9:15:
-    Could not deduce (Integral (Ratio a)) arising from a use of ‘p’
-    from the context (Integral a)
-      bound by the type signature for
-                 f :: Integral a => P (Ratio a) -> P (Ratio a)
-      at tcfail102.hs:8:6-45
-    In the ‘p’ field of a record
-    In the expression: x {p = p x}
-    In an equation for ‘f’: f x = x {p = p x}
+\r
+tcfail102.hs:1:14: Warning:\r
+    -XDatatypeContexts is deprecated: It was widely considered a misfeature, and has been removed from the Haskell language.\r
+\r
+tcfail102.hs:9:15:\r
+    Could not deduce (Integral (Ratio a)) arising from a use of ‘p’\r
+    from the context (Integral a)\r
+      bound by the type signature for:\r
+               f :: Integral a => P (Ratio a) -> P (Ratio a)\r
+      at tcfail102.hs:8:6-45\r
+    In the ‘p’ field of a record\r
+    In the expression: x {p = p x}\r
+    In an equation for ‘f’: f x = x {p = p x}\r
index 1d71a6a..1b57893 100644 (file)
@@ -1,15 +1,15 @@
-
-tcfail103.hs:15:23:
-    Couldn't match type ‘t’ with ‘s’
-      ‘t’ is a rigid type variable bound by
-          the type signature for f :: ST t Int at tcfail103.hs:10:5
-      ‘s’ is a rigid type variable bound by
-          the type signature for g :: ST s Int at tcfail103.hs:13:14
-    Expected type: STRef s Int
-      Actual type: STRef t Int
-    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)
-    In the first argument of ‘readSTRef’, namely ‘v’
-    In the expression: readSTRef v
+\r
+tcfail103.hs:15:23:\r
+    Couldn't match type ‘t’ with ‘s’\r
+      ‘t’ is a rigid type variable bound by\r
+          the type signature for: f :: ST t Int at tcfail103.hs:10:5\r
+      ‘s’ is a rigid type variable bound by\r
+          the type signature for: g :: ST s Int at tcfail103.hs:13:14\r
+    Expected type: STRef s Int\r
+      Actual type: STRef t Int\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
+    In the first argument of ‘readSTRef’, namely ‘v’\r
+    In the expression: readSTRef v\r
index b3e0720..5d31a29 100644 (file)
@@ -1,11 +1,11 @@
-
-tcfail125.hs:1:14: Warning:
-    -XDatatypeContexts is deprecated: It was widely considered a misfeature, and has been removed from the Haskell language.
-
-tcfail125.hs:11:4:
-    No instance for (Show a) arising from a use of ‘LiftObs’
-    Possible fix:
-      add (Show a) to the context of
-        the type signature for f :: Obs a -> String
-    In the pattern: LiftObs _ _
-    In an equation for ‘f’: f (LiftObs _ _) = "yes"
+\r
+tcfail125.hs:1:14: Warning:\r
+    -XDatatypeContexts is deprecated: It was widely considered a misfeature, and has been removed from the Haskell language.\r
+\r
+tcfail125.hs:11:4:\r
+    No instance for (Show a) arising from a use of ‘LiftObs’\r
+    Possible fix:\r
+      add (Show a) to the context of\r
+        the type signature for: f :: Obs a -> String\r
+    In the pattern: LiftObs _ _\r
+    In an equation for ‘f’: f (LiftObs _ _) = "yes"\r
index f49a4b3..cb2bd64 100644 (file)
@@ -1,10 +1,10 @@
-
-tcfail131.hs:7:9:
-    Couldn't match expected type ‘b’ with actual type ‘Integer’
-      ‘b’ is a rigid type variable bound by
-          the type signature for g :: Num b => b -> b at tcfail131.hs:6:8
-    Relevant bindings include
-      x :: b (bound at tcfail131.hs:7:5)
-      g :: b -> b (bound at tcfail131.hs:7:3)
-    In the expression: f x x
-    In an equation for ‘g’: g x = f x x
+\r
+tcfail131.hs:7:9:\r
+    Couldn't match expected type ‘b’ with actual type ‘Integer’\r
+      ‘b’ is a rigid type variable bound by\r
+          the type signature for: g :: Num b => b -> b at tcfail131.hs:6:8\r
+    Relevant bindings include\r
+      x :: b (bound at tcfail131.hs:7:5)\r
+      g :: b -> b (bound at tcfail131.hs:7:3)\r
+    In the expression: f x x\r
+    In an equation for ‘g’: g x = f x x\r
index fecb2f3..3cde64a 100644 (file)
@@ -1,11 +1,11 @@
-
-tcfail142.hs:18:8:
-    Could not deduce (Bar a0 r)
-    from the context (Bar a r)
-      bound by the type signature for bar :: Bar a r => r -> ()
-      at tcfail142.hs:18:8-25
-    The type variable ‘a0’ is ambiguous
-    In the ambiguity check for the type signature for ‘bar’:
-      bar :: forall r a. Bar a r => r -> ()
-    To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
-    In the type signature for ‘bar’: bar :: Bar a r => r -> ()
+\r
+tcfail142.hs:18:8:\r
+    Could not deduce (Bar a0 r)\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 the type signature for ‘bar’:\r
+      bar :: forall r a. Bar a r => r -> ()\r
+    To defer the ambiguity check to use sites, enable AllowAmbiguousTypes\r
+    In the type signature for ‘bar’: bar :: Bar a r => r -> ()\r
index 80efb92..aafe8a2 100644 (file)
@@ -1,16 +1,16 @@
-
-tcfail153.hs:6:7:
-    Couldn't match type ‘a’ with ‘Bool’
-      ‘a’ is a rigid type variable bound by
-          the type signature for f :: a -> [a] at tcfail153.hs:5:6
-    Expected type: [a]
-      Actual type: [Bool]
-    Relevant bindings include
-      x :: a (bound at tcfail153.hs:6:3)
-      f :: a -> [a] (bound at tcfail153.hs:6:1)
-    In the expression: g x
-    In an equation for ‘f’:
-        f x
-          = g x
-          where
-              g y = if y then [] else [...]
+\r
+tcfail153.hs:6:7:\r
+    Couldn't match type ‘a’ with ‘Bool’\r
+      ‘a’ is a rigid type variable bound by\r
+          the type signature for: f :: a -> [a] at tcfail153.hs:5:6\r
+    Expected type: [a]\r
+      Actual type: [Bool]\r
+    Relevant bindings include\r
+      x :: a (bound at tcfail153.hs:6:3)\r
+      f :: a -> [a] (bound at tcfail153.hs:6:1)\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
index e20e1cf..e274c5d 100644 (file)
@@ -1,9 +1,8 @@
-
-tcfail167.hs:14:14:
-    Couldn't match type ‘Char’ with ‘Float’
-    Inaccessible code in
-      a pattern with constructor
-        C2 :: T Float,
-      in an equation for ‘inaccessible’
-    In the pattern: C2
-    In an equation for ‘inaccessible’: inaccessible C2 = ' '
+\r
+tcfail167.hs:14:14:\r
+    Couldn't match type ‘Char’ with ‘Float’\r
+    Inaccessible code in\r
+      a pattern with constructor: C2 :: T Float,\r
+      in an equation for ‘inaccessible’\r
+    In the pattern: C2\r
+    In an equation for ‘inaccessible’: inaccessible C2 = ' '\r
index d29f91e..9c7a786 100644 (file)
@@ -1,8 +1,8 @@
-
-tcfail171.hs:9:10:
-    No instance for (PrintfType b) arising from a use of ‘printf’
-    Possible fix:
-      add (PrintfType b) to the context of
-        the type signature for phex :: a -> b
-    In the expression: printf "0x%x" x
-    In an equation for ‘phex’: phex x = printf "0x%x" x
+\r
+tcfail171.hs:9:10:\r
+    No instance for (PrintfType b) arising from a use of ‘printf’\r
+    Possible fix:\r
+      add (PrintfType b) to the context of\r
+        the type signature for: phex :: a -> b\r
+    In the expression: printf "0x%x" x\r
+    In an equation for ‘phex’: phex x = printf "0x%x" x\r
index 577c36e..42aa7a9 100644 (file)
@@ -1,32 +1,32 @@
-
-tcfail174.hs:9:10:
-    Couldn't match expected type ‘forall a. a -> a’
-                with actual type ‘a0 -> a0’
-    In the first argument of ‘Base’, namely ‘id’
-    In the expression: Base id
-
-tcfail174.hs:13:14:
-    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 forall a2. a2 -> a2
-      at tcfail174.hs:13:1-14
-    Expected type: Capture (forall x. x -> a)
-      Actual type: Capture (forall a. a -> a)
-    Relevant bindings include
-      h1 :: Capture a (bound at tcfail174.hs:13:1)
-    In the first argument of ‘Capture’, namely ‘g’
-    In the expression: Capture g
-
-tcfail174.hs:16:14:
-    Couldn't match type ‘a’ with ‘b’
-      ‘a’ is a rigid type variable bound by
-          the type forall a1. a1 -> a1 at tcfail174.hs:1:1
-      ‘b’ is a rigid type variable bound by
-          the type signature for h2 :: Capture b at tcfail174.hs:15:7
-    Expected type: Capture (forall x. x -> b)
-      Actual type: Capture (forall a. a -> a)
-    Relevant bindings include
-      h2 :: Capture b (bound at tcfail174.hs:16:1)
-    In the first argument of ‘Capture’, namely ‘g’
-    In the expression: Capture g
+\r
+tcfail174.hs:9:10:\r
+    Couldn't match expected type ‘forall a. a -> a’\r
+                with actual type ‘a0 -> a0’\r
+    In the first argument of ‘Base’, namely ‘id’\r
+    In the expression: Base id\r
+\r
+tcfail174.hs:13:14:\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 forall a2. a2 -> a2\r
+      at tcfail174.hs:13:1-14\r
+    Expected type: Capture (forall x. x -> a)\r
+      Actual type: Capture (forall a. a -> a)\r
+    Relevant bindings include\r
+      h1 :: Capture a (bound at tcfail174.hs:13:1)\r
+    In the first argument of ‘Capture’, namely ‘g’\r
+    In the expression: Capture g\r
+\r
+tcfail174.hs:16:14:\r
+    Couldn't match type ‘a’ with ‘b’\r
+      ‘a’ is a rigid type variable bound by\r
+          the type forall a1. a1 -> a1 at tcfail174.hs:1:1\r
+      ‘b’ is a rigid type variable bound by\r
+          the type signature for: h2 :: Capture b at tcfail174.hs:15:7\r
+    Expected type: Capture (forall x. x -> b)\r
+      Actual type: Capture (forall a. a -> a)\r
+    Relevant bindings include\r
+      h2 :: Capture b (bound at tcfail174.hs:16:1)\r
+    In the first argument of ‘Capture’, namely ‘g’\r
+    In the expression: Capture g\r
index 623aab2..8689fd1 100644 (file)
@@ -1,10 +1,10 @@
-
-tcfail175.hs:11:1:
-    Couldn't match expected type ‘String -> String -> String’
-                with actual type ‘a’
-      ‘a’ is a rigid type variable bound by
-          the type signature for evalRHS :: Int -> a at tcfail175.hs:10:12
-    Relevant bindings include
-      evalRHS :: Int -> a (bound at tcfail175.hs:11:1)
-    The equation(s) for ‘evalRHS’ have three arguments,
-    but its type ‘Int -> a’ has only one
+\r
+tcfail175.hs:11:1:\r
+    Couldn't match expected type ‘String -> String -> String’\r
+                with actual type ‘a’\r
+      ‘a’ is a rigid type variable bound by\r
+          the type signature for: evalRHS :: Int -> a at tcfail175.hs:10:12\r
+    Relevant bindings include\r
+      evalRHS :: Int -> a (bound at tcfail175.hs:11:1)\r
+    The equation(s) for ‘evalRHS’ have three arguments,\r
+    but its type ‘Int -> a’ has only one\r
index 0fdaead..51c66e1 100644 (file)
@@ -1,17 +1,17 @@
-
-tcfail179.hs:14:39:
-    Couldn't match expected type ‘s’ with actual type ‘x’
-      ‘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
-      ‘s’ is a rigid type variable bound by
-          the type signature for run :: T s -> Int at tcfail179.hs:12:8
-    Relevant bindings include
-      x :: x (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)
-    In the first argument of ‘g’, namely ‘x’
-    In the expression: g x id
+\r
+tcfail179.hs:14:39:\r
+    Couldn't match expected type ‘s’ with actual type ‘x’\r
+      ‘x’ is a rigid type variable bound by\r
+          a pattern with constructor:\r
+            T :: forall s x. (s -> (x -> s) -> (x, s, Int)) -> T s,\r
+          in a case alternative\r
+          at tcfail179.hs:14:14\r
+      ‘s’ is a rigid type variable bound by\r
+          the type signature for: run :: T s -> Int at tcfail179.hs:12:8\r
+    Relevant bindings include\r
+      x :: x (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
+    In the first argument of ‘g’, namely ‘x’\r
+    In the expression: g x id\r
index 1270315..1414cea 100644 (file)
@@ -1,20 +1,20 @@
-\r
-tcfail201.hs:18:28:\r
-    Couldn't match expected type ‘a’ with actual type ‘HsDoc id1’\r
-      ‘a’ is a rigid type variable bound by\r
-          the type signature for\r
-            gfoldl' :: (forall a1 b. c (a1 -> b) -> a1 -> c b)\r
-                       -> (forall g. g -> c g) -> a -> c a\r
-          at tcfail201.hs:15:12\r
-    Relevant bindings include\r
-      hsDoc :: a (bound at tcfail201.hs:16:13)\r
-      gfoldl' :: (forall a1 b. c (a1 -> b) -> a1 -> c b)\r
-                 -> (forall g. g -> c g) -> a -> c a\r
-        (bound at tcfail201.hs:16:1)\r
-    In the pattern: DocParagraph hsDoc\r
-    In a case alternative:\r
-        (DocParagraph hsDoc) -> z DocParagraph `k` hsDoc\r
-    In the expression:\r
-      case hsDoc of {\r
-        DocEmpty -> z DocEmpty\r
-        (DocParagraph hsDoc) -> z DocParagraph `k` hsDoc }\r
+
+tcfail201.hs:18:28:
+    Couldn't match expected type ‘a’ with actual type ‘HsDoc id1’
+      ‘a’ is a rigid type variable bound by
+          the type signature for:
+            gfoldl' :: (forall a1 b. c (a1 -> b) -> a1 -> c b)
+                       -> (forall g. g -> c g) -> a -> c a
+          at tcfail201.hs:15:12
+    Relevant bindings include
+      hsDoc :: a (bound at tcfail201.hs:16:13)
+      gfoldl' :: (forall a1 b. c (a1 -> b) -> a1 -> c b)
+                 -> (forall g. g -> c g) -> a -> c a
+        (bound at tcfail201.hs:16:1)
+    In the pattern: DocParagraph hsDoc
+    In a case alternative:
+        (DocParagraph hsDoc) -> z DocParagraph `k` hsDoc
+    In the expression:
+      case hsDoc of {
+        DocEmpty -> z DocEmpty
+        (DocParagraph hsDoc) -> z DocParagraph `k` hsDoc }
index 3eec708..bd3d90d 100644 (file)
@@ -16,7 +16,7 @@ tcfail206.hs:8:5:
 tcfail206.hs:11:5:\r
     Couldn't match type ‘a’ with ‘Bool’\r
       ‘a’ is a rigid type variable bound by\r
 tcfail206.hs:11:5:\r
     Couldn't match type ‘a’ with ‘Bool’\r
       ‘a’ is a rigid type variable bound by\r
-          the type signature for c :: a -> (a, Bool) at tcfail206.hs:10:6\r
+          the type signature for: c :: a -> (a, Bool) at tcfail206.hs:10:6\r
     Expected type: a -> (a, Bool)\r
       Actual type: a -> (a, a)\r
     Relevant bindings include\r
     Expected type: a -> (a, Bool)\r
       Actual type: a -> (a, a)\r
     Relevant bindings include\r
@@ -42,7 +42,7 @@ tcfail206.hs:17:5:
 tcfail206.hs:20:5:\r
     Couldn't match type ‘a’ with ‘Bool’\r
       ‘a’ is a rigid type variable bound by\r
 tcfail206.hs:20:5:\r
     Couldn't match type ‘a’ with ‘Bool’\r
       ‘a’ is a rigid type variable bound by\r
-          the type signature for f :: a -> (# a, Bool #) at tcfail206.hs:19:6\r
+          the type signature for: f :: a -> (# a, Bool #) at tcfail206.hs:19:6\r
     Expected type: a -> (# a, Bool #)\r
       Actual type: a -> (# a, a #)\r
     Relevant bindings include\r
     Expected type: a -> (# a, Bool #)\r
       Actual type: a -> (# a, a #)\r
     Relevant bindings include\r
index c83c63b..ec3f4c6 100644 (file)
@@ -1,9 +1,9 @@
-
-tcfail208.hs:4:19:
-    Could not deduce (Eq (m a)) arising from a use of ‘==’
-    from the context (Monad m, Eq a)
-      bound by the type signature for
-                 f :: (Monad m, Eq a) => a -> m a -> Bool
-      at tcfail208.hs:3:6-40
-    In the expression: (return x == y)
-    In an equation for ‘f’: f x y = (return x == y)
+\r
+tcfail208.hs:4:19:\r
+    Could not deduce (Eq (m a)) arising from a use of ‘==’\r
+    from the context (Monad m, Eq a)\r
+      bound by the type signature for:\r
+               f :: (Monad m, Eq a) => a -> m a -> Bool\r
+      at tcfail208.hs:3:6-40\r
+    In the expression: (return x == y)\r
+    In an equation for ‘f’: f x y = (return x == y)\r