Version française
Home     About     Download     Resources     Contact us    

This site is updated infrequently. For up-to-date information, please visit the new OCaml website at

Browse thread
# types and polymorphic variants
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: Jacques Garrigue <garrigue@k...>
Subject: Re: # types and polymorphic variants
From: Manuel Fahndrich <>

> What is the meaning of #foo, when foo is a polymorphic variant set?
> type foo = [`A | `B | `C]
> I assumed that it was the following:
> 	#foo = [<`A | `B | `C ]
> that is a set containing at most `A | `B | `C. In other words a subtype of
> foo.

This is correct. Notice however that [> `A | `B | `C] would also be a
subtype of foo (although from a different point of view), so there is
a choice done here between two possibilities, and I took the seemingly
most useful/intuitive.

> But consider the following example.

It seems that you found a bug in ocaml-2.99. If you are particularly
interested in variants, I suggest you switch to the CVS version.

With the current CVS version it works as you expect:

        Objective Caml version 2.99+6 (2000/02/25)

# type foo = [`A|`B|`C];;
type foo = [`A|`B|`C]
# let foo1 (x : #foo) = x;;
val foo1 : (#foo as 'a) -> 'a = <fun>
# let y1 = foo1 (`A : [`A]);;
val y1 : [`A] = `A
# let foo2 (#foo as x) = x;;
val foo2 : #foo -> [>`A|`B|`C] = <fun>
# foo2 (`A : [`A]);;
- : _[>`A|`B|`C] = `A

foo2 shows the difference between the type #foo, and the pattern #foo,
which intuitively accepts all values of type #foo, but also permits
type refinement when combined with "as".

> The first function returns me only a foo, the second function returns me
> [`A] as expected. Thus my question, what exactly does #foo stand for. I do
> understand row variables, but the issue with the lower and upper bounds > <
> in variant types seems new. Is there a paper describing these?

The answer is that your intuition was correct.
You will find a description of variants in "Programming with polymorphic
variants", ML Workshop '98, Baltimore. You can get it from my home
In fact the system in ocaml 3 is a refinement of that, forgetting the
type of a tag when it disappears from the upper bound, but this
shouldn't matter in most cases.

Jacques Garrigue      Kyoto University     garrigue at
		<A HREF=>JG</A>