Re: Ada case-statement

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

On 2018-03-17 00:49, Randy Brukardt wrote:
> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message
> news:p8g0om$1gpe$1@gioia.aioe.org...
>> On 15/03/2018 23:20, Randy Brukardt wrote:
>>> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message
>>> news:p8dbcp$11bc$1@gioia.aioe.org...
>>
>>>> I don't see how giving a name could add anything to the semantics. Each
>>>> alternative exhaustively defines a constraint. No reason to contaminate
>>>> the name space.
>>>
>>> How does
>>>        when Today: Thurs =>
>>> exhaustively define anything? It just defines a constraint, but there is
>>> not
>>> way to know of what. > You have to look at the selecting_expression to
>>> find
>>> the type -- but it doesn't show it either.
>>
>> This applies to everything:
>>
>>     when Thurs =>
>>
>> What is the type of Thurs? I either know or in most cases simply do not
>> care.
> 
> You have to know, and you usually do with a commonly used enumeration.

Enumeration literals overloading works just fine. And it is really so 
that I frequently don't know the types of enumeration literals and have 
to search for in the sources.

> And
> at the same time it isn't as important to know - you almost never are going
> to use any overloaded operators (which often require qualifying something)
> in a case limb.
> 
> Once you have a general name for something, you can (and do) use it in many
> contexts, and then the type (and its name) become necessary: for "use type",
> for qualifications, for type conversions, and so on.

Literals (all of them: enumerations, numeric, strings) are 
self-contained, you don't need their types in most cases. Adding type 
specification to a literal or a set of literals is just noise, most of 
the time. [*]

>> In any case this is no change of the semantics. Today has the semantics of
>> the case statement argument. You didn't specify the type there, why should
>> you do here?
> 
> You're not declaring an object for the case selector; that's "consuming" a
> value rather than creating one. All objects should have their type defined
> directly next to the declaration.

Maybe, though some trivial type inference is OK. And I see nothing wrong 
when the type is specified as "same as above".

------------------
* Literal values, literal ranges, literal sets, literal arrays is one of 
few cases where structural type equivalence works far better than the 
named one.

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