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
-            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
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 (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
@@ -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")
 
+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
-                 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)
@@ -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
-                 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: () -> ()
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
-            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
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
-      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
-      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
-      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
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
-      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
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
-          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)
@@ -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
-          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
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
-      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))
-      (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
@@ -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
-          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)
@@ -82,7 +81,7 @@
 ../../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
@@ -98,7 +97,7 @@
 ../../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’
     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
 *** 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)
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
-      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)
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)
-        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
-          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
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)
-      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)
@@ -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)
-      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
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
-          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
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
-          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)
@@ -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
-           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)
@@ -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
-           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
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
-      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
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)
-      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
-          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))
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
-          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)
@@ -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
-          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)
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
-          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
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
-      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)
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
-          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
-          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)
@@ -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
-          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
-          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)
@@ -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
-          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
-          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)
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
-      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)
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 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
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)
-      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:
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
-          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
@@ -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
-          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
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