[Caml-list] restricting polymorphic variants

[Caml-list] restricting polymorphic variants

[David Monniaux]

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

Re: [Caml-list] restricting polymorphic variants

[Laurent Vibert]

On Thu, 31 Jan 2002, David Monniaux wrote:

> 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;;
>                                                 ^^^
> Let us try eta-expansion:
> # module N = struct type op=[`A] let f: op->int=fun x->M.f x end;;
>

this one work with an explicit coercion :
module N = struct type op=[`A] let f: op->int=fun x->M.f (x:>M.op) end;;


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

or faster :
module N = struct type op=[`A] let f (#op as x) = M.f x end;;

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