anchor.diff:      let b, u_b = fresh_a_and_u_a "b" in
       let rest_bs =
         match (SS.compress ty).n with
  -      | Tm_arrow ((a', _)::(b', _)::bs, _) when List.length bs >= 2 ->
  -        let bs, _ = List.splitAt (List.length bs - 2) bs in
  -        let substs = [NT (a', bv_to_name (fst a)); NT (b', bv_to_name (fst b))] in
  -        SS.subst_binders substs bs
  +      | Tm_arrow (bs, _) when List.length bs >= 4 ->
  +        (match SS.open_binders bs with
  +         | (a', _)::(b', _)::bs ->
  +           let bs, _ = List.splitAt (List.length bs - 2) bs in
  +           let substs = [NT (a', bv_to_name (fst a)); NT (b', bv_to_name (fst b))] in
  +           SS.subst_binders substs bs
  +         | _ -> failwith "Impossible!")
         | _ -> raise_error (Errors.Fatal_UnexpectedEffect, "") r in  //AR: TODO: FIXME
       let bs = a::b::rest_bs in
       let f, g_f =
  
positive.code:     let x_a = fresh_x_a "x" a in
      let rest_bs =
        match (SS.compress ty).n with
        | Tm_arrow ((a', _)::(x_a', _)::bs, _) ->
          let substs = [NT (a', bv_to_name (fst a)); NT (x_a', bv_to_name (fst x_a))] in
          SS.subst_binders substs bs
        | _ -> raise_error (Errors.Fatal_UnexpectedEffect, "") r in  //AR: TODO: FIXME
      let bs = a::x_a::rest_bs in
      let repr, g = fresh_repr r (Env.push_binders env bs) u_a (fst a) in
      let k = U.arrow bs (S.mk_Total' repr (Some u_a)) in
      let g_eq = Rel.teq env ty k in
      Rel.force_trivial_guard env (Env.conj_guard g g_eq);
      ret_us, ret_t, SS.close_univ_vars us k in
  
    log_combinator "return_repr" return_repr;
  
  
negative.code:     let repr, g_repr = fresh_repr r (Env.push_binders env bs) u_b (fst b) in
      let k = U.arrow (bs@[f; g]) (S.mk_Total' repr (Some u_b)) in
      let g_eq = Rel.teq env ty k in
      List.iter (Rel.force_trivial_guard env) [g_f; g_g; g_repr; g_eq];
      bind_us, bind_t, SS.close_univ_vars bind_us (N.normalize [Beta] env k) in
  
    log_combinator "bind_repr" bind_repr;
  
    //AR: TODO: FIXME: rest of the combinators
  
    let fst (a, _, _) = a in
    let snd (_, b, _) = b in
    let thd (_, _, c) = c in
  
    { ed with
      signature   = (fst signature, snd signature);
      ret_wp      = (fst return_repr, thd return_repr);
      bind_wp     = (fst bind_repr, thd bind_repr);
      repr        = (fst repr, snd repr);
      return_repr = (fst return_repr, snd return_repr);
      bind_repr   = (fst bind_repr, snd bind_repr); }
  
   
    // //typecheck return
  