Tiphaine Turpin <tiphaine.tur...@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 _______________________________________________ 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