isTyVar, isId, cmpAltCon, cmpAlt, ltAlt,
bindersOf, bindersOfBinds, rhssOfBind, rhssOfAlts,
collectBinders, collectTyBinders, collectValBinders, collectTyAndValBinders,
- collectArgs,
- coreExprCc,
- flattenBinds,
+ collectArgs, coreExprCc,
+ mkTyBind, flattenBinds,
isValArg, isTypeArg, valArgCount, valBndrCount, isRuntimeArg, isRuntimeVar,
#include "HsVersions.h"
-import StaticFlags
import CostCentre
import Var
import Type
Invariant: The list of alternatives is ALWAYS EXHAUSTIVE,
meaning that it covers all cases that can occur
- An "exhausive" case does not necessarily mention all constructors:
+ An "exhaustive" case does not necessarily mention all constructors:
data Foo = Red | Green | Blue
...case x of
Note [CoreSyn let goal]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~
* The simplifier tries to ensure that if the RHS of a let is a constructor
application, its arguments are trivial, so that the constructor can be
inlined vigorously.
+Note [Type let]
+~~~~~~~~~~~~~~~
+We allow a *non-recursive* let to bind a type variable, thus
+ Let (NonRec tv (Type ty)) body
+This can be very convenient for postponing type substitutions until
+the next run of the simplifier.
+
+At the moment, the rest of the compiler only deals with type-let
+in a Let expression, rather than at top level. We may want to revist
+this choice.
+
\begin{code}
data Note
= SCC CostCentre
instance Outputable AltCon where
ppr (DataAlt dc) = ppr dc
ppr (LitAlt lit) = ppr lit
- ppr DEFAULT = ptext SLIT("__DEFAULT")
+ ppr DEFAULT = ptext (sLit "__DEFAULT")
instance Show AltCon where
showsPrec p con = showsPrecSDoc p (ppr con)
%************************************************************************
\begin{code}
+mkTyBind :: TyVar -> Type -> CoreBind
+mkTyBind tv ty = NonRec tv (Type ty)
+ -- Note [Type let]
+ -- A non-recursive let can bind a type variable
+
bindersOf :: Bind b -> [b]
bindersOf (NonRec binder _) = [binder]
bindersOf (Rec pairs) = [binder | (binder, _) <- pairs]
%* *
%************************************************************************
+At one time we optionally carried type arguments through to runtime.
@isRuntimeVar v@ returns if (Lam v _) really becomes a lambda at runtime,
i.e. if type applications are actual lambdas because types are kept around
-at runtime.
-
-Similarly isRuntimeArg.
+at runtime. Similarly isRuntimeArg.
\begin{code}
isRuntimeVar :: Var -> Bool
-isRuntimeVar | opt_RuntimeTypes = \_ -> True
- | otherwise = \v -> isId v
+isRuntimeVar = isId
isRuntimeArg :: CoreExpr -> Bool
-isRuntimeArg | opt_RuntimeTypes = \_ -> True
- | otherwise = \e -> isValArg e
-\end{code}
+isRuntimeArg = isValArg
-\begin{code}
isValArg :: Expr b -> Bool
isValArg (Type _) = False
isValArg _ = True