anchor.diff:               (jump2 ((single_line_arg_indent ^^ separate (sep ^^ single_line_arg_indent) (List.map (fun x -> align (hang 2 x)) terms')))))))
                  (align (hang last_n (last_op ^^ List.hd last)))))
   
  -and p_tmArrow' p_Tm e = match e.tm with
  +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]
  +
  +// When printing in `Binders` style, collapse binders which have the same
  +// type, so instead of printing
  +//    val f (a: t) (b: t) (c: t) : Tot nat
  +// print
  +//    val f (a b c: t) : Tot nat
  +// For this, we use the generalised version of p_binder, which returns
  +// the binder, its type (as an optional) and a function which
  +// concatenates them.
  +and collapse_binders (p_Tm: term -> document) (e: term): list<document> =
  +  let rec accumulate_binders p_Tm e: list<(document * option<document> * catf)> =
  +    match e.tm with
  +    | Product(bs, tgt) -> (List.map (fun b -> p_binder' false b) bs) @ (accumulate_binders p_Tm tgt)
  +    | _ -> [(p_Tm e, None, cat_with_colon)]
  +  in
  +  let fold_fun (bs: list<(list<document> * option<document> * catf)>) (x: document * option<document> * catf) =
  +    let b1, t1, f1 = x in
  +    match bs with
  +    | [] -> [([b1], t1, f1)]
  +    | hd::tl ->
  +      let b2s, t2, _ = hd in
  +      match (t1, t2) with
  +      | (Some typ1, Some typ2) ->
  +        if typ1 = typ2 then
  +          (b2s @ [b1], t1, f1) :: tl
  +        else
  +          ([b1], t1, f1) :: hd :: tl
  +      | _ -> ([b1], t1, f1) :: bs
  +  in
  +  let p_collapsed_binder (cb: list<document> * option<document> * catf): document =
  +    let bs, t, f = cb in
  +    match t with
  +    | None -> begin
  +      match bs with
  +      | [b] -> b
  +      | _ -> failwith "Impossible" // can't have dangling type or collapse unannotated binders
  +    end
  +    | Some typ -> begin
  +      match bs with
  +      | [] -> failwith "Impossible" // can't have dangling type
  +      | [b] -> f b typ
  +      | hd::tl -> f (List.fold_left (fun x y -> x ^^ space ^^ y) hd tl) typ
  +    end
  +  in
  +  let binders = List.fold_left fold_fun [] (accumulate_binders p_Tm e) in
  +  map_rev p_collapsed_binder binders
   
   and p_tmFormula e =
       let conj = space ^^ (str "/\\") ^^ break1 in
  
positive.code: 
  let min x y = if x > y then y else x
  let max x y = if x > y then x else y
  
  
  (* [should_print_fs_typ_app] is set when encountering a [LightOff] pragma and *)
  
negative.code:   | Some (Meta _) -> true
    | _ -> false
  
  and p_binder is_atomic b =
    let b', t', catf = p_binder' is_atomic b in
    match t' with
    | Some typ -> catf b' typ
    | None -> b'
  
  (* is_atomic is true if the binder must be parsed atomically *)
  and p_binder' (is_atomic: bool) (b: binder): document * option<document> * catf =
    match b.b with
    | Variable lid -> optional p_aqual b.aqual ^^ p_lident lid, None, cat_with_colon
    | TVariable lid -> p_lident lid, None, cat_with_colon
  