2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1998
5 \section[DataCon]{@DataCon@: Data Constructors}
10 DataCon, DataConIds(..),
13 -- ** Type construction
16 -- ** Type deconstruction
17 dataConRepType, dataConSig, dataConFullSig,
18 dataConName, dataConIdentity, dataConTag, dataConTyCon,
19 dataConOrigTyCon, dataConUserType,
20 dataConUnivTyVars, dataConExTyVars, dataConAllTyVars,
21 dataConEqSpec, eqSpecPreds, dataConEqTheta, dataConDictTheta,
23 dataConInstArgTys, dataConOrigArgTys, dataConOrigResTy,
24 dataConInstOrigArgTys, dataConRepArgTys,
25 dataConFieldLabels, dataConFieldType,
26 dataConStrictMarks, dataConExStricts,
27 dataConSourceArity, dataConRepArity,
29 dataConWorkId, dataConWrapId, dataConWrapId_maybe, dataConImplicitIds,
32 -- ** Predicates on DataCons
33 isNullarySrcDataCon, isNullaryRepDataCon, isTupleCon, isUnboxedTupleCon,
34 isVanillaDataCon, classDataCon,
36 -- * Splitting product types
37 splitProductType_maybe, splitProductType, deepSplitProductType,
38 deepSplitProductType_maybe
41 #include "HsVersions.h"
59 import Data.List ( partition )
63 Data constructor representation
64 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
65 Consider the following Haskell data type declaration
67 data T = T !Int ![Int]
69 Using the strictness annotations, GHC will represent this as
73 That is, the Int has been unboxed. Furthermore, the Haskell source construction
83 That is, the first argument is unboxed, and the second is evaluated. Finally,
84 pattern matching is translated too:
86 case e of { T a b -> ... }
90 case e of { T a' b -> let a = I# a' in ... }
92 To keep ourselves sane, we name the different versions of the data constructor
93 differently, as follows.
96 Note [Data Constructor Naming]
97 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
98 Each data constructor C has two, and possibly up to four, Names associated with it:
100 OccName Name space Name of Notes
101 ---------------------------------------------------------------------------
102 The "data con itself" C DataName DataCon In dom( GlobalRdrEnv )
103 The "worker data con" C VarName Id The worker
104 The "wrapper data con" $WC VarName Id The wrapper
105 The "newtype coercion" :CoT TcClsName TyCon
107 EVERY data constructor (incl for newtypes) has the former two (the
108 data con itself, and its worker. But only some data constructors have a
109 wrapper (see Note [The need for a wrapper]).
111 Each of these three has a distinct Unique. The "data con itself" name
112 appears in the output of the renamer, and names the Haskell-source
113 data constructor. The type checker translates it into either the wrapper Id
114 (if it exists) or worker Id (otherwise).
116 The data con has one or two Ids associated with it:
118 The "worker Id", is the actual data constructor.
119 * Every data constructor (newtype or data type) has a worker
121 * The worker is very like a primop, in that it has no binding.
123 * For a *data* type, the worker *is* the data constructor;
126 * For a *newtype*, the worker has a compulsory unfolding which
129 The worker for MkT has unfolding
130 \\(x:Int). x `cast` sym CoT
131 Here CoT is the type constructor, witnessing the FC axiom
134 The "wrapper Id", \$WC, goes as follows
136 * Its type is exactly what it looks like in the source program.
138 * It is an ordinary function, and it gets a top-level binding
139 like any other function.
141 * The wrapper Id isn't generated for a data type if there is
142 nothing for the wrapper to do. That is, if its defn would be
145 Note [The need for a wrapper]
146 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
147 Why might the wrapper have anything to do? Two reasons:
149 * Unboxing strict fields (with -funbox-strict-fields)
150 data T = MkT !(Int,Int)
151 \$wMkT :: (Int,Int) -> T
152 \$wMkT (x,y) = MkT x y
153 Notice that the worker has two fields where the wapper has
154 just one. That is, the worker has type
155 MkT :: Int -> Int -> T
157 * Equality constraints for GADTs
158 data T a where { MkT :: a -> T [a] }
160 The worker gets a type with explicit equality
162 MkT :: forall a b. (a=[b]) => b -> T a
164 The wrapper has the programmer-specified type:
166 \$wMkT a x = MkT [a] a [a] x
167 The third argument is a coerion
170 INVARIANT: the dictionary constructor for a class
174 A note about the stupid context
175 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
176 Data types can have a context:
178 data (Eq a, Ord b) => T a b = T1 a b | T2 a
180 and that makes the constructors have a context too
181 (notice that T2's context is "thinned"):
183 T1 :: (Eq a, Ord b) => a -> b -> T a b
184 T2 :: (Eq a) => a -> T a b
186 Furthermore, this context pops up when pattern matching
187 (though GHC hasn't implemented this, but it is in H98, and
188 I've fixed GHC so that it now does):
192 f :: Eq a => T a b -> a
194 I say the context is "stupid" because the dictionaries passed
195 are immediately discarded -- they do nothing and have no benefit.
196 It's a flaw in the language.
198 Up to now [March 2002] I have put this stupid context into the
199 type of the "wrapper" constructors functions, T1 and T2, but
200 that turned out to be jolly inconvenient for generics, and
201 record update, and other functions that build values of type T
202 (because they don't have suitable dictionaries available).
204 So now I've taken the stupid context out. I simply deal with
205 it separately in the type checker on occurrences of a
206 constructor, either in an expression or in a pattern.
208 [May 2003: actually I think this decision could evasily be
209 reversed now, and probably should be. Generics could be
210 disabled for types with a stupid context; record updates now
211 (H98) needs the context too; etc. It's an unforced change, so
212 I'm leaving it for now --- but it does seem odd that the
213 wrapper doesn't include the stupid context.]
215 [July 04] With the advent of generalised data types, it's less obvious
216 what the "stupid context" is. Consider
217 C :: forall a. Ord a => a -> a -> T (Foo a)
218 Does the C constructor in Core contain the Ord dictionary? Yes, it must:
223 C a (d:Ord a) (p:a) (q:a) -> compare d p q
225 Note that (Foo a) might not be an instance of Ord.
227 %************************************************************************
229 \subsection{Data constructors}
231 %************************************************************************
234 -- | A data constructor
237 dcName :: Name, -- This is the name of the *source data con*
238 -- (see "Note [Data Constructor Naming]" above)
239 dcUnique :: Unique, -- Cached from Name
240 dcTag :: ConTag, -- ^ Tag, used for ordering 'DataCon's
244 -- *** As declared by the user
246 -- MkT :: forall x y. (x~y,Ord x) => x -> y -> T (x,y)
248 -- *** As represented internally
250 -- MkT :: forall a. forall x y. (a~(x,y),x~y,Ord x) => x -> y -> T a
252 -- The next six fields express the type of the constructor, in pieces
255 -- dcUnivTyVars = [a]
256 -- dcExTyVars = [x,y]
257 -- dcEqSpec = [a~(x,y)]
259 -- dcDictTheta = [Ord x]
260 -- dcOrigArgTys = [a,List b]
263 dcVanilla :: Bool, -- True <=> This is a vanilla Haskell 98 data constructor
264 -- Its type is of form
265 -- forall a1..an . t1 -> ... tm -> T a1..an
266 -- No existentials, no coercions, nothing.
267 -- That is: dcExTyVars = dcEqSpec = dcEqTheta = dcDictTheta = []
268 -- NB 1: newtypes always have a vanilla data con
269 -- NB 2: a vanilla constructor can still be declared in GADT-style
270 -- syntax, provided its type looks like the above.
271 -- The declaration format is held in the TyCon (algTcGadtSyntax)
273 dcUnivTyVars :: [TyVar], -- Universally-quantified type vars [a,b,c]
274 -- INVARIANT: length matches arity of the dcRepTyCon
275 --- result type of (rep) data con is exactly (T a b c)
277 dcExTyVars :: [TyVar], -- Existentially-quantified type vars
278 -- In general, the dcUnivTyVars are NOT NECESSARILY THE SAME AS THE TYVARS
279 -- FOR THE PARENT TyCon. With GADTs the data con might not even have
280 -- the same number of type variables.
281 -- [This is a change (Oct05): previously, vanilla datacons guaranteed to
282 -- have the same type variables as their parent TyCon, but that seems ugly.]
284 -- INVARIANT: the UnivTyVars and ExTyVars all have distinct OccNames
285 -- Reason: less confusing, and easier to generate IfaceSyn
287 dcEqSpec :: [(TyVar,Type)], -- Equalities derived from the result type,
288 -- _as written by the programmer_
289 -- This field allows us to move conveniently between the two ways
290 -- of representing a GADT constructor's type:
291 -- MkT :: forall a b. (a ~ [b]) => b -> T a
292 -- MkT :: forall b. b -> T [b]
293 -- Each equality is of the form (a ~ ty), where 'a' is one of
294 -- the universally quantified type variables
296 -- The next two fields give the type context of the data constructor
297 -- (aside from the GADT constraints,
298 -- which are given by the dcExpSpec)
299 -- In GADT form, this is *exactly* what the programmer writes, even if
300 -- the context constrains only universally quantified variables
301 -- MkT :: forall a b. (a ~ b, Ord b) => a -> T a b
302 dcEqTheta :: ThetaType, -- The *equational* constraints
303 dcDictTheta :: ThetaType, -- The *type-class and implicit-param* constraints
305 dcStupidTheta :: ThetaType, -- The context of the data type declaration
306 -- data Eq a => T a = ...
307 -- or, rather, a "thinned" version thereof
308 -- "Thinned", because the Report says
309 -- to eliminate any constraints that don't mention
310 -- tyvars free in the arg types for this constructor
312 -- INVARIANT: the free tyvars of dcStupidTheta are a subset of dcUnivTyVars
313 -- Reason: dcStupidTeta is gotten by thinning the stupid theta from the tycon
315 -- "Stupid", because the dictionaries aren't used for anything.
316 -- Indeed, [as of March 02] they are no longer in the type of
317 -- the wrapper Id, because that makes it harder to use the wrap-id
318 -- to rebuild values after record selection or in generics.
320 dcOrigArgTys :: [Type], -- Original argument types
321 -- (before unboxing and flattening of strict fields)
322 dcOrigResTy :: Type, -- Original result type, as seen by the user
323 -- NB: for a data instance, the original user result type may
324 -- differ from the DataCon's representation TyCon. Example
325 -- data instance T [a] where MkT :: a -> T [a]
326 -- The OrigResTy is T [a], but the dcRepTyCon might be :T123
328 -- Now the strictness annotations and field labels of the constructor
329 dcStrictMarks :: [StrictnessMark],
330 -- Strictness annotations as decided by the compiler.
331 -- Does *not* include the existential dictionaries
332 -- length = dataConSourceArity dataCon
334 dcFields :: [FieldLabel],
335 -- Field labels for this constructor, in the
336 -- same order as the dcOrigArgTys;
337 -- length = 0 (if not a record) or dataConSourceArity.
339 -- Constructor representation
340 dcRepArgTys :: [Type], -- Final, representation argument types,
341 -- after unboxing and flattening,
342 -- and *including* existential dictionaries
344 dcRepStrictness :: [StrictnessMark], -- One for each *representation* argument
345 -- See also Note [Data-con worker strictness] in MkId.lhs
347 -- Result type of constructor is T t1..tn
348 dcRepTyCon :: TyCon, -- Result tycon, T
350 dcRepType :: Type, -- Type of the constructor
351 -- forall a x y. (a~(x,y), x~y, Ord x) =>
353 -- (this is *not* of the constructor wrapper Id:
354 -- see Note [Data con representation] below)
355 -- Notice that the existential type parameters come *second*.
356 -- Reason: in a case expression we may find:
357 -- case (e :: T t) of
358 -- MkT x y co1 co2 (d:Ord x) (v:r) (w:F s) -> ...
359 -- It's convenient to apply the rep-type of MkT to 't', to get
360 -- forall x y. (t~(x,y), x~y, Ord x) => x -> y -> T t
361 -- and use that to check the pattern. Mind you, this is really only
365 -- The curried worker function that corresponds to the constructor:
366 -- It doesn't have an unfolding; the code generator saturates these Ids
367 -- and allocates a real constructor when it finds one.
369 -- An entirely separate wrapper function is built in TcTyDecls
372 dcInfix :: Bool -- True <=> declared infix
373 -- Used for Template Haskell and 'deriving' only
374 -- The actual fixity is stored elsewhere
377 -- | Contains the Ids of the data constructor functions
379 = DCIds (Maybe Id) Id -- Algebraic data types always have a worker, and
380 -- may or may not have a wrapper, depending on whether
381 -- the wrapper does anything. Newtypes just have a worker
383 -- _Neither_ the worker _nor_ the wrapper take the dcStupidTheta dicts as arguments
385 -- The wrapper takes dcOrigArgTys as its arguments
386 -- The worker takes dcRepArgTys as its arguments
387 -- If the worker is absent, dcRepArgTys is the same as dcOrigArgTys
389 -- The 'Nothing' case of DCIds is important
390 -- Not only is this efficient,
391 -- but it also ensures that the wrapper is replaced
392 -- by the worker (because it *is* the worker)
393 -- even when there are no args. E.g. in
395 -- the (:) *is* the worker.
396 -- This is really important in rule matching,
397 -- (We could match on the wrappers,
398 -- but that makes it less likely that rules will match
399 -- when we bring bits of unfoldings together.)
401 -- | Type of the tags associated with each constructor possibility
405 -- ^ Tags are allocated from here for real constructors
409 Note [Data con representation]
410 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
411 The dcRepType field contains the type of the representation of a contructor
412 This may differ from the type of the contructor *Id* (built
413 by MkId.mkDataConId) for two reasons:
414 a) the constructor Id may be overloaded, but the dictionary isn't stored
415 e.g. data Eq a => T a = MkT a a
417 b) the constructor may store an unboxed version of a strict field.
419 Here's an example illustrating both:
420 data Ord a => T a = MkT Int! a
422 T :: Ord a => Int -> a -> T a
424 Trep :: Int# -> a -> T a
425 Actually, the unboxed part isn't implemented yet!
428 %************************************************************************
430 \subsection{Instances}
432 %************************************************************************
435 instance Eq DataCon where
436 a == b = getUnique a == getUnique b
437 a /= b = getUnique a /= getUnique b
439 instance Ord DataCon where
440 a <= b = getUnique a <= getUnique b
441 a < b = getUnique a < getUnique b
442 a >= b = getUnique a >= getUnique b
443 a > b = getUnique a > getUnique b
444 compare a b = getUnique a `compare` getUnique b
446 instance Uniquable DataCon where
449 instance NamedThing DataCon where
452 instance Outputable DataCon where
453 ppr con = ppr (dataConName con)
455 instance Show DataCon where
456 showsPrec p con = showsPrecSDoc p (ppr con)
460 %************************************************************************
462 \subsection{Construction}
464 %************************************************************************
467 -- | Build a new data constructor
469 -> Bool -- ^ Is the constructor declared infix?
470 -> [StrictnessMark] -- ^ Strictness annotations written in the source file
471 -> [FieldLabel] -- ^ Field labels for the constructor, if it is a record,
473 -> [TyVar] -- ^ Universally quantified type variables
474 -> [TyVar] -- ^ Existentially quantified type variables
475 -> [(TyVar,Type)] -- ^ GADT equalities
476 -> ThetaType -- ^ Theta-type occuring before the arguments proper
477 -> [Type] -- ^ Original argument types
478 -> Type -- ^ Original result type
479 -> TyCon -- ^ Representation type constructor
480 -> ThetaType -- ^ The "stupid theta", context of the data declaration
481 -- e.g. @data Eq a => T a ...@
482 -> DataConIds -- ^ The Ids of the actual builder functions
484 -- Can get the tag from the TyCon
486 mkDataCon name declared_infix
487 arg_stricts -- Must match orig_arg_tys 1-1
491 orig_arg_tys orig_res_ty rep_tycon
493 -- Warning: mkDataCon is not a good place to check invariants.
494 -- If the programmer writes the wrong result type in the decl, thus:
495 -- data T a where { MkT :: S }
496 -- then it's possible that the univ_tvs may hit an assertion failure
497 -- if you pull on univ_tvs. This case is checked by checkValidDataCon,
498 -- so the error is detected properly... it's just that asaertions here
499 -- are a little dodgy.
501 = -- ASSERT( not (any isEqPred theta) )
502 -- We don't currently allow any equality predicates on
503 -- a data constructor (apart from the GADT ones in eq_spec)
506 is_vanilla = null ex_tvs && null eq_spec && null theta
507 con = MkData {dcName = name, dcUnique = nameUnique name,
508 dcVanilla = is_vanilla, dcInfix = declared_infix,
509 dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs,
511 dcStupidTheta = stupid_theta,
512 dcEqTheta = eq_theta, dcDictTheta = dict_theta,
513 dcOrigArgTys = orig_arg_tys, dcOrigResTy = orig_res_ty,
514 dcRepTyCon = rep_tycon,
515 dcRepArgTys = rep_arg_tys,
516 dcStrictMarks = arg_stricts,
517 dcRepStrictness = rep_arg_stricts,
518 dcFields = fields, dcTag = tag, dcRepType = ty,
521 -- Strictness marks for source-args
522 -- *after unboxing choices*,
523 -- but *including existential dictionaries*
525 -- The 'arg_stricts' passed to mkDataCon are simply those for the
526 -- source-language arguments. We add extra ones for the
527 -- dictionary arguments right here.
528 (eq_theta,dict_theta) = partition isEqPred theta
529 dict_tys = mkPredTys dict_theta
530 real_arg_tys = dict_tys ++ orig_arg_tys
531 real_stricts = map mk_dict_strict_mark dict_theta ++ arg_stricts
533 -- Representation arguments and demands
534 -- To do: eliminate duplication with MkId
535 (rep_arg_stricts, rep_arg_tys) = computeRep real_stricts real_arg_tys
537 tag = assoc "mkDataCon" (tyConDataCons rep_tycon `zip` [fIRST_TAG..]) con
538 ty = mkForAllTys univ_tvs $ mkForAllTys ex_tvs $
539 mkFunTys (mkPredTys (eqSpecPreds eq_spec)) $
540 mkFunTys (mkPredTys eq_theta) $
541 -- NB: the dict args are already in rep_arg_tys
542 -- because they might be flattened..
543 -- but the equality predicates are not
544 mkFunTys rep_arg_tys $
545 mkTyConApp rep_tycon (mkTyVarTys univ_tvs)
547 eqSpecPreds :: [(TyVar,Type)] -> ThetaType
548 eqSpecPreds spec = [ mkEqPred (mkTyVarTy tv, ty) | (tv,ty) <- spec ]
550 mk_dict_strict_mark :: PredType -> StrictnessMark
551 mk_dict_strict_mark pred | isStrictPred pred = MarkedStrict
552 | otherwise = NotMarkedStrict
556 -- | The 'Name' of the 'DataCon', giving it a unique, rooted identification
557 dataConName :: DataCon -> Name
560 -- | The tag used for ordering 'DataCon's
561 dataConTag :: DataCon -> ConTag
564 -- | The type constructor that we are building via this data constructor
565 dataConTyCon :: DataCon -> TyCon
566 dataConTyCon = dcRepTyCon
568 -- | The original type constructor used in the definition of this data
569 -- constructor. In case of a data family instance, that will be the family
571 dataConOrigTyCon :: DataCon -> TyCon
573 | Just (tc, _) <- tyConFamInst_maybe (dcRepTyCon dc) = tc
574 | otherwise = dcRepTyCon dc
576 -- | The representation type of the data constructor, i.e. the sort
577 -- type that will represent values of this type at runtime
578 dataConRepType :: DataCon -> Type
579 dataConRepType = dcRepType
581 -- | Should the 'DataCon' be presented infix?
582 dataConIsInfix :: DataCon -> Bool
583 dataConIsInfix = dcInfix
585 -- | The universally-quantified type variables of the constructor
586 dataConUnivTyVars :: DataCon -> [TyVar]
587 dataConUnivTyVars = dcUnivTyVars
589 -- | The existentially-quantified type variables of the constructor
590 dataConExTyVars :: DataCon -> [TyVar]
591 dataConExTyVars = dcExTyVars
593 -- | Both the universal and existentiatial type variables of the constructor
594 dataConAllTyVars :: DataCon -> [TyVar]
595 dataConAllTyVars (MkData { dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs })
598 -- | Equalities derived from the result type of the data constructor, as written
599 -- by the programmer in any GADT declaration
600 dataConEqSpec :: DataCon -> [(TyVar,Type)]
601 dataConEqSpec = dcEqSpec
603 -- | The equational constraints on the data constructor type
604 dataConEqTheta :: DataCon -> ThetaType
605 dataConEqTheta = dcEqTheta
607 -- | The type class and implicit parameter contsraints on the data constructor type
608 dataConDictTheta :: DataCon -> ThetaType
609 dataConDictTheta = dcDictTheta
611 -- | Get the Id of the 'DataCon' worker: a function that is the "actual"
612 -- constructor and has no top level binding in the program. The type may
613 -- be different from the obvious one written in the source program. Panics
614 -- if there is no such 'Id' for this 'DataCon'
615 dataConWorkId :: DataCon -> Id
616 dataConWorkId dc = case dcIds dc of
617 DCIds _ wrk_id -> wrk_id
619 -- | Get the Id of the 'DataCon' wrapper: a function that wraps the "actual"
620 -- constructor so it has the type visible in the source program: c.f. 'dataConWorkId'.
621 -- Returns Nothing if there is no wrapper, which occurs for an algebraic data constructor
622 -- and also for a newtype (whose constructor is inlined compulsorily)
623 dataConWrapId_maybe :: DataCon -> Maybe Id
624 dataConWrapId_maybe dc = case dcIds dc of
625 DCIds mb_wrap _ -> mb_wrap
627 -- | Returns an Id which looks like the Haskell-source constructor by using
628 -- the wrapper if it exists (see 'dataConWrapId_maybe') and failing over to
629 -- the worker (see 'dataConWorkId')
630 dataConWrapId :: DataCon -> Id
631 dataConWrapId dc = case dcIds dc of
632 DCIds (Just wrap) _ -> wrap
633 DCIds Nothing wrk -> wrk -- worker=wrapper
635 -- | Find all the 'Id's implicitly brought into scope by the data constructor. Currently,
636 -- the union of the 'dataConWorkId' and the 'dataConWrapId'
637 dataConImplicitIds :: DataCon -> [Id]
638 dataConImplicitIds dc = case dcIds dc of
639 DCIds (Just wrap) work -> [wrap,work]
640 DCIds Nothing work -> [work]
642 -- | The labels for the fields of this particular 'DataCon'
643 dataConFieldLabels :: DataCon -> [FieldLabel]
644 dataConFieldLabels = dcFields
646 -- | Extract the type for any given labelled field of the 'DataCon'
647 dataConFieldType :: DataCon -> FieldLabel -> Type
648 dataConFieldType con label
649 = case lookup label (dcFields con `zip` dcOrigArgTys con) of
651 Nothing -> pprPanic "dataConFieldType" (ppr con <+> ppr label)
653 -- | The strictness markings decided on by the compiler. Does not include those for
654 -- existential dictionaries. The list is in one-to-one correspondence with the arity of the 'DataCon'
655 dataConStrictMarks :: DataCon -> [StrictnessMark]
656 dataConStrictMarks = dcStrictMarks
658 -- | Strictness of /existential/ arguments only
659 dataConExStricts :: DataCon -> [StrictnessMark]
660 -- Usually empty, so we don't bother to cache this
661 dataConExStricts dc = map mk_dict_strict_mark $ dcDictTheta dc
663 -- | Source-level arity of the data constructor
664 dataConSourceArity :: DataCon -> Arity
665 dataConSourceArity dc = length (dcOrigArgTys dc)
667 -- | Gives the number of actual fields in the /representation/ of the
668 -- data constructor. This may be more than appear in the source code;
669 -- the extra ones are the existentially quantified dictionaries
670 dataConRepArity :: DataCon -> Int
671 dataConRepArity (MkData {dcRepArgTys = arg_tys}) = length arg_tys
673 -- | Return whether there are any argument types for this 'DataCon's original source type
674 isNullarySrcDataCon :: DataCon -> Bool
675 isNullarySrcDataCon dc = null (dcOrigArgTys dc)
677 -- | Return whether there are any argument types for this 'DataCon's runtime representation type
678 isNullaryRepDataCon :: DataCon -> Bool
679 isNullaryRepDataCon dc = null (dcRepArgTys dc)
681 dataConRepStrictness :: DataCon -> [StrictnessMark]
682 -- ^ Give the demands on the arguments of a
683 -- Core constructor application (Con dc args)
684 dataConRepStrictness dc = dcRepStrictness dc
686 -- | The \"signature\" of the 'DataCon' returns, in order:
688 -- 1) The result of 'dataConAllTyVars',
690 -- 2) All the 'ThetaType's relating to the 'DataCon' (coercion, dictionary, implicit
691 -- parameter - whatever)
693 -- 3) The type arguments to the constructor
695 -- 4) The /original/ result type of the 'DataCon'
696 dataConSig :: DataCon -> ([TyVar], ThetaType, [Type], Type)
697 dataConSig (MkData {dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs, dcEqSpec = eq_spec,
698 dcEqTheta = eq_theta, dcDictTheta = dict_theta,
699 dcOrigArgTys = arg_tys, dcOrigResTy = res_ty})
700 = (univ_tvs ++ ex_tvs, eqSpecPreds eq_spec ++ eq_theta ++ dict_theta, arg_tys, res_ty)
702 -- | The \"full signature\" of the 'DataCon' returns, in order:
704 -- 1) The result of 'dataConUnivTyVars'
706 -- 2) The result of 'dataConExTyVars'
708 -- 3) The result of 'dataConEqSpec'
710 -- 4) The result of 'dataConDictTheta'
712 -- 5) The original argument types to the 'DataCon' (i.e. before
713 -- any change of the representation of the type)
715 -- 6) The original result type of the 'DataCon'
716 dataConFullSig :: DataCon
717 -> ([TyVar], [TyVar], [(TyVar,Type)], ThetaType, ThetaType, [Type], Type)
718 dataConFullSig (MkData {dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs, dcEqSpec = eq_spec,
719 dcEqTheta = eq_theta, dcDictTheta = dict_theta,
720 dcOrigArgTys = arg_tys, dcOrigResTy = res_ty})
721 = (univ_tvs, ex_tvs, eq_spec, eq_theta, dict_theta, arg_tys, res_ty)
723 dataConOrigResTy :: DataCon -> Type
724 dataConOrigResTy dc = dcOrigResTy dc
726 -- | The \"stupid theta\" of the 'DataCon', such as @data Eq a@ in:
728 -- > data Eq a => T a = ...
729 dataConStupidTheta :: DataCon -> ThetaType
730 dataConStupidTheta dc = dcStupidTheta dc
732 dataConUserType :: DataCon -> Type
733 -- ^ The user-declared type of the data constructor
734 -- in the nice-to-read form:
736 -- > T :: forall a b. a -> b -> T [a]
740 -- > T :: forall a c. forall b. (c~[a]) => a -> b -> T c
742 -- NB: If the constructor is part of a data instance, the result type
743 -- mentions the family tycon, not the internal one.
744 dataConUserType (MkData { dcUnivTyVars = univ_tvs,
745 dcExTyVars = ex_tvs, dcEqSpec = eq_spec,
746 dcEqTheta = eq_theta, dcDictTheta = dict_theta, dcOrigArgTys = arg_tys,
747 dcOrigResTy = res_ty })
748 = mkForAllTys ((univ_tvs `minusList` map fst eq_spec) ++ ex_tvs) $
749 mkFunTys (mkPredTys eq_theta) $
750 mkFunTys (mkPredTys dict_theta) $
754 -- | Finds the instantiated types of the arguments required to construct a 'DataCon' representation
755 -- NB: these INCLUDE any dictionary args
756 -- but EXCLUDE the data-declaration context, which is discarded
757 -- It's all post-flattening etc; this is a representation type
758 dataConInstArgTys :: DataCon -- ^ A datacon with no existentials or equality constraints
759 -- However, it can have a dcTheta (notably it can be a
760 -- class dictionary, with superclasses)
761 -> [Type] -- ^ Instantiated at these types
763 dataConInstArgTys dc@(MkData {dcRepArgTys = rep_arg_tys,
764 dcUnivTyVars = univ_tvs, dcEqSpec = eq_spec,
765 dcExTyVars = ex_tvs}) inst_tys
766 = ASSERT2 ( length univ_tvs == length inst_tys
767 , ptext (sLit "dataConInstArgTys") <+> ppr dc $$ ppr univ_tvs $$ ppr inst_tys)
768 ASSERT2 ( null ex_tvs && null eq_spec, ppr dc )
769 map (substTyWith univ_tvs inst_tys) rep_arg_tys
771 -- | Returns just the instantiated /value/ argument types of a 'DataCon',
772 -- (excluding dictionary args)
773 dataConInstOrigArgTys
774 :: DataCon -- Works for any DataCon
775 -> [Type] -- Includes existential tyvar args, but NOT
776 -- equality constraints or dicts
778 -- For vanilla datacons, it's all quite straightforward
779 -- But for the call in MatchCon, we really do want just the value args
780 dataConInstOrigArgTys dc@(MkData {dcOrigArgTys = arg_tys,
781 dcUnivTyVars = univ_tvs,
782 dcExTyVars = ex_tvs}) inst_tys
783 = ASSERT2( length tyvars == length inst_tys
784 , ptext (sLit "dataConInstOrigArgTys") <+> ppr dc $$ ppr tyvars $$ ppr inst_tys )
785 map (substTyWith tyvars inst_tys) arg_tys
787 tyvars = univ_tvs ++ ex_tvs
791 -- | Returns the argument types of the wrapper, excluding all dictionary arguments
792 -- and without substituting for any type variables
793 dataConOrigArgTys :: DataCon -> [Type]
794 dataConOrigArgTys dc = dcOrigArgTys dc
796 -- | Returns the arg types of the worker, including all dictionaries, after any
797 -- flattening has been done and without substituting for any type variables
798 dataConRepArgTys :: DataCon -> [Type]
799 dataConRepArgTys dc = dcRepArgTys dc
803 -- | The string @package:module.name@ identifying a constructor, which is attached
804 -- to its info table and used by the GHCi debugger and the heap profiler
805 dataConIdentity :: DataCon -> [Word8]
806 -- We want this string to be UTF-8, so we get the bytes directly from the FastStrings.
807 dataConIdentity dc = bytesFS (packageIdFS (modulePackageId mod)) ++
808 fromIntegral (ord ':') : bytesFS (moduleNameFS (moduleName mod)) ++
809 fromIntegral (ord '.') : bytesFS (occNameFS (nameOccName name))
810 where name = dataConName dc
811 mod = ASSERT( isExternalName name ) nameModule name
815 isTupleCon :: DataCon -> Bool
816 isTupleCon (MkData {dcRepTyCon = tc}) = isTupleTyCon tc
818 isUnboxedTupleCon :: DataCon -> Bool
819 isUnboxedTupleCon (MkData {dcRepTyCon = tc}) = isUnboxedTupleTyCon tc
821 -- | Vanilla 'DataCon's are those that are nice boring Haskell 98 constructors
822 isVanillaDataCon :: DataCon -> Bool
823 isVanillaDataCon dc = dcVanilla dc
827 classDataCon :: Class -> DataCon
828 classDataCon clas = case tyConDataCons (classTyCon clas) of
829 (dict_constr:no_more) -> ASSERT( null no_more ) dict_constr
830 [] -> panic "classDataCon"
833 %************************************************************************
835 \subsection{Splitting products}
837 %************************************************************************
840 -- | Extract the type constructor, type argument, data constructor and it's
841 -- /representation/ argument types from a type if it is a product type.
843 -- Precisely, we return @Just@ for any type that is all of:
845 -- * Concrete (i.e. constructors visible)
847 -- * Single-constructor
849 -- * Not existentially quantified
851 -- Whether the type is a @data@ type or a @newtype@
852 splitProductType_maybe
853 :: Type -- ^ A product type, perhaps
854 -> Maybe (TyCon, -- The type constructor
855 [Type], -- Type args of the tycon
856 DataCon, -- The data constructor
857 [Type]) -- Its /representation/ arg types
859 -- Rejecing existentials is conservative. Maybe some things
860 -- could be made to work with them, but I'm not going to sweat
861 -- it through till someone finds it's important.
863 splitProductType_maybe ty
864 = case splitTyConApp_maybe ty of
866 | isProductTyCon tycon -- Includes check for non-existential,
867 -- and for constructors visible
868 -> Just (tycon, ty_args, data_con, dataConInstArgTys data_con ty_args)
870 data_con = ASSERT( not (null (tyConDataCons tycon)) )
871 head (tyConDataCons tycon)
874 -- | As 'splitProductType_maybe', but panics if the 'Type' is not a product type
875 splitProductType :: String -> Type -> (TyCon, [Type], DataCon, [Type])
876 splitProductType str ty
877 = case splitProductType_maybe ty of
879 Nothing -> pprPanic (str ++ ": not a product") (pprType ty)
882 -- | As 'splitProductType_maybe', but in turn instantiates the 'TyCon' returned
883 -- and hence recursively tries to unpack it as far as it able to
884 deepSplitProductType_maybe :: Type -> Maybe (TyCon, [Type], DataCon, [Type])
885 deepSplitProductType_maybe ty
886 = do { (res@(tycon, tycon_args, _, _)) <- splitProductType_maybe ty
888 | Just (ty', _co) <- instNewTyCon_maybe tycon tycon_args
889 , not (isRecursiveTyCon tycon)
890 = deepSplitProductType_maybe ty' -- Ignore the coercion?
891 | isNewTyCon tycon = Nothing -- cannot unbox through recursive
892 -- newtypes nor through families
893 | otherwise = Just res}
897 -- | As 'deepSplitProductType_maybe', but panics if the 'Type' is not a product type
898 deepSplitProductType :: String -> Type -> (TyCon, [Type], DataCon, [Type])
899 deepSplitProductType str ty
900 = case deepSplitProductType_maybe ty of
902 Nothing -> pprPanic (str ++ ": not a product") (pprType ty)
904 -- | Compute the representation type strictness and type suitable for a 'DataCon'
905 computeRep :: [StrictnessMark] -- ^ Original argument strictness
906 -> [Type] -- ^ Original argument types
907 -> ([StrictnessMark], -- Representation arg strictness
910 computeRep stricts tys
911 = unzip $ concat $ zipWithEqual "computeRep" unbox stricts tys
913 unbox NotMarkedStrict ty = [(NotMarkedStrict, ty)]
914 unbox MarkedStrict ty = [(MarkedStrict, ty)]
915 unbox MarkedUnboxed ty = zipEqual "computeRep" (dataConRepStrictness arg_dc) arg_tys
917 (_tycon, _tycon_args, arg_dc, arg_tys)
918 = deepSplitProductType "unbox_strict_arg_ty" ty