ghc/compiler/tests/typecheck/should_succeed/tc042.stderr

   1 Typechecked:
   2 AbsBinds [] [] [(idb.t1, ShouldSucceed.idb)]
   3     {- nonrec -}
   4     idb.t1 :: ShouldSucceed.Boolean -> ShouldSucceed.Boolean
   5     idb.t1
   6         x.r91 = x.r91
   7 AbsBinds [a.t12, b.t13] [] [(swap.t4, ShouldSucceed.swap)]
   8     {- nonrec -}
   9     swap.t4 :: ShouldSucceed.Pair b.t13 a.t12 -> ShouldSucceed.Pair a.t12 b.t13
  10     swap.t4
  11         t.r92 = case t.r92 of
  12                   (ShouldSucceed.Mkpair x.r93 y.r94)
  13                           -> (ShouldSucceed.Mkpair [a.t12, b.t13]) y.r94 x.r93
  14 AbsBinds [] [] [(neg.t16, ShouldSucceed.neg)]
  15     {- nonrec -}
  16     neg.t16 :: ShouldSucceed.Boolean -> ShouldSucceed.Boolean
  17     neg.t16
  18         b.r95 = case b.r95 of
  19                   ShouldSucceed.FF
  20                           -> ShouldSucceed.TT
  21                   ShouldSucceed.TT
  22                           -> ShouldSucceed.FF
  23 AbsBinds [alpha.t26] [] [(null.t20, ShouldSucceed.null)]
  24     {- nonrec -}
  25     null.t20 :: ShouldSucceed.List alpha.t26 -> ShouldSucceed.Boolean
  26     null.t20
  27         l.r96 = case l.r96 of
  28                   ShouldSucceed.Nil
  29                           -> ShouldSucceed.TT
  30                   (ShouldSucceed.Cons y.r97 ys.r98)
  31                           -> ShouldSucceed.FF
  32 AbsBinds [a.t30] [] [(idl.t29, ShouldSucceed.idl)]
  33     {- rec -}
  34     idl.t29 :: ShouldSucceed.List a.t30 -> ShouldSucceed.List a.t30
  35     idl.t29
  36         xs.r99 = case xs.r99 of
  37                    ShouldSucceed.Nil
  38                            -> ShouldSucceed.Nil a.t30
  39                    (ShouldSucceed.Cons y.r100 ys.r101)
  40                            -> (ShouldSucceed.Cons a.t30)
  41                                   y.r100 (idl.t29 ys.r101)
  42 AbsBinds [] [] [(add.t41, ShouldSucceed.add)]
  43     {- rec -}
  44     add.t41 :: ShouldSucceed.Nat -> ShouldSucceed.Nat -> ShouldSucceed.Nat
  45     add.t41
  46         a.r102 b.r103
  47                 = case a.r102 of
  48                     ShouldSucceed.Zero
  49                             -> b.r103
  50                     (ShouldSucceed.Succ c.r104)
  51                             -> ShouldSucceed.Succ (add.t41 c.r104 b.r103)
  52 AbsBinds [alpha.t49] [] [(app.t48, ShouldSucceed.app)]
  53     {- rec -}
  54     app.t48 ::
  55         ShouldSucceed.List alpha.t49
  56         -> ShouldSucceed.List alpha.t49 -> ShouldSucceed.List alpha.t49
  57     app.t48
  58         xs.r105 zs.r106
  59                 = case xs.r105 of
  60                     ShouldSucceed.Nil
  61                             -> zs.r106
  62                     (ShouldSucceed.Cons y.r107 ys.r108)
  63                             -> (ShouldSucceed.Cons alpha.t49)
  64                                    y.r107 (app.t48 ys.r108 zs.r106)
  65 AbsBinds [a.t61] [] [(length.t60, ShouldSucceed.length)]
  66     {- rec -}
  67     length.t60 :: ShouldSucceed.List a.t61 -> ShouldSucceed.Nat
  68     length.t60
  69         xs.r109 = case xs.r109 of
  70                     ShouldSucceed.Nil
  71                             -> ShouldSucceed.Zero
  72                     (ShouldSucceed.Cons y.r110 ys.r111)
  73                             -> ShouldSucceed.Succ (length.t60 ys.r111)
  74 AbsBinds [] [] [(before.t70, ShouldSucceed.before)]
  75     {- rec -}
  76     before.t70 ::
  77         ShouldSucceed.List ShouldSucceed.Nat
  78         -> ShouldSucceed.List ShouldSucceed.Nat
  79     before.t70
  80         xs.r112 = case xs.r112 of
  81                     ShouldSucceed.Nil
  82                             -> ShouldSucceed.Nil ShouldSucceed.Nat
  83                     (ShouldSucceed.Cons y.r113 ys.r114)
  84                             -> case y.r113 of
  85                                  ShouldSucceed.Zero
  86                                          -> ShouldSucceed.Nil ShouldSucceed.Nat
  87                                  (ShouldSucceed.Succ n.r115)
  88                                          -> (ShouldSucceed.Cons
  89                                                  ShouldSucceed.Nat)
  90                                                 y.r113 (before.t70 ys.r114)
  91 AbsBinds [alpha.t95] [] [(reverse.t84, ShouldSucceed.reverse)]
  92     {- rec -}
  93     reverse.t84 :: ShouldSucceed.List alpha.t95 -> ShouldSucceed.List alpha.t95
  94     reverse.t84
  95         rs.r116 = case rs.r116 of
  96                     ShouldSucceed.Nil
  97                             -> ShouldSucceed.Nil alpha.t95
  98                     (ShouldSucceed.Cons y.r117 ys.r118)
  99                             -> (ShouldSucceed.app alpha.t95)
 100                                    (reverse.t84 ys.r118)
 101                                    ((ShouldSucceed.Cons alpha.t95)
 102                                         y.r117 (ShouldSucceed.Nil alpha.t95))
 103 AbsBinds [alpha.t108] [] [(flatten.t98, ShouldSucceed.flatten)]
 104     {- rec -}
 105     flatten.t98 ::
 106         ShouldSucceed.Tree alpha.t108 -> ShouldSucceed.List alpha.t108
 107     flatten.t98
 108         t.r119 = case t.r119 of
 109                    (ShouldSucceed.Leaf x.r120)
 110                            -> (ShouldSucceed.Cons alpha.t108)
 111                                   x.r120 (ShouldSucceed.Nil alpha.t108)
 112                    (ShouldSucceed.Node l.r121 r.r122)
 113                            -> (ShouldSucceed.app alpha.t108)
 114                                   (flatten.t98 l.r121) (flatten.t98 r.r122)
 115 AbsBinds [] [] [(sum.t113, ShouldSucceed.sum)]
 116     {- rec -}
 117     sum.t113 :: ShouldSucceed.Tree ShouldSucceed.Nat -> ShouldSucceed.Nat
 118     sum.t113
 119         t.r123 = case t.r123 of
 120                    (ShouldSucceed.Leaf t.r124)
 121                            -> t.r124
 122                    (ShouldSucceed.Node l.r125 r.r126)
 123                            -> ShouldSucceed.add
 124                                   (sum.t113 l.r125) (sum.t113 r.r126)
 125