I need a dynamically extensible sum type.  I can think of three approaches:

(1) Use polymorphic variants: `Foo of a * b, `Bar of c * d * e, etc

(2) Use exceptions: exception Foo of a * b, exception Bar of c * d * e, etc

(3) Use thunks: (fun () -> foo a b), (fun () -> bar c d e), etc

Using exceptions seems somewhat sneaky to me.  Does it have any advantages over
polymorphic variants?  The polymorphic variants seem like they might be better
since you could actually limit the domain of certain functions... thus, one
part of your program could be constrained to a subrange of the sum type, while
other parts could be opened up fully.

Until now I have been using the thunking approach in an event-based
architecture (each event on the queue is a unit->unit thunk).  This seems to
work pretty well.  But now I'm thinking that the other approaches would allow
arbitrary filters to be applied to events; i.e., the thunk approach imposes a
"read once" discipline on elements of the sum type, and in some applications
you might want "read multiple".

I'm not asking the question solely in terms of event-based architectures,
though, and I'm interested in others experience with the different approaches
to dynamically extensible sum types, and what led you to choose one approach
over the others.  Thanks!


__________________________________________________
Do you Yahoo!?
Yahoo! Mail Plus - Powerful. Affordable. Sign up now.
http://mailplus.yahoo.com
-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners