Re: Ada case-statement

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

"Stephen Davies" <joviangm@gmail.com> wrote in message 
news:365d65ea-5f4b-4b6a-be9b-1bba146394ab@googlegroups.com...
...
> Ok, I know this isn't going to happen, I just wanted to
> put it out there anyway.

Since the deadline for suggestions for Ada 2020 was January 15th, you are 
right. ;-)

OTOH, someone made a fairly similar suggestion before the deadline; it was 
folded into existing AI12-0214-1. (As usual, no one is really doing a good 
job of explaining the "problem" rather than proposing a cool "solution". The 
ARG is perfectly capable of inventing a half-dozen solutions to any problem. 
:-) This matters mainly because we want to minimize the number of 
"solutions" in a language update.)

The problem is that we have far more "problems" and suggestions than we have 
time to implement in the Standard. We are trying to figure out right now how 
to prioritize the 60+ problems/solutions on our plate. Some worthy ideas are 
certainly going to go nowhere, even though they might be fine.

In any case, you can get what you want with some additional text, so I would 
guess that the priority of such a change would be relatively low:

declare
  Selector : Day_Type renames Calculate_Day;
  subtype Weekend_Subtype is Day_Type range Sat .. Sun;
     -- Or use a static predicate if the range is discontiguous.
begin
  case Selector is
      when Mon .. Fri =>
         ...
      when  Sat | Sun =>
         ...
         case Weekend_Subtype'(Selector) is -- A type conversion works, too.
            when Sat =>
               ...
            when Sun =>
               ...
         end case;
   end case;
end;

Personally, I don't like declarations without explicit subtypes, as the 
subtype of an object is critical for understanding the semantics. Not having 
the subtype in the source makes it much harder to understand the semantics.

Currently, the "id :" notation occurs in three places without an explicit 
subtype (block ids, loop ids, exception occurrences). The first two have 
types that don't even have names (and id can only be used in a handful of 
circumstances). The third has a well-defined composite type that has no 
subtypes (so there is no semantic information to be gained by writing it 
out).

Expanding the "id :" notation would definitely harm understandability of Ada 
code, and with readability being pretty much the first priority for Ada 
syntax, that's a bad thing.

We have been considering making the subtype name in an object renames 
optional -- the subtype is a lie anyway (since it is ignored semantically), 
and other important properties of the renamed object like "constant" are 
omitted. That's about as far as I will go for typeless declarations (and 
perhaps even that is too far).

But - I am not the ARG, I'm just one member. The actual language agreed on 
may differ. :-)

                                     Randy.