Re: [Caml-list] do i need a private row type?

[Goswin von Brederlow <goswin-v-b@web.de>]

Gabriel Scherer <gabriel.scherer@gmail.com> writes:

> On Mon, May 16, 2011 at 8:24 AM, Goswin von Brederlow <goswin-v-b@web.de>
> wrote:
>
>     First thing is that if you have different 'a poll_items then you need to
>     include a callback that accepts a matching 'a Socket.t. E.g.:
>
>     type 'a poll_item = ('a Socket.t * event_mask * ('a Socket.t -> event_mask
>     -> unit))
>
>     Then you can make an unit poll_item array and use
>
>     let set i (item : 'a poll_item) =
>        array.[i] <- Obj.magic item
>
>     let call i =
>        let (sock, mask, fn) = array.[i]
>        in
>        fn sock mask
>
>     The important part here is that you ensure the 'a Socket.t is only
>     accessed through the callback. Only that will have the right type.
>
>
> If "call" is the only thing you wish to do on your array, you don't need such
> an ugly solution. "sock" and "mask" being constants for a given item, you can
> simply capture them in a closure.
>
>   type poll_item_thunk = unit -> unit
>
>   let set i (socket, event_mask, callback) =
>     array.(i) <- (fun () -> callback socket event_mask);
>
>   let call i = array.(i) ()
>
>
> There is no reasonable answer to "how do I force OCaml into breaking type
> safety ?". Joel must have an use case in mind which is actually type-safe;
> maybe it's only the callback as you demonstrated (I fail to see its usefulness,
> but I don't know anything about ZeroMQ), maybe it's something a bit more
> complicated. But we won't be able to give him a satisfying solution unless he
> describes more precisely what this type-safe use is.

This is still type safe given sufficient encapsulation in a module so it
can't be abused. But as I said, it is the dirty solution, like anything
requireing Obj.magic is. And you are right, if all you have is one
callback then a simple closure is better.

But you also need access to the Unix.file_descr underlying the socket to
select on it. And then you need a second callback to handle error
conditions. And then your socket probably has some state and things
become mutable and closures quickly become ugly and use up a lot more
memory if you have many sockets.

> The most general solution, as you alluded, is to use existential types. This
> can be done by an encoding into universal types (this is the "2 records"
> approach), or using first-class modules and abstract types.

I haven't tried this with first-class modules and the better support for
abstract types yet. But I would be interested to see in how they improve
on the 2 records solution.

Another thing I didn't mention is to use objects. This use case is
actually the poster child for objects with virtual functions.

> Joel, may you be more explicit as to what you want to do with those "poll_item"
> array. More precisely, how do you plan to *use* the data in the array?

MfG
        Goswin