Re: GNAT GPL Edition - on the plus side

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

On 15 Oct 2005 10:45:39 -0400, Robert A Duff wrote:

> "Randy Brukardt" <randy@rrsoftware.com> writes:
> 
>> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message
>> news:b4p2ksjzkv4m.6ghazx68f8js.dlg@40tude.net...
>>> Anyway, generics and templates are inherently a mess, but that is another
>>> story. (:-))
>> 
>> Perhaps because we haven't seen any crying need. I, for one would prefer to
>> reduce the need for generics than to pile on more features.

Absolutely.

>> You have said in
>> the past that generics are unnecessary with good OOP, and I tend to agree.
> 
> Could either or both of you explain why generics are unnecessary
> (i.e. what changes to Ada's OOP would make them unnecessary).
> 
> In particular, I want to be able to have a container type tied to the
> type of its elements (perhaps class-wide).  If I have a "sequence of
> T'Class", and I put something in it, and take it back out, I don't want
> to lose the fact that this element is somewhere in the T'Class
> hierarchy.  Generics seem to work well for that.
> 
> How would you define the "sequence" abstraction without generics?

I am not sure I have understood what you meant, but it seems to me that you
want containers constrained to a particular type. I see no great problem
here. Already Ada 83 handled some constraints without any generics:

type String is ...;
subtype Punch_Card is String (1..80); -- Range constraint

We could extend this idea allowing type constraints:

type Container (...) is array (...) of Element'Class;
type Foo is new Element ...;

subtype Foo_Container is
   Container (some sugar to constrain Element'Class to Foo'Class);

As an additional advantage over generics Foo_Container can be used in all
subprograms expecting Container'Class. Otherwise, Foo_Container can be
declared as:

type Foo_Container is new
   Container (some sugar to constrain Element'Class to Foo'Class);

here "is new" has old, Ada 83 sense: create an anonymous copy of Container,
make a constrained subtype and name it Foo_Container.

[It was very unfortunate that Ada 95 used "is new" for inheritance.]

Generally, I think that in all cases when one type is composed out of some
other types (be it a record, array, access etc type) there should be a
unified language-defined way to create constrained subtypes. Maybe
explicitly via discriminants:

type Ptr (Target : T'Tag) is access T'Class (Target);
subtype Ptr_To_A is Ptr (Target => A'Tag);

Maybe implicitly assuming discriminats or attributes for constraints
everywhere.

I believe, this all is equivalent to having "type discriminants", which is
pretty close to usual intent of a programmer using generics, though on a
completely different basis.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de