Generic Property Implementation

[Simen Kjærås]

On Saturday, 10 March 2018 at 17:43:06 UTC, Simen Kjærås wrote:
> I'm not sure how fixable this is, but I am sure that there's 
> plenty of benefit to being able to write code like this:
>
> struct S {
>     int n, m;
>     SomeType!(() => n + m) a;
> }
>
> over this:
>
> struct S {
>     int n, m;
>     auto a() { return SomeType!(() => n + m)(); }
> }
>
> Anyways, I filed a bug for it:
> https://issues.dlang.org/show_bug.cgi?id=18587

Actually, this is not fixable. If we consider for a moment the 
internals of SomeType in the above code, it's something like this:

struct SomeType(alias fn) {
     S* context;
}

The full layout of S then becomes this:

struct S {
     int n;
     int m;
     S* a.context; // points to 'this'.
}

Since structs in D are defined to be movable by blitting only, 
with no cleanup afterwards, internal pointers are a no-no. Ref 
https://dlang.org/spec/garbage.html:

> Do not have pointers in a struct instance that point back to 
> the same instance. The trouble with this is if the instance 
> gets moved in memory, the pointer will point back to where it 
> came from, with likely disastrous results.

One possible solution would be for the above code to generate the 
function a() instead of making 'a' a member. This has its own set 
of issues, though - suddenly something that looks like a member 
isn't one, and its address can't be taken, it can't be passed by 
ref, etc.

--
   Simen