Hello,

Le ven. 09 oct. 2009 09:09:35 CEST,
Gabriel Kerneis <kerneis@pps.jussieu.fr> a écrit :

> On Fri, Oct 09, 2009 at 07:25:41AM +0200, rouanvd@softwarerealisations.com wrote:
> > ======================================================
> > type t = MyInt of int | MyFloat of float | MyString of string ;;
> > 
> > let foo printerf = function
> >   | MyInt i -> printerf string_of_int i
> >   | MyFloat x -> printerf string_of_float x
> >   | MyString s -> printerf (fun x -> x) s
> > ;;
> > ======================================================
> 
> Type-inference has nothing to do with it, it's the type system itself
> which fails.
> 
> What is the type you would expect? I guess:
> (forall 'a. ('a -> string) -> 'a -> 'b) -> t -> 'b
> 
> This is impossible with Ocaml: you cannot have a universal quantifier,
> type variables are existantially quantified.
> 

Well, I'm afraid this the other way round: a polymorphic type in Ocaml
is implicitly universally quantified: (fun x->x : 'a -> 'a) means the
identity function can be applied to an argument of any type, not that
there exists a type 'a on which you can apply it.
In addition, the desired type for printerf is indeed an existential
one (printerf: exists 'a. 'a -> string -> 'a -> 'b): you don't want the
first argument to convert any type to a string, just the type of the
second argument.

A possible but very heavy solution would be to use functors and local
modules everywhere (I guess that Haskell's typeclasses would help here).

type t = MyInt of int | MyFloat of float | MyString of string ;;

module type Printerf=functor(A:sig type t val to_string: t -> string
end) -> sig val print: A.t -> unit
end

module Foo(Printerf:Printerf) = struct
let foo = function
| MyInt i ->
    let module M = Printerf(struct type t = int
                                   let to_string = string_of_int end)
    in M.print i
| MyFloat x ->
    let module M = Printerf(struct type t = float
                                   let to_string = string_of_float end)
    in M.print x
| MyString s ->
    let module M = Printerf(struct type t = string
                                   let to_string = fun x -> x end)
    in M.print s
end
;;

but personally I'd do the same thing as you:
> In you very specific case, though, I guess refactoring it is possible:
> let foo printerf = function
>   | MyInt i -> printerf (string_of_int i)
>   | MyFloat x -> printerf (string_of_float x)
>   | MyString s -> printerf s
> ;;

-- 
E tutto per oggi, a la prossima volta.
Virgile