anchor.diff:  let find_lid (x:lident) xs : string =
     snd (find (fun p -> lid_equals x (fst p)) xs)
   
  -let infix_prim_op_to_string e = find_lid (get_lid e) infix_prim_ops
  -
  -let uni_prim_op_to_string e = find_lid (get_lid e) prim_uni_ops
  +let infix_prim_op_to_string e = find_lid (get_lid e)      infix_prim_ops
  +let unary_prim_op_to_string e = find_lid (get_lid e)      unary_prim_ops
  +let infix_type_op_to_string t = find_lid (get_type_lid t) infix_type_ops
  +let unary_type_op_to_string t = find_lid (get_type_lid t) unary_type_ops
   
   let rec sli (l:lident) : string = 
     if !Options.print_real_names
  
positive.code:     (Const.op_GTE         , ">=");
      (Const.op_LT          , "<" );
      (Const.op_GT          , ">" );
      (Const.op_Modulus     , "mod" );
  ]
  (* CH: What about the Lex ordering, doesn't that belong here too?
  [6:23:30 PM] Nikhil Swamy: are you including printing Precedes as <<
  [6:23:45 PM] Nikhil Swamy: and LexCons ... as %[v1;..vn]?
  [6:23:52 PM] Catalin Hritcu: yes
   *)
  
  let prim_uni_ops = [
      (Const.op_Negation, "not");
      (Const.op_Minus, "-")
  ]
  
  let is_op ps f = match f.n with 
    | Exp_fvar(fv,_) -> ps |> Util.for_some (lid_equals fv.v)
    | _ -> false
  
  let get_lid f = match f.n with 
    | Exp_fvar(fv,_) -> fv.v
    | _ -> failwith "get_lid"
  
  let is_infix_prim_op = is_op (fst (List.split infix_prim_ops))
  
  let is_uni_prim_op (e:exp) = is_op (fst (List.split prim_uni_ops)) e
  
  (* CH: F# List.find has a different type from find in list.fst ... so just a hack for now *)
  let rec find f l = match l with 
  
negative.code:   | Typ_const v -> sli v.v //Util.format2 "%s:%s" (sli v.v) (kind_to_string x.tk)
    | Typ_fun(binders, c) ->     Util.format2 "(%s -> %s)"  (binders_to_string " -> " binders) (comp_typ_to_string c)
    | Typ_refine(xt, f) ->       Util.format3 "%s:%s{%s}" (strBvd xt.v) (xt.sort |> typ_to_string) (f|> formula_to_string)
    | Typ_app(t, args) ->
        let args' = List.filter (fun a -> not (snd a)) args in (* drop implicit arguments for type operators *)
        if is_infix_type_op t && List.length args' = 2 then
          Util.format3 "(%s %s %s)" (List.nth args' 0 |> arg_to_string) (t |> infix_type_op_to_string) (List.nth args' 1 |> arg_to_string)
        else if is_unary_type_op t && List.length args' = 1 then
          Util.format2 "(%s %s)" (t|> unary_type_op_to_string) (List.nth args' 0 |> arg_to_string)
        else Util.format2 "(%s %s)"   (t |> typ_to_string) (args |> args_to_string)
    | Typ_lam(binders, t2) ->      Util.format2 "(fun %s => %s)" (binders_to_string " " binders) (t2|> typ_to_string)
    | Typ_ascribed(t, k) ->
      if !Options.print_real_names  
  