struct Bob
{
void setThing() shared;
}
As I understand, `shared` attribution intends to guarantee that I dun
synchronisation internally.
This method is declared shared, so if I have shared instances, I can
call it... because it must handle thread-safety internally.
void f(ref shared Bob a, ref Bob b)
{
a.setThing(); // I have a shared object, can call shared method
b.setThing(); // ERROR
}
The method is shared, which suggests that it must handle thread-safety. My instance `b` is NOT shared, that is, it is thread-local.
A method that handles thread-safety doesn't not work when it's only accessed from a single thread.
mutable -> shared should work the same as mutable -> const... because surely that's safe?
Comment #1 by turkeyman — 2018-10-01T05:32:29Z
Conversation: https://github.com/dlang/dmd/pull/8782
Reveals that `scope` is also necessary to guarantee that the promoted reference does not escape.
Promotion is safe so long as no promoted-reference outlives the call where the instance was promoted.
struct Bob
{
void setThing() shared scope;
}
void f(ref shared Bob a, ref Bob b)
{
a.setThing(); // I have a shared object, can call shared method
b.setThing(); // this should work with `scope`
}
Comment #2 by robert.schadek — 2024-12-13T19:00:46Z