Try using classes for this purpose:

let show l = List.map (fun x -> x#show) l

class integer x =
  object
    method show = string_of_int x
  end

class floating x =
  object
    method show = string_of_float x
  end

class boolean x =
  object
    method show = string_of_bool x
  end


let _ =
  List.iter
    (Printf.printf "%s\n")
    (show
       [
     new integer 10;
         new floating 3.14;
         new boolean true;
       ]
    )

    Best regards,
    Dmitri Boulytchev,
    St.Petersburg State University.

> Hi,
>
> Is there a way to create lists in which the elements may be of
> differing types but which all have some set of operations defined
> (eg. tostr) in common?  One can then imagine mapping over such lists
> with "generic" versions of those common operations.  Here's a concrete
> example of what I mean:
>
>   module Int = struct
>     type t = int
>     let show x = string_of_int x
>   end
>   module Float = struct
>     type t = float
>     let show x = string_of_float x
>   end
>   module Bool = struct
>     type t = bool
>     let show x = string_of_bool x
>   end
>
>   let xs = [`Int 1; `Float 2.0; `Bool false]
>   let showany x = match x with
>     | `Int x -> Int.show x
>     | `Float x -> Float.show x
>     | `Bool x -> Bool.show x
>   ;;
>   List.map showany xs;;
>
> Essentially we have ints, floats and bools.  All these types can be
> shown.  It would be nice to be able to create a list of them [1; 2.0;
> false] that you can then map a generalized show over.  In the above
> example, I used polymorphic variants in order to get them into the
> same list and then had to define my own generalized show function,
> "showany".  This is fine as there is only one shared operation but if
> there is a large set of these common operations, it becomes
> impractical to define a generalized version for each of them.
>
> I've come across a way to do this in haskell using what they call
> "existential types".
>
>   http://www.haskell.org/haskellwiki/Existential_type
>
> I don't really understand existential types however and don't know if
> OCaml has them nor how to use them.
>
> So.  How can one do this in OCaml?  Is there perhaps a camlp4
> extension that can do this?  Is there a possible functor trick that
> can take N modules as arguments and spit out a new module with a
> generalized type that can take on any of the types in the arguments
> and also make generalized versions of operations common to the N
> modules?  Are there existential types or equivalents in OCaml?  If so
> how does one go about using them?
>
> Thanks in advance to anyone who forays into this bundle of questions.
>
> Peng


_______________________________________________
Caml-list mailing list. Subscription management:
http://yquem.inria.fr/cgi-bin/mailman/listinfo/caml-list
Archives: http://caml.inria.fr
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
Bug reports: http://caml.inria.fr/bin/caml-bugs