andrew cooke writes:
 > 
 > I can't work out how to structure the following in files (there are
 > examples in the documentation, but all seem to be for interactive work). 
 > I don't know if the problem is conceptual (not understanding modules,
 > signatures etc) or practical (don't know what to type).
 > 
 > I have an interface, PersistentArray, that I define in PersistentArray.mli
 > 
 > Then I have an implementation, BinaryTreeArray, that I code in BinaryTree.ml
 > 
 > But where do I put the information that BinaryTreeArray implements
 > PersistentArray?  What should go in BinaryTreeArray.mli so that I can use
 > it as a particular implementation of PersistentArray?

In  ocaml, files  define  modules and  signatures  with the  following
convention: code  in file  a.ml defines  a module A  and code  in file
a.mli defines the signature for this module (The ocaml compiler checks
that a.ml has indeed the signature declared in a.mli).

In a simple situation with  only one implementation, the interface for
your module BinaryTreeArray should go in file BinaryTreeArray.mli (or,
symmetrically,  the code  in BinaryTreeArray.ml  should go  instead in
PersistentArray.ml to have signature PersistentArray.mli).

Since  you  are  willing  to  reuse a  single  interface  for  several
implementations, this simple schema one-file-one-module does not suit.
You need  to *name* your PersistentArray signature;  for this purpose,
you can for instance create a file sig.mli containing its definition:

sig.mli:
	module type PersistentArray = sig
	  ...
	end

Then you can define several implementations with this signature:

	module BinaryTreeArray : Sig.PersistentArray = struct
	  ...
	end
	module TrieArray : Sig.PersistentArray = struct
	  ...
	end	

 > The idea is that later I can define some other implementation, say
 > TrieArray, that can be used as the PersistentArray implementation without
 > changing any more code than is necessary (preferably just one line
 > somewhere).

There are several ways to do this:

1. give a name to the implementation of your choice

	module PA = BinaryTreeArray

   and use PA in the following. Then switching to another
   implementation only requires to change the first line.

2. write your code as a functor

	module F(PA : Sig.PersistentArray) = struct ... end

   and then only the functor instanciation will change:

	module M = F(BinaryTreeArray)

Hope this helps,
-- 
Jean-Christophe

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners