will panic, because the kind of the body of a forall must not mention

 the forall'd variable (and the inner forall's body appears to do so).

 they do renaming on the fly.  But instead we impose

 INVARIANT (NoTypeShadowing):

 -- | A special version of 'exprOkForSpeculation' used during

 -- Note [Speculative evaluation]. When the predicate arg `fun_ok` returns False

 -- for `b`, then `b` is never considered ok-for-spec.

 exprOkForSpecEval :: (Id -> Bool) -> CoreExpr -> Bool

 exprOkForSpecEval fun_ok = expr_ok fun_ok primOpOkForSpeculation

 -----------------------------

 app_ok :: (Id -> Bool) -> (PrimOp -> Bool) -> Id -> [CoreArg] -> Bool

   | not (fun_ok fun)

   = False -- This code path is only taken for exprOkForSpecEval

           -- See Note [Speculative evaluation]

       ClassOpId _ is_terminating_result

         | is_terminating_result -- See Note [exprOkForSpeculation and type classes]

            True

            -- assert: terminating result type => can't be applied;

            -- c.f the _other case below

       PrimOpId op _

         | primOpIsDiv op

             -- there can be 2 args (most div primops) or 3 args

             -- (WordQuotRem2Op), hence the use of last/init

               -- Special case for dividing operations that fail

               -- In general they are NOT ok-for-speculation

               -- (which primop_ok will catch), but they ARE OK

               -- can get rid of a thunk in an inner loop

         | otherwise -> primop_ok op && args_ok

       _other  -- Unlifted and terminating types;

               -- Also c.f. the Var case of exprIsHNF

          |  isTerminatingType fun_ty  -- See Note [exprOkForSpeculation and type classes]

          || definitelyUnliftedType fun_ty

             True  -- Both terminating types (e.g. Eq a), and unlifted types (e.g. Int#)

                   -- are non-functions and so will have no value args.  The assert is

                   -- just to check this.

              --     for evaluated-ness of the fun;

              --     see Note [exprOkForSpeculation and evaluated variables]

   where

     -- Even if a function call itself is OK, any unlifted

     -- args are still evaluated eagerly and must be checked

     --   arg_ok bndr arg = field_ok bndr NotMarkedStrict arg

     -- See Note [exprOkForSpeculation] (a-c)

     -- Used for strict DataCon worker arguments

     -- See (SFC1) of Note [Strict fields in Core]

     -- See Note [exprOkForSpeculation] (a-c)

            Just Lifted   -> str == NotMarkedStrict

            --     (#,#) @rep1 @rep2 @ty1 @ty2 arg1 arg2

            -- We don't /instantiate/ the type (though we could) so we don't know

 -----------------------------

 altsAreExhaustive :: [Alt b] -> Bool

 and their types.  The call is ok-for-speculation if each argument satisfies

 `field_ok`, namely:

   (a) Arg type is definitely lifted   => arg is not marked strict

 For (a), an arbitrary /lazy/ argument is ok provided we don't have a bang.

 For a strict argument you might wonder if we could use exprIsHNF, but see

 we just say "no".

 For (b) a variable, or casted variable is fine.  But not a call, say (f x).

 For (c) we don't know if we are in case (a) or (b) so we conservatively 'and'

 them.  See (EOKS1) for how we can get this situation.

   If we have a call

        (#,#) @LiftedRep @IntRep @Int @Int# 3 4#

   then we could see accurate liftedness by instantiation, but we don't try.

 Note [exprOkForSpeculation and type classes]

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

         -- PAP: Check unlifted val_args

         args_hnf             = all2Prefix check_arg   val_arg_tys           val_args

           -- val_arg_tys = map exprType val_args, but much less costly.

           -- The obvious definition regresses T16577 by 30% so we don't do it.

           | otherwise

           = Nothing

 {-

 Note [exprIsHNF Tick]