Re: [Caml-list] Problem correlating input and output type

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

Tiphaine Turpin <Tiphaine.Turpin@irisa.fr> writes:

> Goswin von Brederlow a écrit :
>> Hi,
>>
>> last night I had a crazy idea
> Definitely :-).
>
>> [...]
>>
>>
>> Can anyone think of a way to express this so that the type system keeps
>> track of which callbacks are already connected?
>>   
> Here is an attempt (with only two "events"). Note that :
> - the imperative version cannot prevent connecting a signal more than once
> - such types can only represent sets of "parallel" edges of a lattice,
> i.e., this doesn't generalises to arbitrary "typestate" properties
> - this is just a curiosity, and not a reasonable way of doing such
> things. Runtime checking would be much easier (but still a bit hackish).

But runtime checks will only show the error when the GUI object is
instantiated. Some obscure dialog might not pop up in month.

> Tiphaine
>
> module LatticeFun : sig
>
>   type ('foo, 'bar) r
>   type t and f
>
>   val make : unit -> (f, f) r
>   val set_foo : (f, 'bar) r -> (t, 'bar) r
>   val set_bar : ('foo, f) r -> ('foo, t) r
>   val use : (t, t) r -> unit
>
> end = struct
>
>   type ('foo, 'bar) r = {foo : bool ; bar : bool}
>
>   type t
>   type f = t
>
>   let make () = {foo = false ; bar = false}
>   let set_foo x = {x with foo = true}
>   let set_bar x = {x with bar = true}
>   let use _ = ()
>
> end
>
> module LatticeImp : sig
>
>   type ('foo, 'bar) r
>   type t and f
>
>   val make : unit -> (f, f) r
>   val set_foo : ('foo, 'bar) r -> (t, 'bar) r
>   val set_bar : ('foo, 'bar) r -> ('foo, t) r
>   val use : (t, t) r -> unit
>
> end = struct
>
>   (* for some reason, the direct declaration causes a module type error *)
>   type r1 = {mutable foo : bool ; mutable bar : bool}
>   type ('foo, 'bar) r = r1
>
>   type t
>   type f = t
>
>   let make () = {foo = false ; bar = false}
>   let set_foo x = x.foo <- true ; x
>   let set_bar x = x.bar <- true ; x
>   let use _ = ()
>
> end

Thanks. That solves the first problem. But how do you translate that
into ocaml objects?

type need_click
type have_click

class type ['click] clickable_type = object
  method set_click : ...?
  method use : ...?
end

I believe a method can not change the type of a class nor can it require
the parametereized class to be of a certain type. And if I write helper
function outside the class like

let set_foo x = x#foo <- true ; x

then I can't use inheritance for them. Maybe I can use inheritance
for the class objects and module inclusion for the set_* helpers. But
how do I write the use function so that one can not use of an inherited
class?

Or how do I specify

method add_connected_obj : (<connected>) obj

The <connected> would need to be specific to the exact type of object
being added. I do believe I need something that simplifies the type with
each aplication of a callback so that all fully connected objects will
have the same basic type, e.g.

unit need_click need_drag obj => unit need_click obj => unit obj

MfG
        Goswin