A second functor question

A second functor question

[John F. Hughes]

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

Re: [Caml-list] A second functor question

[Alain Frisch]

John F. Hughes wrote:
> 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.

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

You need to keep the P1.t and P2.t fields public, otherwise the 
constraint cannot be checked:

module P1 = struct ... end;;
module P2 = struct ... end;;

or:

module P1 : P with type t = int = ...
module P2 : P with type t = int = ...

Btw, maybe you did it on purpose, but the type annotation in:

         let f x:Z.A.t = Z.B.foo x

is upon the result type of f, not its argument (in your case, it's the 
same).


Note also you don't need to combine the two structures in a single 
module, you can just define a functor with several arguments:

module Fun(A : P)(B : P with type t = A.t) = struct
   let f x = B.foo x
end


-- Alain

Re: [Caml-list] A second functor question

[Christophe TROESTLER]

On Fri, 19 Nov 2004, "John F. Hughes" <jfh@cs.brown.edu> wrote:
> 
> I'd like to write a signature like this:
> 
> module type P = 
>   sig
>      type t
>      val foo : t -> t
>      val z:int
>   end;;
>
> I now want to apply a functor to those two modules...but a functor
> wants a single module,

Just like functions want a single argument.

> module type COMBINE =

This is unnecessary.

> I'd like a way to promise to the type system that A.t and B.t are
> always the same.

Does this fit your needs:

module F(A : P) (B : P with type t = A.t) =
struct
  let f x = A.foo(B.foo x)
  (* ... *)
end

ChriS

Re: [Caml-list] A second functor question

[Andreas Rossberg]

John F. Hughes <jfh@cs.brown.edu> wrote:
> 
> module type COMBINE =
>    sig
>       module A : P
>       module B : P
>    end;;
>  with A.t = B.t;;
> 
> [...]
> 
> 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. 

It works when you define COMBINE as

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

Hope this helps,

    - Andreas