[project @ 1996-01-08 20:28:12 by partain]
[ghc.git] / 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