X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftests%2Ftypecheck%2Fshould_succeed%2Ftc065.stderr;fp=ghc%2Fcompiler%2Ftests%2Ftypecheck%2Fshould_succeed%2Ftc065.stderr;h=dbaac2dcc86b5bc394bf378c4d2f5c0f24c7e3d6;hb=4a48f32dfe4d85e07c3b83f1a3327f7ec4220947;hp=10c73c1d9ed3d39d21012c586627160b758163ae;hpb=e2656c348a1b84eaeef62df5877094aa948561ac;p=ghc-hetmet.git diff --git a/ghc/compiler/tests/typecheck/should_succeed/tc065.stderr b/ghc/compiler/tests/typecheck/should_succeed/tc065.stderr index 10c73c1..dbaac2d 100644 --- a/ghc/compiler/tests/typecheck/should_succeed/tc065.stderr +++ b/ghc/compiler/tests/typecheck/should_succeed/tc065.stderr @@ -1,4 +1,486 @@ -"tc065.hs", line 5: import directory list is: - .:/users/fp/grasp/ghc/imports:/users/fp/grasp/ghc/./driver/.././lib/prelude:/users/fp/grasp/ghc/./driver/.././runtimes/standard - Can't find .hi file for module `TheUtils'; on input: \n -ghc2: execution of the Haskell parser had trouble + + +--================================================================================ +Typechecked: +{- nonrec -} +{- nonrec -} +Succeeded{-r4G,x-}{i} = + _/\_ a{-r8v-} b{-r8w-} -> \ tpl_B1 -> + Succeeded{-r4G,x-}{i} + {_@_ a{-r8v-} _@_ b{-r8w-} tpl_B1} +Failed{-r4F,x-}{i} = + _/\_ a{-r8v-} b{-r8w-} -> \ tpl_B1 -> + Failed{-r4F,x-}{i} + {_@_ a{-r8v-} _@_ b{-r8w-} tpl_B1} +{- nonrec -} +MkDigraph{-r8L,x-}{i} = + _/\_ vertex{-r8G-} -> \ tpl_B1 -> + MkDigraph{-r8L,x-}{i} + {_@_ vertex{-r8G-} tpl_B1} +{- nonrec -} +{- rec -} +AbsBinds +[a{-a1lz-}, b{-a1lA-}] +[] +[([a{-a1lz-}, b{-a1lA-}], $d1{-r1lE,x-}, d.Eval_a1kX)] + d.Eval_a1kX = + ({-dict-} [] []) +{- rec -} +AbsBinds +[vertex{-a1lB-}] +[] +[([vertex{-a1lB-}], $d2{-r1lS,x-}, d.Eval_a1l3)] + d.Eval_a1l3 = + ({-dict-} [] []) +{- nonrec -} +d.Monad_a1l5 = + PrelBase.$d24{-rj0,p-} +>>=_a1lQ = + PrelBase.>>={-811,p-} + PrelBase.[]{-3j,p-} + d.Monad_a1l5 +d.Monad_a1l8 = + d.Monad_a1l5 +return_a1lP = + PrelBase.return{-816,p-} + PrelBase.[]{-3j,p-} + d.Monad_a1l8 +d.MonadZero_a1la = + PrelBase.$d23{-riZ,p-} +zero_a1lO = + PrelBase.zero{-810,p-} + PrelBase.[]{-3j,p-} + d.MonadZero_a1la +d.Functor_a1ld = + PrelBase.$d25{-rj1,p-} +map_a1lN = + PrelBase.map{-rkx,p-} + PrelBase.[]{-3j,p-} + d.Functor_a1ld +d.MonadPlus_a1lg = + PrelBase.$d22{-riY,p-} +++_a1lM = + PrelBase.++{-rnk,p-} + PrelBase.[]{-3j,p-} + d.MonadPlus_a1lg +>>=_a1lL = + >>=_a1lQ +return_a1lK = + return_a1lP +>>=_a1lJ = + >>=_a1lQ +return_a1lI = + return_a1lP +>>=_a1lH = + >>=_a1lQ +return_a1lG = + return_a1lP +zero_a1lF = + zero_a1lO +{- nonrec -} +AbsBinds +[vertex{-a1ba-}] +[d.Eq_a1bl] +[([vertex{-a1ba-}], + isRecursiveCycle{-r6x,x-}, + isRecursiveCycle_a1b5)] + d.Eq_a1bp = + d.Eq_a1bl + d.Eq_a1bq = + d.Eq_a1bl + d.Eq_a1bn = + PrelTup.$d9{-rEY,p-} + [vertex{-a1ba-}, vertex{-a1ba-}] + [d.Eq_a1bp, d.Eq_a1bq] + elem_a1lT = + PrelList.elem{-rF6,p-} + (vertex{-a1ba-}, vertex{-a1ba-}) + d.Eq_a1bn + isRecursiveCycle_a1b5 + [vertex_r8n] edges_r8p + = (vertex_r8n, vertex_r8n) elem_a1lT edges_r8p + isRecursiveCycle_a1b5 + cycle_r8r edges_r8t + = PrelBase.True{-5E,p-}{i} +{- nonrec -} +{- nonrec -} +AbsBinds +[vertex{-a1bC-}, name{-a1bD-}, code{-a1bE-}] +[d.Eq_a1cs, d.Ord_a1ct] +[([name{-a1bD-}, vertex{-a1bC-}, code{-a1bE-}], + lookupVertex{-r6w,x-}, + lookupVertex_a1bz)] + d.Eq_a1cv = + d.Eq_a1cs + ==_a1lU = + PrelBase.=={-8Y,p-} + vertex{-a1bC-} + d.Eq_a1cv + lookupVertex_a1bz + flat_info_r8e vertex_r8g + = PrelList.head{-rFm,p-} + code{-a1bE-} code_list_r8i + where + {- nonrec -} + AbsBinds [] [] [([], code_list_r8i, code_list_a1bI)] + code_list_a1bI + = [ code_r8l | + (vertex'_r8k, _, _, code_r8l) <- flat_info_r8e, vertex_r8g + ==_a1lU vertex'_r8k + ] + {- nonrec -} +{- nonrec -} +{- nonrec -} +AbsBinds +[vertex{-a1cO-}, name{-a1cR-}, code{-a1cS-}] +[d.Eq_a1ei, d.Ord_a1ej] +[([name{-a1cR-}, code{-a1cS-}, vertex{-a1cO-}], + mkEdges{-r6v,x-}, + mkEdges_a1cL)] + d.Ord_a1ek = + d.Ord_a1ej + d.MonadZero_a1el = + PrelBase.$d23{-riZ,p-} + mkEdges_a1cL + vertices_r7U flat_info_r7W + = [ (source_vertex_r87, target_vertex_r8c) | + (source_vertex_r87, _, used_names_r88, _) <- flat_info_r7W, target_name_r8a <- Set.setToList{-rhd,p-} + name{-a1cR-} used_names_r88, target_vertex_r8c <- vertices_defining_a1lV target_name_r8a + flat_info_r7W + ] + where + {- nonrec -} + AbsBinds + [t{-a1d5-}, t{-a1da-}, t{-a1dd-}, a{-a1dg-}, a{-a1di-}] + [d.Ord_a1du, d.MonadZero_a1dA] + [([t{-a1d5-}, t{-a1da-}, t{-a1dd-}, a{-a1dg-}, a{-a1di-}], + vertices_defining_r7Y, + vertices_defining_a1cU)] + d.Monad_a1dw = + PrelBase.scsel_MonadZeroPrelBaseMonad{-a1m0,p-} + a{-a1dg-} + d.MonadZero_a1dA + elementOf_a1lZ = + Set.elementOf{-rh5,p-} + a{-a1di-} + d.Ord_a1du + >>=_a1lY = + PrelBase.>>={-811,p-} + a{-a1dg-} + d.Monad_a1dw + d.Monad_a1dy = + d.Monad_a1dw + return_a1lX = + PrelBase.return{-816,p-} + a{-a1dg-} + d.Monad_a1dy + zero_a1lW = + PrelBase.zero{-810,p-} + a{-a1dg-} + d.MonadZero_a1dA + vertices_defining_a1cU + name_r80 flat_info_r82 + = [ vertex_r84 | + (vertex_r84, names_defined_r85, _, _) <- flat_info_r82, name_r80 + elementOf_a1lZ names_defined_r85 + ] + {- nonrec -} + vertices_defining_a1lV = + vertices_defining_r7Y + [vertex{-a1cO-}, Set.Set{-rh2,p-} name{-a1cR-}, code{-a1cS-}, PrelBase.[]{-3j,p-}, name{-a1cR-}] + [d.Ord_a1ek, d.MonadZero_a1el] +{- nonrec -} +{- nonrec -} +AbsBinds +[vertex{-a1eC-}, name{-a1eD-}, code{-a1eE-}] +[] +[([name{-a1eD-}, code{-a1eE-}, vertex{-a1eC-}], + mkVertices{-r6u,x-}, + mkVertices_a1ez)] + mkVertices_a1ez + info_r7Q + = [ vertex_r7S | + (vertex_r7S, _, _, _) <- info_r7Q ] +{- nonrec -} +{- nonrec -} +AbsBinds +[vertex{-a1ff-}] +[d.Eq_a1fs] +[([vertex{-a1ff-}], isCyclic{-r6s,x-}, isCyclic_a1fc)] + d.Eq_a1fw = + d.Eq_a1fs + d.Eq_a1fx = + d.Eq_a1fs + d.Eq_a1fu = + PrelTup.$d9{-rEY,p-} + [vertex{-a1ff-}, vertex{-a1ff-}] + [d.Eq_a1fw, d.Eq_a1fx] + elem_a1m1 = + PrelList.elem{-rF6,p-} + (vertex{-a1ff-}, vertex{-a1ff-}) + d.Eq_a1fu + isCyclic_a1fc + edges_r7w [v_r7y] + = (v_r7y, v_r7y) elem_a1m1 edges_r7w + isCyclic_a1fc + edges_r7A vs_r7C + = PrelBase.True{-5E,p-}{i} +{- nonrec -} +{- rec -} +AbsBinds +[t{-a1gi-}] +[d.Eq_a1gA] +[([t{-a1gi-}], dfs{-r6y,x-}, dfs_a1fz)] + elem_a1m2 = + PrelList.elem{-rF6,p-} + t{-a1gi-} + d.Eq_a1gA + dfs_a1fz + r_r7f (vs_r7h, ns_r7i) PrelBase.[]{-5i,p-}{i} + = (vs_r7h, ns_r7i) + dfs_a1fz + r_r7l (vs_r7n, ns_r7o) (x_r7q PrelBase.:{-55,p-}{i} xs_r7r) + | [x_r7q elem_a1m2 vs_r7n] = + dfs_a1fz r_r7l (vs_r7n, ns_r7o) xs_r7r + | [PrelBase.otherwise{-818,p-}] = + dfs_a1fz r_r7l + (vs'_r7t, + ++_a1lM + t{-a1gi-} + (PrelBase.:{-55,p-}{i} + t{-a1gi-} + x_r7q ns'_r7u) + ns_r7o) + xs_r7r + where + {- nonrec -} + AbsBinds [] [] [([], vs'_r7t, vs'_a1g4), ([], ns'_r7u, ns'_a1g5)] + (vs'_a1g4, ns'_a1g5) + = dfs_a1fz r_r7l + (PrelBase.:{-55,p-}{i} + t{-a1gi-} + x_r7q vs_r7n, + PrelBase.[]{-5i,p-}{i} + t{-a1gi-}) + r_r7l x_r7q + {- nonrec -} +{- nonrec -} +{- nonrec -} +AbsBinds +[vertex{-a1gK-}] +[d.Eq_a1ju] +[([vertex{-a1gK-}], + stronglyConnComp{-r6r,x-}, + stronglyConnComp_a1gH)] + d.Eq_a1jv = + d.Eq_a1ju + d.Eq_a1jq = + d.Eq_a1ju + d.Eq_a1jx = + d.Eq_a1ju + dfs_a1m3 = + dfs{-r6y,x-} + vertex{-a1gK-} + d.Eq_a1jx + d.Eq_a1jr = + d.Eq_a1ju + stronglyConnComp_a1gH + es_r6B vs_r6D + = PrelTup.snd{-rF4,p-} + [[vertex{-a1gK-}], [[vertex{-a1gK-}]]] span_tree_a1m4 new_range_a1m6 reversed_edges_r6F + (PrelBase.[]{-5i,p-}{i} + vertex{-a1gK-}, + PrelBase.[]{-5i,p-}{i} + [vertex{-a1gK-}]) + PrelTup.snd{-rF4,p-} + [[vertex{-a1gK-}], [vertex{-a1gK-}]] dfs_a1m3 new_range_a1m5 es_r6B + (PrelBase.[]{-5i,p-}{i} + vertex{-a1gK-}, + PrelBase.[]{-5i,p-}{i} + vertex{-a1gK-}) + vs_r6D + where + {- rec -} + AbsBinds + [t{-a1h2-}] + [d.Eq_a1hJ] + [([t{-a1h2-}], span_tree_r6I, span_tree_a1gO)] + elem_a1m8 = + PrelList.elem{-rF6,p-} + t{-a1h2-} + d.Eq_a1hJ + d.Eq_a1hL = + d.Eq_a1hJ + dfs_a1m7 = + dfs{-r6y,x-} + t{-a1h2-} + d.Eq_a1hL + span_tree_a1gO + r_r6Y (vs_r70, ns_r71) PrelBase.[]{-5i,p-}{i} + = (vs_r70, ns_r71) + span_tree_a1gO + r_r74 (vs_r76, ns_r77) (x_r79 PrelBase.:{-55,p-}{i} xs_r7a) + | [x_r79 elem_a1m8 vs_r76] = + span_tree_a1gO r_r74 (vs_r76, ns_r77) xs_r7a + | [PrelBase.otherwise{-818,p-}] = + span_tree_a1gO r_r74 + (vs'_r7c, + PrelBase.:{-55,p-}{i} + [t{-a1h2-}] + (PrelBase.:{-55,p-}{i} + t{-a1h2-} + x_r79 ns'_r7d) + ns_r77) + xs_r7a + where + {- nonrec -} + AbsBinds + [] + [] + [([], vs'_r7c, vs'_a1hj), ([], ns'_r7d, ns'_a1hk)] + (vs'_a1hj, ns'_a1hk) + = dfs_a1m7 r_r74 + (PrelBase.:{-55,p-}{i} + t{-a1h2-} + x_r79 vs_r76, + PrelBase.[]{-5i,p-}{i} + t{-a1h2-}) + r_r74 x_r79 + {- nonrec -} + {- nonrec -} + span_tree_a1m4 = + span_tree_r6I + vertex{-a1gK-} + d.Eq_a1jv + {- rec -} + AbsBinds + [t{-a1hV-}, t{-a1i0-}] + [d.Eq_a1ig] + [([t{-a1hV-}, t{-a1i0-}], new_range_r6H, new_range_a1hN)] + ==_a1m9 = + PrelBase.=={-8Y,p-} + t{-a1i0-} + d.Eq_a1ig + new_range_a1hN + PrelBase.[]{-5i,p-}{i} w_r6Q + = PrelBase.[]{-5i,p-}{i} + t{-a1hV-} + new_range_a1hN + ((x_r6S, y_r6T) PrelBase.:{-55,p-}{i} xys_r6U) w_r6W + = if x_r6S ==_a1m9 w_r6W then + PrelBase.:{-55,p-}{i} + t{-a1hV-} + y_r6T (new_range_a1hN xys_r6U w_r6W) + else + new_range_a1hN xys_r6U w_r6W + {- nonrec -} + new_range_a1m6 = + new_range_r6H + [vertex{-a1gK-}, vertex{-a1gK-}] + d.Eq_a1jq + new_range_a1m5 = + new_range_r6H + [vertex{-a1gK-}, vertex{-a1gK-}] + d.Eq_a1jr + {- nonrec -} + AbsBinds [v{-a1iv-}] [] [([v{-a1iv-}], swap_r6G, swap_a1im)] + swap_a1im + (x_r6M, y_r6N) + = (y_r6N, x_r6M) + {- nonrec -} + {- nonrec -} + AbsBinds [] [] [([], reversed_edges_r6F, reversed_edges_a1iy)] + reversed_edges_a1iy + = map_a1lN + [Edge{-r8K,x-} vertex{-a1gK-}, Edge{-r8K,x-} vertex{-a1gK-}] swap_r6G + vertex{-a1gK-} + es_r6B + {- nonrec -} +{- nonrec -} +{- nonrec -} +AbsBinds +[vertex{-a1jI-}] +[d.Eq_a1kA] +[([vertex{-a1jI-}], topSort{-r6t,x-}, topSort_a1jF)] + d.Eq_a1kI = + d.Eq_a1kA + isCyclic_a1mb = + isCyclic{-r6s,x-} + vertex{-a1jI-} + d.Eq_a1kI + d.Eq_a1kK = + d.Eq_a1kA + stronglyConnComp_a1ma = + stronglyConnComp{-r6r,x-} + vertex{-a1jI-} + d.Eq_a1kK + topSort_a1jF + edges_r7E vertices_r7G + = case cycles_r7J of + PrelBase.[]{-5i,p-}{i} + -> Succeeded{-r4G,x-}{i} + [[vertex{-a1jI-}], [[vertex{-a1jI-}]]] [ v_r7N | + [v_r7N] <- singletons_r7K + ] + _ -> Failed{-r4F,x-}{i} + [[vertex{-a1jI-}], [[vertex{-a1jI-}]]] cycles_r7J + where + {- nonrec -} + AbsBinds [] [] [([], sccs_r7I, sccs_a1jM)] + sccs_a1jM + = stronglyConnComp_a1ma edges_r7E vertices_r7G + {- nonrec -} + {- nonrec -} + AbsBinds + [] + [] + [([], cycles_r7J, cycles_a1jT), ([], + singletons_r7K, + singletons_a1jU)] + (cycles_a1jT, singletons_a1jU) + = List.partition{-rhM,p-} + [vertex{-a1jI-}] isCyclic_a1mb edges_r7E sccs_r7I + {- nonrec -} +{- nonrec -} +{- nonrec -} +AbsBinds +[vertex{-a1kQ-}] +[] +[([vertex{-a1kQ-}], mkDigraph{-r6z,x-}, mkDigraph_a1kM)] + mkDigraph_a1kM + = MkDigraph{-r8L,x-}{i} + vertex{-a1kQ-} +{- nonrec -} +ghc: module version changed to 1; reason: no old .hi file +_interface_ Digraphs 1 +_instance_modules_ +ArrBase Foreign IO PrelNum +_usages_ +List 1 :: partition 1; +PrelBase 1 :: $d14 1 $d15 1 $d22 1 $d23 1 $d24 1 $d25 1 $d26 1 $d27 1 $d32 1 $d34 1 $d37 1 $d39 1 $d41 1 $d44 1 $d45 1 $d46 1 $d49 1 $d51 1 $d6 1 $d7 1 otherwise 1 Eq 1 Eval 1 Functor 1 Monad 1 MonadPlus 1 MonadZero 1 Ord 1 Ordering 1; +PrelList 1 :: elem 1 head 1; +PrelNum 1 :: $d17 1 $d18 1; +PrelTup 1 :: $d11 1 $d13 1 $d15 1 $d49 1 $d51 1 $d9 1 snd 1; +Set 2 :: $d1 2 elementOf 2 setToList 2 Set 1; +_exports_ +Digraphs dfs isCyclic isRecursiveCycle lookupVertex mkDigraph mkEdges mkVertices stronglyConnComp topSort Cycle Digraph(MkDigraph) Edge FlattenedDependencyInfo MaybeErr(Succeeded Failed); +_instances_ +instance _forall_ [a b] => {PrelBase.Eval (MaybeErr a b)} = $d1; +instance _forall_ [a] => {PrelBase.Eval (Digraph a)} = $d2; +_declarations_ +1 $d1 _:_ _forall_ [a b] => {PrelBase.Eval (MaybeErr a b)} ;; +1 $d2 _:_ _forall_ [a] => {PrelBase.Eval (Digraph a)} ;; +1 type Cycle r8C = [r8C] ; +1 data Digraph r8G = MkDigraph [r8G] ; +1 type Edge r8E = (r8E, r8E) ; +1 type FlattenedDependencyInfo r8y r8z r8A = [(r8y, Set.Set r8z, Set.Set r8z, r8A)] ; +1 data MaybeErr r8v r8w = Succeeded r8v | Failed r8w ; +1 dfs _:_ _forall_ [a] {PrelBase.Eq a} => (a -> [a]) -> ([a], [a]) -> [a] -> ([a], [a]) ;; +1 isCyclic _:_ _forall_ [a] {PrelBase.Eq a} => [Edge a] -> [a] -> PrelBase.Bool ;; +1 isRecursiveCycle _:_ _forall_ [a] {PrelBase.Eq a} => Cycle a -> [Edge a] -> PrelBase.Bool ;; +1 lookupVertex _:_ _forall_ [a b c] {PrelBase.Eq b, PrelBase.Ord a} => FlattenedDependencyInfo b a c -> b -> c ;; +1 mkDigraph _:_ _forall_ [a] => [a] -> Digraph a ;; +1 mkEdges _:_ _forall_ [a b c] {PrelBase.Eq c, PrelBase.Ord a} => [c] -> FlattenedDependencyInfo c a b -> [Edge c] ;; +1 mkVertices _:_ _forall_ [a b c] => FlattenedDependencyInfo c a b -> [c] ;; +1 stronglyConnComp _:_ _forall_ [a] {PrelBase.Eq a} => [Edge a] -> [a] -> [[a]] ;; +1 topSort _:_ _forall_ [a] {PrelBase.Eq a} => [Edge a] -> [a] -> MaybeErr [a] [[a]] ;;