Re: [Caml-list] accessing the type of a polymorphic parameter

[Gabriel Scherer <gabriel.scherer@gmail.com>]

If you can formulate your problems with ('a ops), the module defining
an abstract type t can provide a (t ops) from inside the abstraction
boundary. Handling composite data types is also rather easy, just
provide for example an ('a ops -> 'a list ops) function.

The runtime type representation idea of Alain can also be extended to
deal with private types, but you need either to pre-plan the required
operation in advance and provide them from inside the abstraction
boundary, or expose the runtime type representation of the abstract
type which lessen encapsulation (but you can hardly do worse than
using Obj.magic in this case). This is present in "ocaml-ty", a
prototype work on runtime type representation by Pierre Chambart and
Grégoire Henry which has been presented during the last OCaml Users
and Developers Meeting back in September. It's experimental work and a
moving target, and comes with a "modification of the language" part
that isn't really the concern here, but you could think of looking at
their work (and providing them feedback!) if you really insist on
making heavy use of ad-hoc polymorphism.
  https://gitorious.org/ocaml-ty



On Fri, Oct 26, 2012 at 9:39 PM, "Mark" <mark@proof-technologies.com> wrote:
> Superb, thanks David, Lilian, Gabriel.  This may be just about sufficient
> for my purposes.  I'll have a play.
>
> As well as predefined OCaml primitive datatypes, what would perfect for me
> would be the ability to also do newly created abstract datatypes, and
> composite datatypes like lists of strings.  Are either of these possible
> with your solutions?
>
> Mark.
>
> on 26/10/12 7:29 PM, David Allsopp <dra-news@metastack.com> wrote:
>
>> ...
>> For this explicit example, you could write:
>>
>> let foo x =
>> match Obj.tag (Obj.repr x) with
>> x when x = Obj.int_tag -> ...
>> | x when x = Obj.string_tag -> ...
>>
>> but this probably isn't what you're after. The type of foo will also be 'a
>> -> '_b so you won't get any help from the type system in the calling of
> foo.
>> ...
>
>
> on 26/10/12 7:50 PM, Lilian Jean BESSON <lilian.besson@ens-cachan.fr> wrote:
>
>> ...
>> In my code "surcharge.ml", the main functions are "typage" : 'a ->
>> string, and "dump" : a' -> string.
>> Examples:
>> #9> Surcharge.typage;;
>> - : 'a -> string = <fun>
>> #10> Surcharge.typage 4  (* ok *);;
>> - : string = "int"
>> #11> Surcharge.typage 8.7  (* ok *);;
>> - : string = "float"
>> #12> Surcharge.typage "ok";; (* ok *)
>> - : string = "string"
>> #13> Surcharge.typage 'k'  (* not ok *);;
>> - : string = "int"
>> #14> Surcharge.typage [4]  (* not ok *);;
>> - : string = "array"
>> #15> Surcharge.typage [|4|];;
>> - : string = "array"
>> #16> Surcharge.typage cos  (* not ok *);;
>> - : string = "unknown"
>> But this function "typage" is very limited : no difference between arrays
>> and strings etc...
>> ...
>
>
> on 26/10/12 8:24 PM, Gabriel Scherer <gabriel.scherer@gmail.com> wrote:
>
>> ...
>> Long answer: I presume that your implementation works for any type
>> providing some fixed set of operations, but that you wish those
>> operations to be implemented differently for each type. You can define
>> a type ('a ops) describing these operations on the type 'a (as a
>> record of functions for example), and use the polymorphic type ('a ->
>> 'a ops -> foo) instead of ('a -> foo) to write your function.
>> Depending on your specific needs there may be slightly different
>> approaches (using a algebraic representation of runtime types rather
>> than a typeclass-like dictionary), a very general way being described
>> in this blog post by Alain Frisch :
>> http://www.lexifi.com/blog/dynamic-types
>> It could help to have more details on your needs to suggest a better
>> solution.
>>
>> Wrong answer: yes, using Obj.magic you can access the runtime
>> representation of values. You can't distinguish between boolean and
>> integers and the empty list, but worrying about that is for the
>> coward, let's shoot yourself in the foot -- starting by reading the
>> documentation on the representation of OCaml values, chapter
>> "interacting with C" in the manual.
>> ...