--- /dev/null
+Desugared:
+Tests.f :: for all d, e, f. <Fractional e> -> <Num d> -> d -> e -> [f]
+Tests.f =
+ /\ t101 t104 t107 -> \ dict.105 dict.102 ->
+ let dict.98 = dict.105 in
+ let dict.91 = dict.98 in
+ let dict.84 = dict.91 in
+ let
+ dict.106 = (sdsel.Num.Eq t104) ((sdsel.Fractional.Num t104) dict.84) in
+ let dict.99 = dict.106 in
+ let dict.92 = dict.99 in
+ let dict.85 = dict.92 in
+ let dict.95 = dict.102 in
+ let dict.88 = dict.95 in
+ let dict.81 = dict.88 in
+ let dict.103 = (sdsel.Num.Eq t101) dict.81 in
+ let dict.96 = dict.103 in
+ let dict.89 = dict.96 in
+ let dict.82 = dict.89 in
+ let
+ f.79 =
+ \ ds.179 ds.180 ->
+ let
+ fail.181 =
+ (error [t107])
+ "\"ds022.hs\", line 10: pattern-matching failure [function binding]\n"S
+ in
+ case
+ ((== t101)
+ dict.82
+ ((fromInteger t101) dict.81 (MkInteger! 1##))
+ ds.179)
+ of {
+ True ->
+ case
+ ((== t104)
+ dict.85
+ ((fromRational t104)
+ dict.84 (MkDouble! 1.1000000000000001##))
+ ds.180)
+ of {
+ True -> Nil! t107
+ False -> fail.181
+ }
+ False ->
+ case
+ ((== t101)
+ dict.89
+ ((fromInteger t101) dict.88 (MkInteger! 2##))
+ ds.179)
+ of {
+ True ->
+ case
+ ((== t104)
+ dict.92
+ ((fromRational t104)
+ dict.91
+ (MkDouble! 2.2000000000000002##))
+ ds.180)
+ of {
+ True -> Nil! t107
+ False -> fail.181
+ }
+ False ->
+ case
+ ((== t101)
+ dict.96
+ ((fromInteger t101)
+ dict.95 (MkInteger! 3##))
+ ds.179)
+ of {
+ True ->
+ case
+ ((== t104)
+ dict.99
+ ((fromRational t104)
+ dict.98
+ (MkDouble!
+ 3.2999999999999998##))
+ ds.180)
+ of {
+ True -> Nil! t107
+ False -> fail.181
+ }
+ False ->
+ case
+ ((== t101)
+ dict.103
+ ((fromInteger t101)
+ dict.102 (MkInteger! 4##))
+ ds.179)
+ of {
+ True ->
+ case
+ ((== t104)
+ dict.106
+ ((fromRational t104)
+ dict.105
+ (MkDouble!
+ 4.4000000000000004##))
+ ds.180)
+ of {
+ True -> Nil! t107
+ False -> fail.181
+ }
+ False -> fail.181
+ }
+ }
+ }
+ }
+ in f.79
+Tests.g :: for all d, e, f. <Fractional e> -> <Num d> -> d -> e -> [f]
+Tests.g =
+ /\ t131 t134 t137 -> \ dict.135 dict.132 ->
+ let dict.128 = dict.135 in
+ let dict.121 = dict.128 in
+ let dict.114 = dict.121 in
+ let
+ dict.136 = (sdsel.Num.Eq t134) ((sdsel.Fractional.Num t134) dict.114) in
+ let dict.129 = dict.136 in
+ let dict.122 = dict.129 in
+ let dict.115 = dict.122 in
+ let dict.125 = dict.132 in
+ let dict.118 = dict.125 in
+ let dict.111 = dict.118 in
+ let dict.133 = (sdsel.Num.Eq t131) dict.111 in
+ let dict.126 = dict.133 in
+ let dict.119 = dict.126 in
+ let dict.112 = dict.119 in
+ let
+ g.109 =
+ \ ds.183 ds.184 ->
+ let
+ fail.185 =
+ (error [t137])
+ "\"ds022.hs\", line 15: pattern-matching failure [function binding]\n"S
+ in
+ case
+ ((== t131)
+ dict.112
+ ((fromInteger t131)
+ dict.111
+ (MkInteger! 11111111111111111111111##))
+ ds.183)
+ of {
+ True ->
+ case
+ ((== t134)
+ dict.115
+ ((fromRational t134)
+ dict.114
+ (MkDouble! 1.1111111111111112##))
+ ds.184)
+ of {
+ True -> Nil! t137
+ False -> fail.185
+ }
+ False ->
+ case
+ ((== t131)
+ dict.119
+ ((fromInteger t131)
+ dict.118
+ (MkInteger! 22222222222222222222222##))
+ ds.183)
+ of {
+ True ->
+ case
+ ((== t134)
+ dict.122
+ ((fromRational t134)
+ dict.121
+ (MkDouble! 2.2222222222222223##))
+ ds.184)
+ of {
+ True -> Nil! t137
+ False -> fail.185
+ }
+ False ->
+ case
+ ((== t131)
+ dict.126
+ ((fromInteger t131)
+ dict.125
+ (MkInteger!
+ 33333333333333333333333##))
+ ds.183)
+ of {
+ True ->
+ case
+ ((== t134)
+ dict.129
+ ((fromRational t134)
+ dict.128
+ (MkDouble!
+ 3.3333333333333335##))
+ ds.184)
+ of {
+ True -> Nil! t137
+ False -> fail.185
+ }
+ False ->
+ case
+ ((== t131)
+ dict.133
+ ((fromInteger t131)
+ dict.132
+ (MkInteger!
+ 44444444444444444444444##))
+ ds.183)
+ of {
+ True ->
+ case
+ ((== t134)
+ dict.136
+ ((fromRational t134)
+ dict.135
+ (MkDouble!
+ 4.4444444444444446##))
+ ds.184)
+ of {
+ True -> Nil! t137
+ False -> fail.185
+ }
+ False -> fail.185
+ }
+ }
+ }
+ }
+ in g.109
+Tests.h :: for all d. Char -> [Char] -> [d]
+Tests.h =
+ /\ t148 -> \ ds.200 ds.201 ->
+ let
+ fail.202 =
+ (error [t148])
+ "\"ds022.hs\", line 20: pattern-matching failure [function binding]\n"S
+ in
+ case ds.200 of {
+ MkChar ds.203 ->
+ case ds.203 of {
+ 'a'# ->
+ case (eqString (Nil! Char) ds.201) of {
+ True -> Nil! t148
+ False -> fail.202
+ }
+ '\''# ->
+ case (eqString "foo"S ds.201) of {
+ True -> Nil! t148
+ False -> fail.202
+ }
+ '"'# ->
+ case ds.201 of {
+ (:) ds.204 ds.205 ->
+ case ds.204 of {
+ MkChar ds.206 ->
+ case ds.206 of {
+ 'b'# ->
+ case ds.205 of {
+ (:) ds.207 ds.208 ->
+ case ds.207 of {
+ MkChar ds.209 ->
+ case ds.209 of {
+ 'a'# ->
+ case ds.208 of {
+ (:) ds.210 ds.211 ->
+ case ds.210 of {
+ MkChar ds.212 ->
+ case
+ ds.212
+ of {
+ 'r'# ->
+ case
+ ds.211
+ of {
+ Nil ->
+ Nil! t148
+ _ ->
+ fail.202
+ }
+ _ ->
+ fail.202
+ }
+ }
+ _ -> fail.202
+ }
+ _ -> fail.202
+ }
+ }
+ _ -> fail.202
+ }
+ _ -> fail.202
+ }
+ }
+ _ -> fail.202
+ }
+ 'ยจ'# -> let blob.213 = ds.201 in Nil! t148
+ _ -> fail.202
+ }
+ }
+Tests.i :: for all d, e, f. <Fractional e> -> <Num d> -> d -> e -> [f]
+Tests.i =
+ /\ t172 t175 t178 -> \ dict.176 dict.173 ->
+ let dict.169 = dict.176 in
+ let dict.162 = dict.169 in
+ let dict.155 = dict.162 in
+ let
+ dict.177 = (sdsel.Num.Eq t175) ((sdsel.Fractional.Num t175) dict.155) in
+ let dict.170 = dict.177 in
+ let dict.163 = dict.170 in
+ let dict.156 = dict.163 in
+ let dict.166 = dict.173 in
+ let dict.159 = dict.166 in
+ let dict.152 = dict.159 in
+ let dict.174 = (sdsel.Num.Eq t172) dict.152 in
+ let dict.167 = dict.174 in
+ let dict.160 = dict.167 in
+ let dict.153 = dict.160 in
+ let
+ i.150 =
+ \ ds.214 ds.215 ->
+ let
+ fail.216 =
+ (error [t178])
+ "\"ds022.hs\", line 25: pattern-matching failure [function binding]\n"S
+ in
+ case
+ ((== t172)
+ dict.153
+ ((fromInteger t172) dict.152 (MkInteger! 1##))
+ ds.214)
+ of {
+ True ->
+ case
+ ((== t175)
+ dict.156
+ ((fromRational t175)
+ dict.155
+ (MkDouble! 1.1000000000000001##))
+ ds.215)
+ of {
+ True -> Nil! t178
+ False -> fail.216
+ }
+ False ->
+ case
+ ((== t172)
+ dict.160
+ ((fromInteger t172) dict.159 (MkInteger! 2##))
+ ds.214)
+ of {
+ True ->
+ case
+ ((== t175)
+ dict.163
+ ((fromRational t175)
+ dict.162
+ (MkDouble! 2.2000000000000002##))
+ ds.215)
+ of {
+ True -> Nil! t178
+ False -> fail.216
+ }
+ False -> fail.216
+ }
+ }
+ in i.150
+
projects / ghc-hetmet.git / blobdiff