-
+%
+% (c) The University of Glasgow 2006
% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
%
-\section[MatchCon]{Pattern-matching constructors}
+
+Pattern-matching constructors
\begin{code}
+{-# OPTIONS -fno-warn-incomplete-patterns #-}
+-- The above warning supression flag is a temporary kludge.
+-- While working on this module you are encouraged to remove it and fix
+-- any warnings in the module. See
+-- http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
+-- for details
+
module MatchCon ( matchConFamily ) where
#include "HsVersions.h"
import {-# SOURCE #-} Match ( match )
-import HsSyn ( Pat(..), LPat, HsConDetails(..) )
-import DsBinds ( dsLHsBinds )
-import DataCon ( DataCon, dataConInstOrigArgTys, dataConEqSpec,
- dataConFieldLabels, dataConSourceArity )
-import TcType ( tcTyConAppArgs )
-import Type ( mkTyVarTys )
+import HsSyn
+import DsBinds
+import DataCon
+import TcType
+import Type
import CoreSyn
+import MkCore
import DsMonad
import DsUtils
-
-import Id ( Id, idName )
-import Type ( Type )
-import SrcLoc ( unLoc, Located(..) )
+import Util ( takeList )
+import Id
+import Var (TyVar)
+import SrcLoc
import Outputable
\end{code}
= do { alts <- mapM (matchOneCon vars ty) groups
; return (mkCoAlgCaseMatchResult var ty alts) }
+matchOneCon :: [Id]
+ -> Type
+ -> [EquationInfo]
+ -> DsM (DataCon, [TyVar], MatchResult)
matchOneCon vars ty (eqn1 : eqns) -- All eqns for a single constructor
= do { (wraps, eqns') <- mapAndUnzipM shift (eqn1:eqns)
- ; arg_vars <- selectMatchVars (take (dataConSourceArity con)
+ ; arg_vars <- selectMatchVars (take (dataConSourceArity con1)
(eqn_pats (head eqns')))
- -- Use the new arugment patterns as a source of
+ -- Use the new argument patterns as a source of
-- suggestions for the new variables
; match_result <- match (arg_vars ++ vars) ty eqns'
- ; return (con, tvs1 ++ dicts1 ++ arg_vars,
+ ; return (con1, tvs1 ++ dicts1 ++ arg_vars,
adjustMatchResult (foldr1 (.) wraps) match_result) }
where
- ConPatOut { pat_con = L _ con, pat_ty = pat_ty1,
+ ConPatOut { pat_con = L _ con1, pat_ty = pat_ty1,
pat_tvs = tvs1, pat_dicts = dicts1 } = firstPat eqn1
- arg_tys = dataConInstOrigArgTys con inst_tys
- n_co_args = length (dataConEqSpec con)
- inst_tys = tcTyConAppArgs pat_ty1 ++ (drop n_co_args $ mkTyVarTys tvs1)
+ arg_tys = dataConInstOrigArgTys con1 inst_tys
+ inst_tys = tcTyConAppArgs pat_ty1 ++
+ mkTyVarTys (takeList (dataConExTyVars con1) tvs1)
-- Newtypes opaque, hence tcTyConAppArgs
+ -- dataConInstOrigArgTys takes the univ and existential tyvars
+ -- and returns the types of the *value* args, which is what we want
shift eqn@(EqnInfo { eqn_pats = ConPatOut{ pat_tvs = tvs, pat_dicts = ds,
pat_binds = bind, pat_args = args
= do { prs <- dsLHsBinds bind
; return (wrapBinds (tvs `zip` tvs1)
. wrapBinds (ds `zip` dicts1)
- . mkDsLet (Rec prs),
- eqn { eqn_pats = conArgPats con arg_tys args ++ pats }) }
+ . mkCoreLet (Rec prs),
+ eqn { eqn_pats = conArgPats con1 arg_tys args ++ pats }) }
conArgPats :: DataCon
-> [Type] -- Instantiated argument types
- -> HsConDetails Id (LPat Id)
+ -- Used only to fill in the types of WildPats, which
+ -- are probably never looked at anyway
+ -> HsConDetails (LPat Id) (HsRecFields Id (LPat Id))
-> [Pat Id]
-conArgPats data_con arg_tys (PrefixCon ps) = map unLoc ps
-conArgPats data_con arg_tys (InfixCon p1 p2) = [unLoc p1, unLoc p2]
-conArgPats data_con arg_tys (RecCon rpats)
+conArgPats _data_con _arg_tys (PrefixCon ps) = map unLoc ps
+conArgPats _data_con _arg_tys (InfixCon p1 p2) = [unLoc p1, unLoc p2]
+conArgPats data_con arg_tys (RecCon (HsRecFields rpats _))
| null rpats
= -- Special case for C {}, which can be used for
-- a constructor that isn't declared to have
-- mk_pat picks a WildPat of the appropriate type for absent fields,
-- and the specified pattern for present fields
mk_pat lbl arg_ty
- = case [ pat | (sel_id,pat) <- rpats, idName (unLoc sel_id) == lbl] of
+ = case [ pat | HsRecField sel_id pat _ <- rpats, idName (unLoc sel_id) == lbl ] of
(pat:pats) -> ASSERT( null pats ) unLoc pat
[] -> WildPat arg_ty
\end{code}