Improve the error messages for class instance errors
authorSimon Peyton Jones <simonpj@microsoft.com>
Wed, 2 Sep 2015 12:05:36 +0000 (14:05 +0200)
committerBen Gamari <bgamari.foss@gmail.com>
Wed, 2 Sep 2015 13:11:51 +0000 (09:11 -0400)
Summary: See Note [Displaying potential instances].

Reviewers: austin

Subscribers: KaneTW, thomie

Differential Revision: https://phabricator.haskell.org/D1176

25 files changed:
compiler/main/DynFlags.hs
compiler/typecheck/TcErrors.hs
docs/users_guide/flags.xml
docs/users_guide/using.xml
testsuite/tests/annotations/should_fail/annfail10.stderr
testsuite/tests/ghci.debugger/scripts/break006.stderr
testsuite/tests/ghci.debugger/scripts/print019.stderr
testsuite/tests/ghci/scripts/Defer02.stderr
testsuite/tests/indexed-types/should_fail/T4485.stderr
testsuite/tests/overloadedlists/should_fail/overloadedlistsfail01.stderr
testsuite/tests/quotes/TH_localname.stderr
testsuite/tests/rebindable/rebindable6.stderr
testsuite/tests/rename/should_fail/mc14.stderr
testsuite/tests/typecheck/should_compile/holes2.stderr
testsuite/tests/typecheck/should_fail/T4921.stderr
testsuite/tests/typecheck/should_fail/T5095.stderr
testsuite/tests/typecheck/should_fail/T5858.stderr
testsuite/tests/typecheck/should_fail/T7857.stderr
testsuite/tests/typecheck/should_fail/tcfail008.stderr
testsuite/tests/typecheck/should_fail/tcfail040.stderr
testsuite/tests/typecheck/should_fail/tcfail043.stderr
testsuite/tests/typecheck/should_fail/tcfail072.stderr
testsuite/tests/typecheck/should_fail/tcfail128.stderr
testsuite/tests/typecheck/should_fail/tcfail133.stderr
testsuite/tests/typecheck/should_fail/tcfail181.stderr

index 0423e78..0dacb0c 100644 (file)
@@ -338,6 +338,7 @@ data GeneralFlag
    | Opt_PrintExplicitKinds
    | Opt_PrintUnicodeSyntax
    | Opt_PrintExpandedSynonyms
+   | Opt_PrintPotentialInstances
 
    -- optimisation opts
    | Opt_CallArity
@@ -3014,6 +3015,7 @@ fFlags = [
   flagSpec "print-explicit-kinds"             Opt_PrintExplicitKinds,
   flagSpec "print-unicode-syntax"             Opt_PrintUnicodeSyntax,
   flagSpec "print-expanded-synonyms"          Opt_PrintExpandedSynonyms,
+  flagSpec "print-potential-instances"        Opt_PrintPotentialInstances,
   flagSpec "prof-cafs"                        Opt_AutoSccsOnIndividualCafs,
   flagSpec "prof-count-entries"               Opt_ProfCountEntries,
   flagSpec "regs-graph"                       Opt_RegsGraph,
index 9694305..f91968d 100644 (file)
@@ -33,6 +33,7 @@ import Id
 import Var
 import VarSet
 import VarEnv
+import NameSet
 import Bag
 import ErrUtils         ( ErrMsg, pprLocErrMsg )
 import BasicTypes
@@ -1530,10 +1531,9 @@ mk_dict_err ctxt (ct, (matches, unifiers, unsafe_overlapped))
 
     potential_msg
       = ppWhen (not (null unifiers) && want_potential orig) $
-        hang (if isSingleton unifiers
-              then ptext (sLit "Note: there is a potential instance available:")
-              else ptext (sLit "Note: there are several potential instances:"))
-           2 (ppr_insts (sortBy fuzzyClsInstCmp unifiers))
+        sdocWithDynFlags $ \dflags ->
+        getPprStyle $ \sty ->
+        pprPotentials dflags sty (ptext (sLit "Potential instances:")) unifiers
 
     -- Report "potential instances" only when the constraint arises
     -- directly from the user's use of an overloaded function
@@ -1587,8 +1587,10 @@ mk_dict_err ctxt (ct, (matches, unifiers, unsafe_overlapped))
                   sep [ptext (sLit "Matching givens (or their superclasses):")
                       , nest 2 (vcat matching_givens)]
 
-             ,  sep [ptext (sLit "Matching instances:"),
-                     nest 2 (vcat [pprInstances ispecs, pprInstances unifiers])]
+             ,  sdocWithDynFlags $ \dflags ->
+                getPprStyle $ \sty ->
+                pprPotentials dflags sty (ptext (sLit "Matching instances:")) $
+                ispecs ++ unifiers
 
              ,  ppWhen (null matching_givens && isSingleton matches && null unifiers) $
                 -- Intuitively, some given matched the wanted in their
@@ -1670,17 +1672,86 @@ show_fixes []     = empty
 show_fixes (f:fs) = sep [ ptext (sLit "Possible fix:")
                         , nest 2 (vcat (f : map (ptext (sLit "or") <+>) fs))]
 
-ppr_insts :: [ClsInst] -> SDoc
-ppr_insts insts
-  = pprInstances (take 3 insts) $$ dot_dot_message
+pprPotentials :: DynFlags -> PprStyle -> SDoc -> [ClsInst] -> SDoc
+-- See Note [Displaying potential instances]
+pprPotentials dflags sty herald insts
+  | null insts
+  = empty
+
+  | null show_these
+  = hang herald
+       2 (vcat [ not_in_scope_msg empty
+               , flag_hint ])
+
+  | otherwise
+  = hang herald
+       2 (vcat [ pprInstances show_these
+               , ppWhen (n_in_scope_hidden > 0) $
+                 ptext (sLit "...plus")
+                   <+> speakNOf n_in_scope_hidden (ptext (sLit "other"))
+               , not_in_scope_msg (ptext (sLit "...plus"))
+               , flag_hint ])
   where
-    n_extra = length insts - 3
-    dot_dot_message
-       | n_extra <= 0 = empty
-       | otherwise    = ptext (sLit "...plus")
-                        <+> speakNOf n_extra (ptext (sLit "other"))
+    n_show = 3 :: Int
+    show_potentials = gopt Opt_PrintPotentialInstances dflags
+
+    (in_scope, not_in_scope) = partition inst_in_scope insts
+    sorted = sortBy fuzzyClsInstCmp in_scope
+    show_these | show_potentials = sorted
+               | otherwise       = take n_show sorted
+    n_in_scope_hidden = length sorted - length show_these
+
+       -- "in scope" means that all the type constructors
+       -- are lexically in scope; these instances are likely
+       -- to be more useful
+    inst_in_scope :: ClsInst -> Bool
+    inst_in_scope cls_inst = foldNameSet ((&&) . name_in_scope) True $
+                             orphNamesOfTypes (is_tys cls_inst)
+
+    name_in_scope name
+      | isBuiltInSyntax name
+      = True -- E.g. (->)
+      | Just mod <- nameModule_maybe name
+      = qual_in_scope (qualName sty mod (nameOccName name))
+      | otherwise
+      = True
+
+    qual_in_scope :: QualifyName -> Bool
+    qual_in_scope NameUnqual    = True
+    qual_in_scope (NameQual {}) = True
+    qual_in_scope _             = False
+
+    not_in_scope_msg herald
+      | null not_in_scope
+      = empty
+      | otherwise
+      = hang (herald <+> speakNOf (length not_in_scope)
+                                  (ptext (sLit "instance involving out-of-scope types")))
+           2 (ppWhen show_potentials (pprInstances not_in_scope))
+
+    flag_hint = ppUnless (show_potentials || length show_these == length insts) $
+                ptext (sLit "(use -fprint-potential-instances to see them all)")
+
+{- Note [Displaying potential instances]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+When showing a list of instances for
+  - overlapping instances (show ones that match)
+  - no such instance (show ones that could match)
+we want to give it a bit of structure.  Here's the plan
+
+* Say that an instance is "in scope" if all of the
+  type constructors it mentions are lexically in scope.
+  These are the ones most likely to be useful to the programmer.
+
+* Show at most n_show in-scope instances,
+  and summarise the rest ("plus 3 others")
+
+* Summarise the not-in-scope instances ("plus 4 not in scope")
+
+* Add the flag -fshow-potential-instances which replaces the
+  summary with the full list
+-}
 
-----------------------
 quickFlattenTy :: TcType -> TcM TcType
 -- See Note [Flattening in error message generation]
 quickFlattenTy ty | Just ty' <- tcView ty = quickFlattenTy ty'
@@ -1705,9 +1776,8 @@ quickFlattenTy (TyConApp tc tys)
          ; flat_resttys <- mapM quickFlattenTy resttys
          ; return (foldl AppTy (mkTyVarTy v) flat_resttys) }
 
-{-
-Note [Flattening in error message generation]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+{- Note [Flattening in error message generation]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Consider (C (Maybe (F x))), where F is a type function, and we have
 instances
                 C (Maybe Int) and C (Maybe a)
index 0683752..24917af 100644 (file)
             <entry>-</entry>
           </row>
           <row>
+            <entry><option>-fprint-potential-instances</option></entry>
+            <entry>display all available instances in type error messages</entry>
+            <entry>dynamic</entry>
+            <entry>-fno-print-potential-instances</entry>
+          </row>
+          <row>
             <entry><option>-fprint-explicit-foralls</option></entry>
             <entry>Print explicit <literal>forall</literal> quantification in types. See also <option>-XExplicitForAll</option></entry>
             <entry>dynamic</entry>
index 502f7a3..71d3467 100644 (file)
@@ -894,6 +894,16 @@ ghc -c Foo.hs
         </listitem>
       </varlistentry>
 
+      <varlistentry>
+        <term><option>--fprint-potential-instances</option>
+          <indexterm><primary><option>-fprint-potential-instances</option></primary></indexterm>
+        </term>
+        <listitem>
+          <para>When GHC can't find an instance for a class, it displays a short list of some
+                in the instances it knows about.  With this flag it prints <emphasis>all</emphasis>
+                the instances it knows about.
+          </para></listitem>
+      </varlistentry>
 
       <varlistentry>
         <term><option>-fprint-explicit-foralls, -fprint-explicit-kinds, -fprint-unicode-syntax</option>
index 5ac8ab5..a823670 100644 (file)
@@ -1,25 +1,27 @@
-\r
-annfail10.hs:9:1:\r
-    No instance for (Data a0) arising from an annotation\r
-    The type variable ‘a0’ is ambiguous\r
-    Note: there are several potential instances:\r
-      instance (Data a, Data b) => Data (Either a b)\r
-        -- Defined in ‘Data.Data’\r
-      instance Data All -- Defined in ‘Data.Data’\r
-      instance (Data (f a), Data a, Typeable f) => Data (Alt f a)\r
-        -- Defined in ‘Data.Data’\r
-      ...plus 39 others\r
-    In the annotation: {-# ANN f 1 #-}\r
-\r
-annfail10.hs:9:11:\r
-    No instance for (Num a0) arising from the literal ‘1’\r
-    The type variable ‘a0’ is ambiguous\r
-    Note: there are several potential instances:\r
-      instance forall (k :: BOX) (f :: k -> *) (a :: k).\r
-               Num (f a) =>\r
-               Num (Alt f a)\r
-        -- Defined in ‘Data.Monoid’\r
-      instance Num a => Num (Product a) -- Defined in ‘Data.Monoid’\r
-      instance Num a => Num (Sum a) -- Defined in ‘Data.Monoid’\r
-      ...plus 14 others\r
-    In the annotation: {-# ANN f 1 #-}\r
+
+annfail10.hs:9:1: error:
+    No instance for (Data a0) arising from an annotation
+    The type variable ‘a0’ is ambiguous
+    Potential instances:
+      instance (Data a, Data b) => Data (Either a b)
+        -- Defined in ‘Data.Data’
+      instance Data All -- Defined in ‘Data.Data’
+      instance (Data (f a), Data a, Typeable f) => Data (Alt f a)
+        -- Defined in ‘Data.Data’
+      ...plus 39 others
+      (use -fprint-potential-instances to see them all)
+    In the annotation: {-# ANN f 1 #-}
+
+annfail10.hs:9:11: error:
+    No instance for (Num a0) arising from the literal ‘1’
+    The type variable ‘a0’ is ambiguous
+    Potential instances:
+      instance forall (k :: BOX) (f :: k -> *) (a :: k).
+               Num (f a) =>
+               Num (Alt f a)
+        -- Defined in ‘Data.Monoid’
+      instance Num a => Num (Product a) -- Defined in ‘Data.Monoid’
+      instance Num a => Num (Sum a) -- Defined in ‘Data.Monoid’
+      ...plus 14 others
+      (use -fprint-potential-instances to see them all)
+    In the annotation: {-# ANN f 1 #-}
index 9822dd7..bf96e55 100644 (file)
@@ -1,32 +1,34 @@
-\r
-<interactive>:5:1:\r
-    No instance for (Show t1) arising from a use of ‘print’\r
-    Cannot resolve unknown runtime type ‘t1’\r
-    Use :print or :force to determine these types\r
-    Relevant bindings include it :: t1 (bound at <interactive>:5:1)\r
-    Note: there are several potential instances:\r
-      instance (Show a, Show b) => Show (Either a b)\r
-        -- Defined in ‘Data.Either’\r
-      instance Show All -- Defined in ‘Data.Monoid’\r
-      instance forall (k :: BOX) (f :: k -> *) (a :: k).\r
-               Show (f a) =>\r
-               Show (Alt f a)\r
-        -- Defined in ‘Data.Monoid’\r
-      ...plus 33 others\r
-    In a stmt of an interactive GHCi command: print it\r
-\r
-<interactive>:7:1:\r
-    No instance for (Show t1) arising from a use of ‘print’\r
-    Cannot resolve unknown runtime type ‘t1’\r
-    Use :print or :force to determine these types\r
-    Relevant bindings include it :: t1 (bound at <interactive>:7:1)\r
-    Note: there are several potential instances:\r
-      instance (Show a, Show b) => Show (Either a b)\r
-        -- Defined in ‘Data.Either’\r
-      instance Show All -- Defined in ‘Data.Monoid’\r
-      instance forall (k :: BOX) (f :: k -> *) (a :: k).\r
-               Show (f a) =>\r
-               Show (Alt f a)\r
-        -- Defined in ‘Data.Monoid’\r
-      ...plus 33 others\r
-    In a stmt of an interactive GHCi command: print it\r
+
+<interactive>:5:1: error:
+    No instance for (Show t1) arising from a use of ‘print’
+    Cannot resolve unknown runtime type ‘t1’
+    Use :print or :force to determine these types
+    Relevant bindings include it :: t1 (bound at <interactive>:5:1)
+    Potential instances:
+      instance (Show a, Show b) => Show (Either a b)
+        -- Defined in ‘Data.Either’
+      instance Show All -- Defined in ‘Data.Monoid’
+      instance forall (k :: BOX) (f :: k -> *) (a :: k).
+               Show (f a) =>
+               Show (Alt f a)
+        -- Defined in ‘Data.Monoid’
+      ...plus 33 others
+      (use -fprint-potential-instances to see them all)
+    In a stmt of an interactive GHCi command: print it
+
+<interactive>:7:1: error:
+    No instance for (Show t1) arising from a use of ‘print’
+    Cannot resolve unknown runtime type ‘t1’
+    Use :print or :force to determine these types
+    Relevant bindings include it :: t1 (bound at <interactive>:7:1)
+    Potential instances:
+      instance (Show a, Show b) => Show (Either a b)
+        -- Defined in ‘Data.Either’
+      instance Show All -- Defined in ‘Data.Monoid’
+      instance forall (k :: BOX) (f :: k -> *) (a :: k).
+               Show (f a) =>
+               Show (Alt f a)
+        -- Defined in ‘Data.Monoid’
+      ...plus 33 others
+      (use -fprint-potential-instances to see them all)
+    In a stmt of an interactive GHCi command: print it
index 15c9f83..39bc29f 100644 (file)
@@ -1,12 +1,13 @@
 
-<interactive>:10:1:
+<interactive>:10:1: error:
     No instance for (Show a1) arising from a use of ‘print’
     Cannot resolve unknown runtime type ‘a1’
     Use :print or :force to determine these types
     Relevant bindings include it :: a1 (bound at <interactive>:10:1)
-    Note: there are several potential instances:
+    Potential instances:
       instance Show TyCon -- Defined in ‘Data.Typeable.Internal’
       instance Show TypeRep -- Defined in ‘Data.Typeable.Internal’
       instance Show a => Show (Maybe a) -- Defined in ‘GHC.Show’
       ...plus 30 others
+      (use -fprint-potential-instances to see them all)
     In a stmt of an interactive GHCi command: print it
index cc5ae21..b2a5efe 100644 (file)
-\r
-..\..\typecheck\should_run\Defer01.hs:11:40: warning:\r
-    Couldn't match type ‘Char’ with ‘[Char]’\r
-    Expected type: String\r
-      Actual type: Char\r
-    In the first argument of ‘putStr’, namely ‘','’\r
-    In the second argument of ‘(>>)’, namely ‘putStr ','’\r
-    In the expression: putStr "Hello World" >> putStr ','\r
-\r
-..\..\typecheck\should_run\Defer01.hs:14:5: warning:\r
-    Couldn't match expected type ‘Int’ with actual type ‘Char’\r
-    In the expression: 'p'\r
-    In an equation for ‘a’: a = 'p'\r
-\r
-..\..\typecheck\should_run\Defer01.hs:18:9: warning:\r
-    No instance for (Eq B) arising from a use of ‘==’\r
-    In the expression: x == x\r
-    In an equation for ‘b’: b x = x == x\r
-\r
-..\..\typecheck\should_run\Defer01.hs:25:4: warning:\r
-    Couldn't match type ‘Int’ with ‘Bool’\r
-    Inaccessible code in\r
-      a pattern with constructor: C2 :: Bool -> C Bool,\r
-      in an equation for ‘c’\r
-    In the pattern: C2 x\r
-    In an equation for ‘c’: c (C2 x) = True\r
-\r
-..\..\typecheck\should_run\Defer01.hs:28:5: warning:\r
-    No instance for (Num (a -> a)) arising from the literal ‘1’\r
-      (maybe you haven't applied a function to enough arguments?)\r
-    In the expression: 1\r
-    In an equation for ‘d’: d = 1\r
-\r
-..\..\typecheck\should_run\Defer01.hs:31:5: warning:\r
-    Couldn't match expected type ‘Char -> t’ with actual type ‘Char’\r
-    Relevant bindings include\r
-      f :: t (bound at ..\..\typecheck\should_run\Defer01.hs:31:1)\r
-    The function ‘e’ is applied to one argument,\r
-    but its type ‘Char’ has none\r
-    In the expression: e 'q'\r
-    In an equation for ‘f’: f = e 'q'\r
-\r
-..\..\typecheck\should_run\Defer01.hs:34:8: warning:\r
-    Couldn't match expected type ‘Char’ with actual type ‘a’\r
-    ‘a’ is a rigid type variable bound by\r
-        the type signature for:\r
-          h :: a -> (Char, Char)\r
-        at ..\..\typecheck\should_run\Defer01.hs:33:6\r
-    Relevant bindings include\r
-      x :: a (bound at ..\..\typecheck\should_run\Defer01.hs:34:3)\r
-      h :: a -> (Char, Char)\r
-        (bound at ..\..\typecheck\should_run\Defer01.hs:34:1)\r
-    In the expression: x\r
-    In the expression: (x, 'c')\r
-\r
-..\..\typecheck\should_run\Defer01.hs:39:17: warning:\r
-    Couldn't match expected type ‘Bool’ with actual type ‘T a’\r
-    Relevant bindings include\r
-      a :: a (bound at ..\..\typecheck\should_run\Defer01.hs:39:3)\r
-      i :: a -> () (bound at ..\..\typecheck\should_run\Defer01.hs:39:1)\r
-    In the first argument of ‘not’, namely ‘(K a)’\r
-    In the expression: (not (K a))\r
-\r
-..\..\typecheck\should_run\Defer01.hs:43:5: warning:\r
-    No instance for (MyClass a1) arising from a use of ‘myOp’\r
-    In the expression: myOp 23\r
-    In an equation for ‘j’: j = myOp 23\r
-\r
-..\..\typecheck\should_run\Defer01.hs:43:10: warning:\r
-    No instance for (Num a1) arising from the literal ‘23’\r
-    The type variable ‘a1’ is ambiguous\r
-    Note: there are several potential instances:\r
-      instance Num Integer -- Defined in ‘GHC.Num’\r
-      instance Num Double -- Defined in ‘GHC.Float’\r
-      instance Num Float -- Defined in ‘GHC.Float’\r
-      ...plus two others\r
-    In the first argument of ‘myOp’, namely ‘23’\r
-    In the expression: myOp 23\r
-    In an equation for ‘j’: j = myOp 23\r
-\r
-..\..\typecheck\should_run\Defer01.hs:45:6: warning:\r
-    Couldn't match type ‘Int’ with ‘Bool’\r
-    Inaccessible code in\r
-      the type signature for:\r
-        k :: (Int ~ Bool) => Int -> Bool\r
-    In the ambiguity check for the type signature for ‘k’:\r
-      k :: (Int ~ Bool) => Int -> Bool\r
-    To defer the ambiguity check to use sites, enable AllowAmbiguousTypes\r
-    In the type signature for ‘k’: k :: (Int ~ Bool) => Int -> Bool\r
-\r
-..\..\typecheck\should_run\Defer01.hs:45:6: warning:\r
-    Couldn't match expected type ‘Bool’ with actual type ‘Int’\r
-    In the ambiguity check for the type signature for ‘k’:\r
-      k :: (Int ~ Bool) => Int -> Bool\r
-    To defer the ambiguity check to use sites, enable AllowAmbiguousTypes\r
-    In the type signature for ‘k’: k :: (Int ~ Bool) => Int -> Bool\r
-\r
-..\..\typecheck\should_run\Defer01.hs:45:6: warning:\r
-    Couldn't match type ‘Int’ with ‘Bool’\r
-    Inaccessible code in\r
-      the type signature for:\r
-        k :: (Int ~ Bool) => Int -> Bool\r
-\r
-..\..\typecheck\should_run\Defer01.hs:46:7: warning:\r
-    Couldn't match expected type ‘Bool’ with actual type ‘Int’\r
-    In the expression: x\r
-    In an equation for ‘k’: k x = x\r
-\r
-..\..\typecheck\should_run\Defer01.hs:49:5: warning:\r
-    Couldn't match expected type ‘IO a0’\r
-                with actual type ‘Char -> IO ()’\r
-    Probable cause: ‘putChar’ is applied to too few arguments\r
-    In the first argument of ‘(>>)’, namely ‘putChar’\r
-    In the expression: putChar >> putChar 'p'\r
-*** Exception: ..\..\typecheck\should_run\Defer01.hs:11:40: error:\r
-    Couldn't match type ‘Char’ with ‘[Char]’\r
-    Expected type: String\r
-      Actual type: Char\r
-    In the first argument of ‘putStr’, namely ‘','’\r
-    In the second argument of ‘(>>)’, namely ‘putStr ','’\r
-    In the expression: putStr "Hello World" >> putStr ','\r
-(deferred type error)\r
-*** Exception: ..\..\typecheck\should_run\Defer01.hs:14:5: error:\r
-    Couldn't match expected type ‘Int’ with actual type ‘Char’\r
-    In the expression: 'p'\r
-    In an equation for ‘a’: a = 'p'\r
-(deferred type error)\r
-*** Exception: ..\..\typecheck\should_run\Defer01.hs:18:9: error:\r
-    No instance for (Eq B) arising from a use of ‘==’\r
-    In the expression: x == x\r
-    In an equation for ‘b’: b x = x == x\r
-(deferred type error)\r
-\r
-<interactive>:7:11: error:\r
-    Couldn't match type ‘Bool’ with ‘Int’\r
-    Expected type: C Int\r
-      Actual type: C Bool\r
-    In the first argument of ‘c’, namely ‘(C2 True)’\r
-    In the first argument of ‘print’, namely ‘(c (C2 True))’\r
-*** Exception: ..\..\typecheck\should_run\Defer01.hs:28:5: error:\r
-    No instance for (Num (a -> a)) arising from the literal ‘1’\r
-      (maybe you haven't applied a function to enough arguments?)\r
-    In the expression: 1\r
-    In an equation for ‘d’: d = 1\r
-(deferred type error)\r
-*** Exception: ..\..\typecheck\should_run\Defer01.hs:31:5: error:\r
-    Couldn't match expected type ‘Char -> t’ with actual type ‘Char’\r
-    Relevant bindings include\r
-      f :: t (bound at ..\..\typecheck\should_run\Defer01.hs:31:1)\r
-    The function ‘e’ is applied to one argument,\r
-    but its type ‘Char’ has none\r
-    In the expression: e 'q'\r
-    In an equation for ‘f’: f = e 'q'\r
-(deferred type error)\r
-*** Exception: ..\..\typecheck\should_run\Defer01.hs:34:8: error:\r
-    Couldn't match expected type ‘Char’ with actual type ‘a’\r
-    ‘a’ is a rigid type variable bound by\r
-        the type signature for:\r
-          h :: a -> (Char, Char)\r
-        at ..\..\typecheck\should_run\Defer01.hs:33:6\r
-    Relevant bindings include\r
-      x :: a (bound at ..\..\typecheck\should_run\Defer01.hs:34:3)\r
-      h :: a -> (Char, Char)\r
-        (bound at ..\..\typecheck\should_run\Defer01.hs:34:1)\r
-    In the expression: x\r
-    In the expression: (x, 'c')\r
-(deferred type error)\r
-*** Exception: ..\..\typecheck\should_run\Defer01.hs:39:17: error:\r
-    Couldn't match expected type ‘Bool’ with actual type ‘T a’\r
-    Relevant bindings include\r
-      a :: a (bound at ..\..\typecheck\should_run\Defer01.hs:39:3)\r
-      i :: a -> () (bound at ..\..\typecheck\should_run\Defer01.hs:39:1)\r
-    In the first argument of ‘not’, namely ‘(K a)’\r
-    In the expression: (not (K a))\r
-(deferred type error)\r
-*** Exception: ..\..\typecheck\should_run\Defer01.hs:43:5: error:\r
-    No instance for (MyClass a1) arising from a use of ‘myOp’\r
-    In the expression: myOp 23\r
-    In an equation for ‘j’: j = myOp 23\r
-(deferred type error)\r
-\r
-<interactive>:13:8: error:\r
-    Couldn't match expected type ‘Bool’ with actual type ‘Int’\r
-    In the first argument of ‘print’, namely ‘(k 2)’\r
-    In the expression: print (k 2)\r
-    In an equation for ‘it’: it = print (k 2)\r
-*** Exception: ..\..\typecheck\should_run\Defer01.hs:49:5: error:\r
-    Couldn't match expected type ‘IO a0’\r
-                with actual type ‘Char -> IO ()’\r
-    Probable cause: ‘putChar’ is applied to too few arguments\r
-    In the first argument of ‘(>>)’, namely ‘putChar’\r
-    In the expression: putChar >> putChar 'p'\r
-(deferred type error)\r
+
+../../typecheck/should_run/Defer01.hs:11:40: warning:
+    Couldn't match type ‘Char’ with ‘[Char]’
+    Expected type: String
+      Actual type: Char
+    In the first argument of ‘putStr’, namely ‘','’
+    In the second argument of ‘(>>)’, namely ‘putStr ','’
+    In the expression: putStr "Hello World" >> putStr ','
+
+../../typecheck/should_run/Defer01.hs:14:5: warning:
+    Couldn't match expected type ‘Int’ with actual type ‘Char’
+    In the expression: 'p'
+    In an equation for ‘a’: a = 'p'
+
+../../typecheck/should_run/Defer01.hs:18:9: warning:
+    No instance for (Eq B) arising from a use of ‘==’
+    In the expression: x == x
+    In an equation for ‘b’: b x = x == x
+
+../../typecheck/should_run/Defer01.hs:25:4: warning:
+    Couldn't match type ‘Int’ with ‘Bool’
+    Inaccessible code in
+      a pattern with constructor: C2 :: Bool -> C Bool,
+      in an equation for ‘c’
+    In the pattern: C2 x
+    In an equation for ‘c’: c (C2 x) = True
+
+../../typecheck/should_run/Defer01.hs:28:5: warning:
+    No instance for (Num (a -> a)) arising from the literal ‘1’
+      (maybe you haven't applied a function to enough arguments?)
+    In the expression: 1
+    In an equation for ‘d’: d = 1
+
+../../typecheck/should_run/Defer01.hs:31:5: warning:
+    Couldn't match expected type ‘Char -> t’ with actual type ‘Char’
+    Relevant bindings include
+      f :: t (bound at ../../typecheck/should_run/Defer01.hs:31:1)
+    The function ‘e’ is applied to one argument,
+    but its type ‘Char’ has none
+    In the expression: e 'q'
+    In an equation for ‘f’: f = e 'q'
+
+../../typecheck/should_run/Defer01.hs:34:8: warning:
+    Couldn't match expected type ‘Char’ with actual type ‘a’
+    ‘a’ is a rigid type variable bound by
+        the type signature for:
+          h :: a -> (Char, Char)
+        at ../../typecheck/should_run/Defer01.hs:33:6
+    Relevant bindings include
+      x :: a (bound at ../../typecheck/should_run/Defer01.hs:34:3)
+      h :: a -> (Char, Char)
+        (bound at ../../typecheck/should_run/Defer01.hs:34:1)
+    In the expression: x
+    In the expression: (x, 'c')
+
+../../typecheck/should_run/Defer01.hs:39:17: warning:
+    Couldn't match expected type ‘Bool’ with actual type ‘T a’
+    Relevant bindings include
+      a :: a (bound at ../../typecheck/should_run/Defer01.hs:39:3)
+      i :: a -> () (bound at ../../typecheck/should_run/Defer01.hs:39:1)
+    In the first argument of ‘not’, namely ‘(K a)’
+    In the expression: (not (K a))
+
+../../typecheck/should_run/Defer01.hs:43:5: warning:
+    No instance for (MyClass a1) arising from a use of ‘myOp’
+    In the expression: myOp 23
+    In an equation for ‘j’: j = myOp 23
+
+../../typecheck/should_run/Defer01.hs:43:10: warning:
+    No instance for (Num a1) arising from the literal ‘23’
+    The type variable ‘a1’ is ambiguous
+    Potential instances:
+      instance Num Integer -- Defined in ‘GHC.Num’
+      instance Num Double -- Defined in ‘GHC.Float’
+      instance Num Float -- Defined in ‘GHC.Float’
+      ...plus two others
+      (use -fprint-potential-instances to see them all)
+    In the first argument of ‘myOp’, namely ‘23’
+    In the expression: myOp 23
+    In an equation for ‘j’: j = myOp 23
+
+../../typecheck/should_run/Defer01.hs:45:6: warning:
+    Couldn't match type ‘Int’ with ‘Bool’
+    Inaccessible code in
+      the type signature for:
+        k :: (Int ~ Bool) => Int -> Bool
+    In the ambiguity check for the type signature for ‘k’:
+      k :: (Int ~ Bool) => Int -> Bool
+    To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
+    In the type signature for ‘k’: k :: (Int ~ Bool) => Int -> Bool
+
+../../typecheck/should_run/Defer01.hs:45:6: warning:
+    Couldn't match expected type ‘Bool’ with actual type ‘Int’
+    In the ambiguity check for the type signature for ‘k’:
+      k :: (Int ~ Bool) => Int -> Bool
+    To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
+    In the type signature for ‘k’: k :: (Int ~ Bool) => Int -> Bool
+
+../../typecheck/should_run/Defer01.hs:45:6: warning:
+    Couldn't match type ‘Int’ with ‘Bool’
+    Inaccessible code in
+      the type signature for:
+        k :: (Int ~ Bool) => Int -> Bool
+
+../../typecheck/should_run/Defer01.hs:46:7: warning:
+    Couldn't match expected type ‘Bool’ with actual type ‘Int’
+    In the expression: x
+    In an equation for ‘k’: k x = x
+
+../../typecheck/should_run/Defer01.hs:49:5: warning:
+    Couldn't match expected type ‘IO a0’
+                with actual type ‘Char -> IO ()’
+    Probable cause: ‘putChar’ is applied to too few arguments
+    In the first argument of ‘(>>)’, namely ‘putChar’
+    In the expression: putChar >> putChar 'p'
+*** Exception: ../../typecheck/should_run/Defer01.hs:11:40: error:
+    Couldn't match type ‘Char’ with ‘[Char]’
+    Expected type: String
+      Actual type: Char
+    In the first argument of ‘putStr’, namely ‘','’
+    In the second argument of ‘(>>)’, namely ‘putStr ','’
+    In the expression: putStr "Hello World" >> putStr ','
+(deferred type error)
+*** Exception: ../../typecheck/should_run/Defer01.hs:14:5: error:
+    Couldn't match expected type ‘Int’ with actual type ‘Char’
+    In the expression: 'p'
+    In an equation for ‘a’: a = 'p'
+(deferred type error)
+*** Exception: ../../typecheck/should_run/Defer01.hs:18:9: error:
+    No instance for (Eq B) arising from a use of ‘==’
+    In the expression: x == x
+    In an equation for ‘b’: b x = x == x
+(deferred type error)
+
+<interactive>:7:11: error:
+    Couldn't match type ‘Bool’ with ‘Int’
+    Expected type: C Int
+      Actual type: C Bool
+    In the first argument of ‘c’, namely ‘(C2 True)’
+    In the first argument of ‘print’, namely ‘(c (C2 True))’
+*** Exception: ../../typecheck/should_run/Defer01.hs:28:5: error:
+    No instance for (Num (a -> a)) arising from the literal ‘1’
+      (maybe you haven't applied a function to enough arguments?)
+    In the expression: 1
+    In an equation for ‘d’: d = 1
+(deferred type error)
+*** Exception: ../../typecheck/should_run/Defer01.hs:31:5: error:
+    Couldn't match expected type ‘Char -> t’ with actual type ‘Char’
+    Relevant bindings include
+      f :: t (bound at ../../typecheck/should_run/Defer01.hs:31:1)
+    The function ‘e’ is applied to one argument,
+    but its type ‘Char’ has none
+    In the expression: e 'q'
+    In an equation for ‘f’: f = e 'q'
+(deferred type error)
+*** Exception: ../../typecheck/should_run/Defer01.hs:34:8: error:
+    Couldn't match expected type ‘Char’ with actual type ‘a’
+    ‘a’ is a rigid type variable bound by
+        the type signature for:
+          h :: a -> (Char, Char)
+        at ../../typecheck/should_run/Defer01.hs:33:6
+    Relevant bindings include
+      x :: a (bound at ../../typecheck/should_run/Defer01.hs:34:3)
+      h :: a -> (Char, Char)
+        (bound at ../../typecheck/should_run/Defer01.hs:34:1)
+    In the expression: x
+    In the expression: (x, 'c')
+(deferred type error)
+*** Exception: ../../typecheck/should_run/Defer01.hs:39:17: error:
+    Couldn't match expected type ‘Bool’ with actual type ‘T a’
+    Relevant bindings include
+      a :: a (bound at ../../typecheck/should_run/Defer01.hs:39:3)
+      i :: a -> () (bound at ../../typecheck/should_run/Defer01.hs:39:1)
+    In the first argument of ‘not’, namely ‘(K a)’
+    In the expression: (not (K a))
+(deferred type error)
+*** Exception: ../../typecheck/should_run/Defer01.hs:43:5: error:
+    No instance for (MyClass a1) arising from a use of ‘myOp’
+    In the expression: myOp 23
+    In an equation for ‘j’: j = myOp 23
+(deferred type error)
+
+<interactive>:13:8: error:
+    Couldn't match expected type ‘Bool’ with actual type ‘Int’
+    In the first argument of ‘print’, namely ‘(k 2)’
+    In the expression: print (k 2)
+    In an equation for ‘it’: it = print (k 2)
+*** Exception: ../../typecheck/should_run/Defer01.hs:49:5: error:
+    Couldn't match expected type ‘IO a0’
+                with actual type ‘Char -> IO ()’
+    Probable cause: ‘putChar’ is applied to too few arguments
+    In the first argument of ‘(>>)’, namely ‘putChar’
+    In the expression: putChar >> putChar 'p'
+(deferred type error)
index 320d9a5..f05eeac 100644 (file)
@@ -1,5 +1,5 @@
 
-T4485.hs:50:15:
+T4485.hs:50:15: error:
     Overlapping instances for EmbedAsChild
                                 (IdentityT IO) (XMLGenT m0 (XML m0))
       arising from a use of ‘asChild’
@@ -18,10 +18,10 @@ T4485.hs:50:15:
     In an equation for ‘asChild’:
         asChild b = asChild $ (genElement "foo")
 
-T4485.hs:50:26:
+T4485.hs:50:26: error:
     No instance for (XMLGen m0) arising from a use of ‘genElement’
     The type variable ‘m0’ is ambiguous
-    Note: there is a potential instance available:
+    Potential instances:
       instance XMLGen (IdentityT m) -- Defined at T4485.hs:37:10
     In the second argument of ‘($)’, namely ‘(genElement "foo")’
     In the expression: asChild $ (genElement "foo")
index 52658fd..79b7865 100644 (file)
@@ -1,33 +1,35 @@
-\r
-overloadedlistsfail01.hs:5:8:\r
-    No instance for (Show a0) arising from a use of ‘print’\r
-    The type variable ‘a0’ is ambiguous\r
-    Note: there are several potential instances:\r
-      instance [safe] Show Version -- Defined in ‘Data.Version’\r
-      instance Show a => Show (Maybe a) -- Defined in ‘GHC.Show’\r
-      instance Show Ordering -- Defined in ‘GHC.Show’\r
-      ...plus 23 others\r
-    In the expression: print [1]\r
-    In an equation for ‘main’: main = print [1]\r
-\r
-overloadedlistsfail01.hs:5:14:\r
-    No instance for (IsList a0) arising from an overloaded list\r
-    The type variable ‘a0’ is ambiguous\r
-    Note: there are several potential instances:\r
-      instance IsList Version -- Defined in ‘GHC.Exts’\r
-      instance IsList [a] -- Defined in ‘GHC.Exts’\r
-    In the first argument of ‘print’, namely ‘[1]’\r
-    In the expression: print [1]\r
-    In an equation for ‘main’: main = print [1]\r
-\r
-overloadedlistsfail01.hs:5:15:\r
-    No instance for (Num (Item a0)) arising from the literal ‘1’\r
-    The type variable ‘a0’ is ambiguous\r
-    Note: there are several potential instances:\r
-      instance Num Integer -- Defined in ‘GHC.Num’\r
-      instance Num Double -- Defined in ‘GHC.Float’\r
-      instance Num Float -- Defined in ‘GHC.Float’\r
-      ...plus two others\r
-    In the expression: 1\r
-    In the first argument of ‘print’, namely ‘[1]’\r
-    In the expression: print [1]\r
+
+overloadedlistsfail01.hs:5:8: error:
+    No instance for (Show a0) arising from a use of ‘print’
+    The type variable ‘a0’ is ambiguous
+    Potential instances:
+      instance [safe] Show Version -- Defined in ‘Data.Version’
+      instance Show a => Show (Maybe a) -- Defined in ‘GHC.Show’
+      instance Show Ordering -- Defined in ‘GHC.Show’
+      ...plus 23 others
+      (use -fprint-potential-instances to see them all)
+    In the expression: print [1]
+    In an equation for ‘main’: main = print [1]
+
+overloadedlistsfail01.hs:5:14: error:
+    No instance for (IsList a0) arising from an overloaded list
+    The type variable ‘a0’ is ambiguous
+    Potential instances:
+      instance IsList Version -- Defined in ‘GHC.Exts’
+      instance IsList [a] -- Defined in ‘GHC.Exts’
+    In the first argument of ‘print’, namely ‘[1]’
+    In the expression: print [1]
+    In an equation for ‘main’: main = print [1]
+
+overloadedlistsfail01.hs:5:15: error:
+    No instance for (Num (Item a0)) arising from the literal ‘1’
+    The type variable ‘a0’ is ambiguous
+    Potential instances:
+      instance Num Integer -- Defined in ‘GHC.Num’
+      instance Num Double -- Defined in ‘GHC.Float’
+      instance Num Float -- Defined in ‘GHC.Float’
+      ...plus two others
+      (use -fprint-potential-instances to see them all)
+    In the expression: 1
+    In the first argument of ‘print’, namely ‘[1]’
+    In the expression: print [1]
index a83c606..76bfeea 100644 (file)
@@ -5,13 +5,14 @@ TH_localname.hs:3:11: error:
     Relevant bindings include
       y :: t0 (bound at TH_localname.hs:3:6)
       x :: t0 -> ExpQ (bound at TH_localname.hs:3:1)
-    Note: there are several potential instances:
+    Potential instances:
       instance (Lift a, Lift b) => Lift (Either a b)
         -- Defined in ‘Language.Haskell.TH.Syntax’
       instance Lift a => Lift (Maybe a)
         -- Defined in ‘Language.Haskell.TH.Syntax’
       instance Lift Int16 -- Defined in ‘Language.Haskell.TH.Syntax’
       ...plus 24 others
+      (use -fprint-potential-instances to see them all)
     In the expression: lift y
     In the expression:
       [| y |]
index 9e3dc0a..b843f33 100644 (file)
@@ -9,7 +9,7 @@ rebindable6.hs:106:17: error:
       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:
+    Potential instances:
       instance HasSeq (IO a -> IO b -> IO b)
         -- Defined at rebindable6.hs:52:18
     In a stmt of a 'do' block: f
@@ -28,7 +28,7 @@ rebindable6.hs:107:17: error:
       arising from a do statement
       (maybe you haven't applied a function to enough arguments?)
     The type variable ‘t1’ is ambiguous
-    Note: there is a potential instance available:
+    Potential instances:
       instance HasFail (String -> IO a)
         -- Defined at rebindable6.hs:57:18
     In a stmt of a 'do' block: Just (b :: b) <- g
@@ -52,7 +52,7 @@ rebindable6.hs:108:17: error:
       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:
+    Potential instances:
       instance HasReturn (a -> IO a) -- Defined at rebindable6.hs:42:18
     In a stmt of a 'do' block: return b
     In the expression:
index 860d483..3f52be3 100644 (file)
@@ -1,14 +1,15 @@
-\r
-mc14.hs:14:16: error:\r
-    No instance for (Functor t0) arising from a use of ‘fmap’\r
-    The type variable ‘t0’ is ambiguous\r
-    Note: there are several potential instances:\r
-      instance Functor Maybe -- Defined in ‘GHC.Base’\r
-      instance Functor IO -- Defined in ‘GHC.Base’\r
-      instance Functor ((->) r) -- Defined in ‘GHC.Base’\r
-      ...plus two others\r
-    In the expression: fmap\r
-    In a stmt of a monad comprehension: then group using f\r
-    In the expression: [() | f <- functions, then group using f]\r
-\r
-mc14.hs:14:49: error: Variable not in scope: f :: [a] -> m (t0 a)\r
+
+mc14.hs:14:16: error:
+    No instance for (Functor t0) arising from a use of ‘fmap’
+    The type variable ‘t0’ is ambiguous
+    Potential instances:
+      instance Functor Maybe -- Defined in ‘GHC.Base’
+      instance Functor IO -- Defined in ‘GHC.Base’
+      instance Functor ((->) r) -- Defined in ‘GHC.Base’
+      ...plus two others
+      (use -fprint-potential-instances to see them all)
+    In the expression: fmap
+    In a stmt of a monad comprehension: then group using f
+    In the expression: [() | f <- functions, then group using f]
+
+mc14.hs:14:49: error: Variable not in scope: f :: [a] -> m (t0 a)
index 4ce2e24..392b699 100644 (file)
@@ -1,19 +1,20 @@
-\r
-holes2.hs:3:5: warning:\r
-    No instance for (Show a0) arising from a use of ‘show’\r
-    The type variable ‘a0’ is ambiguous\r
-    Note: there are several potential instances:\r
-      instance Show a => Show (Maybe a) -- Defined in ‘GHC.Show’\r
-      instance Show Ordering -- Defined in ‘GHC.Show’\r
-      instance Show Integer -- Defined in ‘GHC.Show’\r
-      ...plus 22 others\r
-    In the expression: show _\r
-    In an equation for ‘f’: f = show _\r
-\r
-holes2.hs:3:10: warning:\r
-    Found hole: _ :: a0\r
-    Where: ‘a0’ is an ambiguous type variable\r
-    Relevant bindings include f :: String (bound at holes2.hs:3:1)\r
-    In the first argument of ‘show’, namely ‘_’\r
-    In the expression: show _\r
-    In an equation for ‘f’: f = show _\r
+
+holes2.hs:3:5: warning:
+    No instance for (Show a0) arising from a use of ‘show’
+    The type variable ‘a0’ is ambiguous
+    Potential instances:
+      instance Show a => Show (Maybe a) -- Defined in ‘GHC.Show’
+      instance Show Ordering -- Defined in ‘GHC.Show’
+      instance Show Integer -- Defined in ‘GHC.Show’
+      ...plus 22 others
+      (use -fprint-potential-instances to see them all)
+    In the expression: show _
+    In an equation for ‘f’: f = show _
+
+holes2.hs:3:10: warning:
+    Found hole: _ :: a0
+    Where: ‘a0’ is an ambiguous type variable
+    Relevant bindings include f :: String (bound at holes2.hs:3:1)
+    In the first argument of ‘show’, namely ‘_’
+    In the expression: show _
+    In an equation for ‘f’: f = show _
index a7267a2..091d461 100644 (file)
@@ -1,19 +1,19 @@
-\r
-T4921.hs:10:9:\r
-    No instance for (C a0 b1) arising from a use of ‘f’\r
-    The type variables ‘b1’, ‘a0’ are ambiguous\r
-    Relevant bindings include x :: a0 (bound at T4921.hs:10:1)\r
-    Note: there is a potential instance available:\r
-      instance C Int Char -- Defined at T4921.hs:7:10\r
-    In the first argument of ‘fst’, namely ‘f’\r
-    In the expression: fst f\r
-    In an equation for ‘x’: x = fst f\r
-\r
-T4921.hs:12:9:\r
-    No instance for (C Int b0) arising from a use of ‘f’\r
-    The type variable ‘b0’ is ambiguous\r
-    Note: there is a potential instance available:\r
-      instance C Int Char -- Defined at T4921.hs:7:10\r
-    In the first argument of ‘fst’, namely ‘f’\r
-    In the expression: fst f :: Int\r
-    In an equation for ‘y’: y = fst f :: Int\r
+
+T4921.hs:10:9: error:
+    No instance for (C a0 b1) arising from a use of ‘f’
+    The type variables ‘b1’, ‘a0’ are ambiguous
+    Relevant bindings include x :: a0 (bound at T4921.hs:10:1)
+    Potential instances:
+      instance C Int Char -- Defined at T4921.hs:7:10
+    In the first argument of ‘fst’, namely ‘f’
+    In the expression: fst f
+    In an equation for ‘x’: x = fst f
+
+T4921.hs:12:9: error:
+    No instance for (C Int b0) arising from a use of ‘f’
+    The type variable ‘b0’ is ambiguous
+    Potential instances:
+      instance C Int Char -- Defined at T4921.hs:7:10
+    In the first argument of ‘fst’, namely ‘f’
+    In the expression: fst f :: Int
+    In an equation for ‘y’: y = fst f :: Int
index 0cf8854..46667fb 100644 (file)
@@ -1,82 +1,14 @@
 
-T5095.hs:9:11:
+T5095.hs:9:11: error:
     Overlapping instances for Eq a arising from a use of ‘==’
     Matching instances:
       instance [overlappable] Show a => Eq a -- Defined at T5095.hs:5:31
-      instance Eq a => Eq (Maybe a) -- Defined in ‘GHC.Base’
-      instance Eq () -- Defined in ‘GHC.Classes’
-      instance (Eq a, Eq b) => Eq (a, b) -- Defined in ‘GHC.Classes’
-      instance (Eq a, Eq b, Eq c) => Eq (a, b, c)
-        -- Defined in ‘GHC.Classes’
-      instance (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)
-        -- Defined in ‘GHC.Classes’
-      instance (Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e)
-        -- Defined in ‘GHC.Classes’
-      instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) =>
-               Eq (a, b, c, d, e, f)
-        -- Defined in ‘GHC.Classes’
-      instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) =>
-               Eq (a, b, c, d, e, f, g)
-        -- Defined in ‘GHC.Classes’
-      instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h) =>
-               Eq (a, b, c, d, e, f, g, h)
-        -- Defined in ‘GHC.Classes’
-      instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i) =>
-               Eq (a, b, c, d, e, f, g, h, i)
-        -- Defined in ‘GHC.Classes’
-      instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i,
-                Eq j) =>
-               Eq (a, b, c, d, e, f, g, h, i, j)
-        -- Defined in ‘GHC.Classes’
-      instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i,
-                Eq j, Eq k) =>
-               Eq (a, b, c, d, e, f, g, h, i, j, k)
-        -- Defined in ‘GHC.Classes’
-      instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i,
-                Eq j, Eq k, Eq l) =>
-               Eq (a, b, c, d, e, f, g, h, i, j, k, l)
-        -- Defined in ‘GHC.Classes’
-      instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i,
-                Eq j, Eq k, Eq l, Eq m) =>
-               Eq (a, b, c, d, e, f, g, h, i, j, k, l, m)
-        -- Defined in ‘GHC.Classes’
-      instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i,
-                Eq j, Eq k, Eq l, Eq m, Eq n) =>
-               Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
-        -- Defined in ‘GHC.Classes’
-      instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i,
-                Eq j, Eq k, Eq l, Eq m, Eq n, Eq o) =>
-               Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
-        -- Defined in ‘GHC.Classes’
-      instance Eq Bool -- Defined in ‘GHC.Classes’
-      instance Eq Char -- Defined in ‘GHC.Classes’
-      instance Eq Double -- Defined in ‘GHC.Classes’
-      instance Eq Float -- Defined in ‘GHC.Classes’
-      instance Eq Int -- Defined in ‘GHC.Classes’
-      instance Eq Ordering -- Defined in ‘GHC.Classes’
-      instance Eq Word -- Defined in ‘GHC.Classes’
-      instance Eq a => Eq [a] -- Defined in ‘GHC.Classes’
-      instance Eq integer-gmp-1.0.0.0:GHC.Integer.Type.BigNat
-        -- Defined in ‘integer-gmp-1.0.0.0:GHC.Integer.Type’
-      instance Eq Integer
-        -- Defined in ‘integer-gmp-1.0.0.0:GHC.Integer.Type’
-      instance Eq All -- Defined in ‘Data.Monoid’
-      instance forall (k :: BOX) (f :: k -> *) (a :: k).
-               Eq (f a) =>
-               Eq (Alt f a)
-        -- Defined in ‘Data.Monoid’
-      instance Eq Any -- Defined in ‘Data.Monoid’
-      instance Eq a => Eq (Dual a) -- Defined in ‘Data.Monoid’
-      instance Eq a => Eq (First a) -- Defined in ‘Data.Monoid’
-      instance Eq a => Eq (Last a) -- Defined in ‘Data.Monoid’
-      instance Eq a => Eq (Product a) -- Defined in ‘Data.Monoid’
-      instance Eq a => Eq (Sum a) -- Defined in ‘Data.Monoid’
-      instance forall (k :: BOX) (s :: k). Eq (Proxy s)
-        -- Defined in ‘Data.Proxy’
       instance (Eq a, Eq b) => Eq (Either a b)
         -- Defined in ‘Data.Either’
-      instance (Ix i, Eq e) => Eq (Array i e) -- Defined in ‘GHC.Arr’
-      instance Eq (STArray s i e) -- Defined in ‘GHC.Arr’
+      instance Eq All -- Defined in ‘Data.Monoid’
+      ...plus 35 others
+      ...plus one instance involving out-of-scope types
+      (use -fprint-potential-instances to see them all)
     (The choice depends on the instantiation of ‘a’
      To pick the first instance above, use IncoherentInstances
      when compiling the other instance declarations)
index 1378bae..9c381d9 100644 (file)
@@ -1,9 +1,9 @@
 
-T5858.hs:11:7:
+T5858.hs:11:7: error:
     No instance for (InferOverloaded ([t0], [t1]))
       arising from a use of ‘infer’
     The type variables ‘t0’, ‘t1’ are ambiguous
-    Note: there is a potential instance available:
+    Potential instances:
       instance (t1 ~ String) => InferOverloaded (t1, t1)
         -- Defined at T5858.hs:8:10
     In the expression: infer ([], [])
index bc8fed9..f413eb5 100644 (file)
@@ -1,11 +1,11 @@
 
-T7857.hs:8:11:
+T7857.hs:8:11: error:
     Could not deduce (PrintfType r0) arising from a use of ‘printf’
     from the context: PrintfArg t
       bound by the inferred type of g :: PrintfArg t => t -> b
       at T7857.hs:8:1-21
     The type variable ‘r0’ is ambiguous
-    Note: there are several potential instances:
+    Potential instances:
       instance [safe] (a ~ ()) => PrintfType (IO a)
         -- Defined in ‘Text.Printf’
       instance [safe] (PrintfArg a, PrintfType r) => PrintfType (a -> r)
index 2fc79b2..db70a63 100644 (file)
@@ -1,18 +1,19 @@
 
-tcfail008.hs:3:5:
+tcfail008.hs:3:5: error:
     No instance for (Num a0) arising from the literal ‘1’
     The type variable ‘a0’ is ambiguous
     Relevant bindings include o :: [a0] (bound at tcfail008.hs:3:1)
-    Note: there are several potential instances:
+    Potential instances:
       instance Num Integer -- Defined in ‘GHC.Num’
       instance Num Double -- Defined in ‘GHC.Float’
       instance Num Float -- Defined in ‘GHC.Float’
       ...plus two others
+      (use -fprint-potential-instances to see them all)
     In the first argument of ‘(:)’, namely ‘1’
     In the expression: 1 : 2
     In an equation for ‘o’: o = 1 : 2
 
-tcfail008.hs:3:7:
+tcfail008.hs:3:7: error:
     No instance for (Num [a0]) arising from the literal ‘2’
     In the second argument of ‘(:)’, namely ‘2’
     In the expression: 1 : 2
index 923be56..68e958e 100644 (file)
@@ -1,8 +1,8 @@
 
-tcfail040.hs:19:5:
+tcfail040.hs:19:5: error:
     No instance for (ORD a0) arising from a use of ‘<<’
     The type variable ‘a0’ is ambiguous
-    Note: there is a potential instance available:
+    Potential instances:
       instance ORD (a -> b) -- Defined at tcfail040.hs:17:10
     In the first argument of ‘(===)’, namely ‘(<<)’
     In the expression: (<<) === (<<)
index a058d87..fe24adc 100644 (file)
@@ -1,12 +1,12 @@
 
-tcfail043.hs:38:17:
+tcfail043.hs:38:17: error:
     No instance for (Ord_ a0) arising from a use of ‘gt’
     The type variable ‘a0’ is ambiguous
     Relevant bindings include
       bs :: [a0] (bound at tcfail043.hs:38:8)
       a :: a0 (bound at tcfail043.hs:38:6)
       search :: a0 -> [a0] -> Bool (bound at tcfail043.hs:37:1)
-    Note: there is a potential instance available:
+    Potential instances:
       instance Ord_ Int -- Defined at tcfail043.hs:34:10
     In the expression: gt (hd bs) a
     In the expression:
@@ -21,14 +21,14 @@ tcfail043.hs:38:17:
            else
                if eq a (hd bs) then True else search a (tl bs)
 
-tcfail043.hs:40:25:
+tcfail043.hs:40:25: error:
     No instance for (Eq_ a0) arising from a use of ‘eq’
     The type variable ‘a0’ is ambiguous
     Relevant bindings include
       bs :: [a0] (bound at tcfail043.hs:38:8)
       a :: a0 (bound at tcfail043.hs:38:6)
       search :: a0 -> [a0] -> Bool (bound at tcfail043.hs:37:1)
-    Note: there are several potential instances:
+    Potential instances:
       instance Eq_ Int -- Defined at tcfail043.hs:20:10
       instance Eq_ a => Eq_ [a] -- Defined at tcfail043.hs:23:10
     In the expression: eq a (hd bs)
index c08bb58..f3386f1 100644 (file)
@@ -1,16 +1,18 @@
 
-tcfail072.hs:23:13:
+tcfail072.hs:23:13: error:
     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
+                 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:
+    Potential instances:
       instance Ord a => Ord (Maybe a) -- Defined in ‘GHC.Base’
       instance Ord Ordering -- Defined in ‘GHC.Classes’
-      instance Ord integer-gmp-1.0.0.0:GHC.Integer.Type.BigNat
+      instance Ord Integer
         -- Defined in ‘integer-gmp-1.0.0.0:GHC.Integer.Type’
-      ...plus 23 others
+      ...plus 22 others
+      ...plus one instance involving out-of-scope types
+      (use -fprint-potential-instances to see them all)
     In the expression: g A
     In an equation for ‘g’: g (B _ _) = g A
index 6d59560..4ad7273 100644 (file)
@@ -1,9 +1,9 @@
 
-tcfail128.hs:18:16:
+tcfail128.hs:18:16: error:
     No instance for (Data.Array.Base.MArray b0 FlatVector IO)
       arising from a use of ‘thaw’
     The type variable ‘b0’ is ambiguous
-    Note: there is a potential instance available:
+    Potential instances:
       instance Data.Array.Base.MArray IOArray e IO
         -- Defined in ‘Data.Array.Base’
     In a stmt of a 'do' block: v <- thaw tmp
index dc9c96d..1869cea 100644 (file)
@@ -1,21 +1,22 @@
 
-tcfail133.hs:2:61: Warning:
+tcfail133.hs:2:61: warning:
     -XDatatypeContexts is deprecated: It was widely considered a misfeature, and has been removed from the Haskell language.
 
-tcfail133.hs:68:7:
+tcfail133.hs:68:7: error:
     No instance for (Show r0) arising from a use of ‘show’
     The type variable ‘r0’ is ambiguous
-    Note: there are several potential instances:
+    Potential instances:
       instance Show a => Show (Maybe a) -- Defined in ‘GHC.Show’
       instance Show Ordering -- Defined in ‘GHC.Show’
       instance Show Integer -- Defined in ‘GHC.Show’
       ...plus 25 others
+      (use -fprint-potential-instances to see them all)
     In the expression: show
     In the expression: show $ add (One :@ Zero) (One :@ One)
     In an equation for ‘foo’:
         foo = show $ add (One :@ Zero) (One :@ One)
 
-tcfail133.hs:68:14:
+tcfail133.hs:68:14: error:
     No instance for (AddDigit (Zero :@ (One :@ One)) One r0)
       arising from a use of ‘add’
     In the second argument of ‘($)’, namely
index 787b62e..3d3507f 100644 (file)
@@ -1,16 +1,17 @@
 
-tcfail181.hs:17:9:
+tcfail181.hs:17:9: error:
     Could not deduce (Monad m0) arising from a use of ‘foo’
     from the context: Monad m
       bound by the inferred type of
                wog :: Monad m => t -> Something (m Bool) e
       at tcfail181.hs:17:1-30
     The type variable ‘m0’ is ambiguous
-    Note: there are several potential instances:
+    Potential instances:
       instance Monad Maybe -- Defined in ‘GHC.Base’
       instance Monad IO -- Defined in ‘GHC.Base’
       instance Monad ((->) r) -- Defined in ‘GHC.Base’
       ...plus two others
+      (use -fprint-potential-instances to see them all)
     In the expression: foo
     In the expression: foo {bar = return True}
     In an equation for ‘wog’: wog x = foo {bar = return True}