ghc/compiler/tests/deSugar/ds022.stderr

   1 Desugared:
   2 Tests.f :: for all d, e, f. <Fractional e> -> <Num d> -> d -> e -> [f]
   3 Tests.f =
   4     /\ t101 t104 t107 -> \ dict.105 dict.102 ->
   5         let dict.98 = dict.105 in
   6         let dict.91 = dict.98 in
   7         let dict.84 = dict.91 in
   8         let
   9           dict.106 = (sdsel.Num.Eq t104) ((sdsel.Fractional.Num t104) dict.84) in
  10         let dict.99 = dict.106 in
  11         let dict.92 = dict.99 in
  12         let dict.85 = dict.92 in
  13         let dict.95 = dict.102 in
  14         let dict.88 = dict.95 in
  15         let dict.81 = dict.88 in
  16         let dict.103 = (sdsel.Num.Eq t101) dict.81 in
  17         let dict.96 = dict.103 in
  18         let dict.89 = dict.96 in
  19         let dict.82 = dict.89 in
  20         let
  21           f.79 =
  22               \ ds.179 ds.180 ->
  23                   let
  24                     fail.181 =
  25                         (error [t107])
  26                             "\"ds022.hs\", line 10: pattern-matching failure [function binding]\n"S
  27                   in
  28                     case
  29                         ((== t101)
  30                              dict.82
  31                              ((fromInteger t101) dict.81 (MkInteger! 1##))
  32                              ds.179)
  33                     of {
  34                       True ->
  35                           case
  36                               ((== t104)
  37                                    dict.85
  38                                    ((fromRational t104)
  39                                         dict.84 (MkDouble! 1.1000000000000001##))
  40                                    ds.180)
  41                           of {
  42                             True -> Nil! t107
  43                             False -> fail.181
  44                           }
  45                       False ->
  46                           case
  47                               ((== t101)
  48                                    dict.89
  49                                    ((fromInteger t101) dict.88 (MkInteger! 2##))
  50                                    ds.179)
  51                           of {
  52                             True ->
  53                                 case
  54                                     ((== t104)
  55                                          dict.92
  56                                          ((fromRational t104)
  57                                               dict.91
  58                                               (MkDouble! 2.2000000000000002##))
  59                                          ds.180)
  60                                 of {
  61                                   True -> Nil! t107
  62                                   False -> fail.181
  63                                 }
  64                             False ->
  65                                 case
  66                                     ((== t101)
  67                                          dict.96
  68                                          ((fromInteger t101)
  69                                               dict.95 (MkInteger! 3##))
  70                                          ds.179)
  71                                 of {
  72                                   True ->
  73                                       case
  74                                           ((== t104)
  75                                                dict.99
  76                                                ((fromRational t104)
  77                                                     dict.98
  78                                                     (MkDouble!
  79                                                          3.2999999999999998##))
  80                                                ds.180)
  81                                       of {
  82                                         True -> Nil! t107
  83                                         False -> fail.181
  84                                       }
  85                                   False ->
  86                                       case
  87                                           ((== t101)
  88                                                dict.103
  89                                                ((fromInteger t101)
  90                                                     dict.102 (MkInteger! 4##))
  91                                                ds.179)
  92                                       of {
  93                                         True ->
  94                                             case
  95                                                 ((== t104)
  96                                                      dict.106
  97                                                      ((fromRational t104)
  98                                                           dict.105
  99                                                           (MkDouble!
 100                                                                4.4000000000000004##))
 101                                                      ds.180)
 102                                             of {
 103                                               True -> Nil! t107
 104                                               False -> fail.181
 105                                             }
 106                                         False -> fail.181
 107                                       }
 108                                 }
 109                           }
 110                     }
 111         in  f.79
 112 Tests.g :: for all d, e, f. <Fractional e> -> <Num d> -> d -> e -> [f]
 113 Tests.g =
 114     /\ t131 t134 t137 -> \ dict.135 dict.132 ->
 115         let dict.128 = dict.135 in
 116         let dict.121 = dict.128 in
 117         let dict.114 = dict.121 in
 118         let
 119           dict.136 = (sdsel.Num.Eq t134) ((sdsel.Fractional.Num t134) dict.114) in
 120         let dict.129 = dict.136 in
 121         let dict.122 = dict.129 in
 122         let dict.115 = dict.122 in
 123         let dict.125 = dict.132 in
 124         let dict.118 = dict.125 in
 125         let dict.111 = dict.118 in
 126         let dict.133 = (sdsel.Num.Eq t131) dict.111 in
 127         let dict.126 = dict.133 in
 128         let dict.119 = dict.126 in
 129         let dict.112 = dict.119 in
 130         let
 131           g.109 =
 132               \ ds.183 ds.184 ->
 133                   let
 134                     fail.185 =
 135                         (error [t137])
 136                             "\"ds022.hs\", line 15: pattern-matching failure [function binding]\n"S
 137                   in
 138                     case
 139                         ((== t131)
 140                              dict.112
 141                              ((fromInteger t131)
 142                                   dict.111
 143                                   (MkInteger! 11111111111111111111111##))
 144                              ds.183)
 145                     of {
 146                       True ->
 147                           case
 148                               ((== t134)
 149                                    dict.115
 150                                    ((fromRational t134)
 151                                         dict.114
 152                                         (MkDouble! 1.1111111111111112##))
 153                                    ds.184)
 154                           of {
 155                             True -> Nil! t137
 156                             False -> fail.185
 157                           }
 158                       False ->
 159                           case
 160                               ((== t131)
 161                                    dict.119
 162                                    ((fromInteger t131)
 163                                         dict.118
 164                                         (MkInteger! 22222222222222222222222##))
 165                                    ds.183)
 166                           of {
 167                             True ->
 168                                 case
 169                                     ((== t134)
 170                                          dict.122
 171                                          ((fromRational t134)
 172                                               dict.121
 173                                               (MkDouble! 2.2222222222222223##))
 174                                          ds.184)
 175                                 of {
 176                                   True -> Nil! t137
 177                                   False -> fail.185
 178                                 }
 179                             False ->
 180                                 case
 181                                     ((== t131)
 182                                          dict.126
 183                                          ((fromInteger t131)
 184                                               dict.125
 185                                               (MkInteger!
 186                                                    33333333333333333333333##))
 187                                          ds.183)
 188                                 of {
 189                                   True ->
 190                                       case
 191                                           ((== t134)
 192                                                dict.129
 193                                                ((fromRational t134)
 194                                                     dict.128
 195                                                     (MkDouble!
 196                                                          3.3333333333333335##))
 197                                                ds.184)
 198                                       of {
 199                                         True -> Nil! t137
 200                                         False -> fail.185
 201                                       }
 202                                   False ->
 203                                       case
 204                                           ((== t131)
 205                                                dict.133
 206                                                ((fromInteger t131)
 207                                                     dict.132
 208                                                     (MkInteger!
 209                                                          44444444444444444444444##))
 210                                                ds.183)
 211                                       of {
 212                                         True ->
 213                                             case
 214                                                 ((== t134)
 215                                                      dict.136
 216                                                      ((fromRational t134)
 217                                                           dict.135
 218                                                           (MkDouble!
 219                                                                4.4444444444444446##))
 220                                                      ds.184)
 221                                             of {
 222                                               True -> Nil! t137
 223                                               False -> fail.185
 224                                             }
 225                                         False -> fail.185
 226                                       }
 227                                 }
 228                           }
 229                     }
 230         in  g.109
 231 Tests.h :: for all d. Char -> [Char] -> [d]
 232 Tests.h =
 233     /\ t148 -> \ ds.200 ds.201 ->
 234         let
 235           fail.202 =
 236               (error [t148])
 237                   "\"ds022.hs\", line 20: pattern-matching failure [function binding]\n"S
 238         in
 239           case ds.200 of {
 240             MkChar ds.203 ->
 241                 case ds.203 of {
 242                   'a'# ->
 243                       case (eqString (Nil! Char) ds.201) of {
 244                         True -> Nil! t148
 245                         False -> fail.202
 246                       }
 247                   '\''# ->
 248                       case (eqString "foo"S ds.201) of {
 249                         True -> Nil! t148
 250                         False -> fail.202
 251                       }
 252                   '"'# ->
 253                       case ds.201 of {
 254                         (:) ds.204 ds.205 ->
 255                             case ds.204 of {
 256                               MkChar ds.206 ->
 257                                   case ds.206 of {
 258                                     'b'# ->
 259                                         case ds.205 of {
 260                                           (:) ds.207 ds.208 ->
 261                                               case ds.207 of {
 262                                                 MkChar ds.209 ->
 263                                                     case ds.209 of {
 264                                                       'a'# ->
 265                                                           case ds.208 of {
 266                                                             (:) ds.210 ds.211 ->
 267                                                                 case ds.210 of {
 268                                                                   MkChar ds.212 ->
 269                                                                       case
 270                                                                           ds.212
 271                                                                       of {
 272                                                                         'r'# ->
 273                                                                             case
 274                                                                                 ds.211
 275                                                                             of {
 276                                                                               Nil ->
 277                                                                                   Nil! t148
 278                                                                               _ ->
 279                                                                                   fail.202
 280                                                                             }
 281                                                                         _ ->
 282                                                                             fail.202
 283                                                                       }
 284                                                                 }
 285                                                             _ ->  fail.202
 286                                                           }
 287                                                       _ ->  fail.202
 288                                                     }
 289                                               }
 290                                           _ ->  fail.202
 291                                         }
 292                                     _ ->  fail.202
 293                                   }
 294                             }
 295                         _ ->  fail.202
 296                       }
 297                   '¨'# -> let blob.213 = ds.201 in  Nil! t148
 298                   _ ->  fail.202
 299                 }
 300           }
 301 Tests.i :: for all d, e, f. <Fractional e> -> <Num d> -> d -> e -> [f]
 302 Tests.i =
 303     /\ t172 t175 t178 -> \ dict.176 dict.173 ->
 304         let dict.169 = dict.176 in
 305         let dict.162 = dict.169 in
 306         let dict.155 = dict.162 in
 307         let
 308           dict.177 = (sdsel.Num.Eq t175) ((sdsel.Fractional.Num t175) dict.155) in
 309         let dict.170 = dict.177 in
 310         let dict.163 = dict.170 in
 311         let dict.156 = dict.163 in
 312         let dict.166 = dict.173 in
 313         let dict.159 = dict.166 in
 314         let dict.152 = dict.159 in
 315         let dict.174 = (sdsel.Num.Eq t172) dict.152 in
 316         let dict.167 = dict.174 in
 317         let dict.160 = dict.167 in
 318         let dict.153 = dict.160 in
 319         let
 320           i.150 =
 321               \ ds.214 ds.215 ->
 322                   let
 323                     fail.216 =
 324                         (error [t178])
 325                             "\"ds022.hs\", line 25: pattern-matching failure [function binding]\n"S
 326                   in
 327                     case
 328                         ((== t172)
 329                              dict.153
 330                              ((fromInteger t172) dict.152 (MkInteger! 1##))
 331                              ds.214)
 332                     of {
 333                       True ->
 334                           case
 335                               ((== t175)
 336                                    dict.156
 337                                    ((fromRational t175)
 338                                         dict.155
 339                                         (MkDouble! 1.1000000000000001##))
 340                                    ds.215)
 341                           of {
 342                             True -> Nil! t178
 343                             False -> fail.216
 344                           }
 345                       False ->
 346                           case
 347                               ((== t172)
 348                                    dict.160
 349                                    ((fromInteger t172) dict.159 (MkInteger! 2##))
 350                                    ds.214)
 351                           of {
 352                             True ->
 353                                 case
 354                                     ((== t175)
 355                                          dict.163
 356                                          ((fromRational t175)
 357                                               dict.162
 358                                               (MkDouble! 2.2000000000000002##))
 359                                          ds.215)
 360                                 of {
 361                                   True -> Nil! t178
 362                                   False -> fail.216
 363                                 }
 364                             False -> fail.216
 365                           }
 366                     }
 367         in  i.150
 368