Re: anonymous aggregates?

[Shark8 <onewingedshark@gmail.com>]

On Friday, August 31, 2012 4:37:58 PM UTC-6, Randy Brukardt wrote:
> "Stephen Leake" <stephen_leake@stephe-leake.org> wrote in message 
> 
> news:85mx1bwec4.fsf@stephe-leake.org...
> ...
> 
> > If we introduce the notion of "anonymous aggregates" (styled after
> > "anonymous arrays"), we could do this:
> 
> I'd be more likely to call this idea an "anonymous record" as that is the 
> obvious counterpart to "anonymous array".
> declare
> 
>     function Foo return
>        record
>           A : Integer;
>           B : Float;
>         end record
>     is begin
>         return
>             (A => 1,
>              B => 2.0);
>     end Foo;
> 
> 
> (As a side-benefit, there'd be less griping about not repeating the name in 
> a record declaration. ;-)
> 
> I suspect that this was not done originally in Ada mainly because of 
> concerns about arbitrarily introducing additional identifiers in the middle 
> of other declarations. Not sure that's a real problem; there might be some 
> weird visibility issues that arose.

The thing I see is that if you needed to do something moderately complicated, where a extended-return must be used... There's nothing that lets you do this, to my knowledge, in the language, so we would need a 'TYPE attribute that would return out the given object's type. (We already got the 'Return in Ada 2012 so we could use it in post-conditions.) Then we could have:

SubType Initializing_Info is Boolean; -- To be changed for later/complex items.
Function Testing( Init : Initializing_Info ) Return
        record
           A : Integer;
           B : Float;
         end record
     is begin
         return Result : Testing'Return'Type:=
             (A => 1,
              B => 2.0) do
             if Init then
                 A := 23;
             end if;
         end return;
     end Testing;

There have been a few times I've come across where being able to use the type like that would be advantageous... but no interesting specific example is coming to mind, but with discretes you could make 'Img a bit portable by writing Discrete_var'Type'Image( Discrete_var ) -- A bit wordy, but it would be quite portable in this case and a renames might make that a bit more friendly -- and using streams would be a bit easier if you have things functional but want to use streams and just fiddle with your record components:
Field_Name'Type'Write( [...] );