[project @ 1997-05-26 05:42:53 by sof]

[ghc-hetmet.git] / ghc / compiler / tests / typecheck / should_fail / Digraph.stderr

diff --git a/ghc/compiler/tests/typecheck/should_fail/Digraph.stderr b/ghc/compiler/tests/typecheck/should_fail/Digraph.stderr
index a61101c..03ae28a 100644 (file)
--- a/ghc/compiler/tests/typecheck/should_fail/Digraph.stderr
+++ b/ghc/compiler/tests/typecheck/should_fail/Digraph.stderr
@@ -1,8 +1,58 @@
  
-"Digraph.hs", line 19: Type signature is too polymorphic:
-    Signature: [Edge v]
-    Monomorphic type variables: v
-    In a type signature: [Edge v]
-Fail: Compilation errors found
+Digraph.hs:19: A type signature is more polymorphic than the inferred type
+                  Some type variables in the inferred type can't be forall'd, namely:
+                  `v{-a13W-}'
+                  Possible cause: the RHS mentions something subject to the monomorphism restriction
+    When checking signature for `reversed_edges'
+    In an equation for function `stronglyConnComp':
+       `stronglyConnComp es vs   =   PrelTup.snd
+                                         (span_tree
+                                              (new_range
+                                                   reversed_edges)
+                                              (PrelBase.[], (PrelBase.[]))
+                                              (PrelTup.snd
+                                                   (dfs (new_range
+                                                             es)
+                                                        (PrelBase.[], (PrelBase.[]))
+                                                        vs)))
+                                 where
+                                     span_tree
+                                         r (vs, ns) PrelBase.[]
+                                                 =   (vs, (ns))
+                                     span_tree
+                                         r (vs, ns) (x PrelBase.: xs)
+                                                 | [x PrelList.elem vs] =
+                                                     span_tree
+                                                         r (vs, (ns)) xs
+                                                 | [PrelBase.otherwise] =
+                                                     span_tree
+                                                         r
+                                                         (vs', ((x PrelBase.: ns') PrelBase.: ns))
+                                                         xs
+                                                 where
+                                                     (vs', ns')
+                                                         =   dfs r
+                                                                 (x PrelBase.: vs, (PrelBase.[]))
+                                                                 (r   x)
+                                     new_range
+                                         PrelBase.[] w
+                                                 =   PrelBase.[]
+                                     new_range
+                                         ((x, y) PrelBase.: xys) w
+                                                 =   if x PrelBase.== w then
+                                                         (y
+                                                          PrelBase.: (new_range
+                                                                          xys w))
+                                                     else
+                                                         (new_range
+                                                              xys w)
+                                     swap
+                                         (x, y)  =   (y, (x))
+                                     reversed_edges ::
+                                         _forall_ [v] {PrelBase.Eq v} => [Edge v]
+                                     reversed_edges
+                                         =   PrelBase.map
+                                                 swap es'
 
-ghc: execution of the Haskell compiler had trouble
+
+Compilation had errors