ghc/compiler/tests/deSugar/ds025.stderr

   1 Desugared:
   2 Util.ehead :: for all a. [a] -> [Char] -> a
   3 Util.ehead =
   4     /\ a -> \ xs.152 loc.153 ->
   5         let
   6           fail.154 =
   7               (error a)
   8                   "\"ds025.hs\", line 8: pattern-matching failure [function binding]\n"S
   9         in
  10           case ((null a) xs.152) of {
  11             True -> (error a) ((++ Char) "4"S loc.153)
  12             False -> (head a) xs.152
  13           }
  14 Util.assoc :: for all a, a. <Eq a> -> <Text a> -> a -> [(a, a)] -> [Char] -> a
  15 Util.assoc =
  16     /\ a a -> \ dict.120 dict.128 key.165 lst.166 loc.167 ->
  17         let
  18           res.174 =
  19               let
  20                 {- CoRec -}
  21                 ds.168 =
  22                     \ ds.169 ->
  23                         case ds.169 of {
  24                           Nil -> Nil a
  25                           (:) ds.170 ds.171 ->
  26                               case ds.170 of {
  27                                 MkTuple2 key'.172 val.173 ->
  28                                     case ((== a) dict.120 key.165 key'.172) of {
  29                                       True -> (: a) val.173 (ds.168 ds.171)
  30                                       False -> ds.168 ds.171
  31                                     }
  32                               }
  33                         }
  34                 {- end CoRec -}
  35               in  ds.168 lst.166
  36         in
  37           case ((null a) res.174) of {
  38             True ->
  39                 (error a)
  40                     ((++ Char)
  41                          "1"S
  42                          ((++ Char)
  43                               loc.167
  44                               ((++ Char) "2"S ((show a) dict.128 key.165))))
  45             False -> (Util.ehead a) res.174 "3"S
  46           }
  47 Util.assocMaybe :: for all a, b. <Eq a> -> a -> [(a, b)] -> Util.Maybe b
  48 Util.assocMaybe =
  49     /\ a b -> \ dict.150 ->
  50         let dict.142 = dict.150 in
  51         let
  52           assocMaybe.134 =
  53               \ key.80 lst.81 ->
  54                   let
  55                     res.82 =
  56                         let
  57                           {- CoRec -}
  58                           ds.179 =
  59                               \ ds.180 ->
  60                                   case ds.180 of {
  61                                     Nil -> Nil b
  62                                     (:) ds.181 ds.182 ->
  63                                         case ds.181 of {
  64                                           MkTuple2 key'.183 val.184 ->
  65                                               case
  66                                                   ((== a)
  67                                                        dict.142 key.80 key'.183)
  68                                               of {
  69                                                 True ->
  70                                                     (: b)
  71                                                         val.184 (ds.179 ds.182)
  72                                                 False -> ds.179 ds.182
  73                                               }
  74                                         }
  75                                   }
  76                           {- end CoRec -}
  77                         in  ds.179 lst.81
  78                   in
  79                     case ((null b) res.82) of {
  80                       True -> Util.Nothing b
  81                       False -> (Util.Just b) ((head b) res.82)
  82                     }
  83         in  assocMaybe.134
  84