English version
Accueil     À propos     Téléchargement     Ressources     Contactez-nous    

Ce site est rarement mis à jour. Pour les informations les plus récentes, rendez-vous sur le nouveau site OCaml à l'adresse ocaml.org.

Browse thread
polymorphic lists, existential types and asorted other hattery
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: 2007-11-13 (17:27)
From: Peng Zang <peng.zang@g...>
Subject: polymorphic lists, existential types and asorted other hattery
Hash: SHA1


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
  module Float = struct
    type t = float
    let show x = string_of_float x
  module Bool = struct
    type t = bool
    let show x = string_of_bool x

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


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.

Version: GnuPG v2.0.7 (GNU/Linux)