Re: About String

[Georg Bauhaus <rm.dash-bauhaus@futureapps.de>]

Dmitry A. Kazakov schrieb:

>> Given linear order of elaboration in declarative parts,
>> and thus the possibility of sequencing initialization
>> of local variables:
>>
>>    procedure P is
>>       declare
>>          X1: constant T;  -- like Java final
>>       begin
>>          X1 := New_T(...);  -- may raise CE
>>       exception
>>          when Constraint_Error =>
>>              X1 := Fallback_T;  -- better than Java final
>>       end;
>>       X2: D := New_D(X1, ...);  -- safely refer to X1
>>    begin
>>       ...
>>    end P;
> 
> Huh, if you want closures, just say so. There is no need to break proven
> language concepts in order to have desired effect:

I should have said that the scope of X1 extends beyond
the declare block (which I had stupidly chosen as key words).

> procedure P is
>     X1: constant T := -- Here anonymous function literal begins
>        function return T is
>        begin
>             return New_T (...);  -- may raise CE
>        exception
>           when Constraint_Error =>
>               return Fallback_T;  -- better than Java final
>        end;
>    X2: D := New_D (X1, ...);  -- safely refer to X1
> begin
>    ...
> end P;


Why closures? I was about to mention nesting, which
solves this issue in Ada 95 and Ada:

procedure P is
    function Safe_T return T is
    begin
       return New_T (...);  -- may raise CE
    exception
       when Constraint_Error =>
          return Fallback_T;  -- better than Java final
    end;
    X1: constant T := Safe_T;

    X2: D := New_D (X1, ...);  -- safely refer to X1
begin
    ...
end P;

In a sense, Safe_T works just like constructors that don't raise.


> Note, no magic stuff, no exception handlers in declarations, just a simple
> thing, which Ada should have had from the day one: functional types and
> literals of.

With the function's full environment?