Re: [Caml-list] Avoiding ml/mli code duplication

[Alain Frisch <alain@frisch.fr>]

On 12/28/2010 3:02 PM, Lauri Alanko wrote:
> In this situation, I'm not quite sure what's the best way to
> proceed.

Here is another possibility:

===================================================================
(** BarDefs.ml **)
module type S = sig
   type t
   type u = A of t
end


(** Bar.mli **)
include BarDefs.S
val x: u list


(** Bar.ml **)
type t = X
module rec S_impl : BarDefs.S with type t := t = S_impl
include S_impl
let x = [A X]
===================================================================


I can also mention a local extension we use at LexiFi: a compilation 
unit (.ml) for which an explicit signature (.mli) exists is type-checked 
as a recursive module with itself. (Currently, we disallow recursive 
references to value-like components.)  So in the example above, the 
definition of the module type S could be put in Bar.mli:


===================================================================
(** Bar.mli **)
module type S = sig
   type t
   type u = A of t
end

include S
val x: u list

(** Bar.ml **)
module type S = Bar.S

type t = X
module rec S_impl : S with type t := t = S_impl
include S_impl

let x = [A X]
===================================================================



The same extension allows for easy recursion between, say, type and 
class type definitions:

===================================================================
(** Bar.mli **)
type t = A of Bar.u

class type u = object
   method foo: t
end

.....


(** Bar.ml **)
type t = A of Bar.u

class type u = Bar.u

......
===================================================================


What could be useful would be an extra extension to have an "include" 
statement for specific type declarations, so that the Bar.ml above could 
be written directly:

type t = include Bar.t  (* same as type t = Bar.t = A of Bar.u *)
class type u = Bar.u

.....





-- Alain