anchor.diff:          | Exp_abs (x, _, e) ->
               let lenv = push env x.realname.idText x.ppname.idText in
               let x    = resolve lenv x.realname.idText in
  -            let d    = doc_of_exp (min_op_prec, NonAssoc) lenv e in
  +            let d    = doc_of_exp rg (min_op_prec, NonAssoc) lenv e in
               maybe_paren outer e_bin_prio_lambda (reduce1 [text "fun"; text x; text "->"; d])
   
           | Exp_match ((Exp_fvar _ | Exp_bvar _), [p, None, e]) when Absyn.Util.is_wild_pat p ->
  -            doc_of_exp outer env e
  +            doc_of_exp rg outer env e
   
           | Exp_match (e, bs) -> begin
               match bs with
  
positive.code:     reduce1 [text "type"; combine (text "and") docs]
  
  (* -------------------------------------------------------------------- *)
  let rec doc_of_exp outer (env : env) (e : exp) =
      let doc =
          match maybe_doc_of_primexp_r outer env e with
          | None   -> doc_of_exp_r outer env e
          | Some d -> d
  
      in group doc
  
  (* -------------------------------------------------------------------- *)
  and doc_of_exp_r outer (env : env) (e : exp) =
      let e = Absyn.Util.compress_exp e in
  
      match Absyn.Util.destruct_app e with
      | (e, args) when not (List.isEmpty args) ->
          let e    = doc_of_exp (e_app_prio, ILeft) env e in
          let args = List.map (fun (e, _) -> doc_of_exp (e_app_prio, IRight) env e) args in
          maybe_paren outer e_app_prio (cat1 e (reduce args))
  
      | _ -> begin
  
negative.code:     group doc
  
  (* -------------------------------------------------------------------- *)
  let is_kind_for_mldtype rg (k : knd) =
      match k with
      | Kind_type     -> true
      | Kind_unknown  -> true
      | Kind_dcon _   -> false
      | Kind_tcon _   -> false
      | Kind_effect   -> false
      | Kind_abbrev _ -> unsupported rg
      | Kind_uvar _   -> unexpected rg
  
  (* -------------------------------------------------------------------- *)
  let mldtype_of_bundle (env : env) (indt : list<sigelt>) =
      let (ts, cs) =
          let fold1 sigelt (types, ctors) =
              match sigelt with
              | Sig_tycon (x, tps, k, ts, cs, _, rg) ->
                  if not (is_kind_for_mldtype rg k) then
                      unsupported rg
                  else
                      ((x.ident.idText, tps, cs, rg) :: types, ctors)
  
              | Sig_datacon (x, ty, pr, rg) ->
                  (types, (x.ident.idText, (ty, pr)) :: ctors)
  
              | Sig_val_decl (_, _, _, _, rg)
              | Sig_typ_abbrev (_, _, _, _, rg)
              | Sig_assume (_, _, _, _, rg)
              | Sig_let (_, rg)
              | Sig_logic_function (_, _, _, rg)
              | Sig_main (_, rg)
              | Sig_bundle (_, rg)
              | Sig_monads (_, _, rg) -> unexpected rg
  
          in
  
          let (ts, cs) = List.foldBack fold1 indt ([], []) in
  