ghc/compiler/tests/deSugar/ds009.stderr

   1 Desugared:
   2 SimpleListComp.f :: for all d. [d] -> [d]
   3 SimpleListComp.f =
   4     /\ t104 -> \ xs.145 ->
   5         let
   6           {- CoRec -}
   7           ds.146 =
   8               \ ds.147 ->
   9                   case ds.147 of {
  10                     Nil -> Nil t104
  11                     (:) ds.148 ds.149 ->
  12                         let x.150 = ds.148 in  (: t104) x.150 (ds.146 ds.149)
  13                   }
  14           {- end CoRec -}
  15         in  ds.146 xs.145
  16 SimpleListComp.g :: for all d, e, f. [d] -> [e] -> [f] -> [(d, e, f)]
  17 SimpleListComp.g =
  18     /\ t110 t111 t112 -> \ xs.163 ys.164 zs.165 ->
  19         let
  20           {- CoRec -}
  21           ds.166 =
  22               \ ds.167 ->
  23                   case ds.167 of {
  24                     Nil -> Nil (t110, t111, t112)
  25                     (:) ds.168 ds.169 ->
  26                         let x.170 = ds.168
  27                         in
  28                           let
  29                             {- CoRec -}
  30                             ds.171 =
  31                                 \ ds.172 ->
  32                                     case ds.172 of {
  33                                       Nil -> ds.166 ds.169
  34                                       (:) ds.173 ds.174 ->
  35                                           let y.175 = ds.173
  36                                           in
  37                                             let
  38                                               {- CoRec -}
  39                                               ds.176 =
  40                                                   \ ds.177 ->
  41                                                       case ds.177 of {
  42                                                         Nil -> ds.171 ds.174
  43                                                         (:) ds.178 ds.179 ->
  44                                                             let z.180 = ds.178
  45                                                             in
  46                                                               (: (t110,
  47                                                                   t111,
  48                                                                   t112))
  49                                                                   (MkTuple3!
  50                                                                        t110
  51                                                                        t111
  52                                                                        t112
  53                                                                        x.170
  54                                                                        y.175
  55                                                                        z.180)
  56                                                                   (ds.176 ds.179)
  57                                                       }
  58                                               {- end CoRec -}
  59                                             in  ds.176 zs.165
  60                                     }
  61                             {- end CoRec -}
  62                           in  ds.171 ys.164
  63                   }
  64           {- end CoRec -}
  65         in  ds.166 xs.163
  66 SimpleListComp.h :: for all d. [d] -> [d] -> [[d]]
  67 SimpleListComp.h =
  68     /\ t118 -> \ xs.189 ys.190 ->
  69         let
  70           {- CoRec -}
  71           ds.191 =
  72               \ ds.192 ->
  73                   case ds.192 of {
  74                     Nil -> Nil [t118]
  75                     (:) ds.193 ds.194 ->
  76                         let x.195 = ds.193
  77                         in
  78                           let
  79                             {- CoRec -}
  80                             ds.196 =
  81                                 \ ds.197 ->
  82                                     case ds.197 of {
  83                                       Nil -> ds.191 ds.194
  84                                       (:) ds.198 ds.199 ->
  85                                           let y.200 = ds.198 in  ds.196 ds.199
  86                                     }
  87                             {- end CoRec -}
  88                           in  ds.196 ys.190
  89                   }
  90           {- end CoRec -}
  91         in  ds.191 xs.189
  92 SimpleListComp.i :: for all d, e. <Eq d> -> <Eq e> -> [([e], [d])] -> [[e]]
  93 SimpleListComp.i =
  94     /\ t128 t127 -> \ dict.133 dict.132 ->
  95         let dict.130 = (dfun.Eq.List t127) dict.132 in
  96         let dict.131 = (dfun.Eq.List t128) dict.133 in
  97         let dict.126 = ((dfun.Eq.Tuple2 [t127]) [t128]) dict.130 dict.131 in
  98         let
  99           i.120 =
 100               \ xs.78 ->
 101                   let
 102                     {- CoRec -}
 103                     ds.201 =
 104                         \ ds.202 ->
 105                             case ds.202 of {
 106                               Nil -> Nil [t127]
 107                               (:) ds.203 ds.204 ->
 108                                   case ds.203 of {
 109                                     MkTuple2 x.80 y.81 ->
 110                                         let all.79 = ds.203
 111                                         in
 112                                           case
 113                                               ((== ([t127], [t128]))
 114                                                    dict.126
 115                                                    all.79
 116                                                    (MkTuple2!
 117                                                         [t127]
 118                                                         [t128]
 119                                                         (Nil! t127)
 120                                                         (Nil! t128)))
 121                                           of {
 122                                             True ->
 123                                                 (: [t127]) x.80 (ds.201 ds.204)
 124                                             False -> ds.201 ds.204
 125                                           }
 126                                   }
 127                             }
 128                     {- end CoRec -}
 129                   in  ds.201 xs.78
 130         in  i.120
 131 SimpleListComp.j :: for all d, e, f, g. [(f, g, d, e)] -> [(f, g)]
 132 SimpleListComp.j =
 133     /\ t139 t140 t137 t138 -> \ xs.210 ->
 134         let
 135           {- CoRec -}
 136           ds.211 =
 137               \ ds.212 ->
 138                   case ds.212 of {
 139                     Nil -> Nil (t137, t138)
 140                     (:) ds.213 ds.214 ->
 141                         case ds.213 of {
 142                           MkTuple4 a.215 b.216 c.217 d.218 ->
 143                               (: (t137, t138))
 144                                   (MkTuple2! t137 t138 a.215 b.216)
 145                                   (ds.211 ds.214)
 146                         }
 147                   }
 148           {- end CoRec -}
 149         in  ds.211 xs.210
 150