D equivalent of C++11's function local static initialization?

[bauss via Digitalmars-d-learn]

On Wednesday, 17 May 2017 at 03:08:39 UTC, Timothee Cour wrote:
> NOTE: curious about both cases:
> * thread local
> * shared
>
> On Tue, May 16, 2017 at 8:04 PM, Timothee Cour 
> <thelastmammoth at gmail.com> wrote:
>> what's the best D equivalent of C++11's function local static 
>> initialization?
>> ```
>> void fun(){
>>   static auto a=[](){
>>     //some code
>>    return some_var;
>>   }
>> }
>> ```
>>
>> (C++11 guarantees thread safety)

I don't know the exact equivalent, mostly because I don't really 
know what the C++ statement does tbh. Tried to look it up real 
quick, but can't seem to find anything actual information on it.

However I can answer about thread local and shared.

Every global is per standard thread local in D.

For example:
int foo;

void fun() {
     foo++;
     writeln(foo);
}

void main() {
     spawn(&fun);
     spawn(&fun);
}

In D the output is:
1
1

However in other languages that doesn't have thread-local per 
standard the output may vary depending on race-conditions.

So it could be:
1
1

Or:
1
2

Then there's shared.

Shared is kind of a bottle-neck to use and if you're going to use 
it you should write all your code as shared and synchronized from 
the beginning else you'll just end up ripping your hair out. 
shared variables are required to be used in synchronized 
contexts, that's about it. It sounds simple, but implementing it 
properly is not that easy and tends to just be a bothersome in 
exchange for other safe implementation

On the contrary to shared, there's __gshared which is basically 
the equivalent to plain old globals in C.