Version française
Home     About     Download     Resources     Contact us    
Browse thread
Shared types: dependency in modules with polymorphic type
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: Hugo Ferreira <hmf@i...>
Subject: Re: [Caml-list] Shared types: circular dependency in modules with polymorphic type
Hi,

Peng Zang wrote:
> -----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


Yes, that is what am I going to do.
Something similar was also suggested by someone else.

Thank you,
Hugo F.


> 
> 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
>