2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1998
5 \section[DataCon]{@DataCon@: Data Constructors}
9 DataCon, DataConIds(..),
12 dataConRepType, dataConSig, dataConFullSig,
13 dataConName, dataConIdentity, dataConTag, dataConTyCon, dataConUserType,
14 dataConUnivTyVars, dataConExTyVars, dataConAllTyVars,
15 dataConEqSpec, eqSpecPreds, dataConTheta, dataConStupidTheta,
16 dataConInstArgTys, dataConOrigArgTys, dataConOrigResTy,
17 dataConInstOrigArgTys, dataConRepArgTys,
18 dataConFieldLabels, dataConFieldType,
19 dataConStrictMarks, dataConExStricts,
20 dataConSourceArity, dataConRepArity,
22 dataConWorkId, dataConWrapId, dataConWrapId_maybe, dataConImplicitIds,
24 isNullarySrcDataCon, isNullaryRepDataCon, isTupleCon, isUnboxedTupleCon,
25 isVanillaDataCon, classDataCon,
27 splitProductType_maybe, splitProductType, deepSplitProductType,
28 deepSplitProductType_maybe
31 #include "HsVersions.h"
49 Data constructor representation
50 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
51 Consider the following Haskell data type declaration
53 data T = T !Int ![Int]
55 Using the strictness annotations, GHC will represent this as
59 That is, the Int has been unboxed. Furthermore, the Haskell source construction
69 That is, the first argument is unboxed, and the second is evaluated. Finally,
70 pattern matching is translated too:
72 case e of { T a b -> ... }
76 case e of { T a' b -> let a = I# a' in ... }
78 To keep ourselves sane, we name the different versions of the data constructor
79 differently, as follows.
82 Note [Data Constructor Naming]
83 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
84 Each data constructor C has two, and possibly three, Names associated with it:
86 OccName Name space Used for
87 ---------------------------------------------------------------------------
88 * The "source data con" C DataName The DataCon itself
89 * The "real data con" C VarName Its worker Id
90 * The "wrapper data con" $WC VarName Wrapper Id (optional)
92 Each of these three has a distinct Unique. The "source data con" name
93 appears in the output of the renamer, and names the Haskell-source
94 data constructor. The type checker translates it into either the wrapper Id
95 (if it exists) or worker Id (otherwise).
97 The data con has one or two Ids associated with it:
99 The "worker Id", is the actual data constructor.
100 * Every data constructor (newtype or data type) has a worker
102 * The worker is very like a primop, in that it has no binding.
104 * For a *data* type, the worker *is* the data constructor;
107 * For a *newtype*, the worker has a compulsory unfolding which
110 The worker for MkT has unfolding
111 \(x:Int). x `cast` sym CoT
112 Here CoT is the type constructor, witnessing the FC axiom
115 The "wrapper Id", $WC, goes as follows
117 * Its type is exactly what it looks like in the source program.
119 * It is an ordinary function, and it gets a top-level binding
120 like any other function.
122 * The wrapper Id isn't generated for a data type if there is
123 nothing for the wrapper to do. That is, if its defn would be
126 Why might the wrapper have anything to do? Two reasons:
128 * Unboxing strict fields (with -funbox-strict-fields)
129 data T = MkT !(Int,Int)
130 $wMkT :: (Int,Int) -> T
131 $wMkT (x,y) = MkT x y
132 Notice that the worker has two fields where the wapper has
133 just one. That is, the worker has type
134 MkT :: Int -> Int -> T
136 * Equality constraints for GADTs
137 data T a where { MkT :: a -> T [a] }
139 The worker gets a type with explicit equality
141 MkT :: forall a b. (a=[b]) => b -> T a
143 The wrapper has the programmer-specified type:
145 $wMkT a x = MkT [a] a [a] x
146 The third argument is a coerion
151 A note about the stupid context
152 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
153 Data types can have a context:
155 data (Eq a, Ord b) => T a b = T1 a b | T2 a
157 and that makes the constructors have a context too
158 (notice that T2's context is "thinned"):
160 T1 :: (Eq a, Ord b) => a -> b -> T a b
161 T2 :: (Eq a) => a -> T a b
163 Furthermore, this context pops up when pattern matching
164 (though GHC hasn't implemented this, but it is in H98, and
165 I've fixed GHC so that it now does):
169 f :: Eq a => T a b -> a
171 I say the context is "stupid" because the dictionaries passed
172 are immediately discarded -- they do nothing and have no benefit.
173 It's a flaw in the language.
175 Up to now [March 2002] I have put this stupid context into the
176 type of the "wrapper" constructors functions, T1 and T2, but
177 that turned out to be jolly inconvenient for generics, and
178 record update, and other functions that build values of type T
179 (because they don't have suitable dictionaries available).
181 So now I've taken the stupid context out. I simply deal with
182 it separately in the type checker on occurrences of a
183 constructor, either in an expression or in a pattern.
185 [May 2003: actually I think this decision could evasily be
186 reversed now, and probably should be. Generics could be
187 disabled for types with a stupid context; record updates now
188 (H98) needs the context too; etc. It's an unforced change, so
189 I'm leaving it for now --- but it does seem odd that the
190 wrapper doesn't include the stupid context.]
192 [July 04] With the advent of generalised data types, it's less obvious
193 what the "stupid context" is. Consider
194 C :: forall a. Ord a => a -> a -> T (Foo a)
195 Does the C constructor in Core contain the Ord dictionary? Yes, it must:
200 C a (d:Ord a) (p:a) (q:a) -> compare d p q
202 Note that (Foo a) might not be an instance of Ord.
204 %************************************************************************
206 \subsection{Data constructors}
208 %************************************************************************
213 dcName :: Name, -- This is the name of the *source data con*
214 -- (see "Note [Data Constructor Naming]" above)
215 dcUnique :: Unique, -- Cached from Name
220 -- *** As declared by the user
222 -- MkT :: forall x y. (Ord x) => x -> y -> T (x,y)
224 -- *** As represented internally
226 -- MkT :: forall a. forall x y. (a:=:(x,y), Ord x) => x -> y -> T a
228 -- The next six fields express the type of the constructor, in pieces
231 -- dcUnivTyVars = [a]
232 -- dcExTyVars = [x,y]
233 -- dcEqSpec = [a:=:(x,y)]
235 -- dcOrigArgTys = [a,List b]
238 dcVanilla :: Bool, -- True <=> This is a vanilla Haskell 98 data constructor
239 -- Its type is of form
240 -- forall a1..an . t1 -> ... tm -> T a1..an
241 -- No existentials, no coercions, nothing.
242 -- That is: dcExTyVars = dcEqSpec = dcTheta = []
243 -- NB 1: newtypes always have a vanilla data con
244 -- NB 2: a vanilla constructor can still be declared in GADT-style
245 -- syntax, provided its type looks like the above.
246 -- The declaration format is held in the TyCon (algTcGadtSyntax)
248 dcUnivTyVars :: [TyVar], -- Universally-quantified type vars
249 -- INVARIANT: length matches arity of the dcRepTyCon
251 dcExTyVars :: [TyVar], -- Existentially-quantified type vars
252 -- In general, the dcUnivTyVars are NOT NECESSARILY THE SAME AS THE TYVARS
253 -- FOR THE PARENT TyCon. With GADTs the data con might not even have
254 -- the same number of type variables.
255 -- [This is a change (Oct05): previously, vanilla datacons guaranteed to
256 -- have the same type variables as their parent TyCon, but that seems ugly.]
258 -- INVARIANT: the UnivTyVars and ExTyVars all have distinct OccNames
259 -- Reason: less confusing, and easier to generate IfaceSyn
261 dcEqSpec :: [(TyVar,Type)], -- Equalities derived from the result type,
262 -- *as written by the programmer*
263 -- This field allows us to move conveniently between the two ways
264 -- of representing a GADT constructor's type:
265 -- MkT :: forall a b. (a :=: [b]) => b -> T a
266 -- MkT :: forall b. b -> T [b]
267 -- Each equality is of the form (a :=: ty), where 'a' is one of
268 -- the universally quantified type variables
270 dcTheta :: ThetaType, -- The context of the constructor
271 -- In GADT form, this is *exactly* what the programmer writes, even if
272 -- the context constrains only universally quantified variables
273 -- MkT :: forall a. Eq a => a -> T a
274 -- It may contain user-written equality predicates too
276 dcStupidTheta :: ThetaType, -- The context of the data type declaration
277 -- data Eq a => T a = ...
278 -- or, rather, a "thinned" version thereof
279 -- "Thinned", because the Report says
280 -- to eliminate any constraints that don't mention
281 -- tyvars free in the arg types for this constructor
283 -- INVARIANT: the free tyvars of dcStupidTheta are a subset of dcUnivTyVars
284 -- Reason: dcStupidTeta is gotten by thinning the stupid theta from the tycon
286 -- "Stupid", because the dictionaries aren't used for anything.
287 -- Indeed, [as of March 02] they are no longer in the type of
288 -- the wrapper Id, because that makes it harder to use the wrap-id
289 -- to rebuild values after record selection or in generics.
291 dcOrigArgTys :: [Type], -- Original argument types
292 -- (before unboxing and flattening of strict fields)
293 dcOrigResTy :: Type, -- Original result type
294 -- NB: for a data instance, the original user result type may
295 -- differ from the DataCon's representation TyCon. Example
296 -- data instance T [a] where MkT :: a -> T [a]
297 -- The OrigResTy is T [a], but the dcRepTyCon might be :T123
299 -- Now the strictness annotations and field labels of the constructor
300 dcStrictMarks :: [StrictnessMark],
301 -- Strictness annotations as decided by the compiler.
302 -- Does *not* include the existential dictionaries
303 -- length = dataConSourceArity dataCon
305 dcFields :: [FieldLabel],
306 -- Field labels for this constructor, in the
307 -- same order as the dcOrigArgTys;
308 -- length = 0 (if not a record) or dataConSourceArity.
310 -- Constructor representation
311 dcRepArgTys :: [Type], -- Final, representation argument types,
312 -- after unboxing and flattening,
313 -- and *including* existential dictionaries
315 dcRepStrictness :: [StrictnessMark], -- One for each *representation* argument
316 -- See also Note [Data-con worker strictness] in MkId.lhs
318 -- Result type of constructor is T t1..tn
319 dcRepTyCon :: TyCon, -- Result tycon, T
321 dcRepType :: Type, -- Type of the constructor
322 -- forall a x y. (a:=:(x,y), Ord x) => x -> y -> MkT a
323 -- (this is *not* of the constructor wrapper Id:
324 -- see Note [Data con representation] below)
325 -- Notice that the existential type parameters come *second*.
326 -- Reason: in a case expression we may find:
327 -- case (e :: T t) of { MkT b (d:Ord b) (x:t) (xs:[b]) -> ... }
328 -- It's convenient to apply the rep-type of MkT to 't', to get
329 -- forall b. Ord b => ...
330 -- and use that to check the pattern. Mind you, this is really only
334 -- Finally, the curried worker function that corresponds to the constructor
335 -- It doesn't have an unfolding; the code generator saturates these Ids
336 -- and allocates a real constructor when it finds one.
338 -- An entirely separate wrapper function is built in TcTyDecls
341 dcInfix :: Bool -- True <=> declared infix
342 -- Used for Template Haskell and 'deriving' only
343 -- The actual fixity is stored elsewhere
347 = DCIds (Maybe Id) Id -- Algebraic data types always have a worker, and
348 -- may or may not have a wrapper, depending on whether
349 -- the wrapper does anything. Newtypes just have a worker
351 -- _Neither_ the worker _nor_ the wrapper take the dcStupidTheta dicts as arguments
353 -- The wrapper takes dcOrigArgTys as its arguments
354 -- The worker takes dcRepArgTys as its arguments
355 -- If the worker is absent, dcRepArgTys is the same as dcOrigArgTys
357 -- The 'Nothing' case of DCIds is important
358 -- Not only is this efficient,
359 -- but it also ensures that the wrapper is replaced
360 -- by the worker (becuase it *is* the worker)
361 -- even when there are no args. E.g. in
363 -- the (:) *is* the worker.
364 -- This is really important in rule matching,
365 -- (We could match on the wrappers,
366 -- but that makes it less likely that rules will match
367 -- when we bring bits of unfoldings together.)
372 fIRST_TAG = 1 -- Tags allocated from here for real constructors
375 Note [Data con representation]
376 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
377 The dcRepType field contains the type of the representation of a contructor
378 This may differ from the type of the contructor *Id* (built
379 by MkId.mkDataConId) for two reasons:
380 a) the constructor Id may be overloaded, but the dictionary isn't stored
381 e.g. data Eq a => T a = MkT a a
383 b) the constructor may store an unboxed version of a strict field.
385 Here's an example illustrating both:
386 data Ord a => T a = MkT Int! a
388 T :: Ord a => Int -> a -> T a
390 Trep :: Int# -> a -> T a
391 Actually, the unboxed part isn't implemented yet!
394 %************************************************************************
396 \subsection{Instances}
398 %************************************************************************
401 instance Eq DataCon where
402 a == b = getUnique a == getUnique b
403 a /= b = getUnique a /= getUnique b
405 instance Ord DataCon where
406 a <= b = getUnique a <= getUnique b
407 a < b = getUnique a < getUnique b
408 a >= b = getUnique a >= getUnique b
409 a > b = getUnique a > getUnique b
410 compare a b = getUnique a `compare` getUnique b
412 instance Uniquable DataCon where
415 instance NamedThing DataCon where
418 instance Outputable DataCon where
419 ppr con = ppr (dataConName con)
421 instance Show DataCon where
422 showsPrec p con = showsPrecSDoc p (ppr con)
426 %************************************************************************
428 \subsection{Construction}
430 %************************************************************************
434 -> Bool -- Declared infix
435 -> [StrictnessMark] -> [FieldLabel]
436 -> [TyVar] -> [TyVar]
437 -> [(TyVar,Type)] -> ThetaType
439 -> ThetaType -> DataConIds
441 -- Can get the tag from the TyCon
443 mkDataCon name declared_infix
444 arg_stricts -- Must match orig_arg_tys 1-1
450 -- Warning: mkDataCon is not a good place to check invariants.
451 -- If the programmer writes the wrong result type in the decl, thus:
452 -- data T a where { MkT :: S }
453 -- then it's possible that the univ_tvs may hit an assertion failure
454 -- if you pull on univ_tvs. This case is checked by checkValidDataCon,
455 -- so the error is detected properly... it's just that asaertions here
456 -- are a little dodgy.
458 = ASSERT( not (any isEqPred theta) )
459 -- We don't currently allow any equality predicates on
460 -- a data constructor (apart from the GADT ones in eq_spec)
463 is_vanilla = null ex_tvs && null eq_spec && null theta
464 con = MkData {dcName = name, dcUnique = nameUnique name,
465 dcVanilla = is_vanilla, dcInfix = declared_infix,
466 dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs,
468 dcStupidTheta = stupid_theta, dcTheta = theta,
469 dcOrigArgTys = orig_arg_tys, dcOrigResTy = orig_res_ty,
471 dcRepArgTys = rep_arg_tys,
472 dcStrictMarks = arg_stricts,
473 dcRepStrictness = rep_arg_stricts,
474 dcFields = fields, dcTag = tag, dcRepType = ty,
477 -- Strictness marks for source-args
478 -- *after unboxing choices*,
479 -- but *including existential dictionaries*
481 -- The 'arg_stricts' passed to mkDataCon are simply those for the
482 -- source-language arguments. We add extra ones for the
483 -- dictionary arguments right here.
484 dict_tys = mkPredTys theta
485 real_arg_tys = dict_tys ++ orig_arg_tys
486 real_stricts = map mk_dict_strict_mark theta ++ arg_stricts
489 -- data instance T (b,c) where
490 -- TI :: forall e. e -> T (e,e)
492 -- The representation tycon looks like this:
493 -- data :R7T b c where
494 -- TI :: forall b1 c1. (b1 ~ c1) => b1 -> :R7T b1 c1
497 | Just (fam_tc, fam_tys) <- tyConFamInst_maybe tycon
498 , let fam_subst = zipTopTvSubst (tyConTyVars tycon) res_tys
499 = mkTyConApp fam_tc (substTys fam_subst fam_tys)
501 = mkTyConApp tycon res_tys
503 res_tys = substTyVars (mkTopTvSubst eq_spec) univ_tvs
504 -- In the example above,
505 -- univ_tvs = [ b1, c1 ]
506 -- res_tys = [ b1, b1 ]
508 -- Representation arguments and demands
509 -- To do: eliminate duplication with MkId
510 (rep_arg_stricts, rep_arg_tys) = computeRep real_stricts real_arg_tys
512 tag = assoc "mkDataCon" (tyConDataCons tycon `zip` [fIRST_TAG..]) con
513 ty = mkForAllTys univ_tvs $ mkForAllTys ex_tvs $
514 mkFunTys (mkPredTys (eqSpecPreds eq_spec)) $
515 -- NB: the dict args are already in rep_arg_tys
516 -- because they might be flattened..
517 -- but the equality predicates are not
518 mkFunTys rep_arg_tys $
519 mkTyConApp tycon (mkTyVarTys univ_tvs)
521 eqSpecPreds :: [(TyVar,Type)] -> ThetaType
522 eqSpecPreds spec = [ mkEqPred (mkTyVarTy tv, ty) | (tv,ty) <- spec ]
524 mk_dict_strict_mark pred | isStrictPred pred = MarkedStrict
525 | otherwise = NotMarkedStrict
529 dataConName :: DataCon -> Name
532 -- generate a name in the format: package:Module.OccName
533 -- and the unique identity of the name
534 dataConIdentity :: DataCon -> String
535 dataConIdentity dataCon
538 prettyName = pretty packageModule ++ "." ++ pretty occ
540 packageModule = nameModule nm
541 occ = getOccName dataCon
542 pretty :: Outputable a => a -> String
543 pretty = showSDoc . ppr
545 dataConTag :: DataCon -> ConTag
548 dataConTyCon :: DataCon -> TyCon
549 dataConTyCon = dcRepTyCon
551 dataConRepType :: DataCon -> Type
552 dataConRepType = dcRepType
554 dataConIsInfix :: DataCon -> Bool
555 dataConIsInfix = dcInfix
557 dataConUnivTyVars :: DataCon -> [TyVar]
558 dataConUnivTyVars = dcUnivTyVars
560 dataConExTyVars :: DataCon -> [TyVar]
561 dataConExTyVars = dcExTyVars
563 dataConAllTyVars :: DataCon -> [TyVar]
564 dataConAllTyVars (MkData { dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs })
567 dataConEqSpec :: DataCon -> [(TyVar,Type)]
568 dataConEqSpec = dcEqSpec
570 dataConTheta :: DataCon -> ThetaType
571 dataConTheta = dcTheta
573 dataConWorkId :: DataCon -> Id
574 dataConWorkId dc = case dcIds dc of
575 DCIds _ wrk_id -> wrk_id
577 dataConWrapId_maybe :: DataCon -> Maybe Id
578 -- Returns Nothing if there is no wrapper for an algebraic data con
579 -- and also for a newtype (whose constructor is inlined compulsorily)
580 dataConWrapId_maybe dc = case dcIds dc of
581 DCIds mb_wrap _ -> mb_wrap
583 dataConWrapId :: DataCon -> Id
584 -- Returns an Id which looks like the Haskell-source constructor
585 dataConWrapId dc = case dcIds dc of
586 DCIds (Just wrap) _ -> wrap
587 DCIds Nothing wrk -> wrk -- worker=wrapper
589 dataConImplicitIds :: DataCon -> [Id]
590 dataConImplicitIds dc = case dcIds dc of
591 DCIds (Just wrap) work -> [wrap,work]
592 DCIds Nothing work -> [work]
594 dataConFieldLabels :: DataCon -> [FieldLabel]
595 dataConFieldLabels = dcFields
597 dataConFieldType :: DataCon -> FieldLabel -> Type
598 dataConFieldType con label = expectJust "unexpected label" $
599 lookup label (dcFields con `zip` dcOrigArgTys con)
601 dataConStrictMarks :: DataCon -> [StrictnessMark]
602 dataConStrictMarks = dcStrictMarks
604 dataConExStricts :: DataCon -> [StrictnessMark]
605 -- Strictness of *existential* arguments only
606 -- Usually empty, so we don't bother to cache this
607 dataConExStricts dc = map mk_dict_strict_mark (dcTheta dc)
609 dataConSourceArity :: DataCon -> Arity
610 -- Source-level arity of the data constructor
611 dataConSourceArity dc = length (dcOrigArgTys dc)
613 -- dataConRepArity gives the number of actual fields in the
614 -- {\em representation} of the data constructor. This may be more than appear
615 -- in the source code; the extra ones are the existentially quantified
617 dataConRepArity (MkData {dcRepArgTys = arg_tys}) = length arg_tys
619 isNullarySrcDataCon, isNullaryRepDataCon :: DataCon -> Bool
620 isNullarySrcDataCon dc = null (dcOrigArgTys dc)
621 isNullaryRepDataCon dc = null (dcRepArgTys dc)
623 dataConRepStrictness :: DataCon -> [StrictnessMark]
624 -- Give the demands on the arguments of a
625 -- Core constructor application (Con dc args)
626 dataConRepStrictness dc = dcRepStrictness dc
628 dataConSig :: DataCon -> ([TyVar], ThetaType, [Type], Type)
629 dataConSig (MkData {dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs, dcEqSpec = eq_spec,
630 dcTheta = theta, dcOrigArgTys = arg_tys, dcOrigResTy = res_ty})
631 = (univ_tvs ++ ex_tvs, eqSpecPreds eq_spec ++ theta, arg_tys, res_ty)
633 dataConFullSig :: DataCon
634 -> ([TyVar], [TyVar], [(TyVar,Type)], ThetaType, [Type], Type)
635 dataConFullSig (MkData {dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs, dcEqSpec = eq_spec,
636 dcTheta = theta, dcOrigArgTys = arg_tys, dcOrigResTy = res_ty})
637 = (univ_tvs, ex_tvs, eq_spec, theta, arg_tys, res_ty)
639 dataConOrigResTy :: DataCon -> Type
640 dataConOrigResTy dc = dcOrigResTy dc
642 dataConStupidTheta :: DataCon -> ThetaType
643 dataConStupidTheta dc = dcStupidTheta dc
645 dataConUserType :: DataCon -> Type
646 -- The user-declared type of the data constructor
647 -- in the nice-to-read form
648 -- T :: forall a. a -> T [a]
650 -- T :: forall b. forall a. (a=[b]) => a -> T b
651 -- NB: If the constructor is part of a data instance, the result type
652 -- mentions the family tycon, not the internal one.
653 dataConUserType (MkData { dcUnivTyVars = univ_tvs,
654 dcExTyVars = ex_tvs, dcEqSpec = eq_spec,
655 dcTheta = theta, dcOrigArgTys = arg_tys,
656 dcOrigResTy = res_ty })
657 = mkForAllTys ((univ_tvs `minusList` map fst eq_spec) ++ ex_tvs) $
658 mkFunTys (mkPredTys theta) $
662 dataConInstArgTys :: DataCon
663 -> [Type] -- Instantiated at these types
664 -- NB: these INCLUDE the existentially quantified arg types
665 -> [Type] -- Needs arguments of these types
666 -- NB: these INCLUDE the existentially quantified dict args
667 -- but EXCLUDE the data-decl context which is discarded
668 -- It's all post-flattening etc; this is a representation type
669 dataConInstArgTys dc@(MkData {dcRepArgTys = arg_tys,
670 dcUnivTyVars = univ_tvs,
671 dcExTyVars = ex_tvs}) inst_tys
672 = ASSERT2 ( length tyvars == length inst_tys
673 , ptext SLIT("dataConInstArgTys") <+> ppr dc $$ ppr tyvars $$ ppr inst_tys)
675 map (substTyWith tyvars inst_tys) arg_tys
677 tyvars = univ_tvs ++ ex_tvs
680 -- And the same deal for the original arg tys
681 dataConInstOrigArgTys :: DataCon -> [Type] -> [Type]
682 dataConInstOrigArgTys dc@(MkData {dcOrigArgTys = arg_tys,
683 dcUnivTyVars = univ_tvs,
684 dcExTyVars = ex_tvs}) inst_tys
685 = ASSERT2( length tyvars == length inst_tys
686 , ptext SLIT("dataConInstOrigArgTys") <+> ppr dc $$ ppr tyvars $$ ppr inst_tys )
687 map (substTyWith tyvars inst_tys) arg_tys
689 tyvars = univ_tvs ++ ex_tvs
692 These two functions get the real argument types of the constructor,
693 without substituting for any type variables.
695 dataConOrigArgTys returns the arg types of the wrapper, excluding all dictionary args.
697 dataConRepArgTys retuns the arg types of the worker, including all dictionaries, and
698 after any flattening has been done.
701 dataConOrigArgTys :: DataCon -> [Type]
702 dataConOrigArgTys dc = dcOrigArgTys dc
704 dataConRepArgTys :: DataCon -> [Type]
705 dataConRepArgTys dc = dcRepArgTys dc
710 isTupleCon :: DataCon -> Bool
711 isTupleCon (MkData {dcRepTyCon = tc}) = isTupleTyCon tc
713 isUnboxedTupleCon :: DataCon -> Bool
714 isUnboxedTupleCon (MkData {dcRepTyCon = tc}) = isUnboxedTupleTyCon tc
716 isVanillaDataCon :: DataCon -> Bool
717 isVanillaDataCon dc = dcVanilla dc
722 classDataCon :: Class -> DataCon
723 classDataCon clas = case tyConDataCons (classTyCon clas) of
724 (dict_constr:no_more) -> ASSERT( null no_more ) dict_constr
725 [] -> panic "classDataCon"
728 %************************************************************************
730 \subsection{Splitting products}
732 %************************************************************************
735 splitProductType_maybe
736 :: Type -- A product type, perhaps
737 -> Maybe (TyCon, -- The type constructor
738 [Type], -- Type args of the tycon
739 DataCon, -- The data constructor
740 [Type]) -- Its *representation* arg types
742 -- Returns (Just ...) for any
743 -- concrete (i.e. constructors visible)
744 -- single-constructor
745 -- not existentially quantified
746 -- type whether a data type or a new type
748 -- Rejecing existentials is conservative. Maybe some things
749 -- could be made to work with them, but I'm not going to sweat
750 -- it through till someone finds it's important.
752 splitProductType_maybe ty
753 = case splitTyConApp_maybe ty of
755 | isProductTyCon tycon -- Includes check for non-existential,
756 -- and for constructors visible
757 -> Just (tycon, ty_args, data_con, dataConInstArgTys data_con ty_args)
759 data_con = head (tyConDataCons tycon)
762 splitProductType str ty
763 = case splitProductType_maybe ty of
765 Nothing -> pprPanic (str ++ ": not a product") (pprType ty)
768 deepSplitProductType_maybe ty
769 = do { (res@(tycon, tycon_args, _, _)) <- splitProductType_maybe ty
771 | isClosedNewTyCon tycon && not (isRecursiveTyCon tycon)
772 = deepSplitProductType_maybe (newTyConInstRhs tycon tycon_args)
773 | isNewTyCon tycon = Nothing -- cannot unbox through recursive
774 -- newtypes nor through families
775 | otherwise = Just res}
779 deepSplitProductType str ty
780 = case deepSplitProductType_maybe ty of
782 Nothing -> pprPanic (str ++ ": not a product") (pprType ty)
784 computeRep :: [StrictnessMark] -- Original arg strictness
785 -> [Type] -- and types
786 -> ([StrictnessMark], -- Representation arg strictness
789 computeRep stricts tys
790 = unzip $ concat $ zipWithEqual "computeRep" unbox stricts tys
792 unbox NotMarkedStrict ty = [(NotMarkedStrict, ty)]
793 unbox MarkedStrict ty = [(MarkedStrict, ty)]
794 unbox MarkedUnboxed ty = zipEqual "computeRep" (dataConRepStrictness arg_dc) arg_tys
796 (_tycon, _tycon_args, arg_dc, arg_tys)
797 = deepSplitProductType "unbox_strict_arg_ty" ty