Thank you, Gabriel.
> No, this is currently not supported. For this use-case you will have to use
> modules, typically a functor (in some circumstances a first-class module
> parameter may work as well, if the return type does not depend on the
> parameter).
Let me ask a possibly related question. I want to define types
similar to the following:
type 'v pair_t = {pair : 'a. 'a * ('a -> 'v t)}
and 'v t =
A of 'v pair_t
| V of 'v
but where the type 'a of the pair field should be existential, rather
than universal. Since the above definition is universal, I get an
error for the following definition:
let test : bool t = A {pair = (3, fun x -> V true)}
Error: This field value has type int * (int -> bool t)
which is less general than 'a. 'a * ('a -> 'v t)
To implement an existential type, we need to use modules. Let me try.
If 'v pair_t does not depend on 'v t, for example, if the second
element of the pair has type 'a -> 'v (rather than 'a -> 'v t), I
could write as follows:
module type Pair1_t = sig
type a
type v
val pair : a * (a -> v) (* not a -> v t *)
end
type 'v t1 =
A of (module Pair1_t with type v = 'v)
| V of 'v
Now I can define (3, fun x -> true) as follows:
let test1 : bool t1 =
let module Pair1 = struct
type a = int
type v = bool
let pair = (3, fun x -> true)
end in
A (module Pair1)
On the other hand, if pair_t did not have a type parameter, for
example, if the parameter is fixed to bool, I could write as follows:
module type Pair2_t = sig
type a
type t
val pair : a * (a -> t) (* not a -> v t *)
end
type t2 =
A of (module Pair2_t with type t = t2)
| V of bool
Now I can define (3, fun x -> V true) as follows:
let test2 : t2 =
let module Pair2 = struct
type a = int
type t = t2
let pair = (3, fun x -> V true)
end in
A (module Pair2)
My question is if we can combine these two to achieve my original
goal. I first write:
module type Pair3_t = sig
type a
type v
type 'a t
val pair : a * (a -> v t)
end
and tried to define:
type 'v t3 =
A of (module Pair3_t with type v = 'v and type 'a t = 'a t3)
| V of 'v
but I got the following error:
Error: invalid package type: parametrized types are not supported
If mutual recursion between Pair3_t and t3 is allowed, that would also
be OK. But if I try to connect the two definitons with "and", I get a
syntax error.
You mention a functor, which is suggestive. I tried to use a
functor, but so far without success. Can I define my types using a
functor?
Thank you in advance. Sincerely,
--
Kenichi Asai