2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
6 HsExpr: Abstract Haskell syntax: expressions
11 #include "HsVersions.h"
32 %************************************************************************
34 \subsection{Expressions proper}
36 %************************************************************************
39 type LHsExpr id = Located (HsExpr id)
41 -------------------------
42 -- PostTcExpr is an evidence expression attached to the
43 -- syntax tree by the type checker (c.f. postTcType)
44 -- We use a PostTcTable where there are a bunch of pieces of
45 -- evidence, more than is convenient to keep individually
46 type PostTcExpr = HsExpr Id
47 type PostTcTable = [(Name, Id)]
49 noPostTcExpr :: PostTcExpr
50 noPostTcExpr = HsLit (HsString FSLIT("noPostTcExpr"))
52 noPostTcTable :: PostTcTable
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 -- E.g. (>>=) is filled in before the renamer by the appropriate Name
59 -- for (>>=), and then instantiated by the type checker with its
62 type SyntaxExpr id = HsExpr id
64 noSyntaxExpr :: SyntaxExpr id -- Before renaming, and sometimes after,
65 -- (if the syntax slot makes no sense)
66 noSyntaxExpr = HsLit (HsString FSLIT("noSyntaxExpr"))
69 type SyntaxTable id = [(Name, SyntaxExpr id)]
70 -- *** Currently used only for CmdTop (sigh) ***
71 -- * Before the renamer, this list is noSyntaxTable
73 -- * After the renamer, it takes the form [(std_name, HsVar actual_name)]
74 -- For example, for the 'return' op of a monad
75 -- normal case: (GHC.Base.return, HsVar GHC.Base.return)
76 -- with rebindable syntax: (GHC.Base.return, return_22)
77 -- where return_22 is whatever "return" is in scope
79 -- * After the type checker, it takes the form [(std_name, <expression>)]
80 -- where <expression> is the evidence for the method
82 noSyntaxTable :: SyntaxTable id
86 -------------------------
88 = HsVar id -- variable
89 | HsIPVar (IPName id) -- implicit parameter
90 | HsOverLit (HsOverLit id) -- Overloaded literals
91 | HsLit HsLit -- Simple (non-overloaded) literals
93 | HsLam (MatchGroup id) -- Currently always a single match
95 | HsApp (LHsExpr id) -- Application
98 -- Operator applications:
99 -- NB Bracketed ops such as (+) come out as Vars.
101 -- NB We need an expr for the operator in an OpApp/Section since
102 -- the typechecker may need to apply the operator to a few types.
104 | OpApp (LHsExpr id) -- left operand
105 (LHsExpr id) -- operator
106 Fixity -- Renamer adds fixity; bottom until then
107 (LHsExpr id) -- right operand
109 | NegApp (LHsExpr id) -- negated expr
110 (SyntaxExpr id) -- Name of 'negate'
112 | HsPar (LHsExpr id) -- parenthesised expr
114 | SectionL (LHsExpr id) -- operand
115 (LHsExpr id) -- operator
116 | SectionR (LHsExpr id) -- operator
117 (LHsExpr id) -- operand
119 | HsCase (LHsExpr id)
122 | HsIf (LHsExpr id) -- predicate
123 (LHsExpr id) -- then part
124 (LHsExpr id) -- else part
126 | HsLet (HsLocalBinds id) -- let(rec)
129 | HsDo (HsStmtContext Name) -- The parameterisation is unimportant
130 -- because in this context we never use
131 -- the PatGuard or ParStmt variant
132 [LStmt id] -- "do":one or more stmts
133 (LHsExpr id) -- The body; the last expression in the 'do'
134 -- of [ body | ... ] in a list comp
135 PostTcType -- Type of the whole expression
137 | ExplicitList -- syntactic list
138 PostTcType -- Gives type of components of list
141 | ExplicitPArr -- syntactic parallel array: [:e1, ..., en:]
142 PostTcType -- type of elements of the parallel array
145 | ExplicitTuple -- tuple
147 -- NB: Unit is ExplicitTuple []
148 -- for tuples, we can get the types
149 -- direct from the components
153 -- Record construction
154 | RecordCon (Located id) -- The constructor. After type checking
155 -- it's the dataConWrapId of the constructor
156 PostTcExpr -- Data con Id applied to type args
160 | RecordUpd (LHsExpr id)
162 [DataCon] -- Filled in by the type checker to the *non-empty*
163 -- list of DataCons that have all the upd'd fields
164 [PostTcType] -- Argument types of *input* record type
165 [PostTcType] -- and *output* record type
166 -- For a type family, the arg types are of the *instance* tycon, not the family tycon
168 | ExprWithTySig -- e :: type
172 | ExprWithTySigOut -- TRANSLATION
174 (LHsType Name) -- Retain the signature for round-tripping purposes
176 | ArithSeq -- arithmetic sequence
180 | PArrSeq -- arith. sequence for parallel array
181 PostTcExpr -- [:e1..e2:] or [:e1, e2..e3:]
184 | HsSCC FastString -- "set cost centre" (_scc_) annotation
185 (LHsExpr id) -- expr whose cost is to be measured
187 | HsCoreAnn FastString -- hdaume: core annotation
190 -----------------------------------------------------------
191 -- MetaHaskell Extensions
193 | HsBracket (HsBracket id)
195 | HsBracketOut (HsBracket Name) -- Output of the type checker is the *original*
196 [PendingSplice] -- renamed expression, plus *typechecked* splices
197 -- to be pasted back in by the desugarer
199 | HsSpliceE (HsSplice id)
201 -----------------------------------------------------------
202 -- Arrow notation extension
204 | HsProc (LPat id) -- arrow abstraction, proc
205 (LHsCmdTop id) -- body of the abstraction
206 -- always has an empty stack
208 ---------------------------------------
209 -- The following are commands, not expressions proper
211 | HsArrApp -- Arrow tail, or arrow application (f -< arg)
212 (LHsExpr id) -- arrow expression, f
213 (LHsExpr id) -- input expression, arg
214 PostTcType -- type of the arrow expressions f,
215 -- of the form a t t', where arg :: t
216 HsArrAppType -- higher-order (-<<) or first-order (-<)
217 Bool -- True => right-to-left (f -< arg)
218 -- False => left-to-right (arg >- f)
220 | HsArrForm -- Command formation, (| e cmd1 .. cmdn |)
221 (LHsExpr id) -- the operator
222 -- after type-checking, a type abstraction to be
223 -- applied to the type of the local environment tuple
224 (Maybe Fixity) -- fixity (filled in by the renamer), for forms that
225 -- were converted from OpApp's by the renamer
226 [LHsCmdTop id] -- argument commands
229 ---------------------------------------
230 -- Haskell program coverage (Hpc) Support
233 Int -- module-local tick number
234 [id] -- variables in scope
235 (LHsExpr id) -- sub-expression
238 Int -- module-local tick number for True
239 Int -- module-local tick number for False
240 (LHsExpr id) -- sub-expression
242 | HsTickPragma -- A pragma introduced tick
243 (FastString,(Int,Int),(Int,Int)) -- external span for this tick
246 ---------------------------------------
247 -- These constructors only appear temporarily in the parser.
248 -- The renamer translates them into the Right Thing.
250 | EWildPat -- wildcard
252 | EAsPat (Located id) -- as pattern
255 | ELazyPat (LHsExpr id) -- ~ pattern
257 | HsType (LHsType id) -- Explicit type argument; e.g f {| Int |} x y
259 ---------------------------------------
260 -- Finally, HsWrap appears only in typechecker output
262 | HsWrap HsWrapper -- TRANSLATION
265 type PendingSplice = (Name, LHsExpr Id) -- Typechecked splices, waiting to be
266 -- pasted back in by the desugarer
269 A @Dictionary@, unless of length 0 or 1, becomes a tuple. A
270 @ClassDictLam dictvars methods expr@ is, therefore:
272 \ x -> case x of ( dictvars-and-methods-tuple ) -> expr
276 instance OutputableBndr id => Outputable (HsExpr id) where
277 ppr expr = pprExpr expr
281 -----------------------
282 -- pprExpr, pprLExpr, pprBinds call pprDeeper;
283 -- the underscore versions do not
284 pprLExpr :: OutputableBndr id => LHsExpr id -> SDoc
285 pprLExpr (L _ e) = pprExpr e
287 pprExpr :: OutputableBndr id => HsExpr id -> SDoc
288 pprExpr e | isAtomicHsExpr e || isQuietHsExpr e = ppr_expr e
289 | otherwise = pprDeeper (ppr_expr e)
291 isQuietHsExpr :: HsExpr id -> Bool
292 -- Parentheses do display something, but it gives little info and
293 -- if we go deeper when we go inside them then we get ugly things
295 isQuietHsExpr (HsPar _) = True
296 -- applications don't display anything themselves
297 isQuietHsExpr (HsApp _ _) = True
298 isQuietHsExpr (OpApp _ _ _ _) = True
299 isQuietHsExpr _ = False
301 pprBinds :: OutputableBndr id => HsLocalBinds id -> SDoc
302 pprBinds b = pprDeeper (ppr b)
304 -----------------------
305 ppr_lexpr :: OutputableBndr id => LHsExpr id -> SDoc
306 ppr_lexpr e = ppr_expr (unLoc e)
308 ppr_expr (HsVar v) = pprHsVar v
309 ppr_expr (HsIPVar v) = ppr v
310 ppr_expr (HsLit lit) = ppr lit
311 ppr_expr (HsOverLit lit) = ppr lit
312 ppr_expr (HsPar e) = parens (ppr_lexpr e)
314 ppr_expr (HsCoreAnn s e)
315 = vcat [ptext SLIT("HsCoreAnn") <+> ftext s, ppr_lexpr e]
317 ppr_expr (HsApp e1 e2)
318 = let (fun, args) = collect_args e1 [e2] in
319 hang (ppr_lexpr fun) 2 (sep (map pprParendExpr args))
321 collect_args (L _ (HsApp fun arg)) args = collect_args fun (arg:args)
322 collect_args fun args = (fun, args)
324 ppr_expr (OpApp e1 op fixity e2)
326 HsVar v -> pp_infixly v
329 pp_e1 = pprDebugParendExpr e1 -- In debug mode, add parens
330 pp_e2 = pprDebugParendExpr e2 -- to make precedence clear
333 = hang (ppr op) 2 (sep [pp_e1, pp_e2])
336 = sep [nest 2 pp_e1, pprInfix v, nest 2 pp_e2]
338 ppr_expr (NegApp e _) = char '-' <+> pprDebugParendExpr e
340 ppr_expr (SectionL expr op)
342 HsVar v -> pp_infixly v
345 pp_expr = pprDebugParendExpr expr
347 pp_prefixly = hang (hsep [text " \\ x_ ->", ppr op])
348 4 (hsep [pp_expr, ptext SLIT("x_ )")])
349 pp_infixly v = parens (sep [pp_expr, pprInfix v])
351 ppr_expr (SectionR op expr)
353 HsVar v -> pp_infixly v
356 pp_expr = pprDebugParendExpr expr
358 pp_prefixly = hang (hsep [text "( \\ x_ ->", ppr op, ptext SLIT("x_")])
359 4 ((<>) pp_expr rparen)
361 = parens (sep [pprInfix v, pp_expr])
363 ppr_expr (HsLam matches)
364 = pprMatches LambdaExpr matches
366 ppr_expr (HsCase expr matches)
367 = sep [ sep [ptext SLIT("case"), nest 4 (ppr expr), ptext SLIT("of")],
368 nest 2 (pprMatches CaseAlt matches) ]
370 ppr_expr (HsIf e1 e2 e3)
371 = sep [hsep [ptext SLIT("if"), nest 2 (ppr e1), ptext SLIT("then")],
376 -- special case: let ... in let ...
377 ppr_expr (HsLet binds expr@(L _ (HsLet _ _)))
378 = sep [hang (ptext SLIT("let")) 2 (hsep [pprBinds binds, ptext SLIT("in")]),
381 ppr_expr (HsLet binds expr)
382 = sep [hang (ptext SLIT("let")) 2 (pprBinds binds),
383 hang (ptext SLIT("in")) 2 (ppr expr)]
385 ppr_expr (HsDo do_or_list_comp stmts body _) = pprDo do_or_list_comp stmts body
387 ppr_expr (ExplicitList _ exprs)
388 = brackets (pprDeeperList fsep (punctuate comma (map ppr_lexpr exprs)))
390 ppr_expr (ExplicitPArr _ exprs)
391 = pa_brackets (pprDeeperList fsep (punctuate comma (map ppr_lexpr exprs)))
393 ppr_expr (ExplicitTuple exprs boxity)
394 = tupleParens boxity (sep (punctuate comma (map ppr_lexpr exprs)))
396 ppr_expr (RecordCon con_id con_expr rbinds)
397 = hang (ppr con_id) 2 (ppr rbinds)
399 ppr_expr (RecordUpd aexp rbinds _ _ _)
400 = hang (pprParendExpr aexp) 2 (ppr rbinds)
402 ppr_expr (ExprWithTySig expr sig)
403 = hang (nest 2 (ppr_lexpr expr) <+> dcolon)
405 ppr_expr (ExprWithTySigOut expr sig)
406 = hang (nest 2 (ppr_lexpr expr) <+> dcolon)
409 ppr_expr (ArithSeq expr info) = brackets (ppr info)
410 ppr_expr (PArrSeq expr info) = pa_brackets (ppr info)
412 ppr_expr EWildPat = char '_'
413 ppr_expr (ELazyPat e) = char '~' <> pprParendExpr e
414 ppr_expr (EAsPat v e) = ppr v <> char '@' <> pprParendExpr e
416 ppr_expr (HsSCC lbl expr)
417 = sep [ ptext SLIT("_scc_") <+> doubleQuotes (ftext lbl), pprParendExpr expr ]
419 ppr_expr (HsWrap co_fn e) = pprHsWrapper (pprExpr e) co_fn
420 ppr_expr (HsType id) = ppr id
422 ppr_expr (HsSpliceE s) = pprSplice s
423 ppr_expr (HsBracket b) = pprHsBracket b
424 ppr_expr (HsBracketOut e []) = ppr e
425 ppr_expr (HsBracketOut e ps) = ppr e $$ ptext SLIT("pending") <+> ppr ps
427 ppr_expr (HsProc pat (L _ (HsCmdTop cmd _ _ _)))
428 = hsep [ptext SLIT("proc"), ppr pat, ptext SLIT("->"), ppr cmd]
430 ppr_expr (HsTick tickId vars exp)
431 = hcat [ptext SLIT("tick<"), ppr tickId,ptext SLIT(">("), hsep (map pprHsVar vars), ppr exp,ptext SLIT(")")]
432 ppr_expr (HsBinTick tickIdTrue tickIdFalse exp)
433 = hcat [ptext SLIT("bintick<"),
438 ppr exp,ptext SLIT(")")]
439 ppr_expr (HsTickPragma externalSrcLoc exp)
440 = hcat [ptext SLIT("tickpragma<"), ppr externalSrcLoc,ptext SLIT(">("), ppr exp,ptext SLIT(")")]
442 ppr_expr (HsArrApp arrow arg _ HsFirstOrderApp True)
443 = hsep [ppr_lexpr arrow, ptext SLIT("-<"), ppr_lexpr arg]
444 ppr_expr (HsArrApp arrow arg _ HsFirstOrderApp False)
445 = hsep [ppr_lexpr arg, ptext SLIT(">-"), ppr_lexpr arrow]
446 ppr_expr (HsArrApp arrow arg _ HsHigherOrderApp True)
447 = hsep [ppr_lexpr arrow, ptext SLIT("-<<"), ppr_lexpr arg]
448 ppr_expr (HsArrApp arrow arg _ HsHigherOrderApp False)
449 = hsep [ppr_lexpr arg, ptext SLIT(">>-"), ppr_lexpr arrow]
451 ppr_expr (HsArrForm (L _ (HsVar v)) (Just _) [arg1, arg2])
452 = sep [pprCmdArg (unLoc arg1), hsep [pprInfix v, pprCmdArg (unLoc arg2)]]
453 ppr_expr (HsArrForm op _ args)
454 = hang (ptext SLIT("(|") <> ppr_lexpr op)
455 4 (sep (map (pprCmdArg.unLoc) args) <> ptext SLIT("|)"))
457 pprCmdArg :: OutputableBndr id => HsCmdTop id -> SDoc
458 pprCmdArg (HsCmdTop cmd@(L _ (HsArrForm _ Nothing [])) _ _ _)
460 pprCmdArg (HsCmdTop cmd _ _ _)
461 = parens (ppr_lexpr cmd)
463 -- Put a var in backquotes if it's not an operator already
464 pprInfix :: Outputable name => name -> SDoc
465 pprInfix v | isOperator ppr_v = ppr_v
466 | otherwise = char '`' <> ppr_v <> char '`'
470 -- add parallel array brackets around a document
472 pa_brackets :: SDoc -> SDoc
473 pa_brackets p = ptext SLIT("[:") <> p <> ptext SLIT(":]")
476 HsSyn records exactly where the user put parens, with HsPar.
477 So generally speaking we print without adding any parens.
478 However, some code is internally generated, and in some places
479 parens are absolutely required; so for these places we use
480 pprParendExpr (but don't print double parens of course).
482 For operator applications we don't add parens, because the oprerator
483 fixities should do the job, except in debug mode (-dppr-debug) so we
484 can see the structure of the parse tree.
487 pprDebugParendExpr :: OutputableBndr id => LHsExpr id -> SDoc
488 pprDebugParendExpr expr
489 = getPprStyle (\sty ->
490 if debugStyle sty then pprParendExpr expr
493 pprParendExpr :: OutputableBndr id => LHsExpr id -> SDoc
496 pp_as_was = pprLExpr expr
497 -- Using pprLExpr makes sure that we go 'deeper'
498 -- I think that is usually (always?) right
502 HsOverLit l -> pp_as_was
504 HsIPVar _ -> pp_as_was
505 ExplicitList _ _ -> pp_as_was
506 ExplicitPArr _ _ -> pp_as_was
507 ExplicitTuple _ _ -> pp_as_was
509 HsBracket _ -> pp_as_was
510 HsBracketOut _ [] -> pp_as_was
512 | isListCompExpr sc -> pp_as_was
513 _ -> parens pp_as_was
515 isAtomicHsExpr :: HsExpr id -> Bool -- A single token
516 isAtomicHsExpr (HsVar {}) = True
517 isAtomicHsExpr (HsLit {}) = True
518 isAtomicHsExpr (HsOverLit {}) = True
519 isAtomicHsExpr (HsIPVar {}) = True
520 isAtomicHsExpr (HsWrap _ e) = isAtomicHsExpr e
521 isAtomicHsExpr (HsPar e) = isAtomicHsExpr (unLoc e)
522 isAtomicHsExpr e = False
525 %************************************************************************
527 \subsection{Commands (in arrow abstractions)}
529 %************************************************************************
531 We re-use HsExpr to represent these.
534 type HsCmd id = HsExpr id
536 type LHsCmd id = LHsExpr id
538 data HsArrAppType = HsHigherOrderApp | HsFirstOrderApp
541 The legal constructors for commands are:
543 = HsArrApp ... -- as above
545 | HsArrForm ... -- as above
550 | HsLam (Match id) -- kappa
552 -- the renamer turns this one into HsArrForm
553 | OpApp (HsExpr id) -- left operand
554 (HsCmd id) -- operator
555 Fixity -- Renamer adds fixity; bottom until then
556 (HsCmd id) -- right operand
558 | HsPar (HsCmd id) -- parenthesised command
561 [Match id] -- bodies are HsCmd's
564 | HsIf (HsExpr id) -- predicate
565 (HsCmd id) -- then part
566 (HsCmd id) -- else part
569 | HsLet (HsLocalBinds id) -- let(rec)
572 | HsDo (HsStmtContext Name) -- The parameterisation is unimportant
573 -- because in this context we never use
574 -- the PatGuard or ParStmt variant
575 [Stmt id] -- HsExpr's are really HsCmd's
576 PostTcType -- Type of the whole expression
579 Top-level command, introducing a new arrow.
580 This may occur inside a proc (where the stack is empty) or as an
581 argument of a command-forming operator.
584 type LHsCmdTop id = Located (HsCmdTop id)
587 = HsCmdTop (LHsCmd id)
588 [PostTcType] -- types of inputs on the command's stack
589 PostTcType -- return type of the command
591 -- after type checking:
592 -- names used in the command's desugaring
595 %************************************************************************
597 \subsection{Record binds}
599 %************************************************************************
602 type HsRecordBinds id = HsRecFields id (LHsExpr id)
607 %************************************************************************
609 \subsection{@Match@, @GRHSs@, and @GRHS@ datatypes}
611 %************************************************************************
613 @Match@es are sets of pattern bindings and right hand sides for
614 functions, patterns or case branches. For example, if a function @g@
620 then \tr{g} has two @Match@es: @(x,y) = y@ and @((x:ys),y) = y+1@.
622 It is always the case that each element of an @[Match]@ list has the
623 same number of @pats@s inside it. This corresponds to saying that
624 a function defined by pattern matching must have the same number of
625 patterns in each equation.
630 [LMatch id] -- The alternatives
631 PostTcType -- The type is the type of the entire group
632 -- t1 -> ... -> tn -> tr
633 -- where there are n patterns
635 type LMatch id = Located (Match id)
639 [LPat id] -- The patterns
640 (Maybe (LHsType id)) -- A type signature for the result of the match
641 -- Nothing after typechecking
644 matchGroupArity :: MatchGroup id -> Arity
645 matchGroupArity (MatchGroup [] _)
646 = panic "matchGroupArity" -- MatchGroup is never empty
647 matchGroupArity (MatchGroup (match:matches) _)
648 = ASSERT( all ((== n_pats) . length . hsLMatchPats) matches )
649 -- Assertion just checks that all the matches have the same number of pats
652 n_pats = length (hsLMatchPats match)
654 hsLMatchPats :: LMatch id -> [LPat id]
655 hsLMatchPats (L _ (Match pats _ _)) = pats
657 -- GRHSs are used both for pattern bindings and for Matches
659 = GRHSs [LGRHS id] -- Guarded RHSs
660 (HsLocalBinds id) -- The where clause
662 type LGRHS id = Located (GRHS id)
664 data GRHS id = GRHS [LStmt id] -- Guards
665 (LHsExpr id) -- Right hand side
668 We know the list must have at least one @Match@ in it.
671 pprMatches :: (OutputableBndr id) => HsMatchContext id -> MatchGroup id -> SDoc
672 pprMatches ctxt (MatchGroup matches ty) = vcat (map (pprMatch ctxt) (map unLoc matches))
673 -- Don't print the type; it's only
674 -- a place-holder before typechecking
676 -- Exported to HsBinds, which can't see the defn of HsMatchContext
677 pprFunBind :: (OutputableBndr id) => id -> MatchGroup id -> SDoc
678 pprFunBind fun matches = pprMatches (FunRhs fun) matches
680 -- Exported to HsBinds, which can't see the defn of HsMatchContext
681 pprPatBind :: (OutputableBndr bndr, OutputableBndr id)
682 => LPat bndr -> GRHSs id -> SDoc
683 pprPatBind pat grhss = sep [ppr pat, nest 4 (pprGRHSs PatBindRhs grhss)]
686 pprMatch :: OutputableBndr id => HsMatchContext id -> Match id -> SDoc
687 pprMatch ctxt (Match pats maybe_ty grhss)
688 = pp_name ctxt <+> sep [sep (map ppr pats),
690 nest 2 (pprGRHSs ctxt grhss)]
692 pp_name (FunRhs fun) = ppr fun -- Not pprBndr; the AbsBinds will
693 -- have printed the signature
694 pp_name LambdaExpr = char '\\'
695 pp_name other = empty
697 ppr_maybe_ty = case maybe_ty of
698 Just ty -> dcolon <+> ppr ty
702 pprGRHSs :: OutputableBndr id => HsMatchContext id -> GRHSs id -> SDoc
703 pprGRHSs ctxt (GRHSs grhss binds)
704 = vcat (map (pprGRHS ctxt . unLoc) grhss)
705 $$ if isEmptyLocalBinds binds then empty
706 else text "where" $$ nest 4 (pprBinds binds)
708 pprGRHS :: OutputableBndr id => HsMatchContext id -> GRHS id -> SDoc
710 pprGRHS ctxt (GRHS [] expr)
713 pprGRHS ctxt (GRHS guards expr)
714 = sep [char '|' <+> interpp'SP guards, pp_rhs ctxt expr]
716 pp_rhs ctxt rhs = matchSeparator ctxt <+> pprDeeper (ppr rhs)
719 %************************************************************************
721 \subsection{Do stmts and list comprehensions}
723 %************************************************************************
726 type LStmt id = Located (Stmt id)
728 -- The SyntaxExprs in here are used *only* for do-notation, which
729 -- has rebindable syntax. Otherwise they are unused.
733 (SyntaxExpr id) -- The (>>=) operator
734 (SyntaxExpr id) -- The fail operator
735 -- The fail operator is noSyntaxExpr
736 -- if the pattern match can't fail
738 | ExprStmt (LHsExpr id)
739 (SyntaxExpr id) -- The (>>) operator
740 PostTcType -- Element type of the RHS (used for arrows)
742 | LetStmt (HsLocalBinds id)
744 -- ParStmts only occur in a list comprehension
745 | ParStmt [([LStmt id], [id])] -- After renaming, the ids are the binders
746 -- bound by the stmts and used subsequently
748 -- Recursive statement (see Note [RecStmt] below)
750 --- The next two fields are only valid after renaming
751 [id] -- The ids are a subset of the variables bound by the stmts
752 -- that are used in stmts that follow the RecStmt
754 [id] -- Ditto, but these variables are the "recursive" ones, that
755 -- are used before they are bound in the stmts of the RecStmt
756 -- From a type-checking point of view, these ones have to be monomorphic
758 --- These fields are only valid after typechecking
759 [PostTcExpr] -- These expressions correspond
760 -- 1-to-1 with the "recursive" [id], and are the expresions that
761 -- should be returned by the recursion. They may not quite be the
762 -- Ids themselves, because the Id may be *polymorphic*, but
763 -- the returned thing has to be *monomorphic*.
764 (DictBinds id) -- Method bindings of Ids bound by the RecStmt,
765 -- and used afterwards
768 ExprStmts are a bit tricky, because what they mean
769 depends on the context. Consider the following contexts:
771 A do expression of type (m res_ty)
772 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
773 * ExprStmt E any_ty: do { ....; E; ... }
775 Translation: E >> ...
777 A list comprehensions of type [elt_ty]
778 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
779 * ExprStmt E Bool: [ .. | .... E ]
781 [ .. | .... | ..., E | ... ]
783 Translation: if E then fail else ...
785 A guard list, guarding a RHS of type rhs_ty
786 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
787 * ExprStmt E Bool: f x | ..., E, ... = ...rhs...
789 Translation: if E then fail else ...
791 Array comprehensions are handled like list comprehensions -=chak
798 , RecStmt [a::forall a. a -> a, b]
800 [ BindStmt b (return x)
806 Here, the RecStmt binds a,b,c; but
807 - Only a,b are used in the stmts *following* the RecStmt,
808 This 'a' is *polymorphic'
809 - Only a,c are used in the stmts *inside* the RecStmt
810 *before* their bindings
811 This 'a' is monomorphic
813 Nota Bene: the two a's have different types, even though they
818 instance OutputableBndr id => Outputable (Stmt id) where
819 ppr stmt = pprStmt stmt
821 pprStmt (BindStmt pat expr _ _) = hsep [ppr pat, ptext SLIT("<-"), ppr expr]
822 pprStmt (LetStmt binds) = hsep [ptext SLIT("let"), pprBinds binds]
823 pprStmt (ExprStmt expr _ _) = ppr expr
824 pprStmt (ParStmt stmtss) = hsep (map (\stmts -> ptext SLIT("| ") <> ppr stmts) stmtss)
825 pprStmt (RecStmt segment _ _ _ _) = ptext SLIT("rec") <+> braces (vcat (map ppr segment))
827 pprDo :: OutputableBndr id => HsStmtContext any -> [LStmt id] -> LHsExpr id -> SDoc
828 pprDo DoExpr stmts body = ptext SLIT("do") <+> pprDeeperList vcat (map ppr stmts ++ [ppr body])
829 pprDo (MDoExpr _) stmts body = ptext SLIT("mdo") <+> pprDeeperList vcat (map ppr stmts ++ [ppr body])
830 pprDo ListComp stmts body = pprComp brackets stmts body
831 pprDo PArrComp stmts body = pprComp pa_brackets stmts body
832 pprDo other stmts body = panic "pprDo" -- PatGuard, ParStmtCxt
834 pprComp :: OutputableBndr id => (SDoc -> SDoc) -> [LStmt id] -> LHsExpr id -> SDoc
835 pprComp brack quals body
837 hang (ppr body <+> char '|')
841 %************************************************************************
843 Template Haskell quotation brackets
845 %************************************************************************
848 data HsSplice id = HsSplice -- $z or $(f 4)
849 id -- The id is just a unique name to
850 (LHsExpr id) -- identify this splice point
852 instance OutputableBndr id => Outputable (HsSplice id) where
855 pprSplice :: OutputableBndr id => HsSplice id -> SDoc
856 pprSplice (HsSplice n e) = char '$' <> brackets (ppr n) <> pprParendExpr e
859 data HsBracket id = ExpBr (LHsExpr id) -- [| expr |]
860 | PatBr (LPat id) -- [p| pat |]
861 | DecBr (HsGroup id) -- [d| decls |]
862 | TypBr (LHsType id) -- [t| type |]
863 | VarBr id -- 'x, ''T
865 instance OutputableBndr id => Outputable (HsBracket id) where
869 pprHsBracket (ExpBr e) = thBrackets empty (ppr e)
870 pprHsBracket (PatBr p) = thBrackets (char 'p') (ppr p)
871 pprHsBracket (DecBr d) = thBrackets (char 'd') (ppr d)
872 pprHsBracket (TypBr t) = thBrackets (char 't') (ppr t)
873 pprHsBracket (VarBr n) = char '\'' <> ppr n
874 -- Infelicity: can't show ' vs '', because
875 -- we can't ask n what its OccName is, because the
876 -- pretty-printer for HsExpr doesn't ask for NamedThings
877 -- But the pretty-printer for names will show the OccName class
879 thBrackets pp_kind pp_body = char '[' <> pp_kind <> char '|' <+>
880 pp_body <+> ptext SLIT("|]")
883 %************************************************************************
885 \subsection{Enumerations and list comprehensions}
887 %************************************************************************
892 | FromThen (LHsExpr id)
894 | FromTo (LHsExpr id)
896 | FromThenTo (LHsExpr id)
902 instance OutputableBndr id => Outputable (ArithSeqInfo id) where
903 ppr (From e1) = hcat [ppr e1, pp_dotdot]
904 ppr (FromThen e1 e2) = hcat [ppr e1, comma, space, ppr e2, pp_dotdot]
905 ppr (FromTo e1 e3) = hcat [ppr e1, pp_dotdot, ppr e3]
906 ppr (FromThenTo e1 e2 e3)
907 = hcat [ppr e1, comma, space, ppr e2, pp_dotdot, ppr e3]
909 pp_dotdot = ptext SLIT(" .. ")
913 %************************************************************************
915 \subsection{HsMatchCtxt}
917 %************************************************************************
920 data HsMatchContext id -- Context of a Match
921 = FunRhs id -- Function binding for f
922 | CaseAlt -- Guard on a case alternative
923 | LambdaExpr -- Pattern of a lambda
924 | ProcExpr -- Pattern of a proc
925 | PatBindRhs -- Pattern binding
926 | RecUpd -- Record update [used only in DsExpr to tell matchWrapper
927 -- what sort of runtime error message to generate]
928 | StmtCtxt (HsStmtContext id) -- Pattern of a do-stmt or list comprehension
931 data HsStmtContext id
934 | MDoExpr PostTcTable -- Recursive do-expression
935 -- (tiresomely, it needs table
936 -- of its return/bind ops)
937 | PArrComp -- Parallel array comprehension
938 | PatGuard (HsMatchContext id) -- Pattern guard for specified thing
939 | ParStmtCtxt (HsStmtContext id) -- A branch of a parallel stmt
943 isDoExpr :: HsStmtContext id -> Bool
944 isDoExpr DoExpr = True
945 isDoExpr (MDoExpr _) = True
948 isListCompExpr :: HsStmtContext id -> Bool
949 isListCompExpr ListComp = True
950 isListCompExpr PArrComp = True
951 isListCompExpr _ = False
955 matchSeparator (FunRhs _) = ptext SLIT("=")
956 matchSeparator CaseAlt = ptext SLIT("->")
957 matchSeparator LambdaExpr = ptext SLIT("->")
958 matchSeparator ProcExpr = ptext SLIT("->")
959 matchSeparator PatBindRhs = ptext SLIT("=")
960 matchSeparator (StmtCtxt _) = ptext SLIT("<-")
961 matchSeparator RecUpd = panic "unused"
965 pprMatchContext (FunRhs fun) = ptext SLIT("the definition of") <+> quotes (ppr fun)
966 pprMatchContext CaseAlt = ptext SLIT("a case alternative")
967 pprMatchContext RecUpd = ptext SLIT("a record-update construct")
968 pprMatchContext PatBindRhs = ptext SLIT("a pattern binding")
969 pprMatchContext LambdaExpr = ptext SLIT("a lambda abstraction")
970 pprMatchContext ProcExpr = ptext SLIT("an arrow abstraction")
971 pprMatchContext (StmtCtxt ctxt) = ptext SLIT("a pattern binding in") $$ pprStmtContext ctxt
973 pprStmtContext (ParStmtCtxt c) = sep [ptext SLIT("a parallel branch of"), pprStmtContext c]
974 pprStmtContext (PatGuard ctxt) = ptext SLIT("a pattern guard for") $$ pprMatchContext ctxt
975 pprStmtContext DoExpr = ptext SLIT("a 'do' expression")
976 pprStmtContext (MDoExpr _) = ptext SLIT("an 'mdo' expression")
977 pprStmtContext ListComp = ptext SLIT("a list comprehension")
978 pprStmtContext PArrComp = ptext SLIT("an array comprehension")
981 pprMatchRhsContext (FunRhs fun) = ptext SLIT("a right-hand side of function") <+> quotes (ppr fun)
982 pprMatchRhsContext CaseAlt = ptext SLIT("the body of a case alternative")
983 pprMatchRhsContext PatBindRhs = ptext SLIT("the right-hand side of a pattern binding")
984 pprMatchRhsContext LambdaExpr = ptext SLIT("the body of a lambda")
985 pprMatchRhsContext ProcExpr = ptext SLIT("the body of a proc")
986 pprMatchRhsContext other = panic "pprMatchRhsContext" -- RecUpd, StmtCtxt
988 -- Used for the result statement of comprehension
989 -- e.g. the 'e' in [ e | ... ]
990 -- or the 'r' in f x = r
991 pprStmtResultContext (PatGuard ctxt) = pprMatchRhsContext ctxt
992 pprStmtResultContext other = ptext SLIT("the result of") <+> pprStmtContext other
995 -- Used to generate the string for a *runtime* error message
996 matchContextErrString (FunRhs fun) = "function " ++ showSDoc (ppr fun)
997 matchContextErrString CaseAlt = "case"
998 matchContextErrString PatBindRhs = "pattern binding"
999 matchContextErrString RecUpd = "record update"
1000 matchContextErrString LambdaExpr = "lambda"
1001 matchContextErrString ProcExpr = "proc"
1002 matchContextErrString (StmtCtxt (ParStmtCtxt c)) = matchContextErrString (StmtCtxt c)
1003 matchContextErrString (StmtCtxt (PatGuard _)) = "pattern guard"
1004 matchContextErrString (StmtCtxt DoExpr) = "'do' expression"
1005 matchContextErrString (StmtCtxt (MDoExpr _)) = "'mdo' expression"
1006 matchContextErrString (StmtCtxt ListComp) = "list comprehension"
1007 matchContextErrString (StmtCtxt PArrComp) = "array comprehension"