anchor.diff:    let fallback fv =
       match infix_prim_ops |> BU.find_opt (fun d -> fv_eq_lid fv (fst d)) with
       | Some op ->
  -      Some (snd op, 0)
  +      Some (snd op, None)
       | _ ->
         let length = String.length(fv.fv_name.v.nsstr) in
         let str = if length=0 then fv.fv_name.v.str
             else BU.substring_from fv.fv_name.v.str (length+1) in
  -      if BU.starts_with str "dtuple" then Some ("dtuple", 0)
  -      else if BU.starts_with str "tuple" then Some ("tuple", 0)
  -      else if BU.starts_with str "try_with" then Some ("try_with", 0)
  -      else if fv_eq_lid fv C.sread_lid then Some (fv.fv_name.v.str, 0)
  +      if BU.starts_with str "dtuple" then Some ("dtuple", None)
  +      else if BU.starts_with str "tuple" then Some ("tuple", None)
  +      else if BU.starts_with str "try_with" then Some ("try_with", None)
  +      else if fv_eq_lid fv C.sread_lid then Some (fv.fv_name.v.str, None)
         else None
     in
     match (SS.compress t).n with
  
positive.code:             | [] | [_] -> failwith "last two elements of a list with less than two elements "
              | [a1;a2] -> [a1;a2]
              | _::t -> last_two t
        in
        let rec last_three = function
              | [] | [_] | [_;_] -> failwith "last three elements of a list with less than three elements "
              | [a1;a2;a3] -> [a1;a2;a3]
              | _::t -> last_three t
        in
        let resugar_as_app e args =
          let args =
  
negative.code:           let (e, _ ) = List.hd args in
            resugar_term' env e
  
          | Some (op, expected_arity) ->
            let op = Ident.id_of_text op in
            let resugar args = args |> List.map (fun (e, qual) ->
              resugar_term' env e, resugar_imp qual)
            in
             (* ignore the arguments added by typechecker *)
            (* TODO: we need a place to store the information in the args added by the typechecker *)
            //NS: this seems to produce the wrong output on things like
            begin
            match expected_arity with
            | None ->
              let resugared_args = resugar args in
              let expect_n = D.handleable_args_length op in
              if List.length resugared_args >= expect_n
              then let op_args, rest = BU.first_N expect_n resugared_args in
                   let head = mk (A.Op(op, List.map fst op_args)) in
                   List.fold_left
                          (fun head (arg, qual) -> mk (A.App (head, arg, qual)))
                          head
                          rest
              else resugar_as_app e args
            | Some n when List.length args = n -> mk (A.Op(op, List.map fst (resugar args)))
            | _ -> resugar_as_app e args
            end
      end
  