]>
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)
let rec defproc3 : def -> def =
fun x -> defproc2 defproc3 x
This gives the following error (in OCaml 3.07+2):
File "polyvar2.ml", line 19, characters 29-30:
This expression has type def = [ `D | `E of def | `F of def ]
but is here used with type [< `D | `E of de | `F of de ]
Type def = [ `D | `E of def | `F of def ] is not compatible with type
de = [ `D | `E of de ]
(Note that the expression mentioned is the final x on the last line.)
Replacing the #de line with the commented line above it, however,
yields
val defproc3 : def -> def = <fun>
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?
Could the documentation please be made more accurate at this point?
Thanks.
--KW 8-)
-------------------
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