Re: Generic Collection

[andrew <andrew.carroll@okstate.edu>]

On May 9, 11:12 am, Georg Bauhaus <rm.tsoh+bauh...@maps.futureapps.de>
wrote:
> On Wed, 2007-05-09 at 07:51 -0700, andrew wrote:
> > Actually I take that back.  RDB2 looks promising with respect to how I
> > have my program now.  What I want is to be able to change my program
> > so that I can declare table, tuple and schema to be of a "collection"
> > type like:
>
> > table: collection;
> > tuple: collection;
> > schema: collection;
>
> The question now becomes, do you want table, tuple, and schema
> to have the same behavior? Then you could use instances of the
> same generic collection package, or interface types, or mimick
> duck types... Do you want table, tuple, and schema to be
> interchangeable parameters for some "common" subprograms (other
> than Add)?
>
> Are there cases where you want your program to decide which
> kind of collection it is reading?
>
> > This again would depend on being able to use a common object like Java
> > has.
>
> Interestingly, Java has recently got generics. In part, because
> this circumvents the consequences of everything being an Object.
>
> > What do you think?
>
> 42 if your intent is to blur the distinction between tuple,
> table, and schema to the extent that all have just one common
> type; a reader of you program might then have to inspect quite
> a bit of context to find out what is meant if something goes
> wrong. If this is the case, can you show that the similarities
> implied by Add and such should preclude any explicit distinction
> between tuple, table, and schema?  OTOH, if they are Ada.Containers
> all of them will have a similar interface, even though this fact
> isn't reflected in an interface type.

Since table, tuple and schema are collections I would expect them to
have the same "capability".  So I would expect to be able to add
items, delete items, inspect individual items, change individual
items, sort them, compare them to each other, search them, serialize
individual items and serialize the whole collection.  That's what I
see for now.

There was a problem with my example.  Here is the correction

attr1 : attribute;
attr2 : attribute;
attr3 : attribute;
attr4 : attribute;
attr5 : attribute;
attr6 : attribute;

tuple1 : collection;
tuple1.add(attr1);
tuple1.add(attr2);
tuple1.add(attr3);

tuple2 : collection;
tuple2.add(attr4);
tuple2.add(attr5);
tuple2.add(attr6);

table1 : collection;
table1.add(tuple1);
...add more tuples to table1

table2 : collection;
table2.add(tuple2);
...add more tuples to table2

schema : collection;
schema.add(table1);
schema.add(table2);


So, I'm thinking that many of the "capabilities" or operations I
desire of the collection would have to be "dispatching" to the type of
the collection object.
Also, for that matter, anything stored in the collection would have to
extend (or possibly implement) a collection_object type.  Is that what
you were saying?