anchor.diff:           eff_name (Print.tscheme_to_string (us, t))
                     (Print.tscheme_to_string (us, k));
   
  +  let k = k |> N.remove_uvar_solutions env in
  +
  +  let _check_valid_binders =
  +    match (SS.compress k).n with
  +    | Tm_arrow (bs, c) ->
  +      let bs, c = SS.open_comp bs c in
  +      let res_t = U.comp_result c in
  +      let bs, f_b, g_b =
  +        List.splitAt (List.length bs - 2) bs
  +        |> (fun (l1, l2) -> l1 |> List.tl |> List.tl,
  +                        l2 |> List.hd, l2 |> List.tl |> List.hd) in
  +      let g_sort =
  +        match (SS.compress (fst g_b).sort).n with
  +        | Tm_arrow (_, c) -> U.comp_result c in
  +      validate_layered_effect_binders env bs [(fst f_b).sort; g_sort; res_t] r in
  +
  +
     log_issue r (Errors.Warning_BleedingEdge_Feature,
       BU.format1 "Polymonadic binds (%s in this case) is an experimental feature;\
         it is subject to some redesign in the future. Please keep us informed (on github etc.) about how you are using it"
         eff_name);
   
  -  (us, t), (us, k |> N.remove_uvar_solutions env |> SS.close_univ_vars us)
  +  (us, t), (us, k |> SS.close_univ_vars us)
   
   
   let tc_polymonadic_subcomp env0 (m:lident) (n:lident) (ts:S.tscheme) : (S.tscheme * S.tscheme) =
  
positive.code: 
      let guard_eq = Rel.teq env ty k in
      List.iter (Rel.force_trivial_guard env) [guard_f; guard_g; guard_repr; g_pure_wp_uvar; guard_eq];
      bind_us, bind_t, k |> N.remove_uvar_solutions env |> SS.close_univ_vars bind_us in
  
    log_combinator "bind_repr" bind_repr;
  
  
negative.code: 
    if Env.debug env0 <| Options.Other "LayeredEffectsTc" then
      BU.print1 "After unification k: %s\n" (Print.term_to_string k);
  
    let k = k |> N.remove_uvar_solutions env in
  
    let _check_valid_binders =
      match (SS.compress k).n with
      | Tm_arrow (bs, c) ->
        let bs, c = SS.open_comp bs c in
        let res_t = U.comp_result c in
        let bs, f_b =
          List.splitAt (List.length bs - 1) bs
          |> (fun (l1, l2) -> List.tl l1, List.hd l2) in
        validate_layered_effect_binders env bs [(fst f_b).sort; res_t] r in
  
    let sub = { sub with
      lift = Some (us, lift);
      lift_wp = Some (us, k |> SS.close_univ_vars us) } in
  
    if Env.debug env0 <| Options.Other "LayeredEffectsTc" then
      BU.print1 "Final sub_effect: %s\n" (Print.sub_eff_to_string sub);
  