decomposeFunCo (FunCo { fco_mult = w, fco_arg = co1, fco_res = co2 })

   = (w, co1, co2)

 decomposeFunCo co

   = assertPpr all_ok (ppr co) $

 -- | `tryEtaReduce [x,y,z] e sd` returns `Just e'` if `\x y z -> e` is evaluated

 -- according to `sd` and can soundly and gainfully be eta-reduced to `e'`.

 tryEtaReduce :: UnVarSet -> [Var] -> CoreExpr -> SubDemand -> Maybe CoreExpr

 -- Return an expression equal to (\bndrs. body)

 tryEtaReduce rec_ids bndrs body eval_sd

   = go (reverse bndrs) body (mkRepReflCo (exprType body))

   where

     opts = seOptCoercionOpts env

 addCastMCo :: MOutCoercion -> SimplCont -> SimplCont

 addCastMCo MRefl    cont = cont

 addCastMCo (MCo co) cont = CastIt { sc_co = co, sc_opt = False, sc_cont = cont }

 pushCast :: SimplEnv -> OutCoercion -> SimplCont -> SimplM SimplCont

 pushCast env co cont

   = go co True cont

                                     -- NB!  As the cast goes past, the

                                     -- type of the hole changes (#16312)

     -- where   co :: (s1->s2) ~ (t1->t2)

     --         co1 :: t1 ~ s1

     --         co2 :: s2 ~ t2

       = -- pushCoValArg duplicates the coercion, so optimise first

         go (optOutCoercion (zapSubstEnv env) co co_is_opt) True cont

       | Just (m_co1, m_co2) <- pushCoValArg co

       = {-#SCC "addCoerce-pushCoValArg" #-}

         do { tail' <- go_mco m_co2 co_is_opt tail

            ; return (ApplyToVal { sc_arg  = arg

                                 , sc_env  = arg_se

                                 , sc_cont = tail'

                                 , sc_hole_ty = coercionLKind co }) }

                                    -- See Note [Optimising reflexivity]

       | otherwise = return (CastIt { sc_co = co, sc_opt = co_is_opt, sc_cont = cont })

         -- If the first parameter is MRefl, then simplifying revealed a

         -- reflexive coercion. Omit.

   | otherwise

   = case substId env var of

       ContEx se e mco

         -- Don't trimJoinCont; haven't already simplified e,

         -- so the cont is not embodied in e

            _ -> do { s' <- newId (fsLit "s") ManyTy realWorldStatePrimTy

                    ; let (m,_,_) = splitFunTy fun_ty

                          env'  = arg_env `addNewInScopeIds` [s']

                                 -- cont' applies to s', then K

                    ; body' <- simplExprC env' arg cont'

                    ; return (Lam s' body') }

 -- For example, when simplifying the argument `e` in `f e` and `f` has the

 -- demand signature `<MP(S,A)>`, this function will give you back `P(S,A)` when

 -- simplifying `e`.

     -- Not 100% sure that's correct, . Here's an example:

     --   f (e x) and f :: <SC(S,C(1,L))>

     -- then what is the evaluation context of 'e' when we simplify it? E.g.,

     --   simpl e (ApplyToVal x $ Stop "C(S,C(1,L))")

     -- then it *should* be "C(1,C(S,C(1,L))", so perhaps correct after all.

     -- Perhaps reconstruct the demand on the scrutinee by looking at field

     -- and case binder dmds, see addCaseBndrDmd. No priority right now.

     mb_rhs   = contIsRhs cont

     -- See Note [Eta reduction based on evaluation context]

     try_eta :: [OutBndr] -> OutExpr -> SimplM OutExpr

     try_eta bndrs body