English version
Accueil     À propos     Téléchargement     Ressources     Contactez-nous    

Ce site est rarement mis à jour. Pour les informations les plus récentes, rendez-vous sur le nouveau site OCaml à l'adresse ocaml.org.

Browse thread
Extending modules and signatures
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: 2009-04-20 (00:09)
From: Martin Jambon <martin.jambon@e...>
Subject: Re: [Caml-list] Extending modules and signatures
Ashish Agarwal wrote:
>> The module type exists, it's just that it doesn't have a name.
> Right, thanks for the clarification.
>> let x = (123, "abc")
>> does not define "type x = int * string" either.
> True, but I think the expectations are different for module types. A
> file a.ml <http://a.ml> creates a module named A, and it seems natural
> to expect a.mli to create a module type A. I find it inconsistent that
> it does not.
> Further, if you wanted to name the above type, it is easy, just write
> "type x = int * string". The corresponding solution to naming module
> types is burdensome. You have to define it within another module,
> introducing an unnecessary layer into your module hierarchy. Also that
> doesn't help you when using somebody else's library.
> Having the compiler introduce module type names automatically from mli
> files would be very helpful, and I don't see any disadvantages.

OK, but I think the real issue is inheritance.  In order to truly extend an
existing module, one needs to access the private items of the inherited module
implementation.  In order to avoid messing up with the original module's
global variables, the inherited "module" should be more like a functor that
would create a fresh instance of the module each time it is instantiated, just
like classes generate objects.

I could imagine something like this:

module class A :
  val get_x : unit -> int
end =
  let x = ref 123
  let get_x () = !x

module class B =
  inherit A
  let incr_x () = incr x

module B1 = new module B
module B2 = new module B

B1.incr_x ();;
- : unit = ()
B1.get_x ();;
- : int = 124
B2.get_x ();;
- : int = 123

Module class implementations and signatures could be conveniently created as
whole files using new file extensions, say .mc and .mci.  These would be like
.ml files except that they would support module class inheritance and would be
evaluated only when they are instantiated with "new module".