Re: stopping a loop iteration without exiting it

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

On 2018-01-06 17:50, Niklas Holsti wrote:
> On 18-01-05 10:38 , Dmitry A. Kazakov wrote:
>> On 2018-01-05 00:08, Niklas Holsti wrote:
>>> On 18-01-04 23:17 , Dmitry A. Kazakov wrote:
>>>
> If we have
> 
>     type Root is tagged ...
> 
>     type T is new Root ...
> 
>     type U is new Root ...
> 
> the T'Class and U'Class do not overlap. But if "U is new T ..." then 
> they overlap.

And what will be selected? The semantic of case is of mutually exclusive 
choices, so that the order of the choices were irrelevant. This is why 
if- or independent statements were preferable for type tests. However 
detection of overlapping alternatives would be nice for writing safe 
code. But that would require type ranges (see below) to resolve clashes 
and, that will not work in generics. (That mess taints everything) So, 
no chance.

>> Differently to this case, which is logically OK:
>>
>>    case X'Tag is  -- Tag to denote "type"?
>>       when Same_X : T =>
>>          ...
>>       when Same_X : U =>  -- other instances
>>          ...
>>       when others =>  -- always required
>>          ...
>>    end case;
> 
> That could be a different "case", which is not class-wide.

It is same to me. Compare it with this:

    case Int is
       when 1 =>
          -- Single value
       when 5..Integer'Last =>
          -- A range of values

T is a single type. T'Class is a range of types similar to 
5..Integer'Last. Certainly definite ranges of types must be supported as 
well:

    X in T..S

which same as

    X in T'Class and T in S'Class and (X in S or else X not in S'Class)

But the point is that it is the type of X not its value as it appears 
when reading "case X is".

>> However the idea of re-using exception handler style declarations could
>> be very helpful in general cases. For example this is very frequent in
>> parsers and protocol handlers:
>>
>>    declare
>>       Symbol : constant Character := Get_Character;
>>    begin
>>       case Symbol is
>>          when '0'..'9' =>
>>             -- Process digit
>>          when 'A'..'Z' | 'a'..'z' =>
>>             -- Process letter
>>
>> Much better this:
>>
>>    case Get_Character is
>>       when Digit : '0'..'9' =>
>>          -- Process digit
>>       when Letter : 'A'..'Z' | 'a'..'z' =>
>>          -- Process letter
> 
> Yes, that would be nice in such cases, and would perhaps be easier to 
> get approved by the ARG, because it should be completely compatible with 
> current Ada.

I am afraid that would fall under the category "too simple to be 
approved", together with "raise when", "return when", "goto when".

> The "case" forms with an (access to a) class-wide selector might 
> introduce some incompatibility because they would enlarge the set of 
> expected types of the selector expression.

I think it has the same problem as with type tests.

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