anchor.diff:      | Typ_uvar    _ -> unexpected  rg
       | Typ_unknown   -> unexpected  rg
   
  +and maybe_tuple (rg : range) ty =
  +    let rec unfun n ty =
  +        if n > 0 then
  +            match (Absyn.Util.compress_typ ty).t with
  +            | Typ_lam (_, _, ty)          -> unfun (n-1) ty
  +            | Typ_ascribed (ty, _)        -> unfun n ty
  +            | Typ_meta (Meta_pos (ty, _)) -> unfun n ty
  +            | _ -> unsupported rg
  +        else
  +            ty
  +    in
  +
  +    let rec aux acc ty =
  +        match (Absyn.Util.compress_typ ty).t with
  +        | Typ_const c -> begin
  +            match is_tuple_name c.v with
  +            | None -> None
  +            | Some n ->
  +                if List.length acc <> n then
  +                    unsupported rg;
  +                let acc = List.mapi unfun acc in
  +                Some (List.map (mlty_of_ty rg) acc)
  +        end
  +
  +        | Typ_app (t1, t2, _) ->
  +            aux (t2 :: acc) t1
  +
  +        | Typ_ascribed (ty, _) ->
  +            aux acc ty
  +
  +        | Typ_meta (Meta_pos (ty, _)) ->
  +            aux acc ty
  +
  +        | _ -> None
  +    in
  +
  +    aux [] ty
  +
   (* -------------------------------------------------------------------- *)
   let mltycons_of_mlty (ty : mlty) =
       let rec aux acc ty =
  
positive.code:     match mlty with
      | Ty_var x ->
          text x
  
      | Ty_named ((_, name), args) -> begin
          let doc =
  
negative.code:     | _ -> false
  
  (* -------------------------------------------------------------------- *)
  let is_tuple_name (id : lident) =
      if is_prim_ns id.ns then
          match id.ident.idText with
          | "Tuple2" -> Some 2
          | "Tuple3" -> Some 3
          | "Tuple4" -> Some 4
          | "Tuple5" -> Some 5
          | "Tuple6" -> Some 6
          | _        -> None
      else
          None
  
  (* -------------------------------------------------------------------- *)
  let name_of_let_ident (x : either<bvvdef,lident>) =
      match x with
      | Inl x -> x.realname.idText
  