2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 \section[TcType]{Types used in the typechecker}
6 This module provides the Type interface for front-end parts of the
9 * treat "source types" as opaque:
10 newtypes, and predicates are meaningful.
11 * look through usage types
13 The "tc" prefix is for "typechechecker", because the type checker
14 is the principal client.
18 --------------------------------
20 TcType, TcSigmaType, TcRhoType, TcTauType, TcPredType, TcThetaType,
21 TcTyVar, TcTyVarSet, TcKind,
23 BoxyTyVar, BoxySigmaType, BoxyRhoType, BoxyThetaType, BoxyType,
25 --------------------------------
27 UserTypeCtxt(..), pprUserTypeCtxt,
28 TcTyVarDetails(..), BoxInfo(..), pprTcTyVarDetails,
29 MetaDetails(Flexi, Indirect), SkolemInfo(..), pprSkolTvBinding, pprSkolInfo,
30 isImmutableTyVar, isSkolemTyVar, isMetaTyVar, isBoxyTyVar, isSigTyVar, isExistentialTyVar,
34 --------------------------------
38 --------------------------------
40 -- These are important because they do not look through newtypes
42 tcSplitForAllTys, tcSplitPhiTy,
43 tcSplitFunTy_maybe, tcSplitFunTys, tcFunArgTy, tcFunResultTy, tcSplitFunTysN,
44 tcSplitTyConApp, tcSplitTyConApp_maybe, tcTyConAppTyCon, tcTyConAppArgs,
45 tcSplitAppTy_maybe, tcSplitAppTy, tcSplitAppTys,
46 tcValidInstHeadTy, tcGetTyVar_maybe, tcGetTyVar,
47 tcSplitSigmaTy, tcMultiSplitSigmaTy,
49 ---------------------------------
51 -- Again, newtypes are opaque
52 tcEqType, tcEqTypes, tcEqPred, tcCmpType, tcCmpTypes, tcCmpPred, tcEqTypeX,
53 isSigmaTy, isOverloadedTy, isRigidTy, isBoxyTy,
54 isDoubleTy, isFloatTy, isIntTy, isStringTy,
55 isIntegerTy, isBoolTy, isUnitTy,
56 isTauTy, isTauTyCon, tcIsTyVarTy, tcIsForAllTy,
58 ---------------------------------
59 -- Misc type manipulators
60 deNoteType, classesOfTheta,
61 tyClsNamesOfType, tyClsNamesOfDFunHead,
64 ---------------------------------
66 getClassPredTys_maybe, getClassPredTys,
67 isClassPred, isTyVarClassPred,
68 mkDictTy, tcSplitPredTy_maybe,
69 isPredTy, isDictTy, tcSplitDFunTy, tcSplitDFunHead, predTyUnique,
70 mkClassPred, isInheritablePred, isLinearPred, isIPPred, mkPredName,
71 dataConsStupidTheta, isRefineableTy,
73 ---------------------------------
74 -- Foreign import and export
75 isFFIArgumentTy, -- :: DynFlags -> Safety -> Type -> Bool
76 isFFIImportResultTy, -- :: DynFlags -> Type -> Bool
77 isFFIExportResultTy, -- :: Type -> Bool
78 isFFIExternalTy, -- :: Type -> Bool
79 isFFIDynArgumentTy, -- :: Type -> Bool
80 isFFIDynResultTy, -- :: Type -> Bool
81 isFFILabelTy, -- :: Type -> Bool
82 isFFIDotnetTy, -- :: DynFlags -> Type -> Bool
83 isFFIDotnetObjTy, -- :: Type -> Bool
84 isFFITy, -- :: Type -> Bool
85 tcSplitIOType_maybe, -- :: Type -> Maybe Type
86 toDNType, -- :: Type -> DNType
88 --------------------------------
89 -- Rexported from Type
90 Kind, -- Stuff to do with kinds is insensitive to pre/post Tc
91 unliftedTypeKind, liftedTypeKind, unboxedTypeKind,
92 openTypeKind, mkArrowKind, mkArrowKinds,
93 isLiftedTypeKind, isUnliftedTypeKind, isOpenTypeKind,
94 isArgTypeKind, isSubKind, defaultKind,
96 Type, PredType(..), ThetaType,
97 mkForAllTy, mkForAllTys,
98 mkFunTy, mkFunTys, zipFunTys,
99 mkTyConApp, mkAppTy, mkAppTys, applyTy, applyTys,
100 mkTyVarTy, mkTyVarTys, mkTyConTy, mkPredTy, mkPredTys,
102 -- Type substitutions
103 TvSubst(..), -- Representation visible to a few friends
104 TvSubstEnv, emptyTvSubst,
105 mkOpenTvSubst, zipOpenTvSubst, zipTopTvSubst, mkTopTvSubst, notElemTvSubst,
106 getTvSubstEnv, setTvSubstEnv, getTvInScope, extendTvInScope, lookupTyVar,
107 extendTvSubst, extendTvSubstList, isInScope, mkTvSubst, zipTyEnv,
108 substTy, substTys, substTyWith, substTheta, substTyVar, substTyVarBndr,
110 isUnLiftedType, -- Source types are always lifted
111 isUnboxedTupleType, -- Ditto
114 tidyTopType, tidyType, tidyPred, tidyTypes, tidyFreeTyVars, tidyOpenType, tidyOpenTypes,
115 tidyTyVarBndr, tidyOpenTyVar, tidyOpenTyVars, tidySkolemTyVar,
118 tyVarsOfType, tyVarsOfTypes, tyVarsOfPred, tyVarsOfTheta,
119 tcTyVarsOfType, tcTyVarsOfTypes, exactTyVarsOfType, exactTyVarsOfTypes,
121 pprKind, pprParendKind,
122 pprType, pprParendType, pprTyThingCategory,
123 pprPred, pprTheta, pprThetaArrow, pprClassPred
127 #include "HsVersions.h"
130 import TypeRep ( Type(..), funTyCon ) -- friend
132 import Type ( -- Re-exports
133 tyVarsOfType, tyVarsOfTypes, tyVarsOfPred,
134 tyVarsOfTheta, Kind, PredType(..),
135 ThetaType, unliftedTypeKind, unboxedTypeKind,
136 liftedTypeKind, openTypeKind, mkArrowKind,
137 isLiftedTypeKind, isUnliftedTypeKind,
138 mkArrowKinds, mkForAllTy, mkForAllTys,
139 defaultKind, isArgTypeKind, isOpenTypeKind,
140 mkFunTy, mkFunTys, zipFunTys,
142 mkAppTys, applyTy, applyTys,
143 mkTyVarTy, mkTyVarTys, mkTyConTy, mkPredTy,
144 mkPredTys, isUnLiftedType,
145 isUnboxedTupleType, isPrimitiveType,
147 tidyTopType, tidyType, tidyPred, tidyTypes,
148 tidyFreeTyVars, tidyOpenType, tidyOpenTypes,
149 tidyTyVarBndr, tidyOpenTyVar,
150 tidyOpenTyVars, tidyKind,
153 tcEqType, tcEqTypes, tcCmpType, tcCmpTypes,
154 tcEqPred, tcCmpPred, tcEqTypeX,
157 TvSubstEnv, emptyTvSubst, mkTvSubst, zipTyEnv,
158 mkOpenTvSubst, zipOpenTvSubst, zipTopTvSubst, mkTopTvSubst,
159 getTvSubstEnv, setTvSubstEnv, getTvInScope, extendTvInScope,
160 extendTvSubst, extendTvSubstList, isInScope, notElemTvSubst,
161 substTy, substTys, substTyWith, substTheta,
162 substTyVar, substTyVarBndr, substPred, lookupTyVar,
164 typeKind, repType, coreView,
165 pprKind, pprParendKind,
166 pprType, pprParendType, pprTyThingCategory,
167 pprPred, pprTheta, pprThetaArrow, pprClassPred
169 import TyCon ( TyCon, isUnLiftedTyCon, isSynTyCon, synTyConDefn, tyConUnique )
170 import DataCon ( DataCon, dataConStupidTheta, dataConResTys )
171 import Class ( Class )
172 import Var ( TyVar, Id, isTcTyVar, mkTcTyVar, tyVarName, tyVarKind, tcTyVarDetails )
173 import ForeignCall ( Safety, DNType(..) )
174 import Unify ( tcMatchTys )
178 import DynFlags ( DynFlags, DynFlag( Opt_GlasgowExts ), dopt )
179 import Name ( Name, NamedThing(..), mkInternalName, getSrcLoc )
181 import VarEnv ( TidyEnv )
182 import OccName ( OccName, mkDictOcc )
183 import PrelNames -- Lots (e.g. in isFFIArgumentTy)
184 import TysWiredIn ( unitTyCon, charTyCon, listTyCon )
185 import BasicTypes ( IPName(..), Arity, ipNameName )
186 import SrcLoc ( SrcLoc, SrcSpan )
187 import Util ( snocView, equalLength )
188 import Maybes ( maybeToBool, expectJust, mapCatMaybes )
189 import ListSetOps ( hasNoDups )
190 import List ( nubBy )
196 %************************************************************************
200 %************************************************************************
202 The type checker divides the generic Type world into the
203 following more structured beasts:
205 sigma ::= forall tyvars. phi
206 -- A sigma type is a qualified type
208 -- Note that even if 'tyvars' is empty, theta
209 -- may not be: e.g. (?x::Int) => Int
211 -- Note that 'sigma' is in prenex form:
212 -- all the foralls are at the front.
213 -- A 'phi' type has no foralls to the right of
221 -- A 'tau' type has no quantification anywhere
222 -- Note that the args of a type constructor must be taus
224 | tycon tau_1 .. tau_n
228 -- In all cases, a (saturated) type synonym application is legal,
229 -- provided it expands to the required form.
232 type TcTyVar = TyVar -- Used only during type inference
233 type TcType = Type -- A TcType can have mutable type variables
234 -- Invariant on ForAllTy in TcTypes:
236 -- a cannot occur inside a MutTyVar in T; that is,
237 -- T is "flattened" before quantifying over a
239 -- These types do not have boxy type variables in them
240 type TcPredType = PredType
241 type TcThetaType = ThetaType
242 type TcSigmaType = TcType
243 type TcRhoType = TcType
244 type TcTauType = TcType
246 type TcTyVarSet = TyVarSet
248 -- These types may have boxy type variables in them
249 type BoxyTyVar = TcTyVar
250 type BoxyRhoType = TcType
251 type BoxyThetaType = TcThetaType
252 type BoxySigmaType = TcType
253 type BoxyType = TcType
257 %************************************************************************
259 \subsection{TyVarDetails}
261 %************************************************************************
263 TyVarDetails gives extra info about type variables, used during type
264 checking. It's attached to mutable type variables only.
265 It's knot-tied back to Var.lhs. There is no reason in principle
266 why Var.lhs shouldn't actually have the definition, but it "belongs" here.
269 Note [Signature skolems]
270 ~~~~~~~~~~~~~~~~~~~~~~~~
275 (x,y,z) = ([y,z], z, head x)
277 Here, x and y have type sigs, which go into the environment. We used to
278 instantiate their types with skolem constants, and push those types into
279 the RHS, so we'd typecheck the RHS with type
281 where a*, b* are skolem constants, and c is an ordinary meta type varible.
283 The trouble is that the occurrences of z in the RHS force a* and b* to
284 be the *same*, so we can't make them into skolem constants that don't unify
285 with each other. Alas.
287 One solution would be insist that in the above defn the programmer uses
288 the same type variable in both type signatures. But that takes explanation.
290 The alternative (currently implemented) is to have a special kind of skolem
291 constant, SigTv, which can unify with other SigTvs. These are *not* treated
292 as righd for the purposes of GADTs. And they are used *only* for pattern
293 bindings and mutually recursive function bindings. See the function
294 TcBinds.tcInstSig, and its use_skols parameter.
298 -- A TyVarDetails is inside a TyVar
300 = SkolemTv SkolemInfo -- A skolem constant
302 | MetaTv BoxInfo (IORef MetaDetails)
305 = BoxTv -- The contents is a (non-boxy) sigma-type
306 -- That is, this MetaTv is a "box"
308 | TauTv -- The contents is a (non-boxy) tau-type
309 -- That is, this MetaTv is an ordinary unification variable
311 | SigTv SkolemInfo -- A variant of TauTv, except that it should not be
312 -- unified with a type, only with a type variable
313 -- SigTvs are only distinguished to improve error messages
314 -- see Note [Signature skolems]
315 -- The MetaDetails, if filled in, will
316 -- always be another SigTv or a SkolemTv
319 -- A TauTv is always filled in with a tau-type, which
320 -- never contains any BoxTvs, nor any ForAlls
322 -- However, a BoxTv can contain a type that contains further BoxTvs
323 -- Notably, when typechecking an explicit list, say [e1,e2], with
324 -- expected type being a box b1, we fill in b1 with (List b2), where
325 -- b2 is another (currently empty) box.
328 = Flexi -- Flexi type variables unify to become
331 | Indirect TcType -- INVARIANT:
332 -- For a BoxTv, this type must be non-boxy
333 -- For a TauTv, this type must be a tau-type
336 = SigSkol UserTypeCtxt -- A skolem that is created by instantiating
337 -- a programmer-supplied type signature
338 -- Location of the binding site is on the TyVar
340 -- The rest are for non-scoped skolems
341 | ClsSkol Class -- Bound at a class decl
342 | InstSkol Id -- Bound at an instance decl
343 | PatSkol DataCon -- An existential type variable bound by a pattern for
344 SrcSpan -- a data constructor with an existential type. E.g.
345 -- data T = forall a. Eq a => MkT a
347 -- The pattern MkT x will allocate an existential type
349 | ArrowSkol SrcSpan -- An arrow form (see TcArrows)
351 | GenSkol [TcTyVar] -- Bound when doing a subsumption check for
352 TcType -- (forall tvs. ty)
355 | UnkSkol -- Unhelpful info (until I improve it)
357 -------------------------------------
358 -- UserTypeCtxt describes the places where a
359 -- programmer-written type signature can occur
361 = FunSigCtxt Name -- Function type signature
362 -- Also used for types in SPECIALISE pragmas
363 | ExprSigCtxt -- Expression type signature
364 | ConArgCtxt Name -- Data constructor argument
365 | TySynCtxt Name -- RHS of a type synonym decl
366 | GenPatCtxt -- Pattern in generic decl
367 -- f{| a+b |} (Inl x) = ...
368 | LamPatSigCtxt -- Type sig in lambda pattern
370 | BindPatSigCtxt -- Type sig in pattern binding pattern
372 | ResSigCtxt -- Result type sig
374 | ForSigCtxt Name -- Foreign inport or export signature
375 | RuleSigCtxt Name -- Signature on a forall'd variable in a RULE
376 | DefaultDeclCtxt -- Types in a default declaration
377 | SpecInstCtxt -- SPECIALISE instance pragma
379 -- Notes re TySynCtxt
380 -- We allow type synonyms that aren't types; e.g. type List = []
382 -- If the RHS mentions tyvars that aren't in scope, we'll
383 -- quantify over them:
384 -- e.g. type T = a->a
385 -- will become type T = forall a. a->a
387 -- With gla-exts that's right, but for H98 we should complain.
390 %************************************************************************
394 %************************************************************************
397 pprTcTyVarDetails :: TcTyVarDetails -> SDoc
399 pprTcTyVarDetails (SkolemTv _) = ptext SLIT("sk")
400 pprTcTyVarDetails (MetaTv BoxTv _) = ptext SLIT("box")
401 pprTcTyVarDetails (MetaTv TauTv _) = ptext SLIT("tau")
402 pprTcTyVarDetails (MetaTv (SigTv _) _) = ptext SLIT("sig")
404 pprUserTypeCtxt :: UserTypeCtxt -> SDoc
405 pprUserTypeCtxt (FunSigCtxt n) = ptext SLIT("the type signature for") <+> quotes (ppr n)
406 pprUserTypeCtxt ExprSigCtxt = ptext SLIT("an expression type signature")
407 pprUserTypeCtxt (ConArgCtxt c) = ptext SLIT("the type of the constructor") <+> quotes (ppr c)
408 pprUserTypeCtxt (TySynCtxt c) = ptext SLIT("the RHS of the type synonym") <+> quotes (ppr c)
409 pprUserTypeCtxt GenPatCtxt = ptext SLIT("the type pattern of a generic definition")
410 pprUserTypeCtxt LamPatSigCtxt = ptext SLIT("a pattern type signature")
411 pprUserTypeCtxt BindPatSigCtxt = ptext SLIT("a pattern type signature")
412 pprUserTypeCtxt ResSigCtxt = ptext SLIT("a result type signature")
413 pprUserTypeCtxt (ForSigCtxt n) = ptext SLIT("the foreign declaration for") <+> quotes (ppr n)
414 pprUserTypeCtxt (RuleSigCtxt n) = ptext SLIT("the type signature for") <+> quotes (ppr n)
415 pprUserTypeCtxt DefaultDeclCtxt = ptext SLIT("a type in a `default' declaration")
416 pprUserTypeCtxt SpecInstCtxt = ptext SLIT("a SPECIALISE instance pragma")
419 --------------------------------
420 tidySkolemTyVar :: TidyEnv -> TcTyVar -> (TidyEnv, TcTyVar)
421 -- Tidy the type inside a GenSkol, preparatory to printing it
422 tidySkolemTyVar env tv
423 = ASSERT( isSkolemTyVar tv || isSigTyVar tv )
424 (env1, mkTcTyVar (tyVarName tv) (tyVarKind tv) info1)
426 (env1, info1) = case tcTyVarDetails tv of
427 SkolemTv info -> (env1, SkolemTv info')
429 (env1, info') = tidy_skol_info env info
430 MetaTv (SigTv info) box -> (env1, MetaTv (SigTv info') box)
432 (env1, info') = tidy_skol_info env info
435 tidy_skol_info env (GenSkol tvs ty loc) = (env2, GenSkol tvs1 ty1 loc)
437 (env1, tvs1) = tidyOpenTyVars env tvs
438 (env2, ty1) = tidyOpenType env1 ty
439 tidy_skol_info env info = (env, info)
441 pprSkolTvBinding :: TcTyVar -> SDoc
442 -- Print info about the binding of a skolem tyvar,
443 -- or nothing if we don't have anything useful to say
445 = ppr_details (tcTyVarDetails tv)
447 ppr_details (MetaTv TauTv _) = quotes (ppr tv) <+> ptext SLIT("is a meta type variable")
448 ppr_details (MetaTv BoxTv _) = quotes (ppr tv) <+> ptext SLIT("is a boxy type variable")
449 ppr_details (MetaTv (SigTv info) _) = ppr_skol info
450 ppr_details (SkolemTv info) = ppr_skol info
452 ppr_skol UnkSkol = empty -- Unhelpful; omit
453 ppr_skol (SigSkol ctxt) = sep [quotes (ppr tv) <+> ptext SLIT("is bound by") <+> pprUserTypeCtxt ctxt,
454 nest 2 (ptext SLIT("at") <+> ppr (getSrcLoc tv))]
455 ppr_skol info = quotes (ppr tv) <+> pprSkolInfo info
457 pprSkolInfo :: SkolemInfo -> SDoc
458 pprSkolInfo (SigSkol ctxt) = ptext SLIT("is bound by") <+> pprUserTypeCtxt ctxt
459 pprSkolInfo (ClsSkol cls) = ptext SLIT("is bound by the class declaration for") <+> quotes (ppr cls)
460 pprSkolInfo (InstSkol df) = ptext SLIT("is bound by the instance declaration at") <+> ppr (getSrcLoc df)
461 pprSkolInfo (ArrowSkol loc) = ptext SLIT("is bound by the arrow form at") <+> ppr loc
462 pprSkolInfo (PatSkol dc loc) = sep [ptext SLIT("is bound by the pattern for") <+> quotes (ppr dc),
463 nest 2 (ptext SLIT("at") <+> ppr loc)]
464 pprSkolInfo (GenSkol tvs ty loc) = sep [sep [ptext SLIT("is bound by the polymorphic type"),
465 nest 2 (quotes (ppr (mkForAllTys tvs ty)))],
466 nest 2 (ptext SLIT("at") <+> ppr loc)]
468 -- For type variables the others are dealt with by pprSkolTvBinding.
469 -- For Insts, these cases should not happen
470 pprSkolInfo UnkSkol = panic "UnkSkol"
472 instance Outputable MetaDetails where
473 ppr Flexi = ptext SLIT("Flexi")
474 ppr (Indirect ty) = ptext SLIT("Indirect") <+> ppr ty
478 %************************************************************************
482 %************************************************************************
485 isImmutableTyVar, isSkolemTyVar, isExistentialTyVar, isBoxyTyVar, isMetaTyVar :: TyVar -> Bool
487 | isTcTyVar tv = isSkolemTyVar tv
491 = ASSERT( isTcTyVar tv )
492 case tcTyVarDetails tv of
496 isExistentialTyVar tv -- Existential type variable, bound by a pattern
497 = ASSERT( isTcTyVar tv )
498 case tcTyVarDetails tv of
499 SkolemTv (PatSkol _ _) -> True
503 = ASSERT2( isTcTyVar tv, ppr tv )
504 case tcTyVarDetails tv of
509 = ASSERT( isTcTyVar tv )
510 case tcTyVarDetails tv of
511 MetaTv BoxTv _ -> True
515 = ASSERT( isTcTyVar tv )
516 case tcTyVarDetails tv of
517 MetaTv (SigTv _) _ -> True
520 metaTvRef :: TyVar -> IORef MetaDetails
522 = ASSERT( isTcTyVar tv )
523 case tcTyVarDetails tv of
525 other -> pprPanic "metaTvRef" (ppr tv)
527 isFlexi, isIndirect :: MetaDetails -> Bool
529 isFlexi other = False
531 isIndirect (Indirect _) = True
532 isIndirect other = False
536 %************************************************************************
538 \subsection{Tau, sigma and rho}
540 %************************************************************************
543 mkSigmaTy tyvars theta tau = mkForAllTys tyvars (mkPhiTy theta tau)
545 mkPhiTy :: [PredType] -> Type -> Type
546 mkPhiTy theta ty = foldr (\p r -> FunTy (mkPredTy p) r) ty theta
549 @isTauTy@ tests for nested for-alls. It should not be called on a boxy type.
552 isTauTy :: Type -> Bool
553 isTauTy ty | Just ty' <- tcView ty = isTauTy ty'
554 isTauTy (TyVarTy tv) = ASSERT( not (isTcTyVar tv && isBoxyTyVar tv) )
556 isTauTy (TyConApp tc tys) = all isTauTy tys && isTauTyCon tc
557 isTauTy (AppTy a b) = isTauTy a && isTauTy b
558 isTauTy (FunTy a b) = isTauTy a && isTauTy b
559 isTauTy (PredTy p) = True -- Don't look through source types
560 isTauTy other = False
563 isTauTyCon :: TyCon -> Bool
564 -- Returns False for type synonyms whose expansion is a polytype
565 isTauTyCon tc | isSynTyCon tc = isTauTy (snd (synTyConDefn tc))
569 isBoxyTy :: TcType -> Bool
570 isBoxyTy ty = any isBoxyTyVar (varSetElems (tcTyVarsOfType ty))
572 isRigidTy :: TcType -> Bool
573 -- A type is rigid if it has no meta type variables in it
574 isRigidTy ty = all isSkolemTyVar (varSetElems (tcTyVarsOfType ty))
576 isRefineableTy :: TcType -> Bool
577 -- A type should have type refinements applied to it if it has
578 -- free type variables, and they are all rigid
579 isRefineableTy ty = not (null tc_tvs) && all isSkolemTyVar tc_tvs
581 tc_tvs = varSetElems (tcTyVarsOfType ty)
584 getDFunTyKey :: Type -> OccName -- Get some string from a type, to be used to
585 -- construct a dictionary function name
586 getDFunTyKey ty | Just ty' <- tcView ty = getDFunTyKey ty'
587 getDFunTyKey (TyVarTy tv) = getOccName tv
588 getDFunTyKey (TyConApp tc _) = getOccName tc
589 getDFunTyKey (AppTy fun _) = getDFunTyKey fun
590 getDFunTyKey (FunTy arg _) = getOccName funTyCon
591 getDFunTyKey (ForAllTy _ t) = getDFunTyKey t
592 getDFunTyKey ty = pprPanic "getDFunTyKey" (pprType ty)
593 -- PredTy shouldn't happen
597 %************************************************************************
599 \subsection{Expanding and splitting}
601 %************************************************************************
603 These tcSplit functions are like their non-Tc analogues, but
604 a) they do not look through newtypes
605 b) they do not look through PredTys
606 c) [future] they ignore usage-type annotations
608 However, they are non-monadic and do not follow through mutable type
609 variables. It's up to you to make sure this doesn't matter.
612 tcSplitForAllTys :: Type -> ([TyVar], Type)
613 tcSplitForAllTys ty = split ty ty []
615 split orig_ty ty tvs | Just ty' <- tcView ty = split orig_ty ty' tvs
616 split orig_ty (ForAllTy tv ty) tvs = split ty ty (tv:tvs)
617 split orig_ty t tvs = (reverse tvs, orig_ty)
619 tcIsForAllTy ty | Just ty' <- tcView ty = tcIsForAllTy ty'
620 tcIsForAllTy (ForAllTy tv ty) = True
621 tcIsForAllTy t = False
623 tcSplitPhiTy :: Type -> ([PredType], Type)
624 tcSplitPhiTy ty = split ty ty []
626 split orig_ty ty tvs | Just ty' <- tcView ty = split orig_ty ty' tvs
627 split orig_ty (FunTy arg res) ts = case tcSplitPredTy_maybe arg of
628 Just p -> split res res (p:ts)
629 Nothing -> (reverse ts, orig_ty)
630 split orig_ty ty ts = (reverse ts, orig_ty)
632 tcSplitSigmaTy ty = case tcSplitForAllTys ty of
633 (tvs, rho) -> case tcSplitPhiTy rho of
634 (theta, tau) -> (tvs, theta, tau)
636 -----------------------
639 -> ( [([TyVar], ThetaType)], -- forall as.C => forall bs.D
640 TcSigmaType) -- The rest of the type
642 -- We need a loop here because we are now prepared to entertain
644 -- f:: forall a. Eq a => forall b. Baz b => tau
645 -- We want to instantiate this to
646 -- f2::tau {f2 = f1 b (Baz b), f1 = f a (Eq a)}
648 tcMultiSplitSigmaTy sigma
649 = case (tcSplitSigmaTy sigma) of
650 ([],[],ty) -> ([], sigma)
651 (tvs, theta, ty) -> case tcMultiSplitSigmaTy ty of
652 (pairs, rest) -> ((tvs,theta):pairs, rest)
654 -----------------------
655 tcTyConAppTyCon :: Type -> TyCon
656 tcTyConAppTyCon ty = fst (tcSplitTyConApp ty)
658 tcTyConAppArgs :: Type -> [Type]
659 tcTyConAppArgs ty = snd (tcSplitTyConApp ty)
661 tcSplitTyConApp :: Type -> (TyCon, [Type])
662 tcSplitTyConApp ty = case tcSplitTyConApp_maybe ty of
664 Nothing -> pprPanic "tcSplitTyConApp" (pprType ty)
666 tcSplitTyConApp_maybe :: Type -> Maybe (TyCon, [Type])
667 tcSplitTyConApp_maybe ty | Just ty' <- tcView ty = tcSplitTyConApp_maybe ty'
668 tcSplitTyConApp_maybe (TyConApp tc tys) = Just (tc, tys)
669 tcSplitTyConApp_maybe (FunTy arg res) = Just (funTyCon, [arg,res])
670 -- Newtypes are opaque, so they may be split
671 -- However, predicates are not treated
672 -- as tycon applications by the type checker
673 tcSplitTyConApp_maybe other = Nothing
675 -----------------------
676 tcSplitFunTys :: Type -> ([Type], Type)
677 tcSplitFunTys ty = case tcSplitFunTy_maybe ty of
679 Just (arg,res) -> (arg:args, res')
681 (args,res') = tcSplitFunTys res
683 tcSplitFunTy_maybe :: Type -> Maybe (Type, Type)
684 tcSplitFunTy_maybe ty | Just ty' <- tcView ty = tcSplitFunTy_maybe ty'
685 tcSplitFunTy_maybe (FunTy arg res) = Just (arg, res)
686 tcSplitFunTy_maybe other = Nothing
690 -> Arity -- N: Number of desired args
691 -> ([TcSigmaType], -- Arg types (N or fewer)
692 TcSigmaType) -- The rest of the type
694 tcSplitFunTysN ty n_args
697 | Just (arg,res) <- tcSplitFunTy_maybe ty
698 = case tcSplitFunTysN res (n_args - 1) of
699 (args, res) -> (arg:args, res)
703 tcFunArgTy ty = case tcSplitFunTy_maybe ty of { Just (arg,res) -> arg }
704 tcFunResultTy ty = case tcSplitFunTy_maybe ty of { Just (arg,res) -> res }
707 -----------------------
708 tcSplitAppTy_maybe :: Type -> Maybe (Type, Type)
709 tcSplitAppTy_maybe ty | Just ty' <- tcView ty = tcSplitAppTy_maybe ty'
710 tcSplitAppTy_maybe (FunTy ty1 ty2) = Just (TyConApp funTyCon [ty1], ty2)
711 tcSplitAppTy_maybe (AppTy ty1 ty2) = Just (ty1, ty2)
712 tcSplitAppTy_maybe (TyConApp tc tys) = case snocView tys of
713 Just (tys', ty') -> Just (TyConApp tc tys', ty')
715 tcSplitAppTy_maybe other = Nothing
717 tcSplitAppTy ty = case tcSplitAppTy_maybe ty of
719 Nothing -> pprPanic "tcSplitAppTy" (pprType ty)
721 tcSplitAppTys :: Type -> (Type, [Type])
725 go ty args = case tcSplitAppTy_maybe ty of
726 Just (ty', arg) -> go ty' (arg:args)
729 -----------------------
730 tcGetTyVar_maybe :: Type -> Maybe TyVar
731 tcGetTyVar_maybe ty | Just ty' <- tcView ty = tcGetTyVar_maybe ty'
732 tcGetTyVar_maybe (TyVarTy tv) = Just tv
733 tcGetTyVar_maybe other = Nothing
735 tcGetTyVar :: String -> Type -> TyVar
736 tcGetTyVar msg ty = expectJust msg (tcGetTyVar_maybe ty)
738 tcIsTyVarTy :: Type -> Bool
739 tcIsTyVarTy ty = maybeToBool (tcGetTyVar_maybe ty)
741 -----------------------
742 tcSplitDFunTy :: Type -> ([TyVar], [PredType], Class, [Type])
743 -- Split the type of a dictionary function
745 = case tcSplitSigmaTy ty of { (tvs, theta, tau) ->
746 case tcSplitDFunHead tau of { (clas, tys) ->
747 (tvs, theta, clas, tys) }}
749 tcSplitDFunHead :: Type -> (Class, [Type])
751 = case tcSplitPredTy_maybe tau of
752 Just (ClassP clas tys) -> (clas, tys)
754 tcValidInstHeadTy :: Type -> Bool
755 -- Used in Haskell-98 mode, for the argument types of an instance head
756 -- These must not be type synonyms, but everywhere else type synonyms
757 -- are transparent, so we need a special function here
760 NoteTy _ ty -> tcValidInstHeadTy ty
761 TyConApp tc tys -> not (isSynTyCon tc) && ok tys
762 FunTy arg res -> ok [arg, res]
765 -- Check that all the types are type variables,
766 -- and that each is distinct
767 ok tys = equalLength tvs tys && hasNoDups tvs
769 tvs = mapCatMaybes get_tv tys
771 get_tv (NoteTy _ ty) = get_tv ty -- Again, do not look
772 get_tv (TyVarTy tv) = Just tv -- through synonyms
773 get_tv other = Nothing
778 %************************************************************************
780 \subsection{Predicate types}
782 %************************************************************************
785 tcSplitPredTy_maybe :: Type -> Maybe PredType
786 -- Returns Just for predicates only
787 tcSplitPredTy_maybe ty | Just ty' <- tcView ty = tcSplitPredTy_maybe ty'
788 tcSplitPredTy_maybe (PredTy p) = Just p
789 tcSplitPredTy_maybe other = Nothing
791 predTyUnique :: PredType -> Unique
792 predTyUnique (IParam n _) = getUnique (ipNameName n)
793 predTyUnique (ClassP clas tys) = getUnique clas
795 mkPredName :: Unique -> SrcLoc -> PredType -> Name
796 mkPredName uniq loc (ClassP cls tys) = mkInternalName uniq (mkDictOcc (getOccName cls)) loc
797 mkPredName uniq loc (IParam ip ty) = mkInternalName uniq (getOccName (ipNameName ip)) loc
801 --------------------- Dictionary types ---------------------------------
804 mkClassPred clas tys = ClassP clas tys
806 isClassPred :: PredType -> Bool
807 isClassPred (ClassP clas tys) = True
808 isClassPred other = False
810 isTyVarClassPred (ClassP clas tys) = all tcIsTyVarTy tys
811 isTyVarClassPred other = False
813 getClassPredTys_maybe :: PredType -> Maybe (Class, [Type])
814 getClassPredTys_maybe (ClassP clas tys) = Just (clas, tys)
815 getClassPredTys_maybe _ = Nothing
817 getClassPredTys :: PredType -> (Class, [Type])
818 getClassPredTys (ClassP clas tys) = (clas, tys)
820 mkDictTy :: Class -> [Type] -> Type
821 mkDictTy clas tys = mkPredTy (ClassP clas tys)
823 isDictTy :: Type -> Bool
824 isDictTy ty | Just ty' <- tcView ty = isDictTy ty'
825 isDictTy (PredTy p) = isClassPred p
826 isDictTy other = False
829 --------------------- Implicit parameters ---------------------------------
832 isIPPred :: PredType -> Bool
833 isIPPred (IParam _ _) = True
834 isIPPred other = False
836 isInheritablePred :: PredType -> Bool
837 -- Can be inherited by a context. For example, consider
838 -- f x = let g y = (?v, y+x)
839 -- in (g 3 with ?v = 8,
841 -- The point is that g's type must be quantifed over ?v:
842 -- g :: (?v :: a) => a -> a
843 -- but it doesn't need to be quantified over the Num a dictionary
844 -- which can be free in g's rhs, and shared by both calls to g
845 isInheritablePred (ClassP _ _) = True
846 isInheritablePred other = False
848 isLinearPred :: TcPredType -> Bool
849 isLinearPred (IParam (Linear n) _) = True
850 isLinearPred other = False
853 --------------------- The stupid theta (sigh) ---------------------------------
856 dataConsStupidTheta :: [DataCon] -> ThetaType
857 -- Union the stupid thetas from all the specified constructors (non-empty)
858 -- All the constructors should have the same result type, modulo alpha conversion
859 -- The resulting ThetaType uses type variables from the *first* constructor in the list
861 -- It's here because it's used in MkId.mkRecordSelId, and in TcExpr
862 dataConsStupidTheta (con1:cons)
863 = nubBy tcEqPred all_preds
865 all_preds = dataConStupidTheta con1 ++ other_stupids
866 res_tys1 = dataConResTys con1
867 tvs1 = tyVarsOfTypes res_tys1
868 other_stupids = [ substPred subst pred
870 , let Just subst = tcMatchTys tvs1 res_tys1 (dataConResTys con)
871 , pred <- dataConStupidTheta con ]
875 %************************************************************************
877 \subsection{Predicates}
879 %************************************************************************
881 isSigmaTy returns true of any qualified type. It doesn't *necessarily* have
883 f :: (?x::Int) => Int -> Int
886 isSigmaTy :: Type -> Bool
887 isSigmaTy ty | Just ty' <- tcView ty = isSigmaTy ty'
888 isSigmaTy (ForAllTy tyvar ty) = True
889 isSigmaTy (FunTy a b) = isPredTy a
892 isOverloadedTy :: Type -> Bool
893 isOverloadedTy ty | Just ty' <- tcView ty = isOverloadedTy ty'
894 isOverloadedTy (ForAllTy tyvar ty) = isOverloadedTy ty
895 isOverloadedTy (FunTy a b) = isPredTy a
896 isOverloadedTy _ = False
898 isPredTy :: Type -> Bool -- Belongs in TcType because it does
899 -- not look through newtypes, or predtypes (of course)
900 isPredTy ty | Just ty' <- tcView ty = isPredTy ty'
901 isPredTy (PredTy sty) = True
906 isFloatTy = is_tc floatTyConKey
907 isDoubleTy = is_tc doubleTyConKey
908 isIntegerTy = is_tc integerTyConKey
909 isIntTy = is_tc intTyConKey
910 isBoolTy = is_tc boolTyConKey
911 isUnitTy = is_tc unitTyConKey
913 is_tc :: Unique -> Type -> Bool
914 -- Newtypes are opaque to this
915 is_tc uniq ty = case tcSplitTyConApp_maybe ty of
916 Just (tc, _) -> uniq == getUnique tc
921 %************************************************************************
925 %************************************************************************
928 deNoteType :: Type -> Type
929 -- Remove all *outermost* type synonyms and other notes
930 deNoteType ty | Just ty' <- tcView ty = deNoteType ty'
935 tcTyVarsOfType :: Type -> TcTyVarSet
936 -- Just the tc type variables free in the type
937 tcTyVarsOfType (TyVarTy tv) = if isTcTyVar tv then unitVarSet tv
939 tcTyVarsOfType (TyConApp tycon tys) = tcTyVarsOfTypes tys
940 tcTyVarsOfType (NoteTy _ ty) = tcTyVarsOfType ty
941 tcTyVarsOfType (PredTy sty) = tcTyVarsOfPred sty
942 tcTyVarsOfType (FunTy arg res) = tcTyVarsOfType arg `unionVarSet` tcTyVarsOfType res
943 tcTyVarsOfType (AppTy fun arg) = tcTyVarsOfType fun `unionVarSet` tcTyVarsOfType arg
944 tcTyVarsOfType (ForAllTy tyvar ty) = tcTyVarsOfType ty `delVarSet` tyvar
945 -- We do sometimes quantify over skolem TcTyVars
947 tcTyVarsOfTypes :: [Type] -> TyVarSet
948 tcTyVarsOfTypes tys = foldr (unionVarSet.tcTyVarsOfType) emptyVarSet tys
950 tcTyVarsOfPred :: PredType -> TyVarSet
951 tcTyVarsOfPred (IParam _ ty) = tcTyVarsOfType ty
952 tcTyVarsOfPred (ClassP _ tys) = tcTyVarsOfTypes tys
955 Note [Silly type synonym]
956 ~~~~~~~~~~~~~~~~~~~~~~~~~
959 What are the free tyvars of (T x)? Empty, of course!
960 Here's the example that Ralf Laemmel showed me:
961 foo :: (forall a. C u a -> C u a) -> u
962 mappend :: Monoid u => u -> u -> u
965 bar = foo (\t -> t `mappend` t)
966 We have to generalise at the arg to f, and we don't
967 want to capture the constraint (Monad (C u a)) because
968 it appears to mention a. Pretty silly, but it was useful to him.
970 exactTyVarsOfType is used by the type checker to figure out exactly
971 which type variables are mentioned in a type. It's also used in the
972 smart-app checking code --- see TcExpr.tcIdApp
975 exactTyVarsOfType :: TcType -> TyVarSet
976 -- Find the free type variables (of any kind)
977 -- but *expand* type synonyms. See Note [Silly type synonym] above.
981 go ty | Just ty' <- tcView ty = go ty' -- This is the key line
982 go (TyVarTy tv) = unitVarSet tv
983 go (TyConApp tycon tys) = exactTyVarsOfTypes tys
984 go (PredTy ty) = go_pred ty
985 go (FunTy arg res) = go arg `unionVarSet` go res
986 go (AppTy fun arg) = go fun `unionVarSet` go arg
987 go (ForAllTy tyvar ty) = delVarSet (go ty) tyvar
989 go_pred (IParam _ ty) = go ty
990 go_pred (ClassP _ tys) = exactTyVarsOfTypes tys
992 exactTyVarsOfTypes :: [TcType] -> TyVarSet
993 exactTyVarsOfTypes tys = foldr (unionVarSet . exactTyVarsOfType) emptyVarSet tys
996 Find the free tycons and classes of a type. This is used in the front
1000 tyClsNamesOfType :: Type -> NameSet
1001 tyClsNamesOfType (TyVarTy tv) = emptyNameSet
1002 tyClsNamesOfType (TyConApp tycon tys) = unitNameSet (getName tycon) `unionNameSets` tyClsNamesOfTypes tys
1003 tyClsNamesOfType (NoteTy _ ty2) = tyClsNamesOfType ty2
1004 tyClsNamesOfType (PredTy (IParam n ty)) = tyClsNamesOfType ty
1005 tyClsNamesOfType (PredTy (ClassP cl tys)) = unitNameSet (getName cl) `unionNameSets` tyClsNamesOfTypes tys
1006 tyClsNamesOfType (FunTy arg res) = tyClsNamesOfType arg `unionNameSets` tyClsNamesOfType res
1007 tyClsNamesOfType (AppTy fun arg) = tyClsNamesOfType fun `unionNameSets` tyClsNamesOfType arg
1008 tyClsNamesOfType (ForAllTy tyvar ty) = tyClsNamesOfType ty
1010 tyClsNamesOfTypes tys = foldr (unionNameSets . tyClsNamesOfType) emptyNameSet tys
1012 tyClsNamesOfDFunHead :: Type -> NameSet
1013 -- Find the free type constructors and classes
1014 -- of the head of the dfun instance type
1015 -- The 'dfun_head_type' is because of
1016 -- instance Foo a => Baz T where ...
1017 -- The decl is an orphan if Baz and T are both not locally defined,
1018 -- even if Foo *is* locally defined
1019 tyClsNamesOfDFunHead dfun_ty
1020 = case tcSplitSigmaTy dfun_ty of
1021 (tvs,_,head_ty) -> tyClsNamesOfType head_ty
1023 classesOfTheta :: ThetaType -> [Class]
1024 -- Looks just for ClassP things; maybe it should check
1025 classesOfTheta preds = [ c | ClassP c _ <- preds ]
1029 %************************************************************************
1031 \subsection[TysWiredIn-ext-type]{External types}
1033 %************************************************************************
1035 The compiler's foreign function interface supports the passing of a
1036 restricted set of types as arguments and results (the restricting factor
1040 tcSplitIOType_maybe :: Type -> Maybe (TyCon, Type)
1041 -- (isIOType t) returns (Just (IO,t')) if t is of the form (IO t'), or
1042 -- some newtype wrapping thereof
1043 -- returns Nothing otherwise
1044 tcSplitIOType_maybe ty
1045 | Just (io_tycon, [io_res_ty]) <- tcSplitTyConApp_maybe ty,
1046 -- This split absolutely has to be a tcSplit, because we must
1047 -- see the IO type; and it's a newtype which is transparent to splitTyConApp.
1048 io_tycon `hasKey` ioTyConKey
1049 = Just (io_tycon, io_res_ty)
1051 | Just ty' <- coreView ty -- Look through non-recursive newtypes
1052 = tcSplitIOType_maybe ty'
1057 isFFITy :: Type -> Bool
1058 -- True for any TyCon that can possibly be an arg or result of an FFI call
1059 isFFITy ty = checkRepTyCon legalFFITyCon ty
1061 isFFIArgumentTy :: DynFlags -> Safety -> Type -> Bool
1062 -- Checks for valid argument type for a 'foreign import'
1063 isFFIArgumentTy dflags safety ty
1064 = checkRepTyCon (legalOutgoingTyCon dflags safety) ty
1066 isFFIExternalTy :: Type -> Bool
1067 -- Types that are allowed as arguments of a 'foreign export'
1068 isFFIExternalTy ty = checkRepTyCon legalFEArgTyCon ty
1070 isFFIImportResultTy :: DynFlags -> Type -> Bool
1071 isFFIImportResultTy dflags ty
1072 = checkRepTyCon (legalFIResultTyCon dflags) ty
1074 isFFIExportResultTy :: Type -> Bool
1075 isFFIExportResultTy ty = checkRepTyCon legalFEResultTyCon ty
1077 isFFIDynArgumentTy :: Type -> Bool
1078 -- The argument type of a foreign import dynamic must be Ptr, FunPtr, Addr,
1079 -- or a newtype of either.
1080 isFFIDynArgumentTy = checkRepTyConKey [ptrTyConKey, funPtrTyConKey]
1082 isFFIDynResultTy :: Type -> Bool
1083 -- The result type of a foreign export dynamic must be Ptr, FunPtr, Addr,
1084 -- or a newtype of either.
1085 isFFIDynResultTy = checkRepTyConKey [ptrTyConKey, funPtrTyConKey]
1087 isFFILabelTy :: Type -> Bool
1088 -- The type of a foreign label must be Ptr, FunPtr, Addr,
1089 -- or a newtype of either.
1090 isFFILabelTy = checkRepTyConKey [ptrTyConKey, funPtrTyConKey]
1092 isFFIDotnetTy :: DynFlags -> Type -> Bool
1093 isFFIDotnetTy dflags ty
1094 = checkRepTyCon (\ tc -> (legalFIResultTyCon dflags tc ||
1095 isFFIDotnetObjTy ty || isStringTy ty)) ty
1097 -- Support String as an argument or result from a .NET FFI call.
1099 case tcSplitTyConApp_maybe (repType ty) of
1101 | tc == listTyCon ->
1102 case tcSplitTyConApp_maybe (repType arg_ty) of
1103 Just (cc,[]) -> cc == charTyCon
1107 -- Support String as an argument or result from a .NET FFI call.
1108 isFFIDotnetObjTy ty =
1110 (_, t_ty) = tcSplitForAllTys ty
1112 case tcSplitTyConApp_maybe (repType t_ty) of
1113 Just (tc, [arg_ty]) | getName tc == objectTyConName -> True
1116 toDNType :: Type -> DNType
1118 | isStringTy ty = DNString
1119 | isFFIDotnetObjTy ty = DNObject
1120 | Just (tc,argTys) <- tcSplitTyConApp_maybe ty =
1121 case lookup (getUnique tc) dn_assoc of
1124 | tc `hasKey` ioTyConKey -> toDNType (head argTys)
1125 | otherwise -> pprPanic ("toDNType: unsupported .NET type") (pprType ty <+> parens (hcat (map pprType argTys)) <+> ppr tc)
1127 dn_assoc :: [ (Unique, DNType) ]
1128 dn_assoc = [ (unitTyConKey, DNUnit)
1129 , (intTyConKey, DNInt)
1130 , (int8TyConKey, DNInt8)
1131 , (int16TyConKey, DNInt16)
1132 , (int32TyConKey, DNInt32)
1133 , (int64TyConKey, DNInt64)
1134 , (wordTyConKey, DNInt)
1135 , (word8TyConKey, DNWord8)
1136 , (word16TyConKey, DNWord16)
1137 , (word32TyConKey, DNWord32)
1138 , (word64TyConKey, DNWord64)
1139 , (floatTyConKey, DNFloat)
1140 , (doubleTyConKey, DNDouble)
1141 , (ptrTyConKey, DNPtr)
1142 , (funPtrTyConKey, DNPtr)
1143 , (charTyConKey, DNChar)
1144 , (boolTyConKey, DNBool)
1147 checkRepTyCon :: (TyCon -> Bool) -> Type -> Bool
1148 -- Look through newtypes
1149 -- Non-recursive ones are transparent to splitTyConApp,
1150 -- but recursive ones aren't. Manuel had:
1151 -- newtype T = MkT (Ptr T)
1152 -- and wanted it to work...
1153 checkRepTyCon check_tc ty
1154 | Just (tc,_) <- splitTyConApp_maybe (repType ty) = check_tc tc
1157 checkRepTyConKey :: [Unique] -> Type -> Bool
1158 -- Like checkRepTyCon, but just looks at the TyCon key
1159 checkRepTyConKey keys
1160 = checkRepTyCon (\tc -> tyConUnique tc `elem` keys)
1163 ----------------------------------------------
1164 These chaps do the work; they are not exported
1165 ----------------------------------------------
1168 legalFEArgTyCon :: TyCon -> Bool
1170 -- It's illegal to make foreign exports that take unboxed
1171 -- arguments. The RTS API currently can't invoke such things. --SDM 7/2000
1172 = boxedMarshalableTyCon tc
1174 legalFIResultTyCon :: DynFlags -> TyCon -> Bool
1175 legalFIResultTyCon dflags tc
1176 | tc == unitTyCon = True
1177 | otherwise = marshalableTyCon dflags tc
1179 legalFEResultTyCon :: TyCon -> Bool
1180 legalFEResultTyCon tc
1181 | tc == unitTyCon = True
1182 | otherwise = boxedMarshalableTyCon tc
1184 legalOutgoingTyCon :: DynFlags -> Safety -> TyCon -> Bool
1185 -- Checks validity of types going from Haskell -> external world
1186 legalOutgoingTyCon dflags safety tc
1187 = marshalableTyCon dflags tc
1189 legalFFITyCon :: TyCon -> Bool
1190 -- True for any TyCon that can possibly be an arg or result of an FFI call
1192 = isUnLiftedTyCon tc || boxedMarshalableTyCon tc || tc == unitTyCon
1194 marshalableTyCon dflags tc
1195 = (dopt Opt_GlasgowExts dflags && isUnLiftedTyCon tc)
1196 || boxedMarshalableTyCon tc
1198 boxedMarshalableTyCon tc
1199 = getUnique tc `elem` [ intTyConKey, int8TyConKey, int16TyConKey
1200 , int32TyConKey, int64TyConKey
1201 , wordTyConKey, word8TyConKey, word16TyConKey
1202 , word32TyConKey, word64TyConKey
1203 , floatTyConKey, doubleTyConKey
1204 , ptrTyConKey, funPtrTyConKey