ghc/compiler/coreSyn/CoreSyn.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1996
   3 %
   4 \section[CoreSyn]{A data type for the Haskell compiler midsection}
   5
   6 \begin{code}
   7 #include "HsVersions.h"
   8
   9 module CoreSyn (
  10         GenCoreBinding(..), GenCoreExpr(..),
  11         GenCoreArg(..), GenCoreBinder(..), GenCoreCaseAlts(..),
  12         GenCoreCaseDefault(..),
  13         Coercion(..),
  14
  15         bindersOf, pairsFromCoreBinds, rhssOfBind,
  16
  17         mkGenApp, mkValApp, mkTyApp, mkUseApp,
  18         mkApp, mkCon, mkPrim,
  19         mkValLam, mkTyLam, mkUseLam,
  20         mkLam,
  21         collectBinders, collectUsageAndTyBinders, collectValBinders,
  22         isValBinder, notValBinder,
  23
  24         collectArgs, initialTyArgs, initialValArgs, isValArg, notValArg, numValArgs,
  25
  26         mkCoLetAny, mkCoLetNoUnboxed, mkCoLetUnboxedToCase,
  27         mkCoLetsAny, mkCoLetsNoUnboxed, mkCoLetsUnboxedToCase,
  28         mkCoLetrecAny, mkCoLetrecNoUnboxed,
  29
  30         rhssOfAlts,
  31
  32         -- Common type instantiation...
  33         SYN_IE(CoreBinding),
  34         SYN_IE(CoreExpr),
  35         SYN_IE(CoreBinder),
  36         SYN_IE(CoreArg),
  37         SYN_IE(CoreCaseAlts),
  38         SYN_IE(CoreCaseDefault),
  39
  40         -- And not-so-common type instantiations...
  41         SYN_IE(TaggedCoreBinding),
  42         SYN_IE(TaggedCoreExpr),
  43         SYN_IE(TaggedCoreBinder),
  44         SYN_IE(TaggedCoreArg),
  45         SYN_IE(TaggedCoreCaseAlts),
  46         SYN_IE(TaggedCoreCaseDefault),
  47
  48         SYN_IE(SimplifiableCoreBinding),
  49         SYN_IE(SimplifiableCoreExpr),
  50         SYN_IE(SimplifiableCoreBinder),
  51         SYN_IE(SimplifiableCoreArg),
  52         SYN_IE(SimplifiableCoreCaseAlts),
  53         SYN_IE(SimplifiableCoreCaseDefault)
  54     ) where
  55
  56 IMP_Ubiq(){-uitous-}
  57
  58 import CostCentre       ( showCostCentre, CostCentre )
  59 import Id               ( idType, GenId{-instance Eq-}, SYN_IE(Id) )
  60 import Type             ( isUnboxedType,GenType, SYN_IE(Type) )
  61 import TyVar            ( GenTyVar, SYN_IE(TyVar) )
  62 import Usage            ( SYN_IE(UVar),GenUsage,SYN_IE(Usage) )
  63 import Util             ( panic, assertPanic {-pprTrace:ToDo:rm-} )
  64 #if __GLASGOW_HASKELL__ >= 202
  65 import Literal          ( Literal )
  66 import BinderInfo       ( BinderInfo )
  67 import PrimOp           ( PrimOp )
  68 #endif
  69 \end{code}
  70
  71 %************************************************************************
  72 %*                                                                      *
  73 \subsection[CoreTopBinding_and_CoreBinding]{@CoreTopBinding@ and @GenCoreBinding@}
  74 %*                                                                      *
  75 %************************************************************************
  76
  77 Core programs, bindings, expressions, etc., are parameterised with
  78 respect to the information kept about binding and bound occurrences of
  79 variables, called {\em binders} and {\em val_occ tyvar uvars}, respectively.  [I
  80 don't really like the pair of names; I prefer {\em binder} and {\em
  81 bounder}.  Or {\em binder} and {\em var}.]
  82
  83 A @GenCoreBinding@ is either a single non-recursive binding of a
  84 ``binder'' to an expression, or a mutually-recursive blob of same.
  85 \begin{code}
  86 data GenCoreBinding val_bdr val_occ tyvar uvar
  87   = NonRec      val_bdr (GenCoreExpr val_bdr val_occ tyvar uvar)
  88   | Rec         [(val_bdr, GenCoreExpr val_bdr val_occ tyvar uvar)]
  89 \end{code}
  90
  91 \begin{code}
  92 bindersOf :: GenCoreBinding val_bdr val_occ tyvar uvar -> [val_bdr]
  93
  94 pairsFromCoreBinds ::
  95   [GenCoreBinding val_bdr val_occ tyvar uvar] ->
  96   [(val_bdr, GenCoreExpr val_bdr val_occ tyvar uvar)]
  97
  98 rhssOfBind :: GenCoreBinding val_bdr val_occ tyvar uvar -> [GenCoreExpr val_bdr val_occ tyvar uvar]
  99
 100 bindersOf (NonRec binder _) = [binder]
 101 bindersOf (Rec pairs)       = [binder | (binder, _) <- pairs]
 102
 103 pairsFromCoreBinds []                  = []
 104 pairsFromCoreBinds ((NonRec b e) : bs) = (b,e) :  pairsFromCoreBinds bs
 105 pairsFromCoreBinds ((Rec  pairs) : bs) = pairs ++ pairsFromCoreBinds bs
 106
 107 rhssOfBind (NonRec _ rhs) = [rhs]
 108 rhssOfBind (Rec pairs)    = [rhs | (_,rhs) <- pairs]
 109 \end{code}
 110
 111 %************************************************************************
 112 %*                                                                      *
 113 \subsection[GenCoreExpr]{Core expressions: @GenCoreExpr@}
 114 %*                                                                      *
 115 %************************************************************************
 116
 117 @GenCoreExpr@ is the heart of the ``core'' data types; it is
 118 (more-or-less) boiled-down second-order polymorphic lambda calculus.
 119 For types in the core world, we just keep using @Types@.
 120 \begin{code}
 121 data GenCoreExpr val_bdr val_occ tyvar uvar
 122      = Var    val_occ
 123      | Lit    Literal   -- literal constants
 124 \end{code}
 125
 126 @Cons@ and @Prims@ are saturated constructor and primitive-op
 127 applications (see the comment).  Note: @Con@s are only set up by the
 128 simplifier (and by the desugarer when it knows what it's doing).  The
 129 desugarer sets up constructors as applications of global @Vars@s.
 130
 131 \begin{code}
 132      | Con      Id [GenCoreArg val_occ tyvar uvar]
 133                 -- Saturated constructor application:
 134                 -- The constructor is a function of the form:
 135                 --      /\ a1 -> ... /\ am -> \ b1 -> ... \ bn ->
 136                 -- <expr> where "/\" is a type lambda and "\" the
 137                 -- regular kind; there will be "m" Types and
 138                 -- "n" bindees in the Con args.
 139
 140      | Prim     PrimOp [GenCoreArg val_occ tyvar uvar]
 141                 -- saturated primitive operation;
 142
 143                 -- comment on Cons applies here, too.
 144 \end{code}
 145
 146 Ye olde abstraction and application operators.
 147 \begin{code}
 148      | Lam      (GenCoreBinder val_bdr tyvar uvar)
 149                 (GenCoreExpr   val_bdr val_occ tyvar uvar)
 150
 151      | App      (GenCoreExpr val_bdr val_occ tyvar uvar)
 152                 (GenCoreArg  val_occ tyvar uvar)
 153 \end{code}
 154
 155 Case expressions (\tr{case <expr> of <List of alternatives>}): there
 156 are really two flavours masquerading here---those for scrutinising
 157 {\em algebraic} types and those for {\em primitive} types.  Please see
 158 under @GenCoreCaseAlts@.
 159 \begin{code}
 160      | Case     (GenCoreExpr val_bdr val_occ tyvar uvar)
 161                 (GenCoreCaseAlts val_bdr val_occ tyvar uvar)
 162 \end{code}
 163
 164 A Core case expression \tr{case e of v -> ...} implies evaluation of
 165 \tr{e}; it is not equivalent to \tr{let v = in ...} (as with a Haskell
 166 \tr{case}).
 167
 168 Non-recursive @Lets@ only have one binding; having more than one
 169 doesn't buy you much, and it is an easy way to mess up variable
 170 scoping.
 171 \begin{code}
 172      | Let      (GenCoreBinding val_bdr val_occ tyvar uvar)
 173                 (GenCoreExpr val_bdr val_occ tyvar uvar)
 174                 -- both recursive and non-.
 175                 -- The "GenCoreBinding" records that information
 176 \end{code}
 177
 178 For cost centre scc expressions we introduce a new core construct
 179 @SCC@ so transforming passes have to deal with it explicitly. The
 180 alternative of using a new PrimativeOp may result in a bad
 181 transformations of which we are unaware.
 182 \begin{code}
 183      | SCC      CostCentre                                  -- label of scc
 184                 (GenCoreExpr val_bdr val_occ tyvar uvar)    -- scc expression
 185 \end{code}
 186
 187 Coercions arise from uses of the constructor of a @newtype@
 188 declaration, either in construction (resulting in a @CoreceIn@) or
 189 pattern matching (resulting in a @CoerceOut@).
 190
 191 \begin{code}
 192     | Coerce    Coercion
 193                 (GenType tyvar uvar)            -- Type of the whole expression
 194                 (GenCoreExpr val_bdr val_occ tyvar uvar)
 195 \end{code}
 196
 197 \begin{code}
 198 data Coercion   = CoerceIn Id           -- Apply this constructor
 199                 | CoerceOut Id          -- Strip this constructor
 200 \end{code}
 201
 202
 203 %************************************************************************
 204 %*                                                                      *
 205 \subsection{Core-constructing functions with checking}
 206 %*                                                                      *
 207 %************************************************************************
 208
 209 When making @Lets@, we may want to take evasive action if the thing
 210 being bound has unboxed type. We have different variants ...
 211
 212 @mkCoLet(s|rec)Any@             let-binds any binding, regardless of type
 213 @mkCoLet(s|rec)NoUnboxed@       prohibits unboxed bindings
 214 @mkCoLet(s)UnboxedToCase@       converts an unboxed binding to a case
 215                                 (unboxed bindings in a letrec are still prohibited)
 216
 217 \begin{code}
 218 mkCoLetAny :: GenCoreBinding Id Id tyvar uvar
 219            -> GenCoreExpr    Id Id tyvar uvar
 220            -> GenCoreExpr    Id Id tyvar uvar
 221 mkCoLetsAny :: [GenCoreBinding Id Id tyvar uvar] ->
 222                 GenCoreExpr Id Id tyvar uvar ->
 223                 GenCoreExpr Id Id tyvar uvar
 224
 225 mkCoLetrecAny :: [(val_bdr, GenCoreExpr val_bdr val_occ tyvar uvar)]
 226               -> GenCoreExpr val_bdr val_occ tyvar uvar
 227               -> GenCoreExpr val_bdr val_occ tyvar uvar
 228
 229 mkCoLetrecAny []    body = body
 230 mkCoLetrecAny binds body = Let (Rec binds) body
 231
 232 mkCoLetsAny []    expr = expr
 233 mkCoLetsAny binds expr = foldr mkCoLetAny expr binds
 234
 235 mkCoLetAny bind@(Rec binds)         body = mkCoLetrecAny binds body
 236 mkCoLetAny bind@(NonRec binder rhs) body = Let bind body
 237 \end{code}
 238
 239 \begin{code}
 240 mkCoLetNoUnboxed bind@(Rec binds) body
 241   = mkCoLetrecNoUnboxed binds body
 242
 243 mkCoLetNoUnboxed bind@(NonRec binder rhs) body
 244   = --ASSERT (not (isUnboxedType (idType binder)))
 245     case body of
 246       Var binder2 | binder == binder2
 247          -> rhs   -- hey, I have the rhs
 248       other
 249          -> Let bind body
 250
 251 mkCoLetsNoUnboxed []    expr = expr
 252 mkCoLetsNoUnboxed binds expr = foldr mkCoLetNoUnboxed expr binds
 253
 254 mkCoLetrecNoUnboxed []    body = body
 255 mkCoLetrecNoUnboxed binds body
 256   = ASSERT (all is_boxed_bind binds)
 257     Let (Rec binds) body
 258   where
 259     is_boxed_bind (binder, rhs)
 260       = (not . isUnboxedType . idType) binder
 261 \end{code}
 262
 263 \begin{code}
 264 mkCoLetUnboxedToCase bind@(Rec binds) body
 265   = mkCoLetrecNoUnboxed binds body
 266
 267 mkCoLetUnboxedToCase bind@(NonRec binder rhs) body
 268   = case body of
 269       Var binder2 | binder == binder2
 270          -> rhs   -- hey, I have the rhs
 271       other
 272          -> if (not (isUnboxedType (idType binder))) then
 273                 Let bind body            -- boxed...
 274             else
 275                 Case rhs                  -- unboxed...
 276                   (PrimAlts []
 277                     (BindDefault binder body))
 278
 279 mkCoLetsUnboxedToCase []    expr = expr
 280 mkCoLetsUnboxedToCase binds expr = foldr mkCoLetUnboxedToCase expr binds
 281 \end{code}
 282
 283 %************************************************************************
 284 %*                                                                      *
 285 \subsection{Case alternatives in @GenCoreExpr@}
 286 %*                                                                      *
 287 %************************************************************************
 288
 289 We have different kinds of @case@s, the differences being reflected in
 290 the kinds of alternatives a case has.  We maintain a distinction
 291 between cases for scrutinising algebraic datatypes, as opposed to
 292 primitive types.  In both cases, we carry around a @TyCon@, as a
 293 handle with which we can get info about the case (e.g., total number
 294 of data constructors for this type).
 295
 296 For example:
 297 \begin{verbatim}
 298 let# x=e in b
 299 \end{verbatim}
 300 becomes
 301 \begin{verbatim}
 302 Case e [ BindDefaultAlt x -> b ]
 303 \end{verbatim}
 304
 305 \begin{code}
 306 data GenCoreCaseAlts val_bdr val_occ tyvar uvar
 307   = AlgAlts     [(Id,                           -- alts: data constructor,
 308                   [val_bdr],                    -- constructor's parameters,
 309                   GenCoreExpr val_bdr val_occ tyvar uvar)]      -- rhs.
 310                 (GenCoreCaseDefault val_bdr val_occ tyvar uvar)
 311
 312   | PrimAlts    [(Literal,                      -- alts: unboxed literal,
 313                   GenCoreExpr val_bdr val_occ tyvar uvar)]      -- rhs.
 314                 (GenCoreCaseDefault val_bdr val_occ tyvar uvar)
 315
 316 -- obvious things: if there are no alts in the list, then the default
 317 -- can't be NoDefault.
 318
 319 data GenCoreCaseDefault val_bdr val_occ tyvar uvar
 320   = NoDefault                                   -- small con family: all
 321                                                 -- constructor accounted for
 322   | BindDefault val_bdr                         -- form: var -> expr;
 323                 (GenCoreExpr val_bdr val_occ tyvar uvar)        -- "val_bdr" may or may not
 324                                                 -- be used in RHS.
 325 \end{code}
 326
 327 \begin{code}
 328 rhssOfAlts (AlgAlts alts deflt)  = rhssOfDeflt deflt ++ [rhs | (_,_,rhs) <- alts]
 329 rhssOfAlts (PrimAlts alts deflt) = rhssOfDeflt deflt ++ [rhs | (_,rhs)   <- alts]
 330
 331 rhssOfDeflt NoDefault           = []
 332 rhssOfDeflt (BindDefault _ rhs) = [rhs]
 333 \end{code}
 334
 335 %************************************************************************
 336 %*                                                                      *
 337 \subsection{Core binders}
 338 %*                                                                      *
 339 %************************************************************************
 340
 341 \begin{code}
 342 data GenCoreBinder val_bdr tyvar uvar
 343   = ValBinder   val_bdr
 344   | TyBinder    tyvar
 345   | UsageBinder uvar
 346
 347 isValBinder (ValBinder _) = True
 348 isValBinder _             = False
 349
 350 notValBinder = not . isValBinder
 351 \end{code}
 352
 353 Clump Lams together if possible.
 354
 355 \begin{code}
 356 mkValLam :: [val_bdr]
 357          -> GenCoreExpr val_bdr val_occ tyvar uvar
 358          -> GenCoreExpr val_bdr val_occ tyvar uvar
 359 mkTyLam  :: [tyvar]
 360          -> GenCoreExpr val_bdr val_occ tyvar uvar
 361          -> GenCoreExpr val_bdr val_occ tyvar uvar
 362 mkUseLam :: [uvar]
 363          -> GenCoreExpr val_bdr val_occ tyvar uvar
 364          -> GenCoreExpr val_bdr val_occ tyvar uvar
 365
 366 mkValLam binders body = foldr (Lam . ValBinder)   body binders
 367 mkTyLam  binders body = foldr (Lam . TyBinder)    body binders
 368 mkUseLam binders body = foldr (Lam . UsageBinder) body binders
 369
 370 mkLam :: [tyvar] -> [val_bdr] -- ToDo: could add a [uvar] arg...
 371          -> GenCoreExpr val_bdr val_occ tyvar uvar
 372          -> GenCoreExpr val_bdr val_occ tyvar uvar
 373
 374 mkLam tyvars valvars body
 375   = mkTyLam tyvars (mkValLam valvars body)
 376 \end{code}
 377
 378 We often want to strip off leading lambdas before getting down to
 379 business.  @collectBinders@ is your friend.
 380
 381 We expect (by convention) usage-, type-, and value- lambdas in that
 382 order.
 383
 384 \begin{code}
 385 collectBinders ::
 386   GenCoreExpr val_bdr val_occ tyvar uvar ->
 387   ([uvar], [tyvar], [val_bdr], GenCoreExpr val_bdr val_occ tyvar uvar)
 388
 389 collectBinders expr
 390   = case collectValBinders body1 of { (vals,body) -> (usages, tyvars, vals, body) }
 391   where
 392     (usages, tyvars, body1) = collectUsageAndTyBinders expr
 393 --    (vals, body)          = collectValBinders body1
 394
 395
 396 collectUsageAndTyBinders expr
 397   = case usages expr [] of
 398       ([],tyvars,body) -> ([],tyvars,body)
 399       v                -> v
 400   where
 401     usages (Lam (UsageBinder u) body) uacc = usages body (u:uacc)
 402     usages other uacc
 403       = case (tyvars other []) of { (tacc, expr) ->
 404         (reverse uacc, tacc, expr) }
 405
 406     tyvars (Lam (TyBinder t) body) tacc = tyvars body (t:tacc)
 407     tyvars other tacc
 408       = ASSERT(not (usage_lambda other))
 409         (reverse tacc, other)
 410
 411     ---------------------------------------
 412     usage_lambda (Lam (UsageBinder _) _) = True
 413     usage_lambda _                       = False
 414
 415     tyvar_lambda (Lam (TyBinder _) _)    = True
 416     tyvar_lambda _                       = False
 417
 418
 419 collectValBinders :: GenCoreExpr val_bdr val_occ tyvar uvar ->
 420                      ([val_bdr], GenCoreExpr val_bdr val_occ tyvar uvar)
 421 collectValBinders expr
 422   = case go [] expr of
 423       ([],body) -> ([],body)
 424       v         -> v
 425   where
 426     go acc (Lam (ValBinder v) b) = go (v:acc) b
 427     go acc body                  = (reverse acc, body)
 428
 429 \end{code}
 430
 431 %************************************************************************
 432 %*                                                                      *
 433 \subsection{Core arguments (atoms)}
 434 %*                                                                      *
 435 %************************************************************************
 436
 437 \begin{code}
 438 data GenCoreArg val_occ tyvar uvar
 439   = LitArg      Literal
 440   | VarArg      val_occ
 441   | TyArg       (GenType tyvar uvar)
 442   | UsageArg    (GenUsage uvar)
 443 \end{code}
 444
 445 General and specific forms:
 446 \begin{code}
 447 mkGenApp :: GenCoreExpr val_bdr val_occ tyvar uvar
 448          -> [GenCoreArg val_occ tyvar uvar]
 449          -> GenCoreExpr val_bdr val_occ tyvar uvar
 450 mkTyApp  :: GenCoreExpr val_bdr val_occ tyvar uvar
 451          -> [GenType tyvar uvar]
 452          -> GenCoreExpr val_bdr val_occ tyvar uvar
 453 mkUseApp :: GenCoreExpr val_bdr val_occ tyvar uvar
 454          -> [GenUsage uvar]
 455          -> GenCoreExpr val_bdr val_occ tyvar uvar
 456 mkValApp :: GenCoreExpr val_bdr val_occ tyvar uvar
 457          -> [GenCoreArg val_occ tyvar uvar] -- but we ASSERT they are LitArg or VarArg
 458          -> GenCoreExpr val_bdr val_occ tyvar uvar
 459
 460 mkGenApp f args = foldl App                                f args
 461 mkTyApp  f args = foldl (\ e a -> App e (TyArg a))         f args
 462 mkUseApp f args = foldl (\ e a -> App e (UsageArg a))      f args
 463 mkValApp f args = foldl (\ e a -> App e (is_Lit_or_Var a)) f args
 464
 465 #ifndef DEBUG
 466 is_Lit_or_Var a = a
 467 #else
 468 is_Lit_or_Var a
 469   = if isValArg a then a else panic "CoreSyn.mkValApps:not LitArg or VarArg"
 470 #endif
 471
 472 isValArg (LitArg _) = True  -- often used for sanity-checking
 473 isValArg (VarArg _) = True
 474 isValArg _          = False
 475
 476 notValArg = not . isValArg -- exists only because it's a common use of isValArg
 477
 478 numValArgs as = length [ a | a <- as, isValArg a ] -- again, convenience
 479 \end{code}
 480
 481 \begin{code}
 482 mkApp  fun = mk_thing (mkGenApp fun)
 483 mkCon  con = mk_thing (Con      con)
 484 mkPrim op  = mk_thing (Prim     op)
 485
 486 mk_thing thing uses tys vals
 487   = thing (map UsageArg uses ++ map TyArg tys ++ map is_Lit_or_Var vals)
 488 \end{code}
 489
 490 @collectArgs@ takes an application expression, returning the function
 491 and the arguments to which it is applied.
 492
 493 \begin{code}
 494 collectArgs :: GenCoreExpr val_bdr val_occ tyvar uvar
 495             -> (GenCoreExpr val_bdr val_occ tyvar uvar,
 496                 [GenUsage uvar],
 497                 [GenType tyvar uvar],
 498                 [GenCoreArg val_occ tyvar uvar]{-ValArgs-})
 499
 500 collectArgs expr
 501   = valvars expr []
 502   where
 503     valvars (App fun v) vacc | isValArg v = valvars fun (v:vacc)
 504     valvars fun vacc
 505       = case (tyvars fun []) of { (expr, uacc, tacc) ->
 506         (expr, uacc, tacc, vacc) }
 507
 508     tyvars (App fun (TyArg t))    tacc = tyvars fun (t:tacc)
 509     tyvars fun tacc
 510       = case (usages fun []) of { (expr, uacc) ->
 511         (expr, uacc, tacc) }
 512
 513     usages (App fun (UsageArg u)) uacc = usages fun (u:uacc)
 514     usages fun uacc
 515       = (fun,uacc)
 516 \end{code}
 517
 518
 519 \begin{code}
 520 initialTyArgs :: [GenCoreArg val_occ tyvar uvar]
 521               -> ([GenType tyvar uvar], [GenCoreArg val_occ tyvar uvar])
 522 initialTyArgs (TyArg ty : args) = (ty:tys, args')
 523                                 where
 524                                   (tys, args') = initialTyArgs args
 525 initialTyArgs other             = ([],other)
 526
 527 initialValArgs :: [GenCoreArg val_occ tyvar uvar]
 528               -> ([GenCoreArg val_occ tyvar uvar], [GenCoreArg val_occ tyvar uvar])
 529 initialValArgs args = span isValArg args
 530 \end{code}
 531
 532
 533 %************************************************************************
 534 %*                                                                      *
 535 \subsection{The main @Core*@ instantiation of the @GenCore*@ types}
 536 %*                                                                      *
 537 %************************************************************************
 538
 539 \begin{code}
 540 type CoreBinding = GenCoreBinding  Id Id TyVar UVar
 541 type CoreExpr    = GenCoreExpr     Id Id TyVar UVar
 542 type CoreBinder  = GenCoreBinder   Id    TyVar UVar
 543 type CoreArg     = GenCoreArg         Id TyVar UVar
 544
 545 type CoreCaseAlts    = GenCoreCaseAlts    Id Id TyVar UVar
 546 type CoreCaseDefault = GenCoreCaseDefault Id Id TyVar UVar
 547 \end{code}
 548
 549 %************************************************************************
 550 %*                                                                      *
 551 \subsection{The @TaggedCore*@ instantiation of the @GenCore*@ types}
 552 %*                                                                      *
 553 %************************************************************************
 554
 555 Binders are ``tagged'' with a \tr{t}:
 556 \begin{code}
 557 type Tagged t = (Id, t)
 558
 559 type TaggedCoreBinding t = GenCoreBinding (Tagged t) Id TyVar UVar
 560 type TaggedCoreExpr    t = GenCoreExpr    (Tagged t) Id TyVar UVar
 561 type TaggedCoreBinder  t = GenCoreBinder  (Tagged t)    TyVar UVar
 562 type TaggedCoreArg     t = GenCoreArg                Id TyVar UVar
 563
 564 type TaggedCoreCaseAlts    t = GenCoreCaseAlts    (Tagged t) Id TyVar UVar
 565 type TaggedCoreCaseDefault t = GenCoreCaseDefault (Tagged t) Id TyVar UVar
 566 \end{code}
 567
 568 %************************************************************************
 569 %*                                                                      *
 570 \subsection{The @SimplifiableCore*@ instantiation of the @GenCore*@ types}
 571 %*                                                                      *
 572 %************************************************************************
 573
 574 Binders are tagged with @BinderInfo@:
 575 \begin{code}
 576 type Simplifiable = (Id, BinderInfo)
 577
 578 type SimplifiableCoreBinding = GenCoreBinding Simplifiable Id TyVar UVar
 579 type SimplifiableCoreExpr    = GenCoreExpr    Simplifiable Id TyVar UVar
 580 type SimplifiableCoreBinder  = GenCoreBinder  Simplifiable    TyVar UVar
 581 type SimplifiableCoreArg     = GenCoreArg                  Id TyVar UVar
 582
 583 type SimplifiableCoreCaseAlts    = GenCoreCaseAlts    Simplifiable Id TyVar UVar
 584 type SimplifiableCoreCaseDefault = GenCoreCaseDefault Simplifiable Id TyVar UVar
 585 \end{code}