Re: About String

["Sébastien Morand" <seb.morand@gmail.com>]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Dmitry A. Kazakov a �crit :
> On Mon, 09 Jun 2008 11:43:36 +0200, Georg Bauhaus wrote:
> 
>> Dmitry A. Kazakov schrieb:
> 
>>> On Sun, 08 Jun 2008 17:19:11 -0400, Robert A Duff wrote:
>>>
>>>> Maciej Sobczak <see.my.homepage@gmail.com> writes:
>>>>
>>>>> After all, with the possibility to initialize the new variable with
>>>>> arbitrarily complex expression (including function call), this is
>>>>> already the case and the whole declare-begin-end block is just
>>>>> reflecting some artificial separation.
> 
>>>> I agree.  I suppose it comes from Pascal, where declarations and
>>>> executable code are completely separated.  It makes no sense in
>>>> Ada, where declarations are just as executable as statements.
> 
>>> I disagree. I think it does make sense because it clearly defines the scope
>>> of the declared variable.
>  
>> Still, a somewhat *new* kind kind of handling exceptions in single
>> declarations looks interesting?
> 
>> 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:
> 
> 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;
> 
> 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.

You can do that but not in an anonymous way, so what's the point? I
think it not a good practive to use anonymous function or procedure, it
makes hard to read code (and it's one of the feature of ada: easy to read)

I prefer this kind of writing:
procedure P is

   function Init_T return T;

   function Init_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 := Init_T; -- Here anonymous function literal begins
   X2: D := New_D (X1, ...);  -- safely refer to X1

begin
   ...
end P;
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.5 (Cygwin)

iD8DBQFITQkK+zV9xm4PlDQRAnhxAJ9FKGI7aVenIlDrrnsl3LHJE42FJQCfV9lc
Vvl0CozDP7p/Ah44Ivnz4G8=
=bdGO
-----END PGP SIGNATURE-----