records with polymorphic variants?

records with polymorphic variants?

[Eliot Handelman]

Hi,

I'm trying to figure out how to define a record with a field whose type 
is an extensible polymorphic variant.

I can  this:

type f = [ `A of int ]

type r = { x : f }  

but then I can't do this:

{ x = `B "test" }

I'm not even sure if what I'm asking for is possible.

Guessing at the syntax I tried

type  r = {
    f :  [> #foo]
  }

which results in:

Warning D: this syntax is deprecated.
      f :  [> #foo]
              ^^^^
Characters 24-28:
      f :  [> #foo]
              ^^^^
The type [< foo ] is not a polymorphic variant type

I hope it is clear what I'm trying to do. Thanks for your help.

-- eliot

Re: [Caml-list] records with polymorphic variants?

[Lukasz Stafiniak]

This question should go to the "OCaml Beginners"
<ocaml_beginners@yahoogroups.com>.

On 3/4/07, Eliot Handelman <eliot@generation.net> wrote:
> Hi,
>
> I'm trying to figure out how to define a record with a field whose type
> is an extensible polymorphic variant.
>
> I can  this:
>
> type f = [ `A of int ]
>
> type r = { x : f }
>
> but then I can't do this:
>
> { x = `B "test" }

This is crearly a type mismatch: you specified r.x to allow only `A of int.
>
> I'm not even sure if what I'm asking for is possible.
>
I don't think so.

> Guessing at the syntax I tried
>
> type  r = {
>     f :  [> #foo]
>   }
>
> which results in:
>
> Warning D: this syntax is deprecated.
>       f :  [> #foo]
>               ^^^^
> Characters 24-28:
>       f :  [> #foo]
>               ^^^^
> The type [< foo ] is not a polymorphic variant type
>
Try the syntax:

# type r = {x : [> foo]};;
Characters 14-21:
  type r = {x : [> foo]};;
                ^^^^^^^
Unbound type parameter [..]

The open variant type introduces a type parameter, which is not bound
in definition of type r. I don't think these unnamed parameters can be
bound, so that you could write:

 "type 'a r = {x : foo SUM 'a}".

> I hope it is clear what I'm trying to do. Thanks for your help.
>
No, it is not clear. You haven't specified the context.

Re: [Caml-list] records with polymorphic variants?

[Dmitri Boulytchev]

    Making type r polymorphic works fine:

    type 'a r = {x : 'a}

    let u = {x = `A 3}
    let v = {x = `B "test"}

    Best regards,
    Dmitry Boulytchev,
    St.Petersburg State University.

> Hi,
>
> I'm trying to figure out how to define a record with a field whose 
> type is an extensible polymorphic variant.
>
> I can  this:
>
> type f = [ `A of int ]
>
> type r = { x : f } 
> but then I can't do this:
>
> { x = `B "test" }
>
> I'm not even sure if what I'm asking for is possible.
>
> Guessing at the syntax I tried
>
> type  r = {
>    f :  [> #foo]
>  }
>
> which results in:
>
> Warning D: this syntax is deprecated.
>      f :  [> #foo]
>              ^^^^
> Characters 24-28:
>      f :  [> #foo]
>              ^^^^
> The type [< foo ] is not a polymorphic variant type
>
> I hope it is clear what I'm trying to do. Thanks for your help.
>
> -- eliot
>
>
> _______________________________________________
> 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
>
>

Re: records with polymorphic variants?

[Zheng Li]

Hi,

Eliot Handelman <eliot@generation.net> writes:
> type f = [ `A of int ]
>
> type r = { x : f }  
>
> but then I can't do this:
>
> { x = `B "test" }
Here you want type f polymorphic, however as the type of a record field, its
polymorphism has to be reflected (bound) as type parameter in the declaration
of r.

I guess you want the follows

# type 'a r = { x : 'a } constraint 'a = [> f]
type 'a r = { x : 'a; } constraint 'a = [> f ]
# {x = "test"}
Characters 6-12:
  { x = "test"};;
        ^^^^^^
This expression has type string but is here used with type [> f ]
# {x = `B "test"}
- : [> `A of int | `B of string ] r = {x = `B "test"}

HTH, :)

--
Zheng Li
http://www.pps.jussieu.fr/~li/

Re: [Caml-list] Re: records with polymorphic variants?

[Lukasz Stafiniak]

On 3/4/07, Zheng Li <li@pps.jussieu.fr> wrote:
>
> Hi,
>
> Eliot Handelman <eliot@generation.net> writes:
> > type f = [ `A of int ]
> >
> > type r = { x : f }
> >
> > but then I can't do this:
> >
> > { x = `B "test" }
> Here you want type f polymorphic, however as the type of a record field, its
> polymorphism has to be reflected (bound) as type parameter in the declaration
> of r.

Yes, but the type f itself is not polymorphic, it is not [> f].
>
> I guess you want the follows
>
> # type 'a r = { x : 'a } constraint 'a = [> f]
> type 'a r = { x : 'a; } constraint 'a = [> f ]
> # {x = "test"}
> Characters 6-12:
>   { x = "test"};;
>         ^^^^^^
> This expression has type string but is here used with type [> f ]
> # {x = `B "test"}
> - : [> `A of int | `B of string ] r = {x = `B "test"}
>
Nice! I didn't realize this is possible. Thanks.

Re: [Caml-list] Re: records with polymorphic variants?

[Eliot Handelman]

Lukasz Stafiniak wrote:
> On 3/4/07, Zheng Li <li@pps.jussieu.fr> wrote:
>
> Yes, but the type f itself is not polymorphic, it is not [> f].
>>
>> I guess you want the follows
>>
>> # type 'a r = { x : 'a } constraint 'a = [> f]
>> type 'a r = { x : 'a; } constraint 'a = [> f ]
>> # {x = "test"}
>> Characters 6-12:
>>   { x = "test"};;
>>         ^^^^^^
>> This expression has type string but is here used with type [> f ]
>> # {x = `B "test"}
>> - : [> `A of int | `B of string ] r = {x = `B "test"}
>>
> Nice! I didn't realize this is possible. Thanks.

Just what I was looking for -- many thanks.

-- eliot

Re: [Caml-list] Re: records with polymorphic variants?

[Martin Jambon]

On Sun, 4 Mar 2007, Lukasz Stafiniak wrote:

> On 3/4/07, Zheng Li <li@pps.jussieu.fr> wrote:
>> 
>> Hi,
>> 
>> Eliot Handelman <eliot@generation.net> writes:
>> > type f = [ `A of int ]
>> >
>> > type r = { x : f }
>> >
>> > but then I can't do this:
>> >
>> > { x = `B "test" }
>> Here you want type f polymorphic, however as the type of a record field, 
>> its
>> polymorphism has to be reflected (bound) as type parameter in the 
>> declaration
>> of r.
>
> Yes, but the type f itself is not polymorphic, it is not [> f].

You can do this directly if you prefer:

type 'a f = 'a
   constraint 'a = [> `A of int ]

>> I guess you want the follows
>> 
>> # type 'a r = { x : 'a } constraint 'a = [> f]
>> type 'a r = { x : 'a; } constraint 'a = [> f ]
>> # {x = "test"}
>> Characters 6-12:
>>   { x = "test"};;
>>         ^^^^^^
>> This expression has type string but is here used with type [> f ]
>> # {x = `B "test"}
>> - : [> `A of int | `B of string ] r = {x = `B "test"}
>> 
> Nice! I didn't realize this is possible. Thanks.
>
> _______________________________________________
> 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
>

--
Martin Jambon
http://martin.jambon.free.fr

Re: [Caml-list] records with polymorphic variants?

[Jacques Garrigue]

From: "Lukasz Stafiniak" <lukstafi@gmail.com>

> Try the syntax:
> 
> # type r = {x : [> foo]};;
> Characters 14-21:
>   type r = {x : [> foo]};;
>                 ^^^^^^^
> Unbound type parameter [..]
> 
> The open variant type introduces a type parameter, which is not bound
> in definition of type r. I don't think these unnamed parameters can be
> bound, so that you could write:

The correct syntax in this case is

  type r = {x : 'a. [> foo] as 'a}

Unfortunately there seems to be a bug in 3.09, so that it doesn't
work. This will work again in 3.10.

(This was a stupid bug, as usual. Other cases, like
  type r = {x : 'a. <m : int; ..> as 'a}
do work in 3.09.)

Note that this seems not to be what the original poster wanted
actually, which was just a constrained type.

Jacques Garrigue

Re: [Caml-list] Re: records with polymorphic variants?

[Eliot Handelman]

Martin Jambon wrote:
>
> You can do this directly if you prefer:
>
> type 'a f = 'a
>   constraint 'a = [> `A of int ]

This is exactly what I was trying to do in the first place.
Where exactly is the main documentation for this syntax? Not in
JG's papers, unless I've missed something, as is possible.

Many thanks again,.

-- eliot
 

Re: [Caml-list] Re: records with polymorphic variants?

[Martin Jambon]

On Mon, 5 Mar 2007, Eliot Handelman wrote:

> Martin Jambon wrote:
>> 
>> You can do this directly if you prefer:
>> 
>> type 'a f = 'a
>>   constraint 'a = [> `A of int ]
>
> This is exactly what I was trying to do in the first place.
> Where exactly is the main documentation for this syntax? Not in
> JG's papers, unless I've missed something, as is possible.

Personally, I know it from someone who posted the same answer on caml-list 
sometime around 2004.
:-)


Martin

--
Martin Jambon
http://martin.jambon.free.fr

Re: [Caml-list] Re: records with polymorphic variants?

[Jacques GARRIGUE]

From: Eliot Handelman <eliot@generation.net>
> Martin Jambon wrote:
> >
> > You can do this directly if you prefer:
> >
> > type 'a f = 'a
> >   constraint 'a = [> `A of int ]
> 
> This is exactly what I was trying to do in the first place.
> Where exactly is the main documentation for this syntax? Not in
> JG's papers, unless I've missed something, as is possible.

It's not in my papers, because it is a rather subtle feature of the
type system, and is not directly related to type inference. It should
be in Vouillon&Remy's paper about objects.

It is documented in the manual, at the very end of section 6.8.1.
There are some examples involving objects (using the class syntax) in
section 3.10 of the tutorial.

Jacques Garrigue