Re: About String

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

On Sun, 15 Jun 2008 18:06:00 -0400, Robert A Duff wrote:

> I don't see why a loop needs a declarative part.
> My idea is that every statement list is a scope.

What is so special in statement lists? Pushing this idea further, we should
also conclude that any sequence of expressions is a scope. For example, an
aggregate:

String'(X : constant Character := F(A(I)), 1 => X, 2 => 'a', 3 => X);

a function call etc.

[ That might be useful to overcome some silly limitations on discriminants:

type T (S : Storage_Count) is record
-- Buffer : Storage_Elements_Array (0..S-1);  -- This would be illegal, so
   Buffer : Storage_Elements_Array
      (Last : constant Storage_Offset := S-1, 0..Last);
end record; ]

>> However I find nested declare/begin/end more readable because it clearly
>> disambiguates between the scope of the loop and the scope of one iteration
>> of.
> 
> I don't get it.  You declare something inside a loop body, or the 'then'
> part of an 'if' -- it's local to that.

Local in which sense? There are statical nesting and dynamic execution of
the loop body upon iterations. It is not obvious (rather counterintuitive)
that declarations have to be "executed." To me the purpose of Ada's
"declare" was merely in conversion of "elaboration" to "execution."

>> But what would happen if I said:
>>
>>    begin
>>       raise Foo_Error;
>>       X : constant Character := F(A(I)); -- Not Ada!
>>       Do_Something (X);
>>    exception
>>       when Foo_Error =>
>>          Do_Something_Interesting (X);
>>    end;

> As I said earlier, exception-handler regions deserve their own syntax,
> not connected with declaration blocks.

So an exception handler attached to the statement list will see nothing
from the scope of the list? I.e. everything in the list will be wound up
before the handler gets fired. Then you would need additional nesting if
you wished to handle exceptions from that list. Here we go:

   X : constant ...;
   Y : constant ...;
   begin
      Do_Something (X, Y);
   exception
      when Foo_Error =>
          Do_Something_Interesting (X, Y);
   end;

What is the gain? Just add "declare" in front of this and it becomes legal
Ada.

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