anchor.diff:      let tfun_computed = U.arrow bs cbody in
       let e = U.abs bs body (Some (U.residual_comp_of_comp (dflt cbody c_opt))) in
       let e, tfun, guard = match tfun_opt with
  -        | Some (t, use_teq) ->
  +        | Some t ->
              let t = SS.compress t in
              begin match t.n with
                   | Tm_arrow _ ->
  
positive.code:                 let envbody, bs, g, c = check_actuals_against_formals env bs bs_expected in
                  let envbody, letrecs = if Env.should_verify env then mk_letrec_env envbody bs c else envbody, [] in
                  let envbody = Env.set_expected_typ envbody (U.comp_result c) in
                  Some (t, false), bs, letrecs, Some c, None, envbody, body, g
  
                | _ -> (* expected type is not a function;
                          try normalizing it first;
  
negative.code:                     //just repackage the expression with this type; t is guaranteed to be alpha equivalent to tfun_computed
                      e, t, guard
                  | _ ->
                      let e, guard' = TcUtil.check_and_ascribe env e tfun_computed t in
                      e, t, Rel.conj_guard guard guard'
             end
  
          | None -> e, tfun_computed, guard in
  
      let c = if env.top_level then   mk_Total tfun else TcUtil.return_value env tfun e in
      let c, g = TcUtil.strengthen_precondition None env e (U.lcomp_of_comp c) guard in
      e, c, g
  
  