2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
5 \section[PatSyntax]{Abstract Haskell syntax---patterns}
8 {-# OPTIONS -fno-warn-incomplete-patterns #-}
9 -- The above warning supression flag is a temporary kludge.
10 -- While working on this module you are encouraged to remove it and fix
11 -- any warnings in the module. See
12 -- http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
16 Pat(..), InPat, OutPat, LPat,
19 HsConPatDetails, hsConPatArgs,
20 HsRecFields(..), HsRecField(..), hsRecFields,
24 mkPrefixConPat, mkCharLitPat, mkNilPat, mkCoPat, mkCoPatCoI,
26 isBangHsBind, hsPatNeedsParens,
27 patsAreAllCons, isConPat, isSigPat, isWildPat,
28 patsAreAllLits, isLitPat, isIrrefutableHsPat
31 import {-# SOURCE #-} HsExpr (SyntaxExpr, LHsExpr, pprLExpr)
40 import PprCore ( {- instance OutputableBndr TyVar -} )
53 type InPat id = LPat id -- No 'Out' constructors
54 type OutPat id = LPat id -- No 'In' constructors
56 type LPat id = Located (Pat id)
59 = ------------ Simple patterns ---------------
60 WildPat PostTcType -- Wild card
61 -- The sole reason for a type on a WildPat is to
62 -- support hsPatType :: Pat Id -> Type
64 | VarPat id -- Variable
65 | VarPatOut id (DictBinds id) -- Used only for overloaded Ids; the
66 -- bindings give its overloaded instances
67 | LazyPat (LPat id) -- Lazy pattern
68 | AsPat (Located id) (LPat id) -- As pattern
69 | ParPat (LPat id) -- Parenthesised pattern
70 | BangPat (LPat id) -- Bang pattern
72 ------------ Lists, tuples, arrays ---------------
73 | ListPat [LPat id] -- Syntactic list
74 PostTcType -- The type of the elements
76 | TuplePat [LPat id] -- Tuple
77 Boxity -- UnitPat is TuplePat []
79 -- You might think that the PostTcType was redundant, but it's essential
82 -- f :: (T a, a) -> Int
84 -- When desugaring, we must generate
85 -- f = /\a. \v::a. case v of (t::T a, w::a) ->
86 -- case t of (T1 (x::Int)) ->
87 -- Note the (w::a), NOT (w::Int), because we have not yet
88 -- refined 'a' to Int. So we must know that the second component
89 -- of the tuple is of type 'a' not Int. See selectMatchVar
91 | PArrPat [LPat id] -- Syntactic parallel array
92 PostTcType -- The type of the elements
94 ------------ Constructor patterns ---------------
95 | ConPatIn (Located id)
99 pat_con :: Located DataCon,
100 pat_tvs :: [TyVar], -- Existentially bound type variables (tyvars only)
101 pat_dicts :: [id], -- Ditto *coercion variables* and *dictionaries*
102 -- One reason for putting coercion variable here, I think,
103 -- is to ensure their kinds are zonked
104 pat_binds :: DictBinds id, -- Bindings involving those dictionaries
105 pat_args :: HsConPatDetails id,
106 pat_ty :: Type -- The type of the pattern
109 ------------ View patterns ---------------
110 | ViewPat (LHsExpr id)
112 PostTcType -- The overall type of the pattern
113 -- (= the argument type of the view function)
116 ------------ Quasiquoted patterns ---------------
117 -- See Note [Quasi-quote overview] in TcSplice
118 | QuasiQuotePat (HsQuasiQuote id)
120 ------------ Literal and n+k patterns ---------------
121 | LitPat HsLit -- Used for *non-overloaded* literal patterns:
122 -- Int#, Char#, Int, Char, String, etc.
124 | NPat (HsOverLit id) -- ALWAYS positive
125 (Maybe (SyntaxExpr id)) -- Just (Name of 'negate') for negative
126 -- patterns, Nothing otherwise
127 (SyntaxExpr id) -- Equality checker, of type t->t->Bool
129 | NPlusKPat (Located id) -- n+k pattern
130 (HsOverLit id) -- It'll always be an HsIntegral
131 (SyntaxExpr id) -- (>=) function, of type t->t->Bool
132 (SyntaxExpr id) -- Name of '-' (see RnEnv.lookupSyntaxName)
134 ------------ Generics ---------------
135 | TypePat (LHsType id) -- Type pattern for generic definitions
136 -- e.g f{| a+b |} = ...
137 -- These show up only in class declarations,
138 -- and should be a top-level pattern
140 ------------ Pattern type signatures ---------------
141 | SigPatIn (LPat id) -- Pattern with a type signature
144 | SigPatOut (LPat id) -- Pattern with a type signature
147 ------------ Pattern coercions (translation only) ---------------
148 | CoPat HsWrapper -- If co::t1 -> t2, p::t2,
149 -- then (CoPat co p) :: t1
150 (Pat id) -- Why not LPat? Ans: existing locn will do
151 Type -- Type of whole pattern, t1
152 -- During desugaring a (CoPat co pat) turns into a cast with 'co' on
153 -- the scrutinee, followed by a match on 'pat'
156 HsConDetails is use for patterns/expressions *and* for data type declarations
159 data HsConDetails arg rec
160 = PrefixCon [arg] -- C p1 p2 p3
161 | RecCon rec -- C { x = p1, y = p2 }
162 | InfixCon arg arg -- p1 `C` p2
164 type HsConPatDetails id = HsConDetails (LPat id) (HsRecFields id (LPat id))
166 hsConPatArgs :: HsConPatDetails id -> [LPat id]
167 hsConPatArgs (PrefixCon ps) = ps
168 hsConPatArgs (RecCon fs) = map hsRecFieldArg (rec_flds fs)
169 hsConPatArgs (InfixCon p1 p2) = [p1,p2]
172 However HsRecFields is used only for patterns and expressions
173 (not data type declarations)
176 data HsRecFields id arg -- A bunch of record fields
177 -- { x = 3, y = True }
178 -- Used for both expressions and patterns
179 = HsRecFields { rec_flds :: [HsRecField id arg],
180 rec_dotdot :: Maybe Int } -- Note [DotDot fields]
182 -- Note [DotDot fields]
183 -- ~~~~~~~~~~~~~~~~~~~~
184 -- The rec_dotdot field means this:
185 -- Nothing => the normal case
186 -- Just n => the group uses ".." notation,
188 -- In the latter case:
190 -- *before* renamer: rec_flds are exactly the n user-written fields
192 -- *after* renamer: rec_flds includes *all* fields, with
193 -- the first 'n' being the user-written ones
194 -- and the remainder being 'filled in' implicitly
196 data HsRecField id arg = HsRecField {
197 hsRecFieldId :: Located id,
198 hsRecFieldArg :: arg,
199 hsRecPun :: Bool -- Note [Punning]
204 -- If you write T { x, y = v+1 }, the HsRecFields will be
205 -- HsRecField x x True ...
206 -- HsRecField y (v+1) False ...
207 -- That is, for "punned" field x is expanded (in the renamer)
208 -- to x=x; but with a punning flag so we can detect it later
209 -- (e.g. when pretty printing)
211 -- If the original field was qualified, we un-qualify it, thus
212 -- T { A.x } means T { A.x = x }
214 hsRecFields :: HsRecFields id arg -> [id]
215 hsRecFields rbinds = map (unLoc . hsRecFieldId) (rec_flds rbinds)
219 data HsQuasiQuote id = HsQuasiQuote
225 instance OutputableBndr id => Outputable (HsQuasiQuote id) where
228 ppr_qq :: OutputableBndr id => HsQuasiQuote id -> SDoc
229 ppr_qq (HsQuasiQuote name quoter _ quote) =
230 char '$' <> brackets (ppr name) <>
231 ptext (sLit "[:") <> ppr quoter <> ptext (sLit "|") <>
232 ppr quote <> ptext (sLit "|]")
236 %************************************************************************
240 %************************************************************************
243 instance (OutputableBndr name) => Outputable (Pat name) where
246 pprPatBndr :: OutputableBndr name => name -> SDoc
247 pprPatBndr var -- Print with type info if -dppr-debug is on
248 = getPprStyle $ \ sty ->
249 if debugStyle sty then
250 parens (pprBndr LambdaBind var) -- Could pass the site to pprPat
251 -- but is it worth it?
255 pprPat :: (OutputableBndr name) => Pat name -> SDoc
256 pprPat (VarPat var) = pprPatBndr var
257 pprPat (VarPatOut var bs) = parens (pprPatBndr var <+> braces (ppr bs))
258 pprPat (WildPat _) = char '_'
259 pprPat (LazyPat pat) = char '~' <> ppr pat
260 pprPat (BangPat pat) = char '!' <> ppr pat
261 pprPat (AsPat name pat) = parens (hcat [ppr name, char '@', ppr pat])
262 pprPat (ViewPat expr pat _) = parens (hcat [pprLExpr expr, text " -> ", ppr pat])
263 pprPat (ParPat pat) = parens (ppr pat)
264 pprPat (ListPat pats _) = brackets (interpp'SP pats)
265 pprPat (PArrPat pats _) = pabrackets (interpp'SP pats)
266 pprPat (TuplePat pats bx _) = tupleParens bx (interpp'SP pats)
268 pprPat (ConPatIn con details) = pprUserCon con details
269 pprPat (ConPatOut { pat_con = con, pat_tvs = tvs, pat_dicts = dicts,
270 pat_binds = binds, pat_args = details })
271 = getPprStyle $ \ sty -> -- Tiresome; in TcBinds.tcRhs we print out a
272 if debugStyle sty then -- typechecked Pat in an error message,
273 -- and we want to make sure it prints nicely
274 ppr con <+> sep [ hsep (map pprPatBndr tvs) <+> hsep (map pprPatBndr dicts),
275 pprLHsBinds binds, pprConArgs details]
276 else pprUserCon con details
278 pprPat (LitPat s) = ppr s
279 pprPat (NPat l Nothing _) = ppr l
280 pprPat (NPat l (Just _) _) = char '-' <> ppr l
281 pprPat (NPlusKPat n k _ _) = hcat [ppr n, char '+', ppr k]
282 pprPat (QuasiQuotePat (HsQuasiQuote name quoter _ quote))
283 = char '$' <> brackets (ppr name) <>
284 ptext (sLit "[:") <> ppr quoter <> ptext (sLit "|") <>
285 ppr quote <> ptext (sLit "|]")
286 pprPat (TypePat ty) = ptext (sLit "{|") <> ppr ty <> ptext (sLit "|}")
287 pprPat (CoPat co pat _) = parens (pprHsWrapper (ppr pat) co)
288 pprPat (SigPatIn pat ty) = ppr pat <+> dcolon <+> ppr ty
289 pprPat (SigPatOut pat ty) = ppr pat <+> dcolon <+> ppr ty
291 pprUserCon :: (Outputable con, OutputableBndr id) => con -> HsConPatDetails id -> SDoc
292 pprUserCon c (InfixCon p1 p2) = ppr p1 <+> ppr c <+> ppr p2
293 pprUserCon c details = ppr c <+> pprConArgs details
295 pprConArgs :: OutputableBndr id => HsConPatDetails id -> SDoc
296 pprConArgs (PrefixCon pats) = interppSP pats
297 pprConArgs (InfixCon p1 p2) = interppSP [p1,p2]
298 pprConArgs (RecCon rpats) = ppr rpats
300 instance (OutputableBndr id, Outputable arg)
301 => Outputable (HsRecFields id arg) where
302 ppr (HsRecFields { rec_flds = flds, rec_dotdot = Nothing })
303 = braces (fsep (punctuate comma (map ppr flds)))
304 ppr (HsRecFields { rec_flds = flds, rec_dotdot = Just n })
305 = braces (fsep (punctuate comma (map ppr (take n flds) ++ [dotdot])))
307 dotdot = ptext (sLit "..") <+> ifPprDebug (ppr (drop n flds))
309 instance (OutputableBndr id, Outputable arg)
310 => Outputable (HsRecField id arg) where
311 ppr (HsRecField { hsRecFieldId = f, hsRecFieldArg = arg,
313 = ppr f <+> (ppUnless pun $ equals <+> ppr arg)
315 -- add parallel array brackets around a document
317 pabrackets :: SDoc -> SDoc
318 pabrackets p = ptext (sLit "[:") <> p <> ptext (sLit ":]")
322 %************************************************************************
326 %************************************************************************
329 mkPrefixConPat :: DataCon -> [OutPat id] -> Type -> OutPat id
330 -- Make a vanilla Prefix constructor pattern
331 mkPrefixConPat dc pats ty
332 = noLoc $ ConPatOut { pat_con = noLoc dc, pat_tvs = [], pat_dicts = [],
333 pat_binds = emptyLHsBinds, pat_args = PrefixCon pats,
336 mkNilPat :: Type -> OutPat id
337 mkNilPat ty = mkPrefixConPat nilDataCon [] ty
339 mkCharLitPat :: Char -> OutPat id
340 mkCharLitPat c = mkPrefixConPat charDataCon [noLoc $ LitPat (HsCharPrim c)] charTy
342 mkCoPat :: HsWrapper -> Pat id -> Type -> Pat id
344 | isIdHsWrapper co = pat
345 | otherwise = CoPat co pat ty
347 mkCoPatCoI :: CoercionI -> Pat id -> Type -> Pat id
348 mkCoPatCoI IdCo pat _ = pat
349 mkCoPatCoI (ACo co) pat ty = mkCoPat (WpCast co) pat ty
353 %************************************************************************
355 %* Predicates for checking things about pattern-lists in EquationInfo *
357 %************************************************************************
359 \subsection[Pat-list-predicates]{Look for interesting things in patterns}
361 Unlike in the Wadler chapter, where patterns are either ``variables''
362 or ``constructors,'' here we distinguish between:
365 Patterns that cannot fail to match: variables, wildcards, and lazy
368 These are the irrefutable patterns; the two other categories
369 are refutable patterns.
372 A non-literal constructor pattern (see next category).
374 \item[literal patterns:]
375 At least the numeric ones may be overloaded.
378 A pattern is in {\em exactly one} of the above three categories; `as'
379 patterns are treated specially, of course.
381 The 1.3 report defines what ``irrefutable'' and ``failure-free'' patterns are.
383 isWildPat :: Pat id -> Bool
384 isWildPat (WildPat _) = True
387 patsAreAllCons :: [Pat id] -> Bool
388 patsAreAllCons pat_list = all isConPat pat_list
390 isConPat :: Pat id -> Bool
391 isConPat (AsPat _ pat) = isConPat (unLoc pat)
392 isConPat (ConPatIn {}) = True
393 isConPat (ConPatOut {}) = True
394 isConPat (ListPat {}) = True
395 isConPat (PArrPat {}) = True
396 isConPat (TuplePat {}) = True
399 isSigPat :: Pat id -> Bool
400 isSigPat (SigPatIn _ _) = True
401 isSigPat (SigPatOut _ _) = True
404 patsAreAllLits :: [Pat id] -> Bool
405 patsAreAllLits pat_list = all isLitPat pat_list
407 isLitPat :: Pat id -> Bool
408 isLitPat (AsPat _ pat) = isLitPat (unLoc pat)
409 isLitPat (LitPat _) = True
410 isLitPat (NPat _ _ _) = True
411 isLitPat (NPlusKPat _ _ _ _) = True
414 isBangHsBind :: HsBind id -> Bool
415 -- In this module because HsPat is above HsBinds in the import graph
416 isBangHsBind (PatBind { pat_lhs = L _ (BangPat _) }) = True
417 isBangHsBind _ = False
419 isIrrefutableHsPat :: OutputableBndr id => LPat id -> Bool
420 -- (isIrrefutableHsPat p) is true if matching against p cannot fail,
421 -- in the sense of falling through to the next pattern.
422 -- (NB: this is not quite the same as the (silly) defn
423 -- in 3.17.2 of the Haskell 98 report.)
425 -- isIrrefutableHsPat returns False if it's in doubt; specifically
426 -- on a ConPatIn it doesn't know the size of the constructor family
427 -- But if it returns True, the pattern is definitely irrefutable
428 isIrrefutableHsPat pat
431 go (L _ pat) = go1 pat
433 go1 (WildPat {}) = True
434 go1 (VarPat {}) = True
435 go1 (VarPatOut {}) = True
436 go1 (LazyPat {}) = True
437 go1 (BangPat pat) = go pat
438 go1 (CoPat _ pat _) = go1 pat
439 go1 (ParPat pat) = go pat
440 go1 (AsPat _ pat) = go pat
441 go1 (ViewPat _ pat _) = go pat
442 go1 (SigPatIn pat _) = go pat
443 go1 (SigPatOut pat _) = go pat
444 go1 (TuplePat pats _ _) = all go pats
445 go1 (ListPat {}) = False
446 go1 (PArrPat {}) = False -- ?
448 go1 (ConPatIn {}) = False -- Conservative
449 go1 (ConPatOut{ pat_con = L _ con, pat_args = details })
450 = isProductTyCon (dataConTyCon con)
451 && all go (hsConPatArgs details)
453 go1 (LitPat {}) = False
454 go1 (NPat {}) = False
455 go1 (NPlusKPat {}) = False
457 go1 (QuasiQuotePat {}) = urk pat -- Gotten rid of by renamer, before
458 -- isIrrefutablePat is called
459 go1 (TypePat {}) = urk pat
461 urk pat = pprPanic "isIrrefutableHsPat:" (ppr pat)
463 hsPatNeedsParens :: Pat a -> Bool
464 hsPatNeedsParens (WildPat {}) = False
465 hsPatNeedsParens (VarPat {}) = False
466 hsPatNeedsParens (VarPatOut {}) = True
467 hsPatNeedsParens (LazyPat {}) = False
468 hsPatNeedsParens (BangPat {}) = False
469 hsPatNeedsParens (CoPat {}) = True
470 hsPatNeedsParens (ParPat {}) = False
471 hsPatNeedsParens (AsPat {}) = False
472 hsPatNeedsParens (ViewPat {}) = True
473 hsPatNeedsParens (SigPatIn {}) = True
474 hsPatNeedsParens (SigPatOut {}) = True
475 hsPatNeedsParens (TuplePat {}) = False
476 hsPatNeedsParens (ListPat {}) = False
477 hsPatNeedsParens (PArrPat {}) = False
478 hsPatNeedsParens (ConPatIn _ ds) = conPatNeedsParens ds
479 hsPatNeedsParens (ConPatOut {}) = True
480 hsPatNeedsParens (LitPat {}) = False
481 hsPatNeedsParens (NPat {}) = False
482 hsPatNeedsParens (NPlusKPat {}) = True
483 hsPatNeedsParens (QuasiQuotePat {}) = True
484 hsPatNeedsParens (TypePat {}) = False
486 conPatNeedsParens :: HsConDetails a b -> Bool
487 conPatNeedsParens (PrefixCon args) = not (null args)
488 conPatNeedsParens (InfixCon {}) = False
489 conPatNeedsParens (RecCon {}) = False