Anonymous structs

[Jacob Carlborg]

I've been thinking for this feature for a while. An anonymous struct is 
basically what it sound like, a struct without a name. The inserting 
part is its members. If two anonymous structs have the same members (not 
necessarily in the same order) they are considered to be of the same 
type. This shows how anonymous structs looks like:

{ int x, int y } point = { y: 4, x: 5 };
auto point2 = { x: 1, y: 2 };
point = point2;

In this example "point" and "point2" are of the same type since they 
have the same members. This is basically lowered to something similar to:

struct __AnonymousStruct_int_x_int_y
{
     int x;
     int y;
}

__AnonymousStruct_int_x_int_y point;
point.y = 4;
point.x = 5;

__AnonymousStruct_int_x_int_y point2;
point2.x = 1;
point2.y = 2;
point = point2;

The compiler will implicitly generate a new struct type with a name that 
will always be the same if it has the same members. These structs will 
then behave just like any other structs, accessing members and so on.

assert(point2.x == 1);
assert(point.y == 2);

The advantage of anonymous structs is that they can be declared in 
place, in function declartions for example:

void foo ({ int x, int y } point)
{
}

foo({ y: 5, x: 3 });

When calling a function and passing in an anonymous structs it's 
possible to drop the braces to get a more pleasing and less verbose syntax:

foo(y: 5, x: 3);

With this syntax sugar we can basically get named parameters. With the 
braces it also looks like JSON.

Anonymous structs can be implicitly converted to and from regular named 
struts:

* Named struct to anonymous struct:

struct Bar
{
     int x;
     int y;
}

foo(Bar(1, 2));

* Anonymous struct to named struct:

void bar (Bar b) {}

bar(x: 3, y: 4);

It would also be nice to have opDispatch soak up everything that doesn't 
match, if it's declared in a named struct:

struct Options
{
     int x;
     int y;
     private Variant[string] members;

     void opDispatch (string name, T) (T t)
     {
         members[name] = Variant(t);
     }
}

void fooBar (Options options) {}

fooBar(x: 5, a: "asd", y: 1.2, b: 4);

"x" and "y" are matched with the regular members, "a" and "b" are 
matched to opDispatch which takes care of them.

Perhaps this initializer syntax can be used for classes as well:

class FooBar
{
     int x;
     int y;
}

FooBar fb = { x: 3, y: 5 };

The above would be lowered to:

FooBar fb = new FooBar();
fb.x = 3;
fb.y = 5;

Thoughts?

-- 
/Jacob Carlborg