Re: [Caml-list] Locally abstract parameterized types?

[Jeremy Yallop <yallop@gmail.com>]

On Sat, 18 Apr 2020 at 09:49, Kenichi Asai <asai@is.ocha.ac.jp> wrote:
> > 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.

Here's one fairly direct way to do that:

    type 'v pair_t = Pair : ('a * ('a -> 'v t)) -> 'v pair_t
    and 'v t =
      A of 'v pair_t
    | V of 'v

    let test : bool t = A (Pair (3, fun x -> V true))

But, since '∃a.(a × (a → t))' is isomorphic to 'unit → t', you can
write the example more simply, without universal or existential types:

   type 'v t =
     A of (unit -> 'v t)
   | V of 'v

   let a x f = A (fun () -> f x)
   let test : bool t = a 3 (fun x -> V true)

(Of course, in your real code this scheme may be not be possible.)

> 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

Here's a slight variant of this idea that works by avoiding the
parameterized type in Pair3_t:

  module type Pair3_t = sig
    type a
    type vt
    val pair : a * (a -> vt)
  end

  type 'v t =
    A of (module Pair3_t with type vt = 'v t)
  | V of 'v

  let test : bool t = A (module struct type a = int
                                       type vt = bool t
                                       let pair = (3, fun x -> V true)
                                end)

Kind regards,

Jeremy