Version française
Home     About     Download     Resources     Contact us    

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

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: -- (:)
From: Dmitri Boulytchev <db@t...>
Subject: Re: [Caml-list] polymorphic lists, existential types and asorted other hattery
    Try using classes for this purpose:

let show l = (fun x -> x#show) l

class integer x =
    method show = string_of_int x

class floating x =
    method show = string_of_float x

class boolean x =
    method show = string_of_bool x

let _ =
    (Printf.printf "%s\n")
     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 -> x
>     | `Float x -> x
>     | `Bool x -> x
>   ;;
> 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

Caml-list mailing list. Subscription management:
Beginner's list:
Bug reports: