-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1
You could try factoring the complicated type out of U.t and keep it abstract.
All that was holding back your original solution from working was the fact
that the type was defined in U and so couldn't be shared.
Maybe something like:
module Make_P (VI:VB)
(T:COMPLEXTYPE)
(UI:U with type instance = T.t and type t = T.t VI.t)
(RI:R with type instance = UI.instance and type t = UI.t)
struct .. end
Peng
On Thursday 14 May 2009 08:46:58 am Hugo Ferreira wrote:
> Hello,
>
> Appreciate the feedback.
>
> Peng Zang wrote:
> > -----BEGIN PGP SIGNED MESSAGE-----
> > Hash: SHA1
> >
> > I think this is because UI.t is abstract and is in fact, never created.
> > You need to tell the old caml that UI.t is actuall an int VI.t. Then it
> > should work.
>
> True. However in the real case I am not dealing with an "int"
> but some more complicated data defined in U. I wanted to avoid
> "looking" into U to know what U.t is and therefore set VI.t
> accordingly.
>
> This is important because I will use different U implementations.
> For each such cases I would have to create a module for each U
> implementation. Not doable.
>
> > module Make_P (VI : VB)
> > (UI : U with type t = int VI.t)
> > (RI : R with type t = UI.t and type instance = UI.instance
> > ) = struct ... end
> >
> > module P1 = Make_P ( VB1 ) ( U1 ) ( R1 )
> >
> > Works like a charm for me,
>
> I guess I will have to rethink my modules/types 8-(.
>
> Thanks,
> Hugo F.
>
> > Peng
> >
> > On Thursday 14 May 2009 07:41:24 am Hugo Ferreira wrote:
> >> Hello,
> >>
> >> I have again encountered a problem with sharing types.
> >> However this time I really have a set of interfaces
> >> which need to be "stitched" together via type sharing.
> >>
> >> Problem is I am dealing with a circular polymorphic
> >> type dependency. Or at least seems so. I have added the
> >> very simple code for testing at the end. But the short
> >> of it is: with the code below
> >>
> >> module Make_P (VI : VB)
> >> (UI : U)
> >> (RI : R with type t = UI.t )
> >> = struct
> >>
> >> type instance = UI.instance
> >> type t = UI.t
> >>
> >> let do_something_nice null =
> >> let vb0 = VI.empty in
> >> let vb1 = VI.add vb0 UI.zero in
> >> RI.do_something_else vb1 UI.one
> >>
> >> end
> >>
> >> I get the error:
> >>
> >> This expression (vb1) has type UI.instance VI.t but is here used with
> >> type RI.t = UI.t
> >> vb1: UI.instance VI.t
> >>
> >>
> >> The problem is that VI.t is polymorphic.
> >> And UI uses VI.t setting the polymorphic
> >> type in the process.
> >> I want to make it "UI.instance VI.t."
> >> How can I do that. I have tried:
> >>
> >>
> >> module Make_P (VI : VB)
> >> (UI : U with type t = U.instance VI.t)
> >> (RI : R with type t = UI.t )
> >> and
> >>
> >> module Make_P (UI : U)
> >> (VI : VB with type 'a t = UI.t)
> >> (RI : R with type t = UI.t )
> >>
> >> with no success.
> >>
> >>
> >>
> >> --------------------- Code ---------------
> >>
> >>
> >>
> >> module type VB = sig
> >>
> >> type 'a t
> >>
> >> val empty : 'a t
> >> val add : 'a t -> 'a -> 'a t
> >> end
> >>
> >>
> >> module VB1 : VB
> >> = struct
> >>
> >> type 'a t = 'a list
> >>
> >> let empty = []
> >> let add l e = e :: l
> >> end
> >>
> >>
> >> module type U =
> >> sig
> >>
> >> type instance = int
> >> type t
> >>
> >> val zero : instance
> >> val one : instance
> >>
> >> val empty : t
> >> val do_something : t -> instance -> t
> >> end
> >>
> >>
> >> module Make_U (Vb : VB)
> >> = struct
> >>
> >> type instance = int
> >> type t = instance Vb.t
> >>
> >> let zero = 0
> >> let one = 1
> >>
> >> let empty = Vb.empty
> >> let do_something ts inst = Vb.add ts inst
> >>
> >> end
> >>
> >>
> >> module U1 = Make_U ( VB1 )
> >>
> >> let _ =
> >>
> >> let vb0 = VB1.empty in
> >> let vb1 = VB1.add vb0 U1.zero in
> >> let vb2 = U1.do_something vb1 U1.one in
> >> let _ = VB1.add vb2 U1.zero in
> >> ()
> >>
> >>
> >> module type R =
> >> sig
> >>
> >> type instance = int
> >> type t
> >>
> >> val do_something_else : t -> instance -> t
> >> end
> >>
> >> module Make_R (VI : VB)
> >> (UI : U)
> >> = struct
> >>
> >> type instance = UI.instance
> >> type t = UI.t
> >>
> >> let do_something_else ts inst = UI.do_something ts inst
> >>
> >> end
> >>
> >> module R1 = Make_R ( VB1 ) ( U1 )
> >>
> >>
> >> let _ =
> >>
> >> let vb0 = VB1.empty in
> >> let vb1 = VB1.add vb0 U1.zero in
> >> let vb2 = R1.do_something_else vb1 U1.one in
> >> let _ = VB1.add vb2 U1.zero in
> >> ()
> >>
> >>
> >> module Make_P (VI : VB)
> >> (UI : U)
> >> (RI : R with type t = UI.t )
> >> = struct
> >>
> >> type instance = UI.instance
> >> type t = UI.t
> >>
> >> let do_something_nice null =
> >> let vb0 = VI.empty in
> >> let vb1 = VI.add vb0 UI.zero in
> >> RI.do_something_else vb1 UI.one
> >>
> >> end
> >>
> >> module P1 = Make_P ( U1 ) ( VB1 ) ( R1 )
> >>
> >> or
> >>
> >> module P1 = Make_P ( VB1 ) ( U1 ) ( R1 )
> >>
> >> _______________________________________________
> >> Caml-list mailing list. Subscription management:
> >> http://yquem.inria.fr/cgi-bin/mailman/listinfo/caml-list
> >> Archives: http://caml.inria.fr
> >> Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
> >> Bug reports: http://caml.inria.fr/bin/caml-bugs
> >
> > -----BEGIN PGP SIGNATURE-----
> > Version: GnuPG v2.0.7 (GNU/Linux)
> >
> > iD8DBQFKDAqMfIRcEFL/JewRAikyAKDWuRFALodBLy5NqWJFBH4MDD5FdgCg0Q5J
> > U4I+34lrt7QjpkzQwZpztEE=
> > =VbUW
> > -----END PGP SIGNATURE-----
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2.0.7 (GNU/Linux)
iD8DBQFKDBqUfIRcEFL/JewRAoVtAKCiNVC/v1+qBaKPUZxZrMzHsOKfpACfQdoI
CJ4kV/JL6HCcrwVAYYluY9s=
=HTzi
-----END PGP SIGNATURE-----
_______________________________________________
Caml-list mailing list. Subscription management:
http://yquem.inria.fr/cgi-bin/mailman/listinfo/caml-list
Archives: http://caml.inria.fr
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
Bug reports: http://caml.inria.fr/bin/caml-bugs
