It's Great! Thanks!

didier

2012/11/11 Jacques Garrigue <garrigue@math.nagoya-u.ac.jp>

> On 2012/11/09, at 23:25, Didier Cassirame <didier.cassirame@gmail.com>
> wrote:
>
> > Dear caml-list,
> >
> > I have been trying recently to combine classes, modules and variants
> > in the following fashion:
> >
> > module A1 = struct
> >
> >  class ['a] t = object
> >       constraint 'a = [>`a]
> >       method m : 'a -> string = function `a -> "a" | `a1 -> "a1" | _ ->
> "_"
> >   end
> >
> > end;;
> >
> > […]
> >
> > module type A = sig
> >
> >  class ['a] t : object
> >       constraint 'a = [>`a]
> >       method m : 'a -> string
> >   end
> >
> > end;;
> >
> > type m = (module A);;
> >
> > let l: m list = [ (module A1); (module A2); (module A3)];;
> >
> > --------------------------------
> >
> > Unfortunately the list typecheck fails. However, making a list of
> > class instances from A1.t, A2.t, A3.t succeed, with the type:
> >
> > [> `a | `a1 | `a2 | `a3 ] ct list
> >
> > ct being defined as equal to A.t.
> >
> > I thought that perhaps I should parameterize the type m from the type
> > parameter 'a of A.t to solve my problem, but I am not sure of the
> > syntax, or if it's the problem. Does anyone have an idea?
>
> Actually the parameterization would not help here, since you want to put
> them all in the same list.
> The idea of using first-class modules is to be explicit about types, so
> using an explicit type definition for a solves the problem.
>
> Jacques Garrigue
>
> module A1 = struct
>   type a = private [> `a | `a1]
>
>   class t = object
>     method m : a -> string = function `a -> "a" | `a1 -> "a1" | _ -> "_"
>   end
> end;;
>
> module A2 = struct
>   type a = private [> `a | `a2]
>
>   class t = object
>     method m : a -> string = function `a -> "a" | `a2 -> "a2" | _ -> "_"
>   end
> end;;
>
> module A3 = struct
>   type a = private [> `a | `a3]
>
>   class t = object
>     method m : a -> string = function `a -> "a" | `a3 -> "a3" | _ -> "_"
>   end
> end;;
>
> module type A = sig
>   type a = private [> `a]
>   class t : object
>     method m : a -> string
>   end
> end;;
>
> type m = (module A);;
>
> let l: m list = [ (module A1); (module A2); (module A3)];;
>
>