Accueil     À propos     Téléchargement     Ressources     Contactez-nous

Ce site est rarement mis à jour. Pour les informations les plus récentes, rendez-vous sur le nouveau site OCaml à l'adresse ocaml.org.

[Caml-list] Documentation error - #myvariant
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
 Date: 2004-04-29 (12:40) From: Remi Vanicat Subject: Re: [Caml-list] Documentation error - #myvariant
```Keith Wansbrough <Keith.Wansbrough@cl.cam.ac.uk> writes:

> Hi.. the OCaml documentation, section 4.2 on polymorphic variants,
> Advanced use, explains that
>
>   To make this even more confortable, you may use type definitions as
>   abbreviations for or-patterns. That is, if you have defined type
>   myvariant = [`Tag1 int | `Tag2 bool], then the pattern #myvariant is
>   equivalent to writing (`Tag1(_ : int) | `Tag2(_ : bool)).
>
> But this is not correct!  Consider
>
>   type de = [`D | `E of de];;
>
>   type def = [`D | `E of def | `F of def];;
>
>   let rec deproc2 rfun =
>     function
>       | `D -> print_string "D"; `D
>       | `E(x) -> print_string "E"; `E(rfun x)
>
>   let rec deproc3 x = deproc2 deproc3 x
>
>   let rec defproc2 rfun =
>     function
>   (*    | (`D | `E(_)) as x -> deproc2 rfun x *)
>       | #de as x -> deproc2 rfun x
>       | `F(x) -> print_string "f"; `F(rfun x)

If I read the documentation, this is rewrote as
let rec defproc2 rfun =
function
| (`D | `E(_:de)) as x -> deproc2 rfun x
| `F(x) -> print_string "f"; `F(rfun x)

that mean that what is in the `E must be a de, not a def. There is

In fact, your code will do what you want if you don't define your type
as recursive but as polymorphic :

type 'a de = [`D | `E of 'a];;

type 'a def = [`D | `E of 'a | `F of 'a];;

then, your code will work as expected. Well, the last definition became :
let rec defproc3 : ('a def as 'a) -> 'a =
fun x -> defproc2 defproc3 x

There is a very interesting

[...]

> as expected.  It looks to me like #de means (`D | `E(_:de)), rather
> than (`D | `E(_)) as I expected; except that I'm not even sure what
> `E(_:de) means in this case - does it do type-directed matching at
> runtime?

no, it is a constraint on the type of what is the `E done at compile
time. And it is the source of your error because a de is not a def.

>
> Could the documentation please be made more accurate at this point?
>

The documentation is accurate.

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

```