Yet another MRV proposal!

[downs]

Bill Baxter wrote:
> downs wrote:
>> Let's give this another try.
>> The following proposal has the advantage that it's funded mostly on
>> existing syntax.
>>
>> An anonymous struct, in the position where you'd normally expect a
>> function/method return type, is usable as the return type instead.
>>
>> Example:
>>
>> struct { int a; float b; } test() { return(1, 2f); }
>>
>> writefln(test().a, test().b);
>>
>> The compiler would translate this into "current D" as follows:
>>
>> struct _D_anonymous_struct_1 { int a; float b; }
>> _D_anonymous_struct_1 test() { return _D_anonymous_struct_1(1, 2f); }
>>
>> Because of the not-exactly-clear type name, it is necessary to store
>> the returned value in an auto/const/static variable.
>>
>> This looks like it could be ambiguous, but it really isn't - the two
>> conditions required here - an unnamed struct in the position where a
>> return type would be expected - are quite unambiguous :)
>>
>> Whaddya think?
>>
>>  --downs
> 
> It does seem reasonable that you should be able to return an anonymous
> struct (or class).
> 
> I guess for a no-element struct you could use "return (); "?
> Or for an anon struct with default values.
> 
> struct{int a=1; int b=2;} foo() { return(); }
> 
> The return becomes like an invocation of static opCall, except you leave
> the name of the struct off, because it's anonymous.
> 
> For classes syntax could be like
> 
> class{int a=1; int b=2;} foo() { return new (); }
> 
> Do you have a need for this?
> 
> --bb

Makes sense to extend it to all types that can be anonymously declared.

Except unions. That'd be asking too much. :p

That being said, this is not, per se, a "needed" feature - you can always just give the struct a name and say

struct Foo { int a; float b; } Foo test() { return Foo(2, 3f); }

The problem with this is that you need to repeat the name of the struct thrice in all, more if you have more return statements, whereas the name is often quite irrelevant and redundant :)

The other advantage is that it seems like it would be relatively easy to implement, seeing as all that's needed is allowing to declare anonymous structs outside of their current contexts, and having them evaluate to their own type. (and the return syntax)

 --downs