anchor.diff:      separate_map_with_comments_kw let_doc (str "and") p_letbinding lbs
         (fun (p, t) -> Range.union_ranges p.prange t.range)
     | Val(lid, t) ->
  -    (str "val" ^^ space ^^ p_lident lid ^^ space ^^ colon) ^/+^ p_typ false false t
  +    str "val" ^^ space ^^ p_lident lid ^^ group (colon ^^ space ^^ (p_typ false false t))
       (* KM : not exactly sure which one of the cases below and above is used for 'assume val ..'*)
     | Assume(id, t) ->
       let decl_keyword =
  
positive.code:       then empty
        else str "val" ^^ space
      in
      (decl_keyword ^^ p_ident id ^^ space ^^ colon) ^/+^ p_typ false false t
    | Exception(uid, t_opt) ->
      str "exception" ^^ space ^^ p_uident uid ^^ optional (fun t -> break1 ^^ str "of" ^/+^ p_typ false false t) t_opt
    | NewEffect(ne) ->
  
negative.code:     | Op({idText = "==>"}, [e1;e2]) -> infix0 (str "==>") (p_tmArrow p_tmFormula e1) (p_tmImplies e2)
      | _ -> p_tmArrow p_tmFormula e
  
  (* This function is somewhat convoluted because it is used in a few different contexts and it's trying to properly  *)
  (* indent for each of them. For signatures, it is trying to print the whole arrow on one line. If this fails, it    *)
  (* tries to print everything except the last term on the same line and push the last term on a new line. If this    *)
  (* fails, it prints every term on a separate line. This seems consistent with the current style used in most cases. *)
  (* A trailing space may sometimes be introduced, which we should trim.                                              *)
  and p_tmArrow p_Tm e =
    let terms = p_tmArrow' p_Tm e in
    let terms', last = List.splitAt (List.length terms - 1) terms in
    let last_op = if List.length terms > 1 then space ^^ rarrow else empty in
    match List.length terms with
    | 1 -> List.hd terms
    | _ -> group (ifflat (separate (space ^^ rarrow ^^ break1) terms)
           (group ((ifflat ((separate (space ^^ rarrow ^^ break1) terms') ^^ last_op)
                    (jump2 ((separate (space ^^ rarrow ^^ break1) terms') ^^ last_op)))) ^^ (jump2 <| List.hd last)))
  
  and p_tmArrow' p_Tm e = match e.tm with
    | Product(bs, tgt) -> (List.map (fun b -> p_binder false b) bs) @ (p_tmArrow' p_Tm tgt)
    | _ -> [p_Tm e]
  
  and p_tmFormula e =
      let conj = space ^^ (str "/\\") ^^ break1 in
  