David Rajchenbach-Teller wrote:
>      Dear list,
> 
>  I'm looking for a way to remove one or two annoyances of Batteries,
> which are related to private magic leaking into the type system and into
> the documentation.
> 
> 
> 
> We define a module [IO] with, among other things, a type [output]. In
> fact, in order to avoid circular dependencies, [output] is actually
> defined in a private module [InnerIO], which lets other modules such as
> [ExtString] use [output] and still be used by [IO]. For instance,
> [ExtString] defines a function [print : InnerIO.output -> string ->
> unit].
> 
> At a later stage, we pack [IO], [InnerIO], [ExtString] and others into a
> module [Extlib] and we later define a module [Batteries] containing
> 
> module IO          = Extlib.IO
> module String = ExtString.String
> 
> etc.
> 
> 
> Now, all of this works. Unfortunately, the types visible by the user,
> either from the toplevel, from error messages or from -dannot, reveal
> too much from the inner workings of Batteries.
> 
> For instance,  [InnerIO], as implied by the name, is private. The
> existence of this module should not be visible by the user.
> Unfortunately, on the toplevel, we have
> 
> # String.print;;
> - : Extlib.InnerIO.output -> string -> unit = <fun>
> 
> Two abstractions have leaked out:
> * the existence of [InnerIO]
> * the existence of [Extlib]
> 
> I would rather have
> 
> # String.print;;
> - : IO.output -> string -> unit = <fun>
> 
> or, at worst
> 
> # String.print;;
> - : Batteries.IO.output -> string -> unit = <fun>
> 
> 
> Does anyone have an idea of how we could/should do this?


It looks like you can applying a signature to Batteries.IO does the trick:

(* IO's signature *)
module type A_sig =
sig
  type t
  val add : t -> t -> t
  val create : unit -> t
end

(* Extlib.IO *)
module A : A_sig =
struct
  type t = int
  let add = ( + )
  let create () = 1
end

(* Batteries.IO, version 1 *)
module B = A

(* Batteries.IO, version 2 *)
module C : A_sig = A


This is the problem that you're having, i.e. A.t appears in the error message:

# B.create () = 1;;
Characters 14-15:
  B.create () = 1;;
                ^
This expression has type int but is here used with type B.t = A.t


This looks better:

# C.create () = A.create ();;
Characters 14-25:
  C.create () = A.create ();;
                ^^^^^^^^^^^
This expression has type A.t but is here used with type C.t



I just hope it works for your problem.



Martin

-- 
http://mjambon.com/