2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 \section[Main_match]{The @match@ function}
7 module Match ( match, matchExport, matchWrapper, matchSimply, matchSinglePat ) where
9 #include "HsVersions.h"
11 import CmdLineOpts ( DynFlag(..), dopt )
13 import TcHsSyn ( TypecheckedPat, TypecheckedMatch )
14 import DsHsSyn ( outPatType )
15 import Check ( check, ExhaustivePat )
17 import CoreUtils ( bindNonRec )
19 import DsGRHSs ( dsGRHSs )
21 import Id ( idType, recordSelectorFieldLabel, Id )
22 import DataCon ( dataConFieldLabels, dataConInstOrigArgTys )
23 import MatchCon ( matchConFamily )
24 import MatchLit ( matchLiterals )
25 import PrelInfo ( pAT_ERROR_ID )
26 import Type ( splitAlgTyConApp, mkTyVarTys, Type )
27 import TysWiredIn ( nilDataCon, consDataCon, mkTupleTy, mkListTy, tupleCon )
28 import BasicTypes ( Boxity(..) )
30 import ErrUtils ( addWarnLocHdrLine, dontAddErrLoc )
34 This function is a wrapper of @match@, it must be called from all the parts where
35 it was called match, but only substitutes the firs call, ....
36 if the associated flags are declared, warnings will be issued.
37 It can not be called matchWrapper because this name already exists :-(
42 matchExport :: [Id] -- Vars rep'ing the exprs we're matching with
43 -> [EquationInfo] -- Info about patterns, etc. (type synonym below)
44 -> DsM MatchResult -- Desugared result!
48 = getDOptsDs `thenDs` \ dflags ->
49 matchExport_really dflags vars qs
51 matchExport_really dflags vars qs@((EqnInfo _ ctx _ (MatchResult _ _)) : _)
52 | incomplete && shadow =
53 dsShadowWarn ctx eqns_shadow `thenDs` \ () ->
54 dsIncompleteWarn ctx pats `thenDs` \ () ->
57 dsIncompleteWarn ctx pats `thenDs` \ () ->
60 dsShadowWarn ctx eqns_shadow `thenDs` \ () ->
64 where (pats,indexs) = check qs
65 incomplete = dopt Opt_WarnIncompletePatterns dflags
67 shadow = dopt Opt_WarnOverlappingPatterns dflags
68 && sizeUniqSet indexs < no_eqns
70 unused_eqns = uniqSetToList (mkUniqSet [1..no_eqns] `minusUniqSet` indexs)
71 eqns_shadow = map (\n -> qs!!(n - 1)) unused_eqns
74 This variable shows the maximum number of lines of output generated for warnings.
75 It will limit the number of patterns/equations displayed to@ maximum_output@.
77 (ToDo: add command-line option?)
83 The next two functions create the warning message.
86 dsShadowWarn :: DsMatchContext -> [EquationInfo] -> DsM ()
87 dsShadowWarn ctx@(DsMatchContext kind _ _) qs = dsWarn warn
89 warn | length qs > maximum_output
90 = pp_context ctx (ptext SLIT("are overlapped"))
91 (\ f -> vcat (map (ppr_eqn f kind) (take maximum_output qs)) $$
94 = pp_context ctx (ptext SLIT("are overlapped"))
95 (\ f -> vcat $ map (ppr_eqn f kind) qs)
98 dsIncompleteWarn :: DsMatchContext -> [ExhaustivePat] -> DsM ()
99 dsIncompleteWarn ctx@(DsMatchContext kind _ _) pats = dsWarn warn
101 warn = pp_context ctx (ptext SLIT("are non-exhaustive"))
102 (\f -> hang (ptext SLIT("Patterns not matched:"))
103 4 ((vcat $ map (ppr_incomplete_pats kind)
104 (take maximum_output pats))
107 dots | length pats > maximum_output = ptext SLIT("...")
110 pp_context NoMatchContext msg rest_of_msg_fun
111 = dontAddErrLoc (ptext SLIT("Some match(es)") <+> hang msg 8 (rest_of_msg_fun id))
113 pp_context (DsMatchContext kind pats loc) msg rest_of_msg_fun
114 = addWarnLocHdrLine loc message (nest 8 (rest_of_msg_fun pref))
118 FunRhs fun -> (pprMatchContext kind, \ pp -> ppr fun <+> pp)
119 other -> (pprMatchContext kind <+> ppr_pats pats, \ pp -> pp)
121 message = ptext SLIT("Pattern match(es)") <+> msg <+> ppr_match <> char ':'
123 ppr_pats pats = sep (map ppr pats)
125 ppr_shadow_pats kind pats
126 = sep [ppr_pats pats, ptext (matchSeparator kind), ptext SLIT("...")]
128 ppr_incomplete_pats kind (pats,[]) = ppr_pats pats
129 ppr_incomplete_pats kind (pats,constraints) =
130 sep [ppr_pats pats, ptext SLIT("with"),
131 sep (map ppr_constraint constraints)]
134 ppr_constraint (var,pats) = sep [ppr var, ptext SLIT("`notElem`"), ppr pats]
136 ppr_eqn prefixF kind (EqnInfo _ _ pats _) = prefixF (ppr_shadow_pats kind pats)
140 The function @match@ is basically the same as in the Wadler chapter,
141 except it is monadised, to carry around the name supply, info about
144 Notes on @match@'s arguments, assuming $m$ equations and $n$ patterns:
147 A list of $n$ variable names, those variables presumably bound to the
148 $n$ expressions being matched against the $n$ patterns. Using the
149 list of $n$ expressions as the first argument showed no benefit and
153 The second argument, a list giving the ``equation info'' for each of
157 the $n$ patterns for that equation, and
159 a list of Core bindings [@(Id, CoreExpr)@ pairs] to be ``stuck on
160 the front'' of the matching code, as in:
166 and finally: (ToDo: fill in)
168 The right way to think about the ``after-match function'' is that it
169 is an embryonic @CoreExpr@ with a ``hole'' at the end for the
170 final ``else expression''.
173 There is a type synonym, @EquationInfo@, defined in module @DsUtils@.
175 An experiment with re-ordering this information about equations (in
176 particular, having the patterns available in column-major order)
180 A default expression---what to evaluate if the overall pattern-match
181 fails. This expression will (almost?) always be
182 a measly expression @Var@, unless we know it will only be used once
183 (as we do in @glue_success_exprs@).
185 Leaving out this third argument to @match@ (and slamming in lots of
186 @Var "fail"@s) is a positively {\em bad} idea, because it makes it
187 impossible to share the default expressions. (Also, it stands no
188 chance of working in our post-upheaval world of @Locals@.)
190 So, the full type signature:
192 match :: [Id] -- Variables rep'ing the exprs we're matching with
193 -> [EquationInfo] -- Info about patterns, etc. (type synonym below)
194 -> DsM MatchResult -- Desugared result!
197 Note: @match@ is often called via @matchWrapper@ (end of this module),
198 a function that does much of the house-keeping that goes with a call
201 It is also worth mentioning the {\em typical} way a block of equations
202 is desugared with @match@. At each stage, it is the first column of
203 patterns that is examined. The steps carried out are roughly:
206 Tidy the patterns in column~1 with @tidyEqnInfo@ (this may add
207 bindings to the second component of the equation-info):
210 Remove the `as' patterns from column~1.
212 Make all constructor patterns in column~1 into @ConPats@, notably
213 @ListPats@ and @TuplePats@.
215 Handle any irrefutable (or ``twiddle'') @LazyPats@.
218 Now {\em unmix} the equations into {\em blocks} [w/ local function
219 @unmix_eqns@], in which the equations in a block all have variable
220 patterns in column~1, or they all have constructor patterns in ...
221 (see ``the mixture rule'' in SLPJ).
223 Call @matchUnmixedEqns@ on each block of equations; it will do the
224 appropriate thing for each kind of column-1 pattern, usually ending up
225 in a recursive call to @match@.
228 %************************************************************************
230 %* match: empty rule *
232 %************************************************************************
233 \subsection[Match-empty-rule]{The ``empty rule''}
235 We are a little more paranoid about the ``empty rule'' (SLPJ, p.~87)
236 than the Wadler-chapter code for @match@ (p.~93, first @match@ clause).
237 And gluing the ``success expressions'' together isn't quite so pretty.
241 = complete_matches eqns_info
243 complete_matches [eqn]
246 complete_matches (eqn:eqns)
247 = complete_match eqn `thenDs` \ match_result1 ->
248 complete_matches eqns `thenDs` \ match_result2 ->
249 returnDs (combineMatchResults match_result1 match_result2)
251 complete_match (EqnInfo _ _ pats match_result)
252 = ASSERT( null pats )
253 returnDs match_result
256 %************************************************************************
258 %* match: non-empty rule *
260 %************************************************************************
261 \subsection[Match-nonempty]{@match@ when non-empty: unmixing}
263 This (more interesting) clause of @match@ uses @tidy_and_unmix_eqns@
264 (a)~to get `as'- and `twiddle'-patterns out of the way (tidying), and
265 (b)~to do ``the mixture rule'' (SLPJ, p.~88) [which really {\em
266 un}mixes the equations], producing a list of equation-info
267 blocks, each block having as its first column of patterns either all
268 constructors, or all variables (or similar beasts), etc.
270 @match_unmixed_eqn_blks@ simply takes the place of the @foldr@ in the
271 Wadler-chapter @match@ (p.~93, last clause), and @match_unmixed_blk@
272 corresponds roughly to @matchVarCon@.
275 match vars@(v:vs) eqns_info
276 = mapDs (tidyEqnInfo v) eqns_info `thenDs` \ tidy_eqns_info ->
278 tidy_eqns_blks = unmix_eqns tidy_eqns_info
280 match_unmixed_eqn_blks vars tidy_eqns_blks
283 unmix_eqns [eqn] = [ [eqn] ]
284 unmix_eqns (eq1@(EqnInfo _ _ (p1:p1s) _) : eq2@(EqnInfo _ _ (p2:p2s) _) : eqs)
285 = if ( (isWildPat p1 && isWildPat p2)
286 || (isConPat p1 && isConPat p2)
287 || (isLitPat p1 && isLitPat p2) ) then
288 eq1 `tack_onto` unmixed_rest
290 [ eq1 ] : unmixed_rest
292 unmixed_rest = unmix_eqns (eq2:eqs)
294 x `tack_onto` xss = ( x : head xss) : tail xss
296 -----------------------------------------------------------------------
297 -- loop through the blocks:
298 -- subsequent blocks create a "fail expr" for the first one...
299 match_unmixed_eqn_blks :: [Id]
300 -> [ [EquationInfo] ] -- List of eqn BLOCKS
303 match_unmixed_eqn_blks vars [] = panic "match_unmixed_eqn_blks"
305 match_unmixed_eqn_blks vars [eqn_blk] = matchUnmixedEqns vars eqn_blk
307 match_unmixed_eqn_blks vars (eqn_blk:eqn_blks)
308 = matchUnmixedEqns vars eqn_blk `thenDs` \ match_result1 -> -- try to match with first blk
309 match_unmixed_eqn_blks vars eqn_blks `thenDs` \ match_result2 ->
310 returnDs (combineMatchResults match_result1 match_result2)
313 Tidy up the leftmost pattern in an @EquationInfo@, given the variable @v@
314 which will be scrutinised. This means:
317 Replace variable patterns @x@ (@x /= v@) with the pattern @_@,
318 together with the binding @x = v@.
320 Replace the `as' pattern @x@@p@ with the pattern p and a binding @x = v@.
322 Removing lazy (irrefutable) patterns (you don't want to know...).
324 Converting explicit tuple- and list-pats into ordinary @ConPats@.
326 Convert the literal pat "" to [].
329 The result of this tidying is that the column of patterns will include
333 The @VarPat@ information isn't needed any more after this.
336 @ListPats@, @TuplePats@, etc., are all converted into @ConPats@.
338 \item[@LitPats@ and @NPats@:]
339 @LitPats@/@NPats@ of ``known friendly types'' (Int, Char,
340 Float, Double, at least) are converted to unboxed form; e.g.,
341 \tr{(NPat (HsInt i) _ _)} is converted to:
343 (ConPat I# _ _ [LitPat (HsIntPrim i) _])
348 tidyEqnInfo :: Id -> EquationInfo -> DsM EquationInfo
349 -- DsM'd because of internal call to "match".
350 -- "tidy1" does the interesting stuff, looking at
351 -- one pattern and fiddling the list of bindings.
353 -- POST CONDITION: head pattern in the EqnInfo is
361 tidyEqnInfo v (EqnInfo n ctx (pat : pats) match_result)
362 = tidy1 v pat match_result `thenDs` \ (pat', match_result') ->
363 returnDs (EqnInfo n ctx (pat' : pats) match_result')
365 tidy1 :: Id -- The Id being scrutinised
366 -> TypecheckedPat -- The pattern against which it is to be matched
367 -> MatchResult -- Current thing do do after matching
368 -> DsM (TypecheckedPat, -- Equivalent pattern
369 MatchResult) -- Augmented thing to do afterwards
370 -- The augmentation usually takes the form
371 -- of new bindings to be added to the front
373 tidy1 v (VarPat var) match_result
374 = returnDs (WildPat (idType var), match_result')
376 match_result' | v == var = match_result
377 | otherwise = adjustMatchResult (bindNonRec var (Var v)) match_result
379 tidy1 v (AsPat var pat) match_result
380 = tidy1 v pat match_result'
382 match_result' | v == var = match_result
383 | otherwise = adjustMatchResult (bindNonRec var (Var v)) match_result
385 tidy1 v (WildPat ty) match_result
386 = returnDs (WildPat ty, match_result)
388 {- now, here we handle lazy patterns:
389 tidy1 v ~p bs = (v, v1 = case v of p -> v1 :
390 v2 = case v of p -> v2 : ... : bs )
392 where the v_i's are the binders in the pattern.
394 ToDo: in "v_i = ... -> v_i", are the v_i's really the same thing?
396 The case expr for v_i is just: match [v] [(p, [], \ x -> Var v_i)] any_expr
399 tidy1 v (LazyPat pat) match_result
400 = mkSelectorBinds pat (Var v) `thenDs` \ sel_binds ->
401 returnDs (WildPat (idType v),
402 mkCoLetsMatchResult [NonRec b rhs | (b,rhs) <- sel_binds] match_result)
404 -- re-express <con-something> as (ConPat ...) [directly]
406 tidy1 v (RecPat data_con pat_ty ex_tvs dicts rpats) match_result
408 = -- Special case for C {}, which can be used for
409 -- a constructor that isn't declared to have
411 returnDs (ConPat data_con pat_ty ex_tvs dicts (map WildPat con_arg_tys'), match_result)
414 = returnDs (ConPat data_con pat_ty ex_tvs dicts pats, match_result)
416 pats = map mk_pat tagged_arg_tys
418 -- Boring stuff to find the arg-tys of the constructor
419 (_, inst_tys, _) = splitAlgTyConApp pat_ty
420 con_arg_tys' = dataConInstOrigArgTys data_con (inst_tys ++ mkTyVarTys ex_tvs)
421 tagged_arg_tys = con_arg_tys' `zip` (dataConFieldLabels data_con)
423 -- mk_pat picks a WildPat of the appropriate type for absent fields,
424 -- and the specified pattern for present fields
425 mk_pat (arg_ty, lbl) = case [pat | (sel_id,pat,_) <- rpats,
426 recordSelectorFieldLabel sel_id == lbl
428 (pat:pats) -> ASSERT( null pats )
432 tidy1 v (ListPat ty pats) match_result
433 = returnDs (list_ConPat, match_result)
435 list_ty = mkListTy ty
437 = foldr (\ x -> \y -> ConPat consDataCon list_ty [] [] [x, y])
438 (ConPat nilDataCon list_ty [] [] [])
441 tidy1 v (TuplePat pats boxity) match_result
442 = returnDs (tuple_ConPat, match_result)
446 = ConPat (tupleCon boxity arity)
447 (mkTupleTy boxity arity (map outPatType pats)) [] []
450 tidy1 v (DictPat dicts methods) match_result
451 = case num_of_d_and_ms of
452 0 -> tidy1 v (TuplePat [] Boxed) match_result
453 1 -> tidy1 v (head dict_and_method_pats) match_result
454 _ -> tidy1 v (TuplePat dict_and_method_pats Boxed) match_result
456 num_of_d_and_ms = length dicts + length methods
457 dict_and_method_pats = map VarPat (dicts ++ methods)
459 -- LitPats: we *might* be able to replace these w/ a simpler form
460 tidy1 v pat@(LitPat lit lit_ty) match_result
461 = returnDs (tidyLitPat lit pat, match_result)
463 -- NPats: we *might* be able to replace these w/ a simpler form
464 tidy1 v pat@(NPat lit lit_ty _) match_result
465 = returnDs (tidyNPat lit lit_ty pat, match_result)
467 -- and everything else goes through unchanged...
469 tidy1 v non_interesting_pat match_result
470 = returnDs (non_interesting_pat, match_result)
474 {\bf Previous @matchTwiddled@ stuff:}
476 Now we get to the only interesting part; note: there are choices for
477 translation [from Simon's notes]; translation~1:
484 s = case w of [s,t] -> s
485 t = case w of [s,t] -> t
489 Here \tr{w} is a fresh variable, and the \tr{w}-binding prevents multiple
490 evaluation of \tr{e}. An alternative translation (No.~2):
492 [ w = case e of [s,t] -> (s,t)
493 s = case w of (s,t) -> s
494 t = case w of (s,t) -> t
498 %************************************************************************
500 \subsubsection[improved-unmixing]{UNIMPLEMENTED idea for improved unmixing}
502 %************************************************************************
504 We might be able to optimise unmixing when confronted by
505 only-one-constructor-possible, of which tuples are the most notable
513 This definition would normally be unmixed into four equation blocks,
514 one per equation. But it could be unmixed into just one equation
515 block, because if the one equation matches (on the first column),
516 the others certainly will.
518 You have to be careful, though; the example
526 {\em must} be broken into two blocks at the line shown; otherwise, you
527 are forcing unnecessary evaluation. In any case, the top-left pattern
528 always gives the cue. You could then unmix blocks into groups of...
530 \item[all variables:]
532 \item[constructors or variables (mixed):]
533 Need to make sure the right names get bound for the variable patterns.
534 \item[literals or variables (mixed):]
535 Presumably just a variant on the constructor case (as it is now).
538 %************************************************************************
540 %* match on an unmixed block: the real business *
542 %************************************************************************
543 \subsection[matchUnmixedEqns]{@matchUnmixedEqns@: getting down to business}
545 The function @matchUnmixedEqns@ is where the matching stuff sets to
546 work a block of equations, to which the mixture rule has been applied.
547 Its arguments and results are the same as for the ``top-level'' @match@.
550 matchUnmixedEqns :: [Id]
554 matchUnmixedEqns [] _ = panic "matchUnmixedEqns: no names"
556 matchUnmixedEqns all_vars@(var:vars) eqns_info
557 | isWildPat first_pat
558 = ASSERT( all isWildPat column_1_pats ) -- Sanity check
559 -- Real true variables, just like in matchVar, SLPJ p 94
560 -- No binding to do: they'll all be wildcards by now (done in tidy)
561 match vars remaining_eqns_info
564 = ASSERT( patsAreAllCons column_1_pats )
565 matchConFamily all_vars eqns_info
568 = ASSERT( patsAreAllLits column_1_pats )
569 -- see notes in MatchLiteral
570 -- not worried about the same literal more than once in a column
571 -- (ToDo: sort this out later)
572 matchLiterals all_vars eqns_info
575 first_pat = head column_1_pats
576 column_1_pats = [pat | EqnInfo _ _ (pat:_) _ <- eqns_info]
577 remaining_eqns_info = [EqnInfo n ctx pats match_result | EqnInfo n ctx (_:pats) match_result <- eqns_info]
580 %************************************************************************
582 %* matchWrapper: a convenient way to call @match@ *
584 %************************************************************************
585 \subsection[matchWrapper]{@matchWrapper@: a convenient interface to @match@}
587 Calls to @match@ often involve similar (non-trivial) work; that work
588 is collected here, in @matchWrapper@. This function takes as
592 Typchecked @Matches@ (of a function definition, or a case or lambda
593 expression)---the main input;
595 An error message to be inserted into any (runtime) pattern-matching
599 As results, @matchWrapper@ produces:
602 A list of variables (@Locals@) that the caller must ``promise'' to
603 bind to appropriate values; and
605 a @CoreExpr@, the desugared output (main result).
608 The main actions of @matchWrapper@ include:
611 Flatten the @[TypecheckedMatch]@ into a suitable list of
614 Create as many new variables as there are patterns in a pattern-list
615 (in any one of the @EquationInfo@s).
617 Create a suitable ``if it fails'' expression---a call to @error@ using
618 the error-string input; the {\em type} of this fail value can be found
619 by examining one of the RHS expressions in one of the @EquationInfo@s.
621 Call @match@ with all of this information!
625 matchWrapper :: HsMatchContext -- For shadowing warning messages
626 -> [TypecheckedMatch] -- Matches being desugared
627 -> String -- Error message if the match fails
628 -> DsM ([Id], CoreExpr) -- Results
631 There is one small problem with the Lambda Patterns, when somebody
632 writes something similar to:
636 he/she don't want a warning about incomplete patterns, that is done with
637 the flag @opt_WarnSimplePatterns@.
638 This problem also appears in the:
640 \item @do@ patterns, but if the @do@ can fail
641 it creates another equation if the match can fail
642 (see @DsExpr.doDo@ function)
643 \item @let@ patterns, are treated by @matchSimply@
644 List Comprension Patterns, are treated by @matchSimply@ also
647 We can't call @matchSimply@ with Lambda patterns,
648 due to the fact that lambda patterns can have more than
649 one pattern, and match simply only accepts one pattern.
654 matchWrapper kind matches error_string
655 = getDOptsDs `thenDs` \ dflags ->
656 flattenMatches kind matches `thenDs` \ (result_ty, eqns_info) ->
658 EqnInfo _ _ arg_pats _ : _ = eqns_info
660 mapDs selectMatchVar arg_pats `thenDs` \ new_vars ->
661 match_fun dflags new_vars eqns_info `thenDs` \ match_result ->
663 mkErrorAppDs pAT_ERROR_ID result_ty error_string `thenDs` \ fail_expr ->
664 extractMatchResult match_result fail_expr `thenDs` \ result_expr ->
665 returnDs (new_vars, result_expr)
666 where match_fun dflags
668 LambdaExpr | dopt Opt_WarnSimplePatterns dflags -> matchExport
673 %************************************************************************
675 \subsection[matchSimply]{@matchSimply@: match a single expression against a single pattern}
677 %************************************************************************
679 @mkSimpleMatch@ is a wrapper for @match@ which deals with the
680 situation where we want to match a single expression against a single
681 pattern. It returns an expression.
684 matchSimply :: CoreExpr -- Scrutinee
685 -> HsMatchContext -- Match kind
686 -> TypecheckedPat -- Pattern it should match
687 -> CoreExpr -- Return this if it matches
688 -> CoreExpr -- Return this if it doesn't
691 matchSimply scrut kind pat result_expr fail_expr
692 = getSrcLocDs `thenDs` \ locn ->
694 ctx = DsMatchContext kind [pat] locn
695 match_result = cantFailMatchResult result_expr
697 matchSinglePat scrut ctx pat match_result `thenDs` \ match_result' ->
698 extractMatchResult match_result' fail_expr
701 matchSinglePat :: CoreExpr -> DsMatchContext -> TypecheckedPat
702 -> MatchResult -> DsM MatchResult
704 matchSinglePat (Var var) ctx pat match_result
705 = getDOptsDs `thenDs` \ dflags ->
706 match_fn dflags [var] [EqnInfo 1 ctx [pat] match_result]
709 | dopt Opt_WarnSimplePatterns dflags = matchExport
712 matchSinglePat scrut ctx pat match_result
713 = selectMatchVar pat `thenDs` \ var ->
714 matchSinglePat (Var var) ctx pat match_result `thenDs` \ match_result' ->
715 returnDs (adjustMatchResult (bindNonRec var scrut) match_result')
718 %************************************************************************
720 %* flattenMatches : create a list of EquationInfo *
722 %************************************************************************
724 \subsection[flattenMatches]{@flattenMatches@: create @[EquationInfo]@}
726 This is actually local to @matchWrapper@.
729 flattenMatches :: HsMatchContext
730 -> [TypecheckedMatch]
731 -> DsM (Type, [EquationInfo])
733 flattenMatches kind matches
734 = mapAndUnzipDs flatten_match (matches `zip` [1..]) `thenDs` \ (result_tys, eqn_infos) ->
736 result_ty = head result_tys
738 ASSERT( all (== result_ty) result_tys )
739 returnDs (result_ty, eqn_infos)
741 flatten_match (Match _ pats _ grhss, n)
742 = dsGRHSs kind pats grhss `thenDs` \ (ty, match_result) ->
743 getSrcLocDs `thenDs` \ locn ->
744 returnDs (ty, EqnInfo n (DsMatchContext kind pats locn) pats match_result)