Anonymous structs

[Era Scarecrow]

On Wednesday, 13 February 2013 at 07:28:14 UTC, Jacob Carlborg 
wrote:
> On 2013-02-12 21:30, Era Scarecrow wrote:
>
>> Seems I did misread what you had, however having it creating 
>> dozens of misc/anonymous types doesn't seem like a wise idea. 
>> The entire block as it was defined is more like a scope/code 
>> block rather than a struct declaration; Then is it a delegate 
>> instead? (without return type or input type possibly)
>
> I don't know what you're talking about. Where did "delegate" 
> come from?

  Then let's step back. You can make a scope block without having 
'if' or any other statment that separates it.

   unittest {
     int x;

     {
       x++;//code block is valid
     }

  Now if you attach that to a variable it's effectively a 
delegate, function, or predicate; depending on syntax of how it's 
called.

     auto y = delegate void(){ x++; };
     auto y = (){ x++; }; //shortened to
     auto y = { x++; };   //if no calling variables gets shortened 
to..??

  Now if there's only type declarations and no instructions, it 
can be an anonymous struct (probably), but what if it has code? 
Is it a code block? The code gets defaulted to a function inside 
it? Illegal to do period? (at which point it breaks regular 
compatibility most likely).

     auto z = {int x,y,color;}; //types only, could be struct...
     auto z = { //which is it?
       int x,y,color;
       x++; y++; color = 0xffffff;
     };

  This can either be
  1) POD struct, instructions are illegal
  2) instructions called right away, still a POD struct otherwise
     auto z = {
       int x,y,color;
     };
     z.x++; z.y++; z.color = 0xffffff;

  3) delegate/function/predicate
     z(); //call is legal, or passable to template function

  4) structs legal and instructions are effectively postblit (or 
opCall or something)
     struct anonymous_int_x_y_color {
       int x,y,color;
       this(this) {
         x++; y++; color = 0xffffff;
       }
     }
     anonymous_int_x_y_color z;
   }

  5) none of it is legal, leaves you having to specify what it is 
which is probably safer than assumption or ambiguity.

  It can be easy to forget a simple set of parenthesis (or 
semicolon, or equal sign) sometimes when you're programming, 
having it make assumptions of code 'this is a struct' vs 'this is 
a delegate' could be quite the annoyance, perhaps with very 
confusing error messages. IMO the way you're suggest having 
anonymous structs seems unneeded.