Re: What would you like in Ada202X?

["Randy Brukardt" <randy@rrsoftware.com>]

"Niklas Holsti" <niklas.holsti@tidorum.invalid> wrote in message 
news:a0rsroFp8lU1@mid.individual.net...
> On 12-05-08 03:48 , Randy Brukardt wrote:
...
>> It seemed like a useful idea back in the day,
>
> I think that extending enumeration types by "deepening" is a different 
> idea than the AI95-261 "widening" idea. Don't you think that they are 
> logically different?

The details are different, but the basic idea (adding more literals) is 
unchanged. And the use is in adding more literals, the details on exactly 
how you do that are much less important.

>> but to be really useful, we
>> need the equivalent of class-wide operations.
>
> That is the main question: do we?

We need class-wide operations for Integer and Float and (especially) String, 
so it's hard to imagine how we could avoid needing them for such an 
enumeration!

For example:
              Put (X : in Root_Integer'Class);
is much more useable than a generic that you have to instantiation for each 
kind of type. (Some operations really do cross-cut types.)

Inheritance of operations is virtually useless without class-wide 
operations. Note that class-wide operations don't necessarily have to 
involve dispatching, although that does seem like the most sensible model. 
Dmitry has pointed out repeatedly that one does not need to store tags with 
values of specific types; they can be added when converted to a class-wide 
type and that makes the most sense for elementary and array tagged types.

>> I don't see how to do that if
>> the position numbers are completely different between the various types.
>
> I agree. It seems to me that adding class-wide operations would force to 
> use some kind of tags, call by reference, and view conversions, and then 
> it becomes so similar to tagged types that it is not worth it.

Umm, that's when it *does* become worth it. The problem is untagged types 
are pretty hard to use. (Note that I disagree about call-by-reference, but 
that's a detail.)

> I think the idea of "deepened" enumeration types is worth pursuing only if 
> it is useful without class-wide operations.

Then don't bother. IMHO, at least.

> Another issue is that generic formal types of the "deepened" kind would be 
> needed. I think that would be the next point to work on for this proposal.

We already have that. Generic derived types (with the ancestor being an 
enumeration) would provide the needed inheritance. But of course that better 
make semantic sense!

                                        Randy.