X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftests%2FdeSugar%2Fds020.stderr;fp=ghc%2Fcompiler%2Ftests%2FdeSugar%2Fds020.stderr;h=5c0371c9d7aaa50a27ba909134b095867fbf60b9;hb=e7d21ee4f8ac907665a7e170c71d59e13a01da09;hp=0000000000000000000000000000000000000000;hpb=e48474bff05e6cfb506660420f025f694c870d38;p=ghc-hetmet.git diff --git a/ghc/compiler/tests/deSugar/ds020.stderr b/ghc/compiler/tests/deSugar/ds020.stderr new file mode 100644 index 0000000..5c0371c --- /dev/null +++ b/ghc/compiler/tests/deSugar/ds020.stderr @@ -0,0 +1,464 @@ +Desugared: +Test.a :: for all d, e, f, g. ([d], [e], [f]) -> [g] +Test.a = /\ t118 t119 t120 t121 -> \ ds.314 -> Nil! t121 +Test.b :: for all d, e. [d] -> [e] +Test.b = + /\ t134 t135 -> \ ds.323 -> + let + x.328 = + case ds.323 of { + (:) x.324 ds.325 -> + case ds.325 of { + (:) xs.326 ys.327 -> x.324 + _ -> + (error Char) + "``impossible'' pattern-matching error!\n"S + } + _ -> (error Char) "``impossible'' pattern-matching error!\n"S + } in + let + xs.333 = + case ds.323 of { + (:) x.329 ds.330 -> + case ds.330 of { + (:) xs.331 ys.332 -> xs.331 + _ -> + (error Char) + "``impossible'' pattern-matching error!\n"S + } + _ -> (error Char) "``impossible'' pattern-matching error!\n"S + } in + let + ys.338 = + case ds.323 of { + (:) x.334 ds.335 -> + case ds.335 of { + (:) xs.336 ys.337 -> ys.337 + _ -> + (error Char) + "``impossible'' pattern-matching error!\n"S + } + _ -> (error Char) "``impossible'' pattern-matching error!\n"S + } + in Nil! t135 +Test.c :: for all d, e, f, g. -> -> g -> d -> e -> f -> g +Test.c = + /\ o139 t140 t143 o138 -> \ dict.144 dict.141 -> + let + dict.145 = (sdsel.Num.Eq t143) ((sdsel.Fractional.Num t143) dict.144) in + let dict.142 = (sdsel.Num.Eq t140) dict.141 in + let c.137 = \ x.87 ds.339 ds.340 ds.341 -> let x.87 = x.87 in x.87 + in c.137 +Test.d :: for all d, e. -> -> -> d -> e +Test.d = + /\ t171 t174 -> \ dict.175 dict.173 dict.172 -> + let dict.169 = dict.175 in + let dict.163 = dict.169 in + let dict.157 = dict.163 in + let dict.152 = dict.157 in + let dict.166 = dict.172 in + let dict.160 = dict.166 in + let dict.154 = dict.160 in + let dict.149 = dict.154 in + let dict.167 = dict.173 in + let dict.161 = dict.167 in + let dict.155 = (sdsel.Ord.Eq t171) dict.161 in + let dict.150 = dict.155 in + let + d.147 = + \ ds.344 -> + let + fail.345 = + (error t174) + "\"ds020.hs\", line 17: pattern-matching failure [function binding]\n"S in + let + fail.349 = + let + n.88 = + let + n.346 = + (fromInteger t171) dict.160 (MkInteger! 4##) + in + case + ((>= t171) + dict.161 + ds.344 + ((fromInteger t171) + dict.160 (MkInteger! 4##))) + of { + True -> + let + n.88 = + (- t171) + dict.160 + ds.344 + ((fromInteger t171) + dict.160 (MkInteger! 4##)) + in n.88 + False -> + (error Char) + "``impossible'' pattern-matching error!\n"S + } + in (fromInteger t174) dict.163 (MkInteger! 2##) + in + case + ((== t171) + dict.150 + ((fromInteger t171) dict.149 (MkInteger! 11##)) + ds.344) + of { + True -> (fromInteger t174) dict.152 (MkInteger! 4##) + False -> + case + ((== t171) + dict.155 + ((fromInteger t171) + dict.154 (MkInteger! 12##)) + ds.344) + of { + True -> (fromInteger t174) dict.157 (MkInteger! 3##) + False -> fail.349 + } + } + in d.147 +Test.f :: for all d, e. [d] -> [e] +Test.f = + /\ t182 t183 -> \ x.352 -> + let + x.353 = + case x.352 of { + Nil -> x.352 + _ -> (error Char) "``impossible'' pattern-matching error!\n"S + } + in Nil! t183 +Test.g :: for all d, e. [d] -> [e] +Test.g = /\ t186 t187 -> \ ds.356 -> Nil! t187 +ds.357 :: ([t191], [t192], [t193]) +ds.357 = MkTuple3! [t191] [t192] [t193] (Nil! t191) (Nil! t192) (Nil! t193) +ds.358 :: ([t197], [t198], [t199]) +ds.358 = MkTuple3! [t197] [t198] [t199] (Nil! t197) (Nil! t198) (Nil! t199) +ds.359 :: [t208] +ds.359 = /\ t208 -> Nil! t208 +Test.x1 :: for all d. d +Test.x1 = + /\ t208 -> + case ds.359 of { + (:) x1.363 ds.364 -> + case ds.364 of { + (:) xs1.365 ys1.366 -> x1.363 + _ -> (error Char) "``impossible'' pattern-matching error!\n"S + } + _ -> (error Char) "``impossible'' pattern-matching error!\n"S + } +Test.xs1 :: for all d. d +Test.xs1 = + /\ t208 -> + case ds.359 of { + (:) x1.367 ds.368 -> + case ds.368 of { + (:) xs1.369 ys1.370 -> xs1.369 + _ -> (error Char) "``impossible'' pattern-matching error!\n"S + } + _ -> (error Char) "``impossible'' pattern-matching error!\n"S + } +Test.ys1 :: for all d. [d] +Test.ys1 = + /\ t208 -> + case ds.359 of { + (:) x1.371 ds.372 -> + case ds.372 of { + (:) xs1.373 ys1.374 -> ys1.374 + _ -> (error Char) "``impossible'' pattern-matching error!\n"S + } + _ -> (error Char) "``impossible'' pattern-matching error!\n"S + } +ds.375 :: [t217] +ds.375 = /\ t217 -> Nil! t217 +Test.x :: for all d. d +Test.x = + /\ t217 -> + case ds.375 of { + (:) x.379 ds.380 -> + case ds.380 of { + (:) xs.381 ys.382 -> + let ys.383 = ys.382 in + let xs.384 = xs.381 in let x.385 = x.379 in x.385 + _ -> (error Char) "``impossible'' pattern-matching error!\n"S + } + _ -> (error Char) "``impossible'' pattern-matching error!\n"S + } +Test.xs :: for all d. d +Test.xs = + /\ t217 -> + case ds.375 of { + (:) x.386 ds.387 -> + case ds.387 of { + (:) xs.388 ys.389 -> + let ys.390 = ys.389 in + let xs.391 = xs.388 in let x.392 = x.386 in xs.391 + _ -> (error Char) "``impossible'' pattern-matching error!\n"S + } + _ -> (error Char) "``impossible'' pattern-matching error!\n"S + } +Test.ys :: for all d. [d] +Test.ys = + /\ t217 -> + case ds.375 of { + (:) x.393 ds.394 -> + case ds.394 of { + (:) xs.395 ys.396 -> + let ys.397 = ys.396 in + let xs.398 = xs.395 in let x.399 = x.393 in ys.397 + _ -> (error Char) "``impossible'' pattern-matching error!\n"S + } + _ -> (error Char) "``impossible'' pattern-matching error!\n"S + } +{- plain CoRec -} +ds.406 :: [t254] +ds.406 = + /\ t254 -> + let dict.410 = dfun.Eq.Int in + let + eq2.413 = + eqInt + (let dict.411 = dfun.Num.Int in MkInt! 2#) + (let dict.412 = dfun.Num.Int in MkInt! 4#) in + let dict.414 = dfun.Eq.Int in + let + eq3.417 = + eqInt + (let dict.415 = dfun.Num.Int in MkInt! 3#) + (let dict.416 = dfun.Num.Int in MkInt! 3#) in + let dict.418 = dfun.Eq.Int in + let + eq4.421 = + eqInt + (let dict.419 = dfun.Num.Int in MkInt! 4#) + (let dict.420 = dfun.Num.Int in MkInt! 2#) + in + case eq2.413 of { + True -> Nil! t254 + False -> + case eq3.417 of { + True -> :! t254 (Test.x2 t254) (Nil! t254) + False -> + case eq4.421 of { + True -> :! t254 (Test.x2 t254) (Nil! t254) + False -> Nil! t254 + } + } + } +Test.x2 :: for all d. d +Test.x2 = + /\ t254 -> + case ds.406 of { + (:) x2.422 ds.423 -> + case ds.423 of { + (:) xs2.424 ys2.425 -> x2.422 + _ -> (error Char) "``impossible'' pattern-matching error!\n"S + } + _ -> (error Char) "``impossible'' pattern-matching error!\n"S + } +Test.xs2 :: for all d. d +Test.xs2 = + /\ t254 -> + case ds.406 of { + (:) x2.426 ds.427 -> + case ds.427 of { + (:) xs2.428 ys2.429 -> xs2.428 + _ -> (error Char) "``impossible'' pattern-matching error!\n"S + } + _ -> (error Char) "``impossible'' pattern-matching error!\n"S + } +Test.ys2 :: for all d. [d] +Test.ys2 = + /\ t254 -> + case ds.406 of { + (:) x2.430 ds.431 -> + case ds.431 of { + (:) xs2.432 ys2.433 -> ys2.433 + _ -> (error Char) "``impossible'' pattern-matching error!\n"S + } + _ -> (error Char) "``impossible'' pattern-matching error!\n"S + } +{- end plain CoRec -} +ds.435 :: for all d, e. -> -> -> (d, e) +ds.435 = + /\ t273 t275 -> \ dict.276 dict.269 dict.274 -> + let dict.267 = dict.276 in + let dict.271 = dict.274 in + let dict.265 = dict.271 in + let dict.262 = dict.265 in + let dict.260 = dict.269 + in + let + {- CoRec -} + ds.434 = + case + ((> t273) + dict.260 + x3.257 + ((fromInteger t273) dict.262 (MkInteger! 3##))) + of { + True -> + MkTuple2! + t273 + t275 + ((fromInteger t273) dict.265 (MkInteger! 4##)) + ((fromInteger t275) dict.267 (MkInteger! 5##)) + False -> + case + ((<= t273) + dict.269 + x3.257 + ((fromInteger t273) dict.271 (MkInteger! 3##))) + of { + True -> + MkTuple2! + t273 + t275 + ((fromInteger t273) dict.274 (MkInteger! 2##)) + ((fromInteger t275) dict.276 (MkInteger! 3##)) + False -> + (error (t273, t275)) + "\"ds020.hs\", line 42: pattern-matching failure [pat binding]\n"S + } + } + x3.257 = + case ds.434 of { + MkTuple2 x3.257 y3.258 -> x3.257 + } + y3.258 = + case ds.434 of { + MkTuple2 x3.257 y3.258 -> y3.258 + } + {- end CoRec -} + in MkTuple2! t273 t275 x3.257 y3.258 +Test.x3 :: for all d, e. -> -> -> d +Test.x3 = + /\ t273 t275 -> \ dict.276 dict.269 dict.274 -> + case (((ds.435 t273) t275) dict.276 dict.269 dict.274) of { + MkTuple2 x3.257 y3.258 -> x3.257 + } +Test.y3 :: for all d, e. -> -> -> e +Test.y3 = + /\ t273 t275 -> \ dict.276 dict.269 dict.274 -> + case (((ds.435 t273) t275) dict.276 dict.269 dict.274) of { + MkTuple2 x3.257 y3.258 -> y3.258 + } +ds.442 :: (Char, (Char, (Char, Char))) +ds.442 = + let dict.451 = dfun.Eq.Int in + let + eq2.454 = + eqInt + (let dict.452 = dfun.Num.Int in MkInt! 2#) + (let dict.453 = dfun.Num.Int in MkInt! 4#) in + let dict.455 = dfun.Eq.Int in + let + eq3.458 = + eqInt + (let dict.456 = dfun.Num.Int in MkInt! 3#) + (let dict.457 = dfun.Num.Int in MkInt! 3#) in + let dict.459 = dfun.Eq.Int in + let + eq4.462 = + eqInt + (let dict.460 = dfun.Num.Int in MkInt! 4#) + (let dict.461 = dfun.Num.Int in MkInt! 2#) + in + case eq2.454 of { + True -> + MkTuple2! + Char + (Char, (Char, Char)) + (MkChar! 'a'#) + (MkTuple2! + Char + (Char, Char) + (MkChar! 'a'#) + (MkTuple2! Char Char (MkChar! 'a'#) (MkChar! 'a'#))) + False -> + case eq3.458 of { + True -> + MkTuple2! + Char + (Char, (Char, Char)) + (MkChar! 'b'#) + (MkTuple2! + Char + (Char, Char) + (MkChar! 'b'#) + (MkTuple2! Char Char (MkChar! 'b'#) (MkChar! 'b'#))) + False -> + case eq4.462 of { + True -> + MkTuple2! + Char + (Char, (Char, Char)) + (MkChar! 'c'#) + (MkTuple2! + Char + (Char, Char) + (MkChar! 'c'#) + (MkTuple2! + Char Char (MkChar! 'c'#) (MkChar! 'c'#))) + False -> + MkTuple2! + Char + (Char, (Char, Char)) + (MkChar! 'd'#) + (MkTuple2! + Char + (Char, Char) + (MkChar! 'd'#) + (MkTuple2! + Char Char (MkChar! 'd'#) (MkChar! 'd'#))) + } + } + } +Test.x4 :: Char +Test.x4 = + case ds.442 of { + MkTuple2 x4.463 ds.464 -> + case ds.464 of { + MkTuple2 y4.465 ds.466 -> + case ds.466 of { + MkTuple2 z4.467 a4.468 -> x4.463 + } + } + } +Test.y4 :: Char +Test.y4 = + case ds.442 of { + MkTuple2 x4.469 ds.470 -> + case ds.470 of { + MkTuple2 y4.471 ds.472 -> + case ds.472 of { + MkTuple2 z4.473 a4.474 -> y4.471 + } + } + } +Test.z4 :: Char +Test.z4 = + case ds.442 of { + MkTuple2 x4.475 ds.476 -> + case ds.476 of { + MkTuple2 y4.477 ds.478 -> + case ds.478 of { + MkTuple2 z4.479 a4.480 -> z4.479 + } + } + } +Test.a4 :: Char +Test.a4 = + case ds.442 of { + MkTuple2 x4.481 ds.482 -> + case ds.482 of { + MkTuple2 y4.483 ds.484 -> + case ds.484 of { + MkTuple2 z4.485 a4.486 -> a4.486 + } + } + } +