[Caml-list] dynamically extensible sum types

[Caml-list] dynamically extensible sum types

[Ker Lutyn]

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

Re: [Caml-list] dynamically extensible sum types

[Alessandro Baretta]

Ker Lutyn wrote:
> 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

I have taken this approach to statically type SQL queries. I 
have various application modules defining sum types of 
polymorphic variants such as the following:
module Application1 = struct
type table = [ | `Table1 | `Table2 | ... | `TableN ]
type field = [ | `Field_name1 of foo | `Field_name2 of bar | 
... ]

let string_of_table = function
| `Table1 -> "name_of_table_1"
| `Table2 -> "name_of_table_2"
...

let string_of_field = function
| `Field_name1 (_) -> "field_name_1"
...

end

Several modules share this common approach. I finally tie 
everything up in a Db_interface, whose main element is the 
SQL query generator function. This function takes abstract 
representation of queries, such as
`SELECT(`From_table, field_list, where_conditions,
	order_by_field_list, group_by_field_list)

The names of tables and fields are converted from their 
variant-constructor representation to their string 
representation by a function which is defined as the 
parallelization of all functions of the kind 
ApplicationN.string_of_table/field.
(* In module Db_interface *)
let string_of_field = function
| #Application1.field as f -> Application1.string_of_field f
| #Application2.field as f -> Application2.string_of_field f
...

I like this approach, but it requires some source 
preprocessing to be able to selectively link only some 
application code. I still haven't gotten to figure out how 
to get camlp4 to filter out pattern-matching lines depending
on what application modules are actually being compiled and 
linked.

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

I would greatly indebted to you if you could explain to me 
what thunks are.


-------------------
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