Re: stopping a loop iteration without exiting it

[Niklas Holsti <niklas.holsti@tidorum.invalid>]

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:
>>
>>     [snip]
>>
>>> I thought about really important cases, but could not invent syntax:
>>>
>>>    if X in T'Class then
>>>       declare
>>>          Same_X : T'Class renames T'Class (X);
>>>       begin
>>>          ...
>>>       end;
>>>    end if;
>>
>> A syntax suggestion, drawing on analogy with exception handlers:
>>
>>     case X is
>>     when Same_X : T'Class =>
>>        ...
>>     when Same_X : U'Class =>  -- other named classes
>>        ...
>>     when others =>  -- always required
>>        ...
>>     end case;
>>
>> This would be legal only if no two classes in the "whens" are related
>> with "in", so that at most one "when S'Class" matches X.
>
> It looks nice, but is inconsistent, at least logically. T'Class and
> U'Class always overlap.

How so? Do the letters T and U have some special meaning to you?

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.

> 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.

>>>    if P /= null then
>>>       declare
>>>          X : P_Type renames P.all;
>>>       begin
>>>          ...
>>>       end;
>>>    end if;
>>
>> Similarly, applying an implicit dereference to the selecting
>> expression when it has an access type:
>>
>>     case P is
>>     when X : P_Type =>
>>        ...
>>     when null =>  -- or "when others =>"
>>        ...
>>     end case;
>
> But as heavy weight as if-declare ...

Yes, not much of an improvement, but it could remove one level of 
indentation (depending on how one indents the "whens").

> 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.

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.

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
       .      @       .