ghc/compiler/tests/deSugar/ds036.stderr

   1 Desugared:
   2 Test2.brack' :: for all a. <Eq a> -> a -> a -> Int -> [a] -> ([a], [a])
   3 Test2.brack' =
   4     /\ a -> \ dict.124 ->
   5         let dict.119 = dict.124 in
   6         let dict.96 = dfun.Num.Int in
   7         let dict.97 = dfun.Eq.Int in
   8         let dict.104 = dfun.Num.Int in
   9         let dict.105 = dfun.Ord.Int in
  10         let dict.113 = dfun.Num.Int in
  11         let dict.114 = dfun.Ord.Int in
  12         let
  13           brack'.92 =
  14               \ open.64 close.63 ds.148 xs.65 ->
  15                   let
  16                     fail.149 =
  17                         (error ([a], [a]))
  18                             "\"ds036.hs\", line 24: pattern-matching failure [function binding]\n"S in
  19                   let
  20                     fail.151 =
  21                         let n.150 = MkInt! 1#
  22                         in
  23                           case (geInt ds.148 (MkInt! 1#)) of {
  24                             True ->
  25                                 let n.67 = minusInt ds.148 (MkInt! 1#)
  26                                 in
  27                                   case xs.65 of {
  28                                     Nil ->
  29                                         let close.66 = close.63 in
  30                                         let open.68 = open.64
  31                                         in  MkTuple2! [a] [a] (Nil! a) (Nil! a)
  32                                     (:) h.70 t.73 ->
  33                                         let close.69 = close.63 in
  34                                         let open.72 = open.64
  35                                         in
  36                                           case
  37                                               ((== a) dict.119 h.70 open.72)
  38                                           of {
  39                                             True ->
  40                                                 MkTuple2!
  41                                                     [a] [a] (Nil! a) (Nil! a)
  42                                             False -> fail.149
  43                                           }
  44                                   }
  45                             False -> fail.149
  46                           }
  47                   in
  48                     case ds.148 of {
  49                       MkInt ds.152 ->
  50                           case ds.152 of {
  51                             0# -> MkTuple2! [a] [a] (Nil! a) xs.65
  52                             _ ->  fail.151
  53                           }
  54                     }
  55         in  brack'.92
  56 Test2.kh ::
  57     for all d, e. <Ord e> -> <Num e> -> <Ord d> -> <Num d> -> d -> e -> e
  58 Test2.kh =
  59     /\ t141 t145 -> \ dict.147 dict.146 dict.143 dict.142 ->
  60         let dict.138 = dict.146 in
  61         let dict.136 = dict.138 in
  62         let dict.133 = dict.147 in
  63         let dict.129 = dict.142 in
  64         let dict.130 = dict.143 in
  65         let
  66           kh.126 =
  67               \ n.74 x.75 ->
  68                   let
  69                     fail.154 =
  70                         (error t145)
  71                             "\"ds036.hs\", line 45: pattern-matching failure [function binding]\n"S in
  72                   let n.157 = (fromInteger t141) dict.129 (MkInteger! 2##)
  73                   in
  74                     case
  75                         ((>= t141)
  76                              dict.130
  77                              n.74
  78                              ((fromInteger t141) dict.129 (MkInteger! 2##)))
  79                     of {
  80                       True ->
  81                           let
  82                             n.74 =
  83                                 (- t141)
  84                                     dict.129
  85                                     n.74
  86                                     ((fromInteger t141)
  87                                          dict.129 (MkInteger! 2##))
  88                           in
  89                             case ((> t145) dict.133 x.75 n.74) of {
  90                               True ->
  91                                   (* t145)
  92                                       dict.136
  93                                       x.75
  94                                       ((fromInteger t145)
  95                                            dict.138 (MkInteger! 2##))
  96                               False -> fail.154
  97                             }
  98                       False ->
  99                           let
 100                             x.156 = (fromInteger t141) dict.142 (MkInteger! 1##)
 101                           in
 102                             case
 103                                 ((>= t141)
 104                                      dict.143
 105                                      n.74
 106                                      ((fromInteger t141)
 107                                           dict.142 (MkInteger! 1##)))
 108                             of {
 109                               True ->
 110                                   let
 111                                     x.77 =
 112                                         (- t141)
 113                                             dict.142
 114                                             n.74
 115                                             ((fromInteger t141)
 116                                                  dict.142 (MkInteger! 1##)) in
 117                                   let
 118                                     m.155 =
 119                                         (fromInteger t145)
 120                                             dict.146 (MkInteger! 1##)
 121                                   in
 122                                     case
 123                                         ((>= t145)
 124                                              dict.147
 125                                              x.75
 126                                              ((fromInteger t145)
 127                                                   dict.146 (MkInteger! 1##)))
 128                                     of {
 129                                       True ->
 130                                           let
 131                                             m.76 =
 132                                                 (- t145)
 133                                                     dict.146
 134                                                     x.75
 135                                                     ((fromInteger t145)
 136                                                          dict.146
 137                                                          (MkInteger! 1##))
 138                                           in  m.76
 139                                       False -> fail.154
 140                                     }
 141                               False -> fail.154
 142                             }
 143                     }
 144         in  kh.126
 145