[Caml-list] References to polymorphic variants

[Caml-list] References to polymorphic variants

[nickgrey]

Hi, 

I want to be able to store an arbitrary polymorphic variant in a reference: 

let (x : ([> ] option) ref ) = ref None ;; 

(Not my actual code, I've boiled it down to a minimal example.) 

This won't compile because it "contains a type variable which cannot be 
generalized".  I understand this error message in other contexts.  If my 
code were 

let x = ref None 

then I could break type safety by putting (Some 1) into the reference, and 
later reading the reference with type (string option) thus casting a string 
to an int. 

But as I'm dealing with a polymorphic variant, surely this should not apply. 
My understanding of polymorphic variants is that you do not need to specify 
at the time of declaration what types it might contain. 

So, what am I doing wrong and how can I get around it? 

Regards,
Nick 

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners

Re: [Caml-list] References to polymorphic variants

[Eric C. Cooper]

On Wed, Feb 25, 2004 at 09:05:48AM -0700, nickgrey@softhome.net wrote:
> I want to be able to store an arbitrary polymorphic variant in a reference: 
> 
> let (x : ([> ] option) ref ) = ref None ;; 
> 
> (Not my actual code, I've boiled it down to a minimal example.) 
> 
> This won't compile because it "contains a type variable which cannot be 
> generalized".

It works in version 3.07+2:

        Objective Caml version 3.07+2

# let (x : [> ] option ref) = ref None;;
val x : _[>  ] option ref = {contents = None}

-- 
Eric C. Cooper          e c c @ c m u . e d u

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners

[Caml-list] Re: Caml-list References to polymorphic variants

[Remi Vanicat]

nickgrey@softhome.net writes:

> Hi,
>
> I want to be able to store an arbitrary polymorphic variant in a
> reference:
>
> let (x : ([> ] option) ref ) = ref None ;;
>
> (Not my actual code, I've boiled it down to a minimal example.)
>
> This won't compile because it "contains a type variable which cannot
> be generalized".  I understand this error message in other contexts.
> If my code were
>
> let x = ref None
>
> then I could break type safety by putting (Some 1) into the reference,
> and later reading the reference with type (string option) thus casting
> a string to an int.
>
> But as I'm dealing with a polymorphic variant, surely this should not
> apply. My understanding of polymorphic variants is that you do not
> need to specify at the time of declaration what types it might
> contain.

you can break type safety with your example :

`Foo 10
and
`Foo "string"
are both some polymorphic variant, and if your generalized type would
be ok, nothing could forbid you to "convert" one to another, having
the same effect that the (Some 1) and (string option) example.
 


-- 
Rémi Vanicat

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners

Re: [Caml-list] References to polymorphic variants

[Issac Trotts]

On Wed, Feb 25, 2004 at 05:41:09PM -0500, Eric C. Cooper wrote:
> On Wed, Feb 25, 2004 at 09:05:48AM -0700, nickgrey@softhome.net wrote:
> > I want to be able to store an arbitrary polymorphic variant in a reference: 
> > 
> > let (x : ([> ] option) ref ) = ref None ;; 
> > 
> > (Not my actual code, I've boiled it down to a minimal example.) 
> > 
> > This won't compile because it "contains a type variable which cannot be 
> > generalized".
> 
> It works in version 3.07+2:
> 
>         Objective Caml version 3.07+2
> 
> # let (x : [> ] option ref) = ref None;;
> val x : _[>  ] option ref = {contents = None}

He's talking about compiling it, which is slightly different:

$ cat foo.ml
let (x : ([> ] option) ref ) = ref None ;;

$ /usr/bin/ocamlc -c foo.ml
File "foo.ml", line 1, characters 31-39:
The type of this expression, _[>  ] option ref,
contains type variables that cannot be generalized

$ /usr/bin/ocamlc -v
The Objective Caml compiler, version 3.07+2
Standard library directory: /usr/lib/ocaml/3.07

The set of values that x can have is still unspecified, so there is
implicitly a type variable whose value needs to be nailed down before
the example can compile.  Here's a way to work around it:

type t = [ `bleh | `woof ];;
let x = ref (None : t option);; 

-- 
Issac Trotts
http://redwood.ucdavis.edu/~issac

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners

Re: [Caml-list] References to polymorphic variants

[Eric C. Cooper]

On Wed, Feb 25, 2004 at 03:07:19PM -0800, Issac Trotts wrote:
> He's talking about compiling it, which is slightly different:
> 
> $ cat foo.ml
> let (x : ([> ] option) ref ) = ref None ;;
> 
> $ /usr/bin/ocamlc -c foo.ml
> File "foo.ml", line 1, characters 31-39:
> The type of this expression, _[>  ] option ref,
> contains type variables that cannot be generalized
> 
> The set of values that x can have is still unspecified, so there is
> implicitly a type variable whose value needs to be nailed down before
> the example can compile.  Here's a way to work around it:
> 
> type t = [ `bleh | `woof ];;
> let x = ref (None : t option);; 

Or, he can just use x in the scope of that module, if that's
sufficient for his application.

$ cat foo.ml 
let (x : [> ] option ref) = ref None

let () =
  x := Some `Apple;
  x := Some (`Pair (17, "foo"));
  x := Some `Cheese

$ ocamlc -i -c foo.ml
val x : _[> `Apple | `Cheese | `Pair of int * string ] option ref

-- 
Eric C. Cooper          e c c @ c m u . e d u

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners

Re: [Caml-list] References to polymorphic variants

[Eric C. Cooper]

Please ignore my last post.  I thought that since

> $ ocamlc -i -c foo.ml
> val x : _[> `Apple | `Cheese | `Pair of int * string ] option ref

didn't complain, the compiler had accepted it, but it does complain when I
omit the -i. (Is this a bug?)

-- 
Eric C. Cooper          e c c @ c m u . e d u

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners

Re: [Caml-list] References to polymorphic variants

[Jacques Garrigue]

From: "Eric C. Cooper" <ecc@cmu.edu>

> Please ignore my last post.  I thought that since
> 
> > $ ocamlc -i -c foo.ml
> > val x : _[> `Apple | `Cheese | `Pair of int * string ] option ref
> 
> didn't complain, the compiler had accepted it, but it does complain when I
> omit the -i. (Is this a bug?)

It's not a bug: -i does the type checking, but does not actually
compile.
It's useful, because you can use this information to write your .mli.
In the above case, you would have to write in foo.mli:
  val x : [ `Apple | `Cheese | `Pair of int * string ] option ref
This makes sure your reference is no longer polymorphic, and makes the
compiler happy.

To go back to the original question, a polymorphic variant is just a
more refined way to the described the possible values of a sum type.
This is not a universal type, like variants in Visual Basic.
As the above example shows, you can still use polymorphic variants to
have the type checker compute the contents of a reference inside a
compilation unit, but this will not work across compilation units.
If you need a universal type, you can use [exn], the type of
exceptions, as exceptions defined in different modules can be
distinguished (whereas polymorphic variant tags cannot).

Jacques Garrigue

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners