ghc/compiler/abstractSyn/HsMatches.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1994
   3 %
   4 \section[HsMatches]{Abstract syntax: matches and guarded right-hand-sides}
   5
   6 The @Match@, @GRHSsAndBinds@ and @GRHS@ datatypes.
   7
   8 \begin{code}
   9 #include "HsVersions.h"
  10
  11 module HsMatches where
  12
  13 import AbsUniType       ( UniType
  14                           IF_ATTACK_PRAGMAS(COMMA cmpUniType)
  15                         )
  16 import HsBinds          ( Binds, nullBinds )
  17 import HsExpr           ( Expr )
  18 import HsPat            ( ProtoNamePat(..), RenamedPat(..),
  19                           TypecheckedPat, InPat
  20                           IF_ATTACK_PRAGMAS(COMMA typeOfPat)
  21                         )
  22 import Name             ( Name )
  23 import Unique           ( Unique )
  24 import Id               ( Id )
  25 import Outputable
  26 import Pretty
  27 import ProtoName        ( ProtoName(..) ) -- .. for pragmas only
  28 import SrcLoc           ( SrcLoc )
  29 import Util
  30 \end{code}
  31
  32 %************************************************************************
  33 %*                                                                      *
  34 \subsection[AbsSyntax-Match]{@Match@}
  35 %*                                                                      *
  36 %************************************************************************
  37
  38 Sets of pattern bindings and right hand sides for
  39 functions, patterns or case branches. For example,
  40 if a function @g@ is defined as:
  41 \begin{verbatim}
  42 g (x,y) = y
  43 g ((x:ys),y) = y+1,
  44 \end{verbatim}
  45 then a single @Match@ would be either @(x,y) = y@ or
  46 @((x:ys),y) = y+1@, and @[Match]@ would be
  47 @[((x,y) = y), (((x:ys),y) = y+1)]@.
  48
  49 It is always the case that each element of an @[Match]@ list has the
  50 same number of @PatMatch@s inside it.  This corresponds to saying that
  51 a function defined by pattern matching must have the same number of
  52 patterns in each equation.
  53
  54 So, a single ``match'':
  55 \begin{code}
  56 data Match bdee pat
  57   = PatMatch        pat
  58                     (Match bdee pat)
  59   | GRHSMatch       (GRHSsAndBinds bdee pat)
  60
  61 type ProtoNameMatch     = Match ProtoName ProtoNamePat
  62 type RenamedMatch       = Match Name      RenamedPat
  63 type TypecheckedMatch   = Match Id        TypecheckedPat
  64 \end{code}
  65
  66 Printing, of one and several @Matches@.
  67 \begin{code}
  68 pprMatch :: (NamedThing bdee, Outputable bdee,
  69              NamedThing pat, Outputable pat) =>
  70         PprStyle -> Bool -> Match bdee pat -> Pretty
  71
  72 pprMatch sty is_case first_match
  73  = ppHang (ppSep (map (ppr sty) row_of_pats))
  74         8 grhss_etc_stuff
  75  where
  76     (row_of_pats, grhss_etc_stuff) = ppr_match sty is_case first_match
  77
  78     ppr_match sty is_case (PatMatch pat match)
  79      = (pat:pats, grhss_stuff)
  80      where
  81         (pats, grhss_stuff) = ppr_match sty is_case match
  82
  83     ppr_match sty is_case (GRHSMatch grhss_n_binds)
  84      = ([], pprGRHSsAndBinds sty is_case grhss_n_binds)
  85 \end{code}
  86
  87 We know the list must have at least one @Match@ in it.
  88 \begin{code}
  89 pprMatches :: (NamedThing bdee, Outputable bdee,
  90                NamedThing pat, Outputable pat) =>
  91                 PprStyle -> (Bool, Pretty) -> [Match bdee pat] -> Pretty
  92
  93 pprMatches sty print_info@(is_case, name) [match]
  94   = if is_case then
  95         pprMatch sty is_case match
  96     else
  97         ppHang name 4 (pprMatch sty is_case match)
  98
  99 pprMatches sty print_info (match1 : rest)
 100  = ppAbove (pprMatches sty print_info [match1])
 101            (pprMatches sty print_info rest)
 102 \end{code}
 103
 104 \begin{code}
 105 instance (NamedThing bdee, Outputable bdee,
 106              NamedThing pat, Outputable pat) =>
 107                 Outputable (Match bdee pat) where
 108     ppr sty b   = panic "ppr: Match"
 109 \end{code}
 110
 111 %************************************************************************
 112 %*                                                                      *
 113 \subsection[AbsSyntax-GRHSsAndBinds]{Guarded RHSs plus their Binds}
 114 %*                                                                      *
 115 %************************************************************************
 116
 117 Possibly \tr{NoGuardNoBinds{In,Out}}, etc.? ToDo
 118
 119 \begin{code}
 120 data GRHSsAndBinds bdee pat
 121    = GRHSsAndBindsIn    [GRHS bdee pat]     -- at least one GRHS
 122                         (Binds bdee pat)
 123
 124    | GRHSsAndBindsOut   [GRHS bdee pat]     -- at least one GRHS
 125                         (Binds bdee pat)
 126                         UniType
 127
 128 type ProtoNameGRHSsAndBinds   = GRHSsAndBinds ProtoName ProtoNamePat
 129 type RenamedGRHSsAndBinds     = GRHSsAndBinds Name      RenamedPat
 130 type TypecheckedGRHSsAndBinds = GRHSsAndBinds Id        TypecheckedPat
 131 \end{code}
 132
 133 \begin{code}
 134 pprGRHSsAndBinds sty is_case (GRHSsAndBindsIn grhss binds)
 135  = ppAbove (ppAboves (map (pprGRHS sty is_case) grhss))
 136            (if (nullBinds binds)
 137             then ppNil
 138             else ppAboves [ ppStr "where", ppNest 4 (ppr sty binds) ])
 139
 140 pprGRHSsAndBinds sty is_case (GRHSsAndBindsOut grhss binds ty)
 141  = ppAbove (ppAboves (map (pprGRHS sty is_case) grhss))
 142            (if (nullBinds binds)
 143             then ppNil
 144             else ppAboves [ ifPprShowAll sty
 145                                 (ppCat [ppStr "{- ty:", ppr sty ty, ppStr "-}"]),
 146                             ppStr "where", ppNest 4 (ppr sty binds) ])
 147 \end{code}
 148
 149 \begin{code}
 150 instance (NamedThing bdee, Outputable bdee,
 151              NamedThing pat, Outputable pat) =>
 152                 Outputable (GRHSsAndBinds bdee pat) where
 153     ppr sty b = panic "ppr:GRHSsAndBinds"
 154 \end{code}
 155
 156 %************************************************************************
 157 %*                                                                      *
 158 \subsection[AbsSyntax-GRHS]{A guarded right-hand-side}
 159 %*                                                                      *
 160 %************************************************************************
 161
 162 Sets of guarded right hand sides. In
 163 \begin{verbatim}
 164 f (x,y) | x==True = y
 165         | otherwise = y*2
 166 \end{verbatim}
 167 a guarded right hand side is either
 168 @(x==True = y)@, or @(otherwise = y*2)@.
 169
 170 For each match, there may be several guarded right hand
 171 sides, as the definition of @f@ shows.
 172
 173 \begin{code}
 174 data GRHS bdee pat
 175   = GRHS            (Expr bdee pat)     -- guard(ed)...
 176                     (Expr bdee pat)     -- ... right-hand side
 177                     SrcLoc
 178
 179   | OtherwiseGRHS   (Expr bdee pat)     -- guard-free
 180                     SrcLoc
 181 \end{code}
 182
 183 And, as always:
 184 \begin{code}
 185 type ProtoNameGRHS   = GRHS ProtoName ProtoNamePat
 186 type RenamedGRHS     = GRHS Name      RenamedPat
 187 type TypecheckedGRHS = GRHS Id        TypecheckedPat
 188 \end{code}
 189
 190 \begin{code}
 191 pprGRHS :: (NamedThing bdee, Outputable bdee,
 192               NamedThing pat, Outputable pat) =>
 193                 PprStyle -> Bool -> GRHS bdee pat -> Pretty
 194
 195 pprGRHS sty is_case (GRHS guard expr locn)
 196  = ppAboves [
 197         ifPprShowAll sty (ppr sty locn),
 198         ppHang (ppCat [ppStr "|", ppr sty guard, ppStr (if is_case then "->" else "=")])
 199                   4 (ppr sty expr)
 200    ]
 201
 202 pprGRHS sty is_case (OtherwiseGRHS  expr locn)
 203  = ppAboves [
 204         ifPprShowAll sty (ppr sty locn),
 205         ppHang (ppStr (if is_case then "->" else "="))
 206           4 (ppr sty expr)
 207    ]
 208 \end{code}
 209
 210 \begin{code}
 211 instance (NamedThing bdee, Outputable bdee,
 212             NamedThing pat, Outputable pat) =>
 213                 Outputable (GRHS bdee pat) where
 214     ppr sty b   = panic "ppr: GRHSs"
 215 \end{code}