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, dataConUserType,
19 dataConUnivTyVars, dataConExTyVars, dataConAllTyVars,
20 dataConEqSpec, eqSpecPreds, dataConEqTheta, dataConDictTheta, dataConStupidTheta,
21 dataConInstArgTys, dataConOrigArgTys, dataConOrigResTy,
22 dataConInstOrigArgTys, dataConRepArgTys,
23 dataConFieldLabels, dataConFieldType,
24 dataConStrictMarks, dataConExStricts,
25 dataConSourceArity, dataConRepArity,
27 dataConWorkId, dataConWrapId, dataConWrapId_maybe, dataConImplicitIds,
30 -- ** Predicates on DataCons
31 isNullarySrcDataCon, isNullaryRepDataCon, isTupleCon, isUnboxedTupleCon,
32 isVanillaDataCon, classDataCon,
34 -- * Splitting product types
35 splitProductType_maybe, splitProductType, deepSplitProductType,
36 deepSplitProductType_maybe
39 #include "HsVersions.h"
58 import Data.List ( partition )
62 Data constructor representation
63 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
64 Consider the following Haskell data type declaration
66 data T = T !Int ![Int]
68 Using the strictness annotations, GHC will represent this as
72 That is, the Int has been unboxed. Furthermore, the Haskell source construction
82 That is, the first argument is unboxed, and the second is evaluated. Finally,
83 pattern matching is translated too:
85 case e of { T a b -> ... }
89 case e of { T a' b -> let a = I# a' in ... }
91 To keep ourselves sane, we name the different versions of the data constructor
92 differently, as follows.
95 Note [Data Constructor Naming]
96 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
97 Each data constructor C has two, and possibly up to four, Names associated with it:
99 OccName Name space Name of
100 ---------------------------------------------------------------------------
101 * The "data con itself" C DataName DataCon
102 * The "worker data con" C VarName Id (the worker)
103 * The "wrapper data con" \$WC VarName Id (the wrapper)
104 * The "newtype coercion" :CoT TcClsName TyCon
106 EVERY data constructor (incl for newtypes) has the former two (the
107 data con itself, and its worker. But only some data constructors have a
108 wrapper (see Note [The need for a wrapper]).
110 Each of these three has a distinct Unique. The "data con itself" name
111 appears in the output of the renamer, and names the Haskell-source
112 data constructor. The type checker translates it into either the wrapper Id
113 (if it exists) or worker Id (otherwise).
115 The data con has one or two Ids associated with it:
117 The "worker Id", is the actual data constructor.
118 * Every data constructor (newtype or data type) has a worker
120 * The worker is very like a primop, in that it has no binding.
122 * For a *data* type, the worker *is* the data constructor;
125 * For a *newtype*, the worker has a compulsory unfolding which
128 The worker for MkT has unfolding
129 \\(x:Int). x `cast` sym CoT
130 Here CoT is the type constructor, witnessing the FC axiom
133 The "wrapper Id", \$WC, goes as follows
135 * Its type is exactly what it looks like in the source program.
137 * It is an ordinary function, and it gets a top-level binding
138 like any other function.
140 * The wrapper Id isn't generated for a data type if there is
141 nothing for the wrapper to do. That is, if its defn would be
144 Note [The need for a wrapper]
145 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
146 Why might the wrapper have anything to do? Two reasons:
148 * Unboxing strict fields (with -funbox-strict-fields)
149 data T = MkT !(Int,Int)
150 \$wMkT :: (Int,Int) -> T
151 \$wMkT (x,y) = MkT x y
152 Notice that the worker has two fields where the wapper has
153 just one. That is, the worker has type
154 MkT :: Int -> Int -> T
156 * Equality constraints for GADTs
157 data T a where { MkT :: a -> T [a] }
159 The worker gets a type with explicit equality
161 MkT :: forall a b. (a=[b]) => b -> T a
163 The wrapper has the programmer-specified type:
165 \$wMkT a x = MkT [a] a [a] x
166 The third argument is a coerion
169 INVARIANT: the dictionary constructor for a class
173 A note about the stupid context
174 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
175 Data types can have a context:
177 data (Eq a, Ord b) => T a b = T1 a b | T2 a
179 and that makes the constructors have a context too
180 (notice that T2's context is "thinned"):
182 T1 :: (Eq a, Ord b) => a -> b -> T a b
183 T2 :: (Eq a) => a -> T a b
185 Furthermore, this context pops up when pattern matching
186 (though GHC hasn't implemented this, but it is in H98, and
187 I've fixed GHC so that it now does):
191 f :: Eq a => T a b -> a
193 I say the context is "stupid" because the dictionaries passed
194 are immediately discarded -- they do nothing and have no benefit.
195 It's a flaw in the language.
197 Up to now [March 2002] I have put this stupid context into the
198 type of the "wrapper" constructors functions, T1 and T2, but
199 that turned out to be jolly inconvenient for generics, and
200 record update, and other functions that build values of type T
201 (because they don't have suitable dictionaries available).
203 So now I've taken the stupid context out. I simply deal with
204 it separately in the type checker on occurrences of a
205 constructor, either in an expression or in a pattern.
207 [May 2003: actually I think this decision could evasily be
208 reversed now, and probably should be. Generics could be
209 disabled for types with a stupid context; record updates now
210 (H98) needs the context too; etc. It's an unforced change, so
211 I'm leaving it for now --- but it does seem odd that the
212 wrapper doesn't include the stupid context.]
214 [July 04] With the advent of generalised data types, it's less obvious
215 what the "stupid context" is. Consider
216 C :: forall a. Ord a => a -> a -> T (Foo a)
217 Does the C constructor in Core contain the Ord dictionary? Yes, it must:
222 C a (d:Ord a) (p:a) (q:a) -> compare d p q
224 Note that (Foo a) might not be an instance of Ord.
226 %************************************************************************
228 \subsection{Data constructors}
230 %************************************************************************
233 -- | A data constructor
236 dcName :: Name, -- This is the name of the *source data con*
237 -- (see "Note [Data Constructor Naming]" above)
238 dcUnique :: Unique, -- Cached from Name
239 dcTag :: ConTag, -- ^ Tag, used for ordering 'DataCon's
243 -- *** As declared by the user
245 -- MkT :: forall x y. (x~y,Ord x) => x -> y -> T (x,y)
247 -- *** As represented internally
249 -- MkT :: forall a. forall x y. (a:=:(x,y),x~y,Ord x) => x -> y -> T a
251 -- The next six fields express the type of the constructor, in pieces
254 -- dcUnivTyVars = [a]
255 -- dcExTyVars = [x,y]
256 -- dcEqSpec = [a:=:(x,y)]
258 -- dcDictTheta = [Ord x]
259 -- dcOrigArgTys = [a,List b]
262 dcVanilla :: Bool, -- True <=> This is a vanilla Haskell 98 data constructor
263 -- Its type is of form
264 -- forall a1..an . t1 -> ... tm -> T a1..an
265 -- No existentials, no coercions, nothing.
266 -- That is: dcExTyVars = dcEqSpec = dcEqTheta = dcDictTheta = []
267 -- NB 1: newtypes always have a vanilla data con
268 -- NB 2: a vanilla constructor can still be declared in GADT-style
269 -- syntax, provided its type looks like the above.
270 -- The declaration format is held in the TyCon (algTcGadtSyntax)
272 dcUnivTyVars :: [TyVar], -- Universally-quantified type vars
273 -- INVARIANT: length matches arity of the dcRepTyCon
275 dcExTyVars :: [TyVar], -- Existentially-quantified type vars
276 -- In general, the dcUnivTyVars are NOT NECESSARILY THE SAME AS THE TYVARS
277 -- FOR THE PARENT TyCon. With GADTs the data con might not even have
278 -- the same number of type variables.
279 -- [This is a change (Oct05): previously, vanilla datacons guaranteed to
280 -- have the same type variables as their parent TyCon, but that seems ugly.]
282 -- INVARIANT: the UnivTyVars and ExTyVars all have distinct OccNames
283 -- Reason: less confusing, and easier to generate IfaceSyn
285 dcEqSpec :: [(TyVar,Type)], -- Equalities derived from the result type,
286 -- _as written by the programmer_
287 -- This field allows us to move conveniently between the two ways
288 -- of representing a GADT constructor's type:
289 -- MkT :: forall a b. (a :=: [b]) => b -> T a
290 -- MkT :: forall b. b -> T [b]
291 -- Each equality is of the form (a :=: ty), where 'a' is one of
292 -- the universally quantified type variables
294 -- The next two fields give the type context of the data constructor
295 -- (aside from the GADT constraints,
296 -- which are given by the dcExpSpec)
297 -- In GADT form, this is *exactly* what the programmer writes, even if
298 -- the context constrains only universally quantified variables
299 -- MkT :: forall a b. (a ~ b, Ord b) => a -> T a b
300 dcEqTheta :: ThetaType, -- The *equational* constraints
301 dcDictTheta :: ThetaType, -- The *type-class and implicit-param* constraints
303 dcStupidTheta :: ThetaType, -- The context of the data type declaration
304 -- data Eq a => T a = ...
305 -- or, rather, a "thinned" version thereof
306 -- "Thinned", because the Report says
307 -- to eliminate any constraints that don't mention
308 -- tyvars free in the arg types for this constructor
310 -- INVARIANT: the free tyvars of dcStupidTheta are a subset of dcUnivTyVars
311 -- Reason: dcStupidTeta is gotten by thinning the stupid theta from the tycon
313 -- "Stupid", because the dictionaries aren't used for anything.
314 -- Indeed, [as of March 02] they are no longer in the type of
315 -- the wrapper Id, because that makes it harder to use the wrap-id
316 -- to rebuild values after record selection or in generics.
318 dcOrigArgTys :: [Type], -- Original argument types
319 -- (before unboxing and flattening of strict fields)
320 dcOrigResTy :: Type, -- Original result type
321 -- NB: for a data instance, the original user result type may
322 -- differ from the DataCon's representation TyCon. Example
323 -- data instance T [a] where MkT :: a -> T [a]
324 -- The OrigResTy is T [a], but the dcRepTyCon might be :T123
326 -- Now the strictness annotations and field labels of the constructor
327 dcStrictMarks :: [StrictnessMark],
328 -- Strictness annotations as decided by the compiler.
329 -- Does *not* include the existential dictionaries
330 -- length = dataConSourceArity dataCon
332 dcFields :: [FieldLabel],
333 -- Field labels for this constructor, in the
334 -- same order as the dcOrigArgTys;
335 -- length = 0 (if not a record) or dataConSourceArity.
337 -- Constructor representation
338 dcRepArgTys :: [Type], -- Final, representation argument types,
339 -- after unboxing and flattening,
340 -- and *including* existential dictionaries
342 dcRepStrictness :: [StrictnessMark], -- One for each *representation* argument
343 -- See also Note [Data-con worker strictness] in MkId.lhs
345 -- Result type of constructor is T t1..tn
346 dcRepTyCon :: TyCon, -- Result tycon, T
348 dcRepType :: Type, -- Type of the constructor
349 -- forall a x y. (a:=:(x,y), x~y, Ord x) =>
351 -- (this is *not* of the constructor wrapper Id:
352 -- see Note [Data con representation] below)
353 -- Notice that the existential type parameters come *second*.
354 -- Reason: in a case expression we may find:
355 -- case (e :: T t) of
356 -- MkT x y co1 co2 (d:Ord x) (v:r) (w:F s) -> ...
357 -- It's convenient to apply the rep-type of MkT to 't', to get
358 -- forall x y. (t:=:(x,y), x~y, Ord x) => x -> y -> T t
359 -- and use that to check the pattern. Mind you, this is really only
363 -- The curried worker function that corresponds to the constructor:
364 -- It doesn't have an unfolding; the code generator saturates these Ids
365 -- and allocates a real constructor when it finds one.
367 -- An entirely separate wrapper function is built in TcTyDecls
370 dcInfix :: Bool -- True <=> declared infix
371 -- Used for Template Haskell and 'deriving' only
372 -- The actual fixity is stored elsewhere
375 -- | Contains the Ids of the data constructor functions
377 = DCIds (Maybe Id) Id -- Algebraic data types always have a worker, and
378 -- may or may not have a wrapper, depending on whether
379 -- the wrapper does anything. Newtypes just have a worker
381 -- _Neither_ the worker _nor_ the wrapper take the dcStupidTheta dicts as arguments
383 -- The wrapper takes dcOrigArgTys as its arguments
384 -- The worker takes dcRepArgTys as its arguments
385 -- If the worker is absent, dcRepArgTys is the same as dcOrigArgTys
387 -- The 'Nothing' case of DCIds is important
388 -- Not only is this efficient,
389 -- but it also ensures that the wrapper is replaced
390 -- by the worker (because it *is* the worker)
391 -- even when there are no args. E.g. in
393 -- the (:) *is* the worker.
394 -- This is really important in rule matching,
395 -- (We could match on the wrappers,
396 -- but that makes it less likely that rules will match
397 -- when we bring bits of unfoldings together.)
399 -- | Type of the tags associated with each constructor possibility
403 -- ^ Tags are allocated from here for real constructors
407 Note [Data con representation]
408 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
409 The dcRepType field contains the type of the representation of a contructor
410 This may differ from the type of the contructor *Id* (built
411 by MkId.mkDataConId) for two reasons:
412 a) the constructor Id may be overloaded, but the dictionary isn't stored
413 e.g. data Eq a => T a = MkT a a
415 b) the constructor may store an unboxed version of a strict field.
417 Here's an example illustrating both:
418 data Ord a => T a = MkT Int! a
420 T :: Ord a => Int -> a -> T a
422 Trep :: Int# -> a -> T a
423 Actually, the unboxed part isn't implemented yet!
426 %************************************************************************
428 \subsection{Instances}
430 %************************************************************************
433 instance Eq DataCon where
434 a == b = getUnique a == getUnique b
435 a /= b = getUnique a /= getUnique b
437 instance Ord DataCon where
438 a <= b = getUnique a <= getUnique b
439 a < b = getUnique a < getUnique b
440 a >= b = getUnique a >= getUnique b
441 a > b = getUnique a > getUnique b
442 compare a b = getUnique a `compare` getUnique b
444 instance Uniquable DataCon where
447 instance NamedThing DataCon where
450 instance Outputable DataCon where
451 ppr con = ppr (dataConName con)
453 instance Show DataCon where
454 showsPrec p con = showsPrecSDoc p (ppr con)
458 %************************************************************************
460 \subsection{Construction}
462 %************************************************************************
465 -- | Build a new data constructor
467 -> Bool -- ^ Is the constructor declared infix?
468 -> [StrictnessMark] -- ^ Strictness annotations written in the source file
469 -> [FieldLabel] -- ^ Field labels for the constructor, if it is a record, otherwise empty
470 -> [TyVar] -- ^ Universally quantified type variables
471 -> [TyVar] -- ^ Existentially quantified type variables
472 -> [(TyVar,Type)] -- ^ GADT equalities
473 -> ThetaType -- ^ Theta-type occuring before the arguments proper
474 -> [Type] -- ^ Argument types
475 -> TyCon -- ^ Type constructor we are for
476 -> ThetaType -- ^ The "stupid theta", context of the data declaration e.g. @data Eq a => T a ...@
477 -> DataConIds -- ^ The Ids of the actual builder functions
479 -- Can get the tag from the TyCon
481 mkDataCon name declared_infix
482 arg_stricts -- Must match orig_arg_tys 1-1
488 -- Warning: mkDataCon is not a good place to check invariants.
489 -- If the programmer writes the wrong result type in the decl, thus:
490 -- data T a where { MkT :: S }
491 -- then it's possible that the univ_tvs may hit an assertion failure
492 -- if you pull on univ_tvs. This case is checked by checkValidDataCon,
493 -- so the error is detected properly... it's just that asaertions here
494 -- are a little dodgy.
496 = -- ASSERT( not (any isEqPred theta) )
497 -- We don't currently allow any equality predicates on
498 -- a data constructor (apart from the GADT ones in eq_spec)
501 is_vanilla = null ex_tvs && null eq_spec && null theta
502 con = MkData {dcName = name, dcUnique = nameUnique name,
503 dcVanilla = is_vanilla, dcInfix = declared_infix,
504 dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs,
506 dcStupidTheta = stupid_theta,
507 dcEqTheta = eq_theta, dcDictTheta = dict_theta,
508 dcOrigArgTys = orig_arg_tys, dcOrigResTy = orig_res_ty,
510 dcRepArgTys = rep_arg_tys,
511 dcStrictMarks = arg_stricts,
512 dcRepStrictness = rep_arg_stricts,
513 dcFields = fields, dcTag = tag, dcRepType = ty,
516 -- Strictness marks for source-args
517 -- *after unboxing choices*,
518 -- but *including existential dictionaries*
520 -- The 'arg_stricts' passed to mkDataCon are simply those for the
521 -- source-language arguments. We add extra ones for the
522 -- dictionary arguments right here.
523 (eq_theta,dict_theta) = partition isEqPred theta
524 dict_tys = mkPredTys dict_theta
525 real_arg_tys = dict_tys ++ orig_arg_tys
526 real_stricts = map mk_dict_strict_mark dict_theta ++ arg_stricts
529 -- data instance T (b,c) where
530 -- TI :: forall e. e -> T (e,e)
532 -- The representation tycon looks like this:
533 -- data :R7T b c where
534 -- TI :: forall b1 c1. (b1 ~ c1) => b1 -> :R7T b1 c1
535 -- In this case orig_res_ty = T (e,e)
536 orig_res_ty = mkFamilyTyConApp tycon (substTyVars (mkTopTvSubst eq_spec) univ_tvs)
538 -- Representation arguments and demands
539 -- To do: eliminate duplication with MkId
540 (rep_arg_stricts, rep_arg_tys) = computeRep real_stricts real_arg_tys
542 tag = assoc "mkDataCon" (tyConDataCons tycon `zip` [fIRST_TAG..]) con
543 ty = mkForAllTys univ_tvs $ mkForAllTys ex_tvs $
544 mkFunTys (mkPredTys (eqSpecPreds eq_spec)) $
545 mkFunTys (mkPredTys eq_theta) $
546 -- NB: the dict args are already in rep_arg_tys
547 -- because they might be flattened..
548 -- but the equality predicates are not
549 mkFunTys rep_arg_tys $
550 mkTyConApp tycon (mkTyVarTys univ_tvs)
552 eqSpecPreds :: [(TyVar,Type)] -> ThetaType
553 eqSpecPreds spec = [ mkEqPred (mkTyVarTy tv, ty) | (tv,ty) <- spec ]
555 mk_dict_strict_mark :: PredType -> StrictnessMark
556 mk_dict_strict_mark pred | isStrictPred pred = MarkedStrict
557 | otherwise = NotMarkedStrict
561 -- | The 'Name' of the 'DataCon', giving it a unique, rooted identification
562 dataConName :: DataCon -> Name
565 -- | The tag used for ordering 'DataCon's
566 dataConTag :: DataCon -> ConTag
569 -- | The type constructor that we are building via this data constructor
570 dataConTyCon :: DataCon -> TyCon
571 dataConTyCon = dcRepTyCon
573 -- | The representation type of the data constructor, i.e. the sort
574 -- type that will represent values of this type at runtime
575 dataConRepType :: DataCon -> Type
576 dataConRepType = dcRepType
578 -- | Should the 'DataCon' be presented infix?
579 dataConIsInfix :: DataCon -> Bool
580 dataConIsInfix = dcInfix
582 -- | The universally-quantified type variables of the constructor
583 dataConUnivTyVars :: DataCon -> [TyVar]
584 dataConUnivTyVars = dcUnivTyVars
586 -- | The existentially-quantified type variables of the constructor
587 dataConExTyVars :: DataCon -> [TyVar]
588 dataConExTyVars = dcExTyVars
590 -- | Both the universal and existentiatial type variables of the constructor
591 dataConAllTyVars :: DataCon -> [TyVar]
592 dataConAllTyVars (MkData { dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs })
595 -- | Equalities derived from the result type of the data constructor, as written
596 -- by the programmer in any GADT declaration
597 dataConEqSpec :: DataCon -> [(TyVar,Type)]
598 dataConEqSpec = dcEqSpec
600 -- | The equational constraints on the data constructor type
601 dataConEqTheta :: DataCon -> ThetaType
602 dataConEqTheta = dcEqTheta
604 -- | The type class and implicit parameter contsraints on the data constructor type
605 dataConDictTheta :: DataCon -> ThetaType
606 dataConDictTheta = dcDictTheta
608 -- | Get the Id of the 'DataCon' worker: a function that is the "actual"
609 -- constructor and has no top level binding in the program. The type may
610 -- be different from the obvious one written in the source program. Panics
611 -- if there is no such 'Id' for this 'DataCon'
612 dataConWorkId :: DataCon -> Id
613 dataConWorkId dc = case dcIds dc of
614 DCIds _ wrk_id -> wrk_id
616 -- | Get the Id of the 'DataCon' wrapper: a function that wraps the "actual"
617 -- constructor so it has the type visible in the source program: c.f. 'dataConWorkId'.
618 -- Returns Nothing if there is no wrapper, which occurs for an algebraic data constructor
619 -- and also for a newtype (whose constructor is inlined compulsorily)
620 dataConWrapId_maybe :: DataCon -> Maybe Id
621 dataConWrapId_maybe dc = case dcIds dc of
622 DCIds mb_wrap _ -> mb_wrap
624 -- | Returns an Id which looks like the Haskell-source constructor by using
625 -- the wrapper if it exists (see 'dataConWrapId_maybe') and failing over to
626 -- the worker (see 'dataConWorkId')
627 dataConWrapId :: DataCon -> Id
628 dataConWrapId dc = case dcIds dc of
629 DCIds (Just wrap) _ -> wrap
630 DCIds Nothing wrk -> wrk -- worker=wrapper
632 -- | Find all the 'Id's implicitly brought into scope by the data constructor. Currently,
633 -- the union of the 'dataConWorkId' and the 'dataConWrapId'
634 dataConImplicitIds :: DataCon -> [Id]
635 dataConImplicitIds dc = case dcIds dc of
636 DCIds (Just wrap) work -> [wrap,work]
637 DCIds Nothing work -> [work]
639 -- | The labels for the fields of this particular 'DataCon'
640 dataConFieldLabels :: DataCon -> [FieldLabel]
641 dataConFieldLabels = dcFields
643 -- | Extract the type for any given labelled field of the 'DataCon'
644 dataConFieldType :: DataCon -> FieldLabel -> Type
645 dataConFieldType con label = expectJust "unexpected label" $
646 lookup label (dcFields con `zip` dcOrigArgTys con)
648 -- | The strictness markings decided on by the compiler. Does not include those for
649 -- existential dictionaries. The list is in one-to-one correspondence with the arity of the 'DataCon'
650 dataConStrictMarks :: DataCon -> [StrictnessMark]
651 dataConStrictMarks = dcStrictMarks
653 -- | Strictness of /existential/ arguments only
654 dataConExStricts :: DataCon -> [StrictnessMark]
655 -- Usually empty, so we don't bother to cache this
656 dataConExStricts dc = map mk_dict_strict_mark $ dcDictTheta dc
658 -- | Source-level arity of the data constructor
659 dataConSourceArity :: DataCon -> Arity
660 dataConSourceArity dc = length (dcOrigArgTys dc)
662 -- | Gives the number of actual fields in the /representation/ of the
663 -- data constructor. This may be more than appear in the source code;
664 -- the extra ones are the existentially quantified dictionaries
665 dataConRepArity :: DataCon -> Int
666 dataConRepArity (MkData {dcRepArgTys = arg_tys}) = length arg_tys
668 -- | Return whether there are any argument types for this 'DataCon's original source type
669 isNullarySrcDataCon :: DataCon -> Bool
670 isNullarySrcDataCon dc = null (dcOrigArgTys dc)
672 -- | Return whether there are any argument types for this 'DataCon's runtime representation type
673 isNullaryRepDataCon :: DataCon -> Bool
674 isNullaryRepDataCon dc = null (dcRepArgTys dc)
676 dataConRepStrictness :: DataCon -> [StrictnessMark]
677 -- ^ Give the demands on the arguments of a
678 -- Core constructor application (Con dc args)
679 dataConRepStrictness dc = dcRepStrictness dc
681 -- | The \"signature\" of the 'DataCon' returns, in order:
683 -- 1) The result of 'dataConAllTyVars',
685 -- 2) All the 'ThetaType's relating to the 'DataCon' (coercion, dictionary, implicit
686 -- parameter - whatever)
688 -- 3) The type arguments to the constructor
690 -- 4) The /original/ result type of the 'DataCon'
691 dataConSig :: DataCon -> ([TyVar], ThetaType, [Type], Type)
692 dataConSig (MkData {dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs, dcEqSpec = eq_spec,
693 dcEqTheta = eq_theta, dcDictTheta = dict_theta, dcOrigArgTys = arg_tys, dcOrigResTy = res_ty})
694 = (univ_tvs ++ ex_tvs, eqSpecPreds eq_spec ++ eq_theta ++ dict_theta, arg_tys, res_ty)
696 -- | The \"full signature\" of the 'DataCon' returns, in order:
698 -- 1) The result of 'dataConUnivTyVars'
700 -- 2) The result of 'dataConExTyVars'
702 -- 3) The result of 'dataConEqSpec'
704 -- 4) The result of 'dataConDictTheta'
706 -- 5) The original argument types to the 'DataCon' (i.e. before any change of the representation of the type)
708 -- 6) The original result type of the 'DataCon'
709 dataConFullSig :: DataCon
710 -> ([TyVar], [TyVar], [(TyVar,Type)], ThetaType, ThetaType, [Type], Type)
711 dataConFullSig (MkData {dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs, dcEqSpec = eq_spec,
712 dcEqTheta = eq_theta, dcDictTheta = dict_theta, dcOrigArgTys = arg_tys, dcOrigResTy = res_ty})
713 = (univ_tvs, ex_tvs, eq_spec, eq_theta, dict_theta, arg_tys, res_ty)
715 dataConOrigResTy :: DataCon -> Type
716 dataConOrigResTy dc = dcOrigResTy dc
718 -- | The \"stupid theta\" of the 'DataCon', such as @data Eq a@ in:
720 -- > data Eq a => T a = ...
721 dataConStupidTheta :: DataCon -> ThetaType
722 dataConStupidTheta dc = dcStupidTheta dc
724 dataConUserType :: DataCon -> Type
725 -- ^ The user-declared type of the data constructor
726 -- in the nice-to-read form:
728 -- > T :: forall a b. a -> b -> T [a]
732 -- > T :: forall a c. forall b. (c=[a]) => a -> b -> T c
734 -- NB: If the constructor is part of a data instance, the result type
735 -- mentions the family tycon, not the internal one.
736 dataConUserType (MkData { dcUnivTyVars = univ_tvs,
737 dcExTyVars = ex_tvs, dcEqSpec = eq_spec,
738 dcEqTheta = eq_theta, dcDictTheta = dict_theta, dcOrigArgTys = arg_tys,
739 dcOrigResTy = res_ty })
740 = mkForAllTys ((univ_tvs `minusList` map fst eq_spec) ++ ex_tvs) $
741 mkFunTys (mkPredTys eq_theta) $
742 mkFunTys (mkPredTys dict_theta) $
746 -- | Finds the instantiated types of the arguments required to construct a 'DataCon' representation
747 -- NB: these INCLUDE any dictionary args
748 -- but EXCLUDE the data-declaration context, which is discarded
749 -- It's all post-flattening etc; this is a representation type
750 dataConInstArgTys :: DataCon -- ^ A datacon with no existentials or equality constraints
751 -- However, it can have a dcTheta (notably it can be a
752 -- class dictionary, with superclasses)
753 -> [Type] -- ^ Instantiated at these types
755 dataConInstArgTys dc@(MkData {dcRepArgTys = rep_arg_tys,
756 dcUnivTyVars = univ_tvs, dcEqSpec = eq_spec,
757 dcExTyVars = ex_tvs}) inst_tys
758 = ASSERT2 ( length univ_tvs == length inst_tys
759 , ptext (sLit "dataConInstArgTys") <+> ppr dc $$ ppr univ_tvs $$ ppr inst_tys)
760 ASSERT2 ( null ex_tvs && null eq_spec, ppr dc )
761 map (substTyWith univ_tvs inst_tys) rep_arg_tys
763 -- | Returns just the instantiated /value/ argument types of a 'DataCon',
764 -- (excluding dictionary args)
765 dataConInstOrigArgTys
766 :: DataCon -- Works for any DataCon
767 -> [Type] -- Includes existential tyvar args, but NOT
768 -- equality constraints or dicts
770 -- For vanilla datacons, it's all quite straightforward
771 -- But for the call in MatchCon, we really do want just the value args
772 dataConInstOrigArgTys dc@(MkData {dcOrigArgTys = arg_tys,
773 dcUnivTyVars = univ_tvs,
774 dcExTyVars = ex_tvs}) inst_tys
775 = ASSERT2( length tyvars == length inst_tys
776 , ptext (sLit "dataConInstOrigArgTys") <+> ppr dc $$ ppr tyvars $$ ppr inst_tys )
777 map (substTyWith tyvars inst_tys) arg_tys
779 tyvars = univ_tvs ++ ex_tvs
783 -- | Returns the argument types of the wrapper, excluding all dictionary arguments
784 -- and without substituting for any type variables
785 dataConOrigArgTys :: DataCon -> [Type]
786 dataConOrigArgTys dc = dcOrigArgTys dc
788 -- | Returns the arg types of the worker, including all dictionaries, after any
789 -- flattening has been done and without substituting for any type variables
790 dataConRepArgTys :: DataCon -> [Type]
791 dataConRepArgTys dc = dcRepArgTys dc
795 -- | The string @package:module.name@ identifying a constructor, which is attached
796 -- to its info table and used by the GHCi debugger and the heap profiler
797 dataConIdentity :: DataCon -> [Word8]
798 -- We want this string to be UTF-8, so we get the bytes directly from the FastStrings.
799 dataConIdentity dc = bytesFS (packageIdFS (modulePackageId mod)) ++
800 fromIntegral (ord ':') : bytesFS (moduleNameFS (moduleName mod)) ++
801 fromIntegral (ord '.') : bytesFS (occNameFS (nameOccName name))
802 where name = dataConName dc
803 mod = ASSERT( isExternalName name ) nameModule name
807 isTupleCon :: DataCon -> Bool
808 isTupleCon (MkData {dcRepTyCon = tc}) = isTupleTyCon tc
810 isUnboxedTupleCon :: DataCon -> Bool
811 isUnboxedTupleCon (MkData {dcRepTyCon = tc}) = isUnboxedTupleTyCon tc
813 -- | Vanilla 'DataCon's are those that are nice boring Haskell 98 constructors
814 isVanillaDataCon :: DataCon -> Bool
815 isVanillaDataCon dc = dcVanilla dc
819 classDataCon :: Class -> DataCon
820 classDataCon clas = case tyConDataCons (classTyCon clas) of
821 (dict_constr:no_more) -> ASSERT( null no_more ) dict_constr
822 [] -> panic "classDataCon"
825 %************************************************************************
827 \subsection{Splitting products}
829 %************************************************************************
832 -- | Extract the type constructor, type argument, data constructor and it's
833 -- /representation/ argument types from a type if it is a product type.
835 -- Precisely, we return @Just@ for any type that is all of:
837 -- * Concrete (i.e. constructors visible)
839 -- * Single-constructor
841 -- * Not existentially quantified
843 -- Whether the type is a @data@ type or a @newtype@
844 splitProductType_maybe
845 :: Type -- ^ A product type, perhaps
846 -> Maybe (TyCon, -- The type constructor
847 [Type], -- Type args of the tycon
848 DataCon, -- The data constructor
849 [Type]) -- Its /representation/ arg types
851 -- Rejecing existentials is conservative. Maybe some things
852 -- could be made to work with them, but I'm not going to sweat
853 -- it through till someone finds it's important.
855 splitProductType_maybe ty
856 = case splitTyConApp_maybe ty of
858 | isProductTyCon tycon -- Includes check for non-existential,
859 -- and for constructors visible
860 -> Just (tycon, ty_args, data_con, dataConInstArgTys data_con ty_args)
862 data_con = ASSERT( not (null (tyConDataCons tycon)) )
863 head (tyConDataCons tycon)
866 -- | As 'splitProductType_maybe', but panics if the 'Type' is not a product type
867 splitProductType :: String -> Type -> (TyCon, [Type], DataCon, [Type])
868 splitProductType str ty
869 = case splitProductType_maybe ty of
871 Nothing -> pprPanic (str ++ ": not a product") (pprType ty)
874 -- | As 'splitProductType_maybe', but in turn instantiates the 'TyCon' returned
875 -- and hence recursively tries to unpack it as far as it able to
876 deepSplitProductType_maybe :: Type -> Maybe (TyCon, [Type], DataCon, [Type])
877 deepSplitProductType_maybe ty
878 = do { (res@(tycon, tycon_args, _, _)) <- splitProductType_maybe ty
880 | Just (ty', _co) <- instNewTyCon_maybe tycon tycon_args
881 , not (isRecursiveTyCon tycon)
882 = deepSplitProductType_maybe ty' -- Ignore the coercion?
883 | isNewTyCon tycon = Nothing -- cannot unbox through recursive
884 -- newtypes nor through families
885 | otherwise = Just res}
889 -- | As 'deepSplitProductType_maybe', but panics if the 'Type' is not a product type
890 deepSplitProductType :: String -> Type -> (TyCon, [Type], DataCon, [Type])
891 deepSplitProductType str ty
892 = case deepSplitProductType_maybe ty of
894 Nothing -> pprPanic (str ++ ": not a product") (pprType ty)
896 -- | Compute the representation type strictness and type suitable for a 'DataCon'
897 computeRep :: [StrictnessMark] -- ^ Original argument strictness
898 -> [Type] -- ^ Original argument types
899 -> ([StrictnessMark], -- Representation arg strictness
902 computeRep stricts tys
903 = unzip $ concat $ zipWithEqual "computeRep" unbox stricts tys
905 unbox NotMarkedStrict ty = [(NotMarkedStrict, ty)]
906 unbox MarkedStrict ty = [(MarkedStrict, ty)]
907 unbox MarkedUnboxed ty = zipEqual "computeRep" (dataConRepStrictness arg_dc) arg_tys
909 (_tycon, _tycon_args, arg_dc, arg_tys)
910 = deepSplitProductType "unbox_strict_arg_ty" ty