Core: Drop the app-invariant

The app invariant says that the argument in an App must not be unlifted. This gets in the way of rule matching on functions with unlifted arguments (#19313 (closed)), and Simon PJ suggests that we may be better off without that invariant.

There is an analogous invariant on lets (hence “let-app-invariant”). He suggests to keep the let-invariant. (And I suggest to henceforce call it the “let-lifted-invariant” for more clarity.)

I’ll give it a shot and see what comes up.

assigned to @nomeata

added needs triage label

mentioned in issue #19313 (closed)

Hurrah! I don't this this will be that hard, in fact. The main place you'll need to take care is in beta-reduction

(\x. body) arg    ==>   let x = arg in body

If arg can't be let-bound (because it's unlifted), then we need to make a case binding instead. Not very hard, I think.

Something similar happens in rule rewrites. Suppose we have

RULE   forall x. f (g x) = ...x..x...

Then we rewrite like this:

 f (g arg)   ===>   let x = arg in ...x...x...

and again we need to be careful to case-bind that arg if it is unlifted.

That's all I can think of. It may be really simple!

marked this issue as related to #19223 (closed)

Yes, that’s my hope too. Also, we use smart constructors in most places, so enforcing an invariant there instead of here should not be hard. But we’ll see :-)

added Ttask label

removed needs triage label

added Pnormal core lint simplifier labels

mentioned in issue #20361

Removing the invariant on apps is easy, of course. The next problem is of course that much code in the simplifier assumes the app-invariant, especially when simplifying and possibly introducing lets, and it is not obvious to me where I should add branches that handle the needsCaseBinding case.

The starting point seems to be simplLam … (ApplyToVal …). From there we have the following chain of functions:

• simplNonRecX
• completeNonRecX
• completeBind
• tryCastWorkerWrapper
• mkFloatBind
• wrapFloats And it seems any of them might be a candidate for “do something different”, and it is unclear to me which one should be it.

In particular: Do we want drop the (so far implicit) “float-invariant” as well, and keep these RHSs in floats (turning them into cases when we wrapFloats)? Or do we need to casify then earlier, and never let them be floats?

(Replacing Let with mkCoreLet in wrapFloats seems like the easiest, but I wonder if this might be wrong semantically, given that floats, well, “float” around.)

mentioned in commit 05d7bbaf

mentioned in merge request !6865 (closed)

I think that the place to behave specially is in simplLam itself. Add an initial guard for an isUnliftedType argument. For that we want to behave very like case e of b -> blah. Something like

simplLam env (bndr:bndrs) body (ApplyToVal { sc_arg = arg, sc_env = arg_se
                                           , sc_cont = cont, sc_dup = dup })
  | isSimplified dup
  , lifted_type
  = ...as now...

  | isSimplified dup
  = -- Unlifted binding
    do { (env1, bndr1) <- simplNonRecBndr env bndr
       ; (floats, expr') <- simplLam env1 bndrs body cont
       ; return (floats, Case arg bndr1 [(DEFAULT, [], expr')] }

  | lifted_type
  = ...as now, calling simplNonRecE...

  | otherwise  -- Unlifted binding
  = simplExprF (rhs_se `setInScopeFromE` env) rhs
               (StrictBind { sc_bndr = bndr, sc_bndrs = bndrs, sc_body = body
                           , sc_env = env, sc_cont = cont, sc_dup = NoDup })

Then when returning from StrictBind we may need to make a Case rather than Let:

rebuild env expr cont
  = case cont of
      ...
      StrictBind { sc_bndr = b, sc_bndrs = bs, sc_body = body
                 , sc_env = se, sc_cont = cont }
        | lifted_type
        -> do { (floats1, env') <- simplNonRecX (se `setInScopeFromE` env) b expr
                                  -- expr satisfies let/app since it started life
                                  -- in a call to simplNonRecE
              ; (floats2, expr') <- simplLam env' bs body cont
              ; return (floats1 `addFloats` floats2, expr') }

         | otherwise -- Unlifted, so make a case-expression
         = do { (env', bndr') <- simplBinder env bndr
              ; (floats, expr') <- simplLam env' bs body cont
              ; return (floats, Case new_rhs bndr' [(DEFAULT,[],expr')] }

Or something like that. I'd be happy to have a call if that would help.

I’ll release the lock on this one, as I’ll be traveling without a laptop for a while now, and if someone wants to pick this up in the meantime, please do. Early experiments in !6865 (closed), but not much useful there yet.

unassigned @nomeata

mentioned in commit 03ad2d44

Picking this up again. Thanks for your example code for simplLam, playing around with it right now.

assigned to @nomeata

mentioned in commit 2b99fd86