I'd like to write a signature like this:

module type P = 
  sig
     type t
     val foo : t -> t
     val z:int
  end;;

And make two modules matching that signature:

module P1 : P = 
   struct
      type t = int
      let foo x:t = x
      let z = 1
   end;;

module P2 : P = 
   struct 
      type t = int
      let foo x:t = x
      let z = 2 
   end;;

I now want to apply a functor to those two modules...but a functor
wants a single module, so I make a signature for a "joined" type:

module type COMBINE =
   sig
      module A : P
      module B : P
   end;;
 with A.t = B.t;;

and create a module of that type:

module C : COMBINE = 
   struct
      module A = P1 
      module B = P2
   end;;

And now I can write a functor:

module Fun = 
   functor (Z : COMBINE) -> 
     struct
        let f x:Z.A.t = Z.B.foo x 
     end;;

This will fail because Z.B.foo expects a B.t, but is being handed an
A.t. 

I'd like it to work. In other words, I'd like a way to promise to the
type system
that A.t and B.t (within a COMBINE) are always the same. I tried

module type COMBINE =
   sig
      module A : P
      module B : P
   end with A.t = B.t

I tried telling it they were the same when I created the module C:

module C : COMBINE = 
   struct
      module A = P1 
      module B = P2
   end with A.t = B.t;;

Neither worked. Can someone suggest a way to make this work, or am I
asking too
much of the module system. (I used to be able to do this in ML, using
the 
"sharing type" construct, but...)

---John