English version
Accueil     À propos     Téléchargement     Ressources     Contactez-nous    
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: Arnaud Spiwack <Arnaud.Spiwack@l...>
Subject: Re: [Caml-list] polymorphic lists, existential types and asorted other hattery
What you are describing is rather existential in essence. Existential 
type do not exist in OCaml but are encodable through interesting tricks 
(I know so because I kinda asked a similar question a few month ago :p 
). See discussion thread here (which was pointed to me this very time I 
asked the question) : http://tinyurl.com/2p5oan .

Here is your example refactored with this methodology :

type 'e show = { item : 'e; show: 'e-> string }
type 't show_scope = { bind_show : 'e. 'e show -> 't }
type showable = { open_showable : 't. 't show_scope -> 't }

let create_showable sh it =
  { open_showable = fun scope -> scope.bind_show { item = it ; show = sh } }

let use_showable shw f = shw.open_showable f

let show shw = use_showable shw { bind_show = fun sh -> sh.show sh.item }

let showable_int = create_showable string_of_int
let showable_bool = create_showable string_of_bool
let showable_float = create_showable string_of_float

let xs = [(showable_int 1); (showable_float 2.0); (showable_bool false)]

List.map show xs

Peng Zang a écrit :
> -----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".
>
>   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
> -----BEGIN PGP SIGNATURE-----
> Version: GnuPG v2.0.7 (GNU/Linux)
>
> iD8DBQFHOd52fIRcEFL/JewRAkZNAJ9MUE4Ph4ybbtKjiV9h9ZxPsvDwGQCgwIJz
> aOceerrixiPZosJq4a+r0qM=
> =zOZF
> -----END PGP SIGNATURE-----
>
> _______________________________________________
> 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
>
>