static code generation

[js.mdnq]

On Sunday, 16 December 2012 at 06:38:13 UTC, anonymous wrote:
> On Saturday, 15 December 2012 at 16:32:27 UTC, r_m_r wrote:
>> On 12/15/2012 08:57 PM, anonymous wrote:
>>> Note that here s1alpha and s2alpha are distinct types.
>>
>> what about this: http://dpaste.dzfl.pl/95f7a74d
>
> Consider
>
> struct Foo {mixin (genStruct!("s1"));}
> struct Bar {mixin (genStruct!("s1"));}
>
> Foo.s1alpha and Bar.s1alpha are the same type. In my version 
> they are not.


Yes, they should be the same type. If you are inserting an actual 
struct with the same name("s1") then you would expect them to be 
identical. (else you could just do something like 
mixin(genStruct!("_1", "s1")); to get a different copy of the 
struct.

But we are not talking about inserting a field but "combining" 
structs.

I think the updated answer is more pertinent:

http://dpaste.dzfl.pl/d9f001db

Here we are "inserting" a struct(well, now it is simply a 
template) into another(not a struct field, different things).

struct B { int x; }
struct A { Insert(B); }

should be indentical to

struct A { int x; }

r_rm_r has parameterized it so that it's really A!(B) which is 
better so we can combine them in many ways.

What all this is analogous to is multiple inheritance at compile 
time. A inherits B, so to speak. It is helpful in breaking down 
larges structs into smaller ones and being able to mix and match.

One could also think of it as an algebra of structs.

It would be nice to be able to do stuff like

A + B, A - B(possibly useless), A*B(possibly useless), etc...

A + B would just combine the members, A - B could remove the 
members that overlap, A*B could qualify overlapping members.

struct A
{
   int x;
   int y;
}

struct B
{
   int x;
   int z;
}

A + B <==>

struct ApB {
   int x;   // Possible error because of overlap
   int y;
   int z;
}

A - B <==>
struct AmB {
    int y;
    int z;
}

A*B <==>
struct AtB {
    int x.A;
    int x.B;
    int y;
    int z;
}

or whatever. The usefulness is mainly that you can decompose a 
struct into pieces then recombine them into something possibly 
different. I'm not interested in the algebra aspect, just the 
ability to break down into two pieces, one I supply, one the user 
of the struct supplies. A simple A + B type of operation. The 
point, is, a lot of possible with such a feature. Possibly no one 
will use it but it could be quite powerful if it was designed 
appropriately.