Proposal to make "shared" (more) useful

[Arafel]

On 09/13/2018 05:11 PM, Adam D. Ruppe wrote:
> On Thursday, 13 September 2018 at 14:43:51 UTC, Arafel wrote:
>>  Why must __gshared be static?? (BTW, thanks a lot, you have just 
>> saved me a lot of debugging!!).
> 
> The memory location differences of shared doesn't apply to class 
> members. All members are stored with the instance, and shared only 
> changes the type. (Contrast to global variables, where shared changes 
> where they are stored - the default is to put them in thread-local 
> storage, and shared moves it back out of that.)
> 
> Class static variables btw follow the same TLS rules. A static member is 
> really the same as a global thing, just in a different namespace.
> 
> 
> Now, the rule of __gshared is it puts it in that global memory storage 
> using the unshared type. Unshared type you like here, but also, since 
> normally, class members are stored in the object, changing the memory 
> storage to the global shared area means it is no longer with the 
> object... thus it becomes static.
> 
>> Then, how on earth are we supposed to have a struct like SysTime as a 
>> field in a shared class? Other than the "fun" of having a shared 
>> *pointer* to such a struct that then you can cast as non-shared as 
>> needed...
> 
> What you want is an unshared type without changing the memory layout. 
> There's no syntax for this at declaration, but there is one at usage 
> point: you can cast away attributes on an lvalue:
> 
> shared class Foo {
>          void update() {
>                  // the cast below strips it of all attributes, 
> including shared,
>                  // allowing the assignment to succeed
>                  cast() s = Clock.currTime;
>          }
>          SysTime s;
> }
> 
> 
> 
> Using the private field with a public/protected/whatever accessor 
> method, you can encapsulate this assignment a little and make it more 
> sane to the outside world.

Thanks a lot!! I remember having tried casting shared away, and ending 
up with a duplicate, but I have just tried it now and indeed it seems to 
work, will have to try with more complex use cases (comparing, adding 
dates and intervals, etc.), but it looks promising.

The problem might have been that I think I tried:

shared SysTime s_;
SysTime s = cast () s_; // Now I've got a duplicate! Ugh!

Because that works with classes... but (in hindsight) obviously not with 
value types.

I still think that it would be useful:

1) Allow __gshared for non-static fields to have this meaning, it would 
make it much more intuitive. A library solution is perhaps possible, but 
cumbersome.

2) Make it (sometimes) automatic as the original proposal.

Of course 1) is the most important part.

A.