Add tuple sections as a new feature
[ghc.git] / compiler / hsSyn / HsExpr.lhs
1 %
2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 %
5 \begin{code}
6
7 -- | Abstract Haskell syntax for expressions.
8 module HsExpr where
9
10 #include "HsVersions.h"
11
12 -- friends:
13 import HsDecls
14 import HsPat
15 import HsLit
16 import HsTypes
17 import HsBinds
18
19 -- others:
20 import Var
21 import Name
22 import BasicTypes
23 import DataCon
24 import SrcLoc
25 import Outputable
26 import FastString
27 \end{code}
28
29
30 %************************************************************************
31 %*                                                                      *
32 \subsection{Expressions proper}
33 %*                                                                      *
34 %************************************************************************
35
36 \begin{code}
37 -- * Expressions proper
38
39 type LHsExpr id = Located (HsExpr id)
40
41 -------------------------
42 -- | PostTcExpr is an evidence expression attached to the syntax tree by the
43 -- type checker (c.f. postTcType).
44 type PostTcExpr  = HsExpr Id
45 -- | We use a PostTcTable where there are a bunch of pieces of evidence, more
46 -- than is convenient to keep individually.
47 type PostTcTable = [(Name, Id)]
48
49 noPostTcExpr :: PostTcExpr
50 noPostTcExpr = HsLit (HsString (fsLit "noPostTcExpr"))
51
52 noPostTcTable :: PostTcTable
53 noPostTcTable = []
54
55 -------------------------
56 -- | SyntaxExpr is like 'PostTcExpr', but it's filled in a little earlier,
57 -- by the renamer.  It's used for rebindable syntax.
58 --
59 -- E.g. @(>>=)@ is filled in before the renamer by the appropriate 'Name' for
60 --      @(>>=)@, and then instantiated by the type checker with its type args
61 --      tec
62
63 type SyntaxExpr id = HsExpr id
64
65 noSyntaxExpr :: SyntaxExpr id -- Before renaming, and sometimes after,
66                               -- (if the syntax slot makes no sense)
67 noSyntaxExpr = HsLit (HsString (fsLit "noSyntaxExpr"))
68
69
70 type SyntaxTable id = [(Name, SyntaxExpr id)]
71 -- ^ Currently used only for 'CmdTop' (sigh)
72 --
73 -- * Before the renamer, this list is 'noSyntaxTable'
74 --
75 -- * After the renamer, it takes the form @[(std_name, HsVar actual_name)]@
76 --   For example, for the 'return' op of a monad
77 --
78 --    * normal case:            @(GHC.Base.return, HsVar GHC.Base.return)@
79 --
80 --    * with rebindable syntax: @(GHC.Base.return, return_22)@
81 --              where @return_22@ is whatever @return@ is in scope
82 --
83 -- * After the type checker, it takes the form @[(std_name, <expression>)]@
84 --      where @<expression>@ is the evidence for the method
85
86 noSyntaxTable :: SyntaxTable id
87 noSyntaxTable = []
88
89
90 -------------------------
91 -- | A Haskell expression.
92 data HsExpr id
93   = HsVar     id                        -- ^ variable
94   | HsIPVar   (IPName id)               -- ^ implicit parameter
95   | HsOverLit (HsOverLit id)            -- ^ Overloaded literals
96
97   | HsLit     HsLit                     -- ^ Simple (non-overloaded) literals
98
99   | HsLam     (MatchGroup id)           -- Currently always a single match
100
101   | HsApp     (LHsExpr id) (LHsExpr id) -- Application
102
103   -- Operator applications:
104   -- NB Bracketed ops such as (+) come out as Vars.
105
106   -- NB We need an expr for the operator in an OpApp/Section since
107   -- the typechecker may need to apply the operator to a few types.
108
109   | OpApp       (LHsExpr id)    -- left operand
110                 (LHsExpr id)    -- operator
111                 Fixity          -- Renamer adds fixity; bottom until then
112                 (LHsExpr id)    -- right operand
113
114   | NegApp      (LHsExpr id)    -- negated expr
115                 (SyntaxExpr id) -- Name of 'negate'
116
117   | HsPar       (LHsExpr id)    -- parenthesised expr
118
119   | SectionL    (LHsExpr id)    -- operand
120                 (LHsExpr id)    -- operator
121   | SectionR    (LHsExpr id)    -- operator
122                 (LHsExpr id)    -- operand
123
124   | ExplicitTuple               -- Used for explicit tuples and sections thereof
125         [HsTupArg id] 
126         Boxity
127
128   | HsCase      (LHsExpr id)
129                 (MatchGroup id)
130
131   | HsIf        (LHsExpr id)    --  predicate
132                 (LHsExpr id)    --  then part
133                 (LHsExpr id)    --  else part
134
135   | HsLet       (HsLocalBinds id) -- let(rec)
136                 (LHsExpr  id)
137
138   | HsDo        (HsStmtContext Name) -- The parameterisation is unimportant
139                                      -- because in this context we never use
140                                      -- the PatGuard or ParStmt variant
141                 [LStmt id]           -- "do":one or more stmts
142                 (LHsExpr id)         -- The body; the last expression in the
143                                      -- 'do' of [ body | ... ] in a list comp
144                 PostTcType           -- Type of the whole expression
145
146   | ExplicitList                -- syntactic list
147                 PostTcType      -- Gives type of components of list
148                 [LHsExpr id]
149
150   | ExplicitPArr                -- syntactic parallel array: [:e1, ..., en:]
151                 PostTcType      -- type of elements of the parallel array
152                 [LHsExpr id]
153
154   -- Record construction
155   | RecordCon   (Located id)       -- The constructor.  After type checking
156                                    -- it's the dataConWrapId of the constructor
157                 PostTcExpr         -- Data con Id applied to type args
158                 (HsRecordBinds id)
159
160   -- Record update
161   | RecordUpd   (LHsExpr id)
162                 (HsRecordBinds id)
163 --              (HsMatchGroup Id)  -- Filled in by the type checker to be 
164 --                                 -- a match that does the job
165                 [DataCon]          -- Filled in by the type checker to the
166                                    -- _non-empty_ list of DataCons that have
167                                    -- all the upd'd fields
168                 [PostTcType]       -- Argument types of *input* record type
169                 [PostTcType]       --              and  *output* record type
170   -- For a type family, the arg types are of the *instance* tycon,
171   -- not the family tycon
172
173   | ExprWithTySig                       -- e :: type
174                 (LHsExpr id)
175                 (LHsType id)
176
177   | ExprWithTySigOut                    -- TRANSLATION
178                 (LHsExpr id)
179                 (LHsType Name)          -- Retain the signature for
180                                         -- round-tripping purposes
181
182   | ArithSeq                            -- arithmetic sequence
183                 PostTcExpr
184                 (ArithSeqInfo id)
185
186   | PArrSeq                             -- arith. sequence for parallel array
187                 PostTcExpr              -- [:e1..e2:] or [:e1, e2..e3:]
188                 (ArithSeqInfo id)
189
190   | HsSCC       FastString              -- "set cost centre" SCC pragma
191                 (LHsExpr id)            -- expr whose cost is to be measured
192
193   | HsCoreAnn   FastString              -- hdaume: core annotation
194                 (LHsExpr id)
195
196   -----------------------------------------------------------
197   -- MetaHaskell Extensions
198
199   | HsBracket    (HsBracket id)
200
201   | HsBracketOut (HsBracket Name)       -- Output of the type checker is
202                                         -- the *original*
203                  [PendingSplice]        -- renamed expression, plus
204                                         -- _typechecked_ splices to be
205                                         -- pasted back in by the desugarer
206
207   | HsSpliceE (HsSplice id)
208
209   | HsQuasiQuoteE (HsQuasiQuote id)
210         -- See Note [Quasi-quote overview] in TcSplice
211
212   -----------------------------------------------------------
213   -- Arrow notation extension
214
215   | HsProc      (LPat id)               -- arrow abstraction, proc
216                 (LHsCmdTop id)          -- body of the abstraction
217                                         -- always has an empty stack
218
219   ---------------------------------------
220   -- The following are commands, not expressions proper
221
222   | HsArrApp            -- Arrow tail, or arrow application (f -< arg)
223         (LHsExpr id)    -- arrow expression, f
224         (LHsExpr id)    -- input expression, arg
225         PostTcType      -- type of the arrow expressions f,
226                         -- of the form a t t', where arg :: t
227         HsArrAppType    -- higher-order (-<<) or first-order (-<)
228         Bool            -- True => right-to-left (f -< arg)
229                         -- False => left-to-right (arg >- f)
230
231   | HsArrForm           -- Command formation,  (| e cmd1 .. cmdn |)
232         (LHsExpr id)    -- the operator
233                         -- after type-checking, a type abstraction to be
234                         -- applied to the type of the local environment tuple
235         (Maybe Fixity)  -- fixity (filled in by the renamer), for forms that
236                         -- were converted from OpApp's by the renamer
237         [LHsCmdTop id]  -- argument commands
238
239
240   ---------------------------------------
241   -- Haskell program coverage (Hpc) Support
242
243   | HsTick
244      Int                                -- module-local tick number
245      [id]                               -- variables in scope
246      (LHsExpr id)                       -- sub-expression
247
248   | HsBinTick
249      Int                                -- module-local tick number for True
250      Int                                -- module-local tick number for False
251      (LHsExpr id)                       -- sub-expression
252
253   | HsTickPragma                        -- A pragma introduced tick
254      (FastString,(Int,Int),(Int,Int))   -- external span for this tick
255      (LHsExpr id)
256
257   ---------------------------------------
258   -- These constructors only appear temporarily in the parser.
259   -- The renamer translates them into the Right Thing.
260
261   | EWildPat                 -- wildcard
262
263   | EAsPat      (Located id) -- as pattern
264                 (LHsExpr id)
265
266   | EViewPat    (LHsExpr id) -- view pattern
267                 (LHsExpr id)
268
269   | ELazyPat    (LHsExpr id) -- ~ pattern
270
271   | HsType      (LHsType id) -- Explicit type argument; e.g  f {| Int |} x y
272
273   ---------------------------------------
274   -- Finally, HsWrap appears only in typechecker output
275
276   |  HsWrap     HsWrapper    -- TRANSLATION
277                 (HsExpr id)
278
279 -- HsTupArg is used for tuple sections
280 --  (,a,) is represented by  ExplicitTuple [Mising ty1, Present a, Missing ty3]
281 --  Which in turn stands for (\x:ty1 \y:ty2. (x,a,y))
282 data HsTupArg id
283   = Present (LHsExpr id)        -- The argument
284   | Missing PostTcType          -- The argument is missing, but this is its type
285
286 tupArgPresent :: HsTupArg id -> Bool
287 tupArgPresent (Present {}) = True
288 tupArgPresent (Missing {}) = False
289
290 type PendingSplice = (Name, LHsExpr Id) -- Typechecked splices, waiting to be
291                                         -- pasted back in by the desugarer
292 \end{code}
293
294 A @Dictionary@, unless of length 0 or 1, becomes a tuple.  A
295 @ClassDictLam dictvars methods expr@ is, therefore:
296 \begin{verbatim}
297 \ x -> case x of ( dictvars-and-methods-tuple ) -> expr
298 \end{verbatim}
299
300 \begin{code}
301 instance OutputableBndr id => Outputable (HsExpr id) where
302     ppr expr = pprExpr expr
303 \end{code}
304
305 \begin{code}
306 -----------------------
307 -- pprExpr, pprLExpr, pprBinds call pprDeeper;
308 -- the underscore versions do not
309 pprLExpr :: OutputableBndr id => LHsExpr id -> SDoc
310 pprLExpr (L _ e) = pprExpr e
311
312 pprExpr :: OutputableBndr id => HsExpr id -> SDoc
313 pprExpr e | isAtomicHsExpr e || isQuietHsExpr e =            ppr_expr e
314           | otherwise                           = pprDeeper (ppr_expr e)
315
316 isQuietHsExpr :: HsExpr id -> Bool
317 -- Parentheses do display something, but it gives little info and
318 -- if we go deeper when we go inside them then we get ugly things
319 -- like (...)
320 isQuietHsExpr (HsPar _) = True
321 -- applications don't display anything themselves
322 isQuietHsExpr (HsApp _ _) = True
323 isQuietHsExpr (OpApp _ _ _ _) = True
324 isQuietHsExpr _ = False
325
326 pprBinds :: (OutputableBndr idL, OutputableBndr idR)
327          => HsLocalBindsLR idL idR -> SDoc
328 pprBinds b = pprDeeper (ppr b)
329
330 -----------------------
331 ppr_lexpr :: OutputableBndr id => LHsExpr id -> SDoc
332 ppr_lexpr e = ppr_expr (unLoc e)
333
334 ppr_expr :: OutputableBndr id => HsExpr id -> SDoc
335 ppr_expr (HsVar v)       = pprHsVar v
336 ppr_expr (HsIPVar v)     = ppr v
337 ppr_expr (HsLit lit)     = ppr lit
338 ppr_expr (HsOverLit lit) = ppr lit
339 ppr_expr (HsPar e)       = parens (ppr_lexpr e)
340
341 ppr_expr (HsCoreAnn s e)
342   = vcat [ptext (sLit "HsCoreAnn") <+> ftext s, ppr_lexpr e]
343
344 ppr_expr (HsApp e1 e2)
345   = let (fun, args) = collect_args e1 [e2] in
346     hang (ppr_lexpr fun) 2 (sep (map pprParendExpr args))
347   where
348     collect_args (L _ (HsApp fun arg)) args = collect_args fun (arg:args)
349     collect_args fun args = (fun, args)
350
351 ppr_expr (OpApp e1 op _ e2)
352   = case unLoc op of
353       HsVar v -> pp_infixly v
354       _       -> pp_prefixly
355   where
356     pp_e1 = pprDebugParendExpr e1   -- In debug mode, add parens
357     pp_e2 = pprDebugParendExpr e2   -- to make precedence clear
358
359     pp_prefixly
360       = hang (ppr op) 2 (sep [pp_e1, pp_e2])
361
362     pp_infixly v
363       = sep [nest 2 pp_e1, pprHsInfix v, nest 2 pp_e2]
364
365 ppr_expr (NegApp e _) = char '-' <+> pprDebugParendExpr e
366
367 ppr_expr (SectionL expr op)
368   = case unLoc op of
369       HsVar v -> pp_infixly v
370       _       -> pp_prefixly
371   where
372     pp_expr = pprDebugParendExpr expr
373
374     pp_prefixly = hang (hsep [text " \\ x_ ->", ppr op])
375                        4 (hsep [pp_expr, ptext (sLit "x_ )")])
376     pp_infixly v = (sep [pp_expr, pprHsInfix v])
377
378 ppr_expr (SectionR op expr)
379   = case unLoc op of
380       HsVar v -> pp_infixly v
381       _       -> pp_prefixly
382   where
383     pp_expr = pprDebugParendExpr expr
384
385     pp_prefixly = hang (hsep [text "( \\ x_ ->", ppr op, ptext (sLit "x_")])
386                        4 ((<>) pp_expr rparen)
387     pp_infixly v
388       = (sep [pprHsInfix v, pp_expr])
389
390 ppr_expr (ExplicitTuple exprs boxity)
391   = tupleParens boxity (fcat (ppr_tup_args exprs))
392   where
393     ppr_tup_args []               = []
394     ppr_tup_args (Present e : es) = (ppr_lexpr e <> punc es) : ppr_tup_args es
395     ppr_tup_args (Missing _ : es) = comma : ppr_tup_args es
396
397     punc (Present {} : _) = comma <> space
398     punc (Missing {} : _) = comma
399     punc []               = empty
400
401 --avoid using PatternSignatures for stage1 code portability
402 ppr_expr exprType@(HsLam matches)
403   = pprMatches (LambdaExpr `asTypeOf` idType exprType) matches
404  where idType :: HsExpr id -> HsMatchContext id; idType = undefined
405
406 ppr_expr exprType@(HsCase expr matches)
407   = sep [ sep [ptext (sLit "case"), nest 4 (ppr expr), ptext (sLit "of {")],
408           nest 2 (pprMatches (CaseAlt `asTypeOf` idType exprType) matches <+> char '}') ]
409  where idType :: HsExpr id -> HsMatchContext id; idType = undefined
410
411 ppr_expr (HsIf e1 e2 e3)
412   = sep [hsep [ptext (sLit "if"), nest 2 (ppr e1), ptext (sLit "then")],
413          nest 4 (ppr e2),
414          ptext (sLit "else"),
415          nest 4 (ppr e3)]
416
417 -- special case: let ... in let ...
418 ppr_expr (HsLet binds expr@(L _ (HsLet _ _)))
419   = sep [hang (ptext (sLit "let")) 2 (hsep [pprBinds binds, ptext (sLit "in")]),
420          ppr_lexpr expr]
421
422 ppr_expr (HsLet binds expr)
423   = sep [hang (ptext (sLit "let")) 2 (pprBinds binds),
424          hang (ptext (sLit "in"))  2 (ppr expr)]
425
426 ppr_expr (HsDo do_or_list_comp stmts body _) = pprDo do_or_list_comp stmts body
427
428 ppr_expr (ExplicitList _ exprs)
429   = brackets (pprDeeperList fsep (punctuate comma (map ppr_lexpr exprs)))
430
431 ppr_expr (ExplicitPArr _ exprs)
432   = pa_brackets (pprDeeperList fsep (punctuate comma (map ppr_lexpr exprs)))
433
434 ppr_expr (RecordCon con_id _ rbinds)
435   = hang (ppr con_id) 2 (ppr rbinds)
436
437 ppr_expr (RecordUpd aexp rbinds _ _ _)
438   = hang (pprParendExpr aexp) 2 (ppr rbinds)
439
440 ppr_expr (ExprWithTySig expr sig)
441   = hang (nest 2 (ppr_lexpr expr) <+> dcolon)
442          4 (ppr sig)
443 ppr_expr (ExprWithTySigOut expr sig)
444   = hang (nest 2 (ppr_lexpr expr) <+> dcolon)
445          4 (ppr sig)
446
447 ppr_expr (ArithSeq _ info) = brackets (ppr info)
448 ppr_expr (PArrSeq  _ info) = pa_brackets (ppr info)
449
450 ppr_expr EWildPat       = char '_'
451 ppr_expr (ELazyPat e)   = char '~' <> pprParendExpr e
452 ppr_expr (EAsPat v e)   = ppr v <> char '@' <> pprParendExpr e
453 ppr_expr (EViewPat p e) = ppr p <+> ptext (sLit "->") <+> ppr e
454
455 ppr_expr (HsSCC lbl expr)
456   = sep [ ptext (sLit "_scc_") <+> doubleQuotes (ftext lbl),
457           pprParendExpr expr ]
458
459 ppr_expr (HsWrap co_fn e) = pprHsWrapper (pprExpr e) co_fn
460 ppr_expr (HsType id)      = ppr id
461
462 ppr_expr (HsSpliceE s)       = pprSplice s
463 ppr_expr (HsBracket b)       = pprHsBracket b
464 ppr_expr (HsBracketOut e []) = ppr e
465 ppr_expr (HsBracketOut e ps) = ppr e $$ ptext (sLit "pending") <+> ppr ps
466 ppr_expr (HsQuasiQuoteE qq)  = ppr qq
467
468 ppr_expr (HsProc pat (L _ (HsCmdTop cmd _ _ _)))
469   = hsep [ptext (sLit "proc"), ppr pat, ptext (sLit "->"), ppr cmd]
470
471 ppr_expr (HsTick tickId vars exp)
472   = hcat [ptext (sLit "tick<"),
473           ppr tickId,
474           ptext (sLit ">("),
475           hsep (map pprHsVar vars),
476           ppr exp,
477           ptext (sLit ")")]
478 ppr_expr (HsBinTick tickIdTrue tickIdFalse exp)
479   = hcat [ptext (sLit "bintick<"),
480           ppr tickIdTrue,
481           ptext (sLit ","),
482           ppr tickIdFalse,
483           ptext (sLit ">("),
484           ppr exp,ptext (sLit ")")]
485 ppr_expr (HsTickPragma externalSrcLoc exp)
486   = hcat [ptext (sLit "tickpragma<"),
487           ppr externalSrcLoc,
488           ptext (sLit ">("),
489           ppr exp,
490           ptext (sLit ")")]
491
492 ppr_expr (HsArrApp arrow arg _ HsFirstOrderApp True)
493   = hsep [ppr_lexpr arrow, ptext (sLit "-<"), ppr_lexpr arg]
494 ppr_expr (HsArrApp arrow arg _ HsFirstOrderApp False)
495   = hsep [ppr_lexpr arg, ptext (sLit ">-"), ppr_lexpr arrow]
496 ppr_expr (HsArrApp arrow arg _ HsHigherOrderApp True)
497   = hsep [ppr_lexpr arrow, ptext (sLit "-<<"), ppr_lexpr arg]
498 ppr_expr (HsArrApp arrow arg _ HsHigherOrderApp False)
499   = hsep [ppr_lexpr arg, ptext (sLit ">>-"), ppr_lexpr arrow]
500
501 ppr_expr (HsArrForm (L _ (HsVar v)) (Just _) [arg1, arg2])
502   = sep [pprCmdArg (unLoc arg1), hsep [pprHsInfix v, pprCmdArg (unLoc arg2)]]
503 ppr_expr (HsArrForm op _ args)
504   = hang (ptext (sLit "(|") <> ppr_lexpr op)
505          4 (sep (map (pprCmdArg.unLoc) args) <> ptext (sLit "|)"))
506
507 pprCmdArg :: OutputableBndr id => HsCmdTop id -> SDoc
508 pprCmdArg (HsCmdTop cmd@(L _ (HsArrForm _ Nothing [])) _ _ _)
509   = ppr_lexpr cmd
510 pprCmdArg (HsCmdTop cmd _ _ _)
511   = parens (ppr_lexpr cmd)
512
513 instance OutputableBndr id => Outputable (HsCmdTop id) where
514     ppr = pprCmdArg
515
516 -- add parallel array brackets around a document
517 --
518 pa_brackets :: SDoc -> SDoc
519 pa_brackets p = ptext (sLit "[:") <> p <> ptext (sLit ":]")
520 \end{code}
521
522 HsSyn records exactly where the user put parens, with HsPar.
523 So generally speaking we print without adding any parens.
524 However, some code is internally generated, and in some places
525 parens are absolutely required; so for these places we use
526 pprParendExpr (but don't print double parens of course).
527
528 For operator applications we don't add parens, because the oprerator
529 fixities should do the job, except in debug mode (-dppr-debug) so we
530 can see the structure of the parse tree.
531
532 \begin{code}
533 pprDebugParendExpr :: OutputableBndr id => LHsExpr id -> SDoc
534 pprDebugParendExpr expr
535   = getPprStyle (\sty ->
536     if debugStyle sty then pprParendExpr expr
537                       else pprLExpr      expr)
538
539 pprParendExpr :: OutputableBndr id => LHsExpr id -> SDoc
540 pprParendExpr expr
541   = let
542         pp_as_was = pprLExpr expr
543         -- Using pprLExpr makes sure that we go 'deeper'
544         -- I think that is usually (always?) right
545     in
546     case unLoc expr of
547       ArithSeq {}       -> pp_as_was
548       PArrSeq {}        -> pp_as_was
549       HsLit {}          -> pp_as_was
550       HsOverLit {}      -> pp_as_was
551       HsVar {}          -> pp_as_was
552       HsIPVar {}        -> pp_as_was
553       ExplicitTuple {}  -> pp_as_was
554       ExplicitList {}   -> pp_as_was
555       ExplicitPArr {}   -> pp_as_was
556       HsPar {}          -> pp_as_was
557       HsBracket {}      -> pp_as_was
558       HsBracketOut _ [] -> pp_as_was
559       HsDo sc _ _ _
560        | isListCompExpr sc -> pp_as_was
561       _                    -> parens pp_as_was
562
563 isAtomicHsExpr :: HsExpr id -> Bool -- A single token
564 isAtomicHsExpr (HsVar {})     = True
565 isAtomicHsExpr (HsLit {})     = True
566 isAtomicHsExpr (HsOverLit {}) = True
567 isAtomicHsExpr (HsIPVar {})   = True
568 isAtomicHsExpr (HsWrap _ e)   = isAtomicHsExpr e
569 isAtomicHsExpr (HsPar e)      = isAtomicHsExpr (unLoc e)
570 isAtomicHsExpr _              = False
571 \end{code}
572
573 %************************************************************************
574 %*                                                                      *
575 \subsection{Commands (in arrow abstractions)}
576 %*                                                                      *
577 %************************************************************************
578
579 We re-use HsExpr to represent these.
580
581 \begin{code}
582 type HsCmd id = HsExpr id
583
584 type LHsCmd id = LHsExpr id
585
586 data HsArrAppType = HsHigherOrderApp | HsFirstOrderApp
587 \end{code}
588
589 The legal constructors for commands are:
590
591   = HsArrApp ...                -- as above
592
593   | HsArrForm ...               -- as above
594
595   | HsApp       (HsCmd id)
596                 (HsExpr id)
597
598   | HsLam       (Match  id)     -- kappa
599
600   -- the renamer turns this one into HsArrForm
601   | OpApp       (HsExpr id)     -- left operand
602                 (HsCmd id)      -- operator
603                 Fixity          -- Renamer adds fixity; bottom until then
604                 (HsCmd id)      -- right operand
605
606   | HsPar       (HsCmd id)      -- parenthesised command
607
608   | HsCase      (HsExpr id)
609                 [Match id]      -- bodies are HsCmd's
610                 SrcLoc
611
612   | HsIf        (HsExpr id)     --  predicate
613                 (HsCmd id)      --  then part
614                 (HsCmd id)      --  else part
615                 SrcLoc
616
617   | HsLet       (HsLocalBinds id)       -- let(rec)
618                 (HsCmd  id)
619
620   | HsDo        (HsStmtContext Name)    -- The parameterisation is unimportant
621                                         -- because in this context we never use
622                                         -- the PatGuard or ParStmt variant
623                 [Stmt id]       -- HsExpr's are really HsCmd's
624                 PostTcType      -- Type of the whole expression
625                 SrcLoc
626
627 Top-level command, introducing a new arrow.
628 This may occur inside a proc (where the stack is empty) or as an
629 argument of a command-forming operator.
630
631 \begin{code}
632 type LHsCmdTop id = Located (HsCmdTop id)
633
634 data HsCmdTop id
635   = HsCmdTop (LHsCmd id)
636              [PostTcType]     -- types of inputs on the command's stack
637              PostTcType       -- return type of the command
638              (SyntaxTable id) -- after type checking:
639                               -- names used in the command's desugaring
640 \end{code}
641
642 %************************************************************************
643 %*                                                                      *
644 \subsection{Record binds}
645 %*                                                                      *
646 %************************************************************************
647
648 \begin{code}
649 type HsRecordBinds id = HsRecFields id (LHsExpr id)
650 \end{code}
651
652
653
654 %************************************************************************
655 %*                                                                      *
656 \subsection{@Match@, @GRHSs@, and @GRHS@ datatypes}
657 %*                                                                      *
658 %************************************************************************
659
660 @Match@es are sets of pattern bindings and right hand sides for
661 functions, patterns or case branches. For example, if a function @g@
662 is defined as:
663 \begin{verbatim}
664 g (x,y) = y
665 g ((x:ys),y) = y+1,
666 \end{verbatim}
667 then \tr{g} has two @Match@es: @(x,y) = y@ and @((x:ys),y) = y+1@.
668
669 It is always the case that each element of an @[Match]@ list has the
670 same number of @pats@s inside it.  This corresponds to saying that
671 a function defined by pattern matching must have the same number of
672 patterns in each equation.
673
674 \begin{code}
675 data MatchGroup id
676   = MatchGroup
677         [LMatch id]     -- The alternatives
678         PostTcType      -- The type is the type of the entire group
679                         --      t1 -> ... -> tn -> tr
680                         -- where there are n patterns
681
682 type LMatch id = Located (Match id)
683
684 data Match id
685   = Match
686         [LPat id]               -- The patterns
687         (Maybe (LHsType id))    -- A type signature for the result of the match
688                                 -- Nothing after typechecking
689         (GRHSs id)
690
691 isEmptyMatchGroup :: MatchGroup id -> Bool
692 isEmptyMatchGroup (MatchGroup ms _) = null ms
693
694 matchGroupArity :: MatchGroup id -> Arity
695 matchGroupArity (MatchGroup [] _)
696   = panic "matchGroupArity"     -- Precondition: MatchGroup is non-empty
697 matchGroupArity (MatchGroup (match:matches) _)
698   = ASSERT( all ((== n_pats) . length . hsLMatchPats) matches )
699     -- Assertion just checks that all the matches have the same number of pats
700     n_pats
701   where
702     n_pats = length (hsLMatchPats match)
703
704 hsLMatchPats :: LMatch id -> [LPat id]
705 hsLMatchPats (L _ (Match pats _ _)) = pats
706
707 -- | GRHSs are used both for pattern bindings and for Matches
708 data GRHSs id
709   = GRHSs {
710       grhssGRHSs :: [LGRHS id],  -- ^ Guarded RHSs
711       grhssLocalBinds :: (HsLocalBinds id) -- ^ The where clause
712     }
713
714 type LGRHS id = Located (GRHS id)
715
716 -- | Guarded Right Hand Side.
717 data GRHS id = GRHS [LStmt id]   -- Guards
718                     (LHsExpr id) -- Right hand side
719 \end{code}
720
721 We know the list must have at least one @Match@ in it.
722
723 \begin{code}
724 pprMatches :: (OutputableBndr idL, OutputableBndr idR) => HsMatchContext idL -> MatchGroup idR -> SDoc
725 pprMatches ctxt (MatchGroup matches _)
726     = vcat (map (pprMatch ctxt) (map unLoc matches))
727       -- Don't print the type; it's only a place-holder before typechecking
728
729 -- Exported to HsBinds, which can't see the defn of HsMatchContext
730 pprFunBind :: (OutputableBndr idL, OutputableBndr idR) => idL -> Bool -> MatchGroup idR -> SDoc
731 pprFunBind fun inf matches = pprMatches (FunRhs fun inf) matches
732
733 -- Exported to HsBinds, which can't see the defn of HsMatchContext
734 pprPatBind :: (OutputableBndr bndr, OutputableBndr id)
735            => LPat bndr -> GRHSs id -> SDoc
736 pprPatBind pat ty@(grhss)
737  = sep [ppr pat, nest 4 (pprGRHSs (PatBindRhs `asTypeOf` idType ty) grhss)]
738 --avoid using PatternSignatures for stage1 code portability
739  where idType :: GRHSs id -> HsMatchContext id; idType = undefined
740
741
742 pprMatch :: (OutputableBndr idL, OutputableBndr idR) => HsMatchContext idL -> Match idR -> SDoc
743 pprMatch ctxt (Match pats maybe_ty grhss)
744   = herald <+> sep [sep (map ppr other_pats),
745                     ppr_maybe_ty,
746                     nest 2 (pprGRHSs ctxt grhss)]
747   where
748     (herald, other_pats)
749         = case ctxt of
750             FunRhs fun is_infix
751                 | not is_infix -> (ppr fun, pats)
752                         -- f x y z = e
753                         -- Not pprBndr; the AbsBinds will
754                         -- have printed the signature
755
756                 | null pats3 -> (pp_infix, [])
757                         -- x &&& y = e
758
759                 | otherwise -> (parens pp_infix, pats3)
760                         -- (x &&& y) z = e
761                 where
762                   (pat1:pat2:pats3) = pats
763                   pp_infix = ppr pat1 <+> ppr fun <+> ppr pat2
764
765             LambdaExpr -> (char '\\', pats)
766             _          -> (empty,     pats)
767
768     ppr_maybe_ty = case maybe_ty of
769                         Just ty -> dcolon <+> ppr ty
770                         Nothing -> empty
771
772
773 pprGRHSs :: (OutputableBndr idL, OutputableBndr idR)
774          => HsMatchContext idL -> GRHSs idR -> SDoc
775 pprGRHSs ctxt (GRHSs grhss binds)
776   = vcat (map (pprGRHS ctxt . unLoc) grhss)
777  $$ if isEmptyLocalBinds binds then empty
778                                else text "where" $$ nest 4 (pprBinds binds)
779
780 pprGRHS :: (OutputableBndr idL, OutputableBndr idR)
781         => HsMatchContext idL -> GRHS idR -> SDoc
782
783 pprGRHS ctxt (GRHS [] expr)
784  =  pp_rhs ctxt expr
785
786 pprGRHS ctxt (GRHS guards expr)
787  = sep [char '|' <+> interpp'SP guards, pp_rhs ctxt expr]
788
789 pp_rhs :: OutputableBndr idR => HsMatchContext idL -> LHsExpr idR -> SDoc
790 pp_rhs ctxt rhs = matchSeparator ctxt <+> pprDeeper (ppr rhs)
791 \end{code}
792
793 %************************************************************************
794 %*                                                                      *
795 \subsection{Do stmts and list comprehensions}
796 %*                                                                      *
797 %************************************************************************
798
799 \begin{code}
800 type LStmt id = Located (StmtLR id id)
801 type LStmtLR idL idR = Located (StmtLR idL idR)
802
803 type Stmt id = StmtLR id id
804
805 data GroupByClause id
806     = GroupByNothing (LHsExpr id) -- Using expression, i.e.
807                                   -- "then group using f" ==> GroupByNothing f
808     | GroupBySomething (Either (LHsExpr id) (SyntaxExpr id)) (LHsExpr id)
809       -- "then group using f by e" ==> GroupBySomething (Left f) e
810       -- "then group by e"         ==> GroupBySomething (Right _) e: in
811       --                               this case the expression is filled
812       --                               in by the renamer
813
814 -- The SyntaxExprs in here are used *only* for do-notation, which
815 -- has rebindable syntax.  Otherwise they are unused.
816 data StmtLR idL idR
817   = BindStmt (LPat idL)
818              (LHsExpr idR)
819              (SyntaxExpr idR) -- The (>>=) operator
820              (SyntaxExpr idR) -- The fail operator
821              -- The fail operator is noSyntaxExpr
822              -- if the pattern match can't fail
823
824   | ExprStmt (LHsExpr idR)
825              (SyntaxExpr idR) -- The (>>) operator
826              PostTcType       -- Element type of the RHS (used for arrows)
827
828   | LetStmt  (HsLocalBindsLR idL idR)
829
830   -- ParStmts only occur in a list comprehension
831   | ParStmt  [([LStmt idL], [idR])]
832   -- After renaming, the ids are the binders bound by the stmts and used
833   -- after them
834
835   | TransformStmt ([LStmt idL], [idR]) (LHsExpr idR) (Maybe (LHsExpr idR))
836   -- After renaming, the IDs are the binders occurring within this
837   -- transform statement that are used after it
838   -- "qs, then f by e" ==> TransformStmt (qs, binders) f (Just e)
839   -- "qs, then f"      ==> TransformStmt (qs, binders) f Nothing
840
841   | GroupStmt ([LStmt idL], [(idR, idR)]) (GroupByClause idR)
842   -- After renaming, the IDs are the binders occurring within this
843   -- transform statement that are used after it which are paired with
844   -- the names which they group over in statements
845
846   -- Recursive statement (see Note [RecStmt] below)
847   | RecStmt  [LStmtLR idL idR]
848              --- The next two fields are only valid after renaming
849              [idR] -- The ids are a subset of the variables bound by the
850                    -- stmts that are used in stmts that follow the RecStmt
851
852              [idR] -- Ditto, but these variables are the "recursive" ones,
853                    -- that are used before they are bound in the stmts of
854                    -- the RecStmt. From a type-checking point of view,
855                    -- these ones have to be monomorphic
856
857              --- These fields are only valid after typechecking
858              [PostTcExpr]       -- These expressions correspond 1-to-1 with
859                                 -- the "recursive" [id], and are the
860                                 -- expressions that should be returned by
861                                 -- the recursion.
862                                 -- They may not quite be the Ids themselves,
863                                 -- because the Id may be *polymorphic*, but
864                                 -- the returned thing has to be *monomorphic*.
865              (DictBinds idR)    -- Method bindings of Ids bound by the
866                                 -- RecStmt, and used afterwards
867 \end{code}
868
869 ExprStmts are a bit tricky, because what they mean
870 depends on the context.  Consider the following contexts:
871
872         A do expression of type (m res_ty)
873         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
874         * ExprStmt E any_ty:   do { ....; E; ... }
875                 E :: m any_ty
876           Translation: E >> ...
877
878         A list comprehensions of type [elt_ty]
879         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
880         * ExprStmt E Bool:   [ .. | .... E ]
881                         [ .. | ..., E, ... ]
882                         [ .. | .... | ..., E | ... ]
883                 E :: Bool
884           Translation: if E then fail else ...
885
886         A guard list, guarding a RHS of type rhs_ty
887         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
888         * ExprStmt E Bool:   f x | ..., E, ... = ...rhs...
889                 E :: Bool
890           Translation: if E then fail else ...
891
892 Array comprehensions are handled like list comprehensions -=chak
893
894 Note [RecStmt]
895 ~~~~~~~~~~~~~~
896 Example:
897         HsDo [ BindStmt x ex
898
899              , RecStmt [a::forall a. a -> a, b]
900                        [a::Int -> Int,       c]
901                        [ BindStmt b (return x)
902                        , LetStmt a = ea
903                        , BindStmt c ec ]
904
905              , return (a b) ]
906
907 Here, the RecStmt binds a,b,c; but
908   - Only a,b are used in the stmts *following* the RecStmt,
909         This 'a' is *polymorphic'
910   - Only a,c are used in the stmts *inside* the RecStmt
911         *before* their bindings
912         This 'a' is monomorphic
913
914 Nota Bene: the two a's have different types, even though they
915 have the same Name.
916
917
918 \begin{code}
919 instance (OutputableBndr idL, OutputableBndr idR) => Outputable (StmtLR idL idR) where
920     ppr stmt = pprStmt stmt
921
922 pprStmt :: (OutputableBndr idL, OutputableBndr idR) => (StmtLR idL idR) -> SDoc
923 pprStmt (BindStmt pat expr _ _)   = hsep [ppr pat, ptext (sLit "<-"), ppr expr]
924 pprStmt (LetStmt binds)           = hsep [ptext (sLit "let"), pprBinds binds]
925 pprStmt (ExprStmt expr _ _)       = ppr expr
926 pprStmt (ParStmt stmtss)          = hsep (map doStmts stmtss)
927   where doStmts stmts = ptext (sLit "| ") <> ppr stmts
928 pprStmt (TransformStmt (stmts, _) usingExpr maybeByExpr)
929     = (hsep [stmtsDoc, ptext (sLit "then"), ppr usingExpr, byExprDoc])
930   where stmtsDoc = interpp'SP stmts
931         byExprDoc = maybe empty (\byExpr -> hsep [ptext (sLit "by"), ppr byExpr]) maybeByExpr
932 pprStmt (GroupStmt (stmts, _) groupByClause) = (hsep [stmtsDoc, ptext (sLit "then group"), pprGroupByClause groupByClause])
933   where stmtsDoc = interpp'SP stmts
934 pprStmt (RecStmt segment _ _ _ _) = ptext (sLit "rec") <+> braces (vcat (map ppr segment))
935
936 pprGroupByClause :: (OutputableBndr id) => GroupByClause id -> SDoc
937 pprGroupByClause (GroupByNothing usingExpr) = hsep [ptext (sLit "using"), ppr usingExpr]
938 pprGroupByClause (GroupBySomething eitherUsingExpr byExpr) = hsep [ptext (sLit "by"), ppr byExpr, usingExprDoc]
939   where usingExprDoc = either (\usingExpr -> hsep [ptext (sLit "using"), ppr usingExpr]) (const empty) eitherUsingExpr
940
941 pprDo :: OutputableBndr id => HsStmtContext any -> [LStmt id] -> LHsExpr id -> SDoc
942 pprDo DoExpr      stmts body = ptext (sLit "do")  <+> pprDeeperList vcat (map ppr stmts ++ [ppr body])
943 pprDo (MDoExpr _) stmts body = ptext (sLit "mdo") <+> pprDeeperList vcat (map ppr stmts ++ [ppr body])
944 pprDo ListComp    stmts body = pprComp brackets    stmts body
945 pprDo PArrComp    stmts body = pprComp pa_brackets stmts body
946 pprDo _           _     _    = panic "pprDo" -- PatGuard, ParStmtCxt
947
948 pprComp :: OutputableBndr id => (SDoc -> SDoc) -> [LStmt id] -> LHsExpr id -> SDoc
949 pprComp brack quals body
950   = brack $
951         hang (ppr body <+> char '|')
952              4 (interpp'SP quals)
953 \end{code}
954
955 %************************************************************************
956 %*                                                                      *
957                 Template Haskell quotation brackets
958 %*                                                                      *
959 %************************************************************************
960
961 \begin{code}
962 data HsSplice id  = HsSplice            --  $z  or $(f 4)
963                         id              -- The id is just a unique name to
964                         (LHsExpr id)    -- identify this splice point
965
966 instance OutputableBndr id => Outputable (HsSplice id) where
967   ppr = pprSplice
968
969 pprSplice :: OutputableBndr id => HsSplice id -> SDoc
970 pprSplice (HsSplice n e)
971     = char '$' <> ifPprDebug (brackets (ppr n)) <> pprParendExpr e
972
973
974 data HsBracket id = ExpBr (LHsExpr id)          -- [|  expr  |]
975                   | PatBr (LPat id)             -- [p| pat   |]
976                   | DecBr (HsGroup id)          -- [d| decls |]
977                   | TypBr (LHsType id)          -- [t| type  |]
978                   | VarBr id                    -- 'x, ''T
979
980 instance OutputableBndr id => Outputable (HsBracket id) where
981   ppr = pprHsBracket
982
983
984 pprHsBracket :: OutputableBndr id => HsBracket id -> SDoc
985 pprHsBracket (ExpBr e) = thBrackets empty (ppr e)
986 pprHsBracket (PatBr p) = thBrackets (char 'p') (ppr p)
987 pprHsBracket (DecBr d) = thBrackets (char 'd') (ppr d)
988 pprHsBracket (TypBr t) = thBrackets (char 't') (ppr t)
989 pprHsBracket (VarBr n) = char '\'' <> ppr n
990 -- Infelicity: can't show ' vs '', because
991 -- we can't ask n what its OccName is, because the
992 -- pretty-printer for HsExpr doesn't ask for NamedThings
993 -- But the pretty-printer for names will show the OccName class
994
995 thBrackets :: SDoc -> SDoc -> SDoc
996 thBrackets pp_kind pp_body = char '[' <> pp_kind <> char '|' <+>
997                              pp_body <+> ptext (sLit "|]")
998 \end{code}
999
1000 %************************************************************************
1001 %*                                                                      *
1002 \subsection{Enumerations and list comprehensions}
1003 %*                                                                      *
1004 %************************************************************************
1005
1006 \begin{code}
1007 data ArithSeqInfo id
1008   = From            (LHsExpr id)
1009   | FromThen        (LHsExpr id)
1010                     (LHsExpr id)
1011   | FromTo          (LHsExpr id)
1012                     (LHsExpr id)
1013   | FromThenTo      (LHsExpr id)
1014                     (LHsExpr id)
1015                     (LHsExpr id)
1016 \end{code}
1017
1018 \begin{code}
1019 instance OutputableBndr id => Outputable (ArithSeqInfo id) where
1020     ppr (From e1)             = hcat [ppr e1, pp_dotdot]
1021     ppr (FromThen e1 e2)      = hcat [ppr e1, comma, space, ppr e2, pp_dotdot]
1022     ppr (FromTo e1 e3)        = hcat [ppr e1, pp_dotdot, ppr e3]
1023     ppr (FromThenTo e1 e2 e3)
1024       = hcat [ppr e1, comma, space, ppr e2, pp_dotdot, ppr e3]
1025
1026 pp_dotdot :: SDoc
1027 pp_dotdot = ptext (sLit " .. ")
1028 \end{code}
1029
1030
1031 %************************************************************************
1032 %*                                                                      *
1033 \subsection{HsMatchCtxt}
1034 %*                                                                      *
1035 %************************************************************************
1036
1037 \begin{code}
1038 data HsMatchContext id  -- Context of a Match
1039   = FunRhs id Bool              -- Function binding for f; True <=> written infix
1040   | CaseAlt                     -- Patterns and guards on a case alternative
1041   | LambdaExpr                  -- Patterns of a lambda
1042   | ProcExpr                    -- Patterns of a proc
1043   | PatBindRhs                  -- Patterns in the *guards* of a pattern binding
1044   | RecUpd                      -- Record update [used only in DsExpr to
1045                                 --    tell matchWrapper what sort of
1046                                 --    runtime error message to generate]
1047   | StmtCtxt (HsStmtContext id) -- Pattern of a do-stmt or list comprehension
1048   deriving ()
1049
1050 data HsStmtContext id
1051   = ListComp
1052   | DoExpr
1053   | MDoExpr PostTcTable                  -- Recursive do-expression
1054                                          -- (tiresomely, it needs table
1055                                          --  of its return/bind ops)
1056   | PArrComp                             -- Parallel array comprehension
1057   | PatGuard (HsMatchContext id)         -- Pattern guard for specified thing
1058   | ParStmtCtxt (HsStmtContext id)       -- A branch of a parallel stmt
1059   | TransformStmtCtxt (HsStmtContext id) -- A branch of a transform stmt
1060 \end{code}
1061
1062 \begin{code}
1063 isDoExpr :: HsStmtContext id -> Bool
1064 isDoExpr DoExpr      = True
1065 isDoExpr (MDoExpr _) = True
1066 isDoExpr _           = False
1067
1068 isListCompExpr :: HsStmtContext id -> Bool
1069 isListCompExpr ListComp = True
1070 isListCompExpr PArrComp = True
1071 isListCompExpr _        = False
1072 \end{code}
1073
1074 \begin{code}
1075 matchSeparator :: HsMatchContext id -> SDoc
1076 matchSeparator (FunRhs {})  = ptext (sLit "=")
1077 matchSeparator CaseAlt      = ptext (sLit "->")
1078 matchSeparator LambdaExpr   = ptext (sLit "->")
1079 matchSeparator ProcExpr     = ptext (sLit "->")
1080 matchSeparator PatBindRhs   = ptext (sLit "=")
1081 matchSeparator (StmtCtxt _) = ptext (sLit "<-")
1082 matchSeparator RecUpd       = panic "unused"
1083 \end{code}
1084
1085 \begin{code}
1086 pprMatchContext :: Outputable id => HsMatchContext id -> SDoc
1087 pprMatchContext (FunRhs fun _)    = ptext (sLit "the definition of")
1088                                     <+> quotes (ppr fun)
1089 pprMatchContext CaseAlt           = ptext (sLit "a case alternative")
1090 pprMatchContext RecUpd            = ptext (sLit "a record-update construct")
1091 pprMatchContext PatBindRhs        = ptext (sLit "a pattern binding")
1092 pprMatchContext LambdaExpr        = ptext (sLit "a lambda abstraction")
1093 pprMatchContext ProcExpr          = ptext (sLit "an arrow abstraction")
1094 pprMatchContext (StmtCtxt ctxt)   = ptext (sLit "a pattern binding in")
1095                                     $$ pprStmtContext ctxt
1096
1097 pprStmtContext :: Outputable id => HsStmtContext id -> SDoc
1098 pprStmtContext (ParStmtCtxt c)
1099  = sep [ptext (sLit "a parallel branch of"), pprStmtContext c]
1100 pprStmtContext (TransformStmtCtxt c)
1101  = sep [ptext (sLit "a transformed branch of"), pprStmtContext c]
1102 pprStmtContext (PatGuard ctxt)
1103  = ptext (sLit "a pattern guard for") $$ pprMatchContext ctxt
1104 pprStmtContext DoExpr          = ptext (sLit "a 'do' expression")
1105 pprStmtContext (MDoExpr _)     = ptext (sLit "an 'mdo' expression")
1106 pprStmtContext ListComp        = ptext (sLit "a list comprehension")
1107 pprStmtContext PArrComp        = ptext (sLit "an array comprehension")
1108
1109 {-
1110 pprMatchRhsContext (FunRhs fun) = ptext (sLit "a right-hand side of function") <+> quotes (ppr fun)
1111 pprMatchRhsContext CaseAlt      = ptext (sLit "the body of a case alternative")
1112 pprMatchRhsContext PatBindRhs   = ptext (sLit "the right-hand side of a pattern binding")
1113 pprMatchRhsContext LambdaExpr   = ptext (sLit "the body of a lambda")
1114 pprMatchRhsContext ProcExpr     = ptext (sLit "the body of a proc")
1115 pprMatchRhsContext other        = panic "pprMatchRhsContext"    -- RecUpd, StmtCtxt
1116
1117 -- Used for the result statement of comprehension
1118 -- e.g. the 'e' in      [ e | ... ]
1119 --      or the 'r' in   f x = r
1120 pprStmtResultContext (PatGuard ctxt) = pprMatchRhsContext ctxt
1121 pprStmtResultContext other           = ptext (sLit "the result of") <+> pprStmtContext other
1122 -}
1123
1124 -- Used to generate the string for a *runtime* error message
1125 matchContextErrString :: Outputable id => HsMatchContext id -> SDoc
1126 matchContextErrString (FunRhs fun _)             = ptext (sLit "function") <+> ppr fun
1127 matchContextErrString CaseAlt                    = ptext (sLit "case")
1128 matchContextErrString PatBindRhs                 = ptext (sLit "pattern binding")
1129 matchContextErrString RecUpd                     = ptext (sLit "record update")
1130 matchContextErrString LambdaExpr                 = ptext (sLit "lambda")
1131 matchContextErrString ProcExpr                   = ptext (sLit "proc")
1132 matchContextErrString (StmtCtxt (ParStmtCtxt c)) = matchContextErrString (StmtCtxt c)
1133 matchContextErrString (StmtCtxt (TransformStmtCtxt c)) = matchContextErrString (StmtCtxt c)
1134 matchContextErrString (StmtCtxt (PatGuard _))    = ptext (sLit "pattern guard")
1135 matchContextErrString (StmtCtxt DoExpr)          = ptext (sLit "'do' expression")
1136 matchContextErrString (StmtCtxt (MDoExpr _))     = ptext (sLit "'mdo' expression")
1137 matchContextErrString (StmtCtxt ListComp)        = ptext (sLit "list comprehension")
1138 matchContextErrString (StmtCtxt PArrComp)        = ptext (sLit "array comprehension")
1139 \end{code}
1140
1141 \begin{code}
1142 pprMatchInCtxt :: (OutputableBndr idL, OutputableBndr idR)
1143                => HsMatchContext idL -> Match idR -> SDoc
1144 pprMatchInCtxt ctxt match  = hang (ptext (sLit "In") <+> pprMatchContext ctxt <> colon) 
1145                              4 (pprMatch ctxt match)
1146
1147 pprStmtInCtxt :: (OutputableBndr idL, OutputableBndr idR)
1148                => HsStmtContext idL -> StmtLR idL idR -> SDoc
1149 pprStmtInCtxt ctxt stmt = hang (ptext (sLit "In a stmt of") <+> pprStmtContext ctxt <> colon)
1150                           4 (ppr stmt)
1151 \end{code}