Re: About String

[Robert A Duff <bobduff@shell01.TheWorld.com>]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:

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

Well, I suppose something like that could work, but it seems like it
would be confusing -- how many components are there, which pieces of
text belong to which components (or which parameters, in the function
call case)?

> [ 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; ]

I don't see the point.  Why not just make it legal (the line marked
"This would be illegal").  Rules would be needed about when to evaluate
that expression -- presumably on elaboration of a discriminant
constraint, or an aggregate, or a discriminant default.  I don't think
having a name for Last makes this any easier.

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

The same sense as declare blocks.  That is, in my "circus",
this:

    ... loop
        <decls>
        <statements>
    end loop;

has identical semantics to:

    ... loop
        declare
            <decls>
        begin
            <statements>
        end;
    end loop;

The <decls> are elaborated each time through the loop.
(I can't imagine what _else_ it might mean!)

>...It is not obvious (rather counterintuitive)
> that declarations have to be "executed."

Well, it's a fundamental aspect of Ada, so Ada programmers have to get
used to it, even if they find it counterintuitive at first.

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

That's where this conversation started: If you add "declare" above,
you get confusing syntax -- it looks like the exception handler handles
exceptions during the elab of X and Y, but it does not.
That's why I think it would be better to have a separate
"handle" statement.

- Bob