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

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 Subject: polymorphic lists, existential types and asorted other hattery
```-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

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

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
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2.0.7 (GNU/Linux)

iD8DBQFHOd52fIRcEFL/JewRAkZNAJ9MUE4Ph4ybbtKjiV9h9ZxPsvDwGQCgwIJz
aOceerrixiPZosJq4a+r0qM=
=zOZF
-----END PGP SIGNATURE-----

```