Re: [Caml-list] Trying to define a functor combining polymorphic variants

[Leo White <lpw25@cam.ac.uk>]

Hi,

I'm afraid that I don't think you can do what you are trying to
do. Without going into full detail, consider what would happen with your
imagined functor `PROD` in the following case:

    module A = struct
      type message = [`Alpha of int]
      let string_of_message = function `Alpha i -> string_of_int i
    end

    module B = struct
      type message = [`Alpha of string]
      let string_of_message = function `Alpha s -> s
    end

    let b : B.message = `Alpha "hello"

    module AB = PROD(A)(B)

    let bad = AB.string_of_message b

`b` would match the pattern for `#A.message`, and you would get a
segfault. It is not sufficient to restrict `A.message` and `B.message`
to be polymorphic variants, they must be polymorphic variants that share
no tags.

Regards,

Leo

Berke Durak <berke.durak@gmail.com> writes:

> Hello all,
>
> I have been using the following kind of construct:
>
>   module A = struct
>     type message = [`Alpha]
>     let string_of_message = function `Alpha -> "alpha"
>   end
>
>   module B = struct
>     type message = [`Beta]
>     let string_of_message = function `Beta -> "beta"
>   end
>
>   module AB = struct
>     type message = [ A.message | B.message ]
>     let string_of_message = function
>     | #A.message as msg -> A.string_of_message msg
>     | #B.message as msg -> B.string_of_message msg
>   end
>
> So I naturally wanted to write a functor that does what the module AB does:
>
>   module type S = sig
>     type message
>     val string_of_message : message -> string
>   end
>
>   module PROD(A : S)(B : S) = struct
>     type message = [ A.message | B.message ]
>     let string_of_message = function
>     | #A.t as msg -> A.string_of_message msg
>     | #B.t as msg -> B.string_of_message msg
>   end
>
> But we (me + people on #ocaml: mrvn, drup, ggole, whitequark...) couldn't find a
> way to specify, in the signature S, that message is a polymorphic variant so
> that [ A.message | B.message ] is legal.
>
> We tried things like:
>
>   module type S = sig type 'a t = ([> ] as 'a) end
>
>   module PROD(X : S)(Y : S) = struct
>     type ('a,'b) t = [ 'a X.t | 'b Y.t ]
>   end
>
> but all we get is:
>
>   Error: The type [>  ] A.message is not a polymorphic variant type
>
> Any suggestions?
> -- 
> Berke Durak