anchor.diff:          match List.tryFind test infix_prim_ops with
           | None -> None
           | Some (_, prio, txt) ->
  -            let d1 = doc_of_exp (prio, Left ) env e1 in
  -            let d2 = doc_of_exp (prio, Right) env e2 in
  +            let d1 = doc_of_exp rg (prio, Left ) env e1 in
  +            let d2 = doc_of_exp rg (prio, Right) env e2 in
               Some (maybe_paren outer prio (reduce1 [d1; text txt; d2]))
       end
   
       | (Exp_fvar (x, _), [(e, _)])
           when is_prim_ns x.v.ns && x.v.ident.idText = "op_Negation" -> begin
   
  -        let d = doc_of_exp (min_op_prec, NonAssoc) env e in
  +        let d = doc_of_exp rg (min_op_prec, NonAssoc) env e in
           Some (cat1 (text "not") (parens d)) (* FIXME *)
       end
   
       | _ -> None
   
   (* -------------------------------------------------------------------- *)
  -and doc_of_constr (env : env) c args =
  +and doc_of_constr (rg : range) (env : env) c args =
       let x = c.ident.idText in
   
       match args with
  
positive.code: }
  
  (* -------------------------------------------------------------------- *)
  let unexpected () =
      failwith "ocaml-backend-unexpected-construction"
  
  (* -------------------------------------------------------------------- *)
  let unsupported () =
      failwith "ocaml-backend-unsupported-construction"
  
  (* -------------------------------------------------------------------- *)
  let ocaml_u8_codepoint (i : byte) =
  
negative.code:     (List.map (fun x -> x.idText) ns, x.idText)
  
  (* -------------------------------------------------------------------- *)
  let rec mlty_of_ty (rg : range) (ty : typ) =
      let ty = Absyn.Util.compress_typ ty in
  
      match maybe_mltynamed_of_ty rg [] ty with
      | None -> begin
          match ty.t with
          | Typ_btvar x ->
              Ty_var x.v.realname.idText
  
          | Typ_refine (_, ty, _) ->
              mlty_of_ty rg ty
  
          | Typ_ascribed (ty, _) ->
              mlty_of_ty rg ty
  
          | Typ_meta (Meta_pos (ty, rg)) ->
              mlty_of_ty rg ty
  
          | Typ_fun (x, t1, Pure t2, _) ->
              let mlt1 = mlty_of_ty rg t1 in
              let mlt2 = mlty_of_ty rg t2 in
              Ty_fun (Option.map (fun x -> x.ppname.idText) x, mlt1, mlt2)
  
          | Typ_fun (_, _, Computation _, _) ->
              unsupported rg
  
          | Typ_const   _ -> unexpected  rg
          | Typ_app     _ -> unsupported rg
          | Typ_dep     _ -> unsupported rg
          | Typ_lam     _ -> unsupported rg
          | Typ_tlam    _ -> unsupported rg
          | Typ_univ    _ -> unsupported rg
          | Typ_meta    _ -> unexpected  rg
          | Typ_uvar    _ -> unexpected  rg
          | Typ_unknown   -> unexpected  rg
      end
  
      | Some (c, tys) -> Ty_named (c, tys)
  
  and maybe_mltynamed_of_ty (rg : range) acc ty =
      match (Absyn.Util.compress_typ ty).t with
      | Typ_const c ->
          Some (mltyname_of_lident (c.v.ns, c.v.ident), List.rev acc)
  
      | Typ_app (t1, t2, _) ->
          maybe_mltynamed_of_ty rg (mlty_of_ty rg t2 :: acc) t1
  
      | Typ_refine (_, ty, _) ->
          maybe_mltynamed_of_ty rg acc ty
  
      | Typ_ascribed (ty, _) ->
          maybe_mltynamed_of_ty rg acc ty
  
      | Typ_meta (Meta_pos (ty, rg)) ->
          maybe_mltynamed_of_ty rg acc ty
  
      | Typ_btvar   _ -> None
      | Typ_fun     _ -> None
      | Typ_dep     _ -> unsupported rg
      | Typ_lam     _ -> unsupported rg
      | Typ_tlam    _ -> unsupported rg
      | Typ_univ    _ -> unsupported rg
      | Typ_meta    _ -> unexpected  rg
      | Typ_uvar    _ -> unexpected  rg
      | Typ_unknown   -> unexpected  rg
  
  (* -------------------------------------------------------------------- *)
  let mltycons_of_mlty (ty : mlty) =
  