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

[Caml-list] restricting polymorphic variants
• David Monniaux
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
 Date: -- (:) From: David Monniaux Subject: [Caml-list] restricting polymorphic variants
```Let us say I have a module M as follows:
module M = struct type op=[`A|`B] let f: op->int=function `A->0|`B->1 end;

I cannot just sat that f has type [< `A|`B]->int because M has to fit
within a signature:
module type MT=sig type op val f: op->int end;;

I would like to obtain another module where f only accepts `A:
# module N = struct type op=[`A] let f: op->int=M.f end;;
^^^
This expression has type M.op -> int but is here used with type op -> int

Let us try eta-expansion:
# module N = struct type op=[`A] let f: op->int=fun x->M.f x end;;
^
This expression has type op = [ `A] but is here used with type
M.op = [ `A | `B]

Well, let us try enumerating all the constructors in the closed type op!
# module N = struct type op=[`A] let f: op->int=function (`A as x)->M.f x
end;;
module N : sig type op = [ `A] val f : op -> int end

Ok, it now works, but it is a bit clumsy: the typer knows all the
constructors of type N.op, which all fit into type M.op, why should I have
to enumerate them again?

This would not be so bad if this code was optimized away (after all, this
is a tail call with the same argument). Is it the case?

David Monniaux            http://www.di.ens.fr/~monniaux
Laboratoire d'informatique de l'École Normale Supérieure,
Paris, France

-------------------
Bug reports: http://caml.inria.fr/bin/caml-bugs  FAQ: http://caml.inria.fr/FAQ/
To unsubscribe, mail caml-list-request@inria.fr  Archives: http://caml.inria.fr

```