Re: 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 
<thelastmamm...@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.