`shared`...

[ag0aep6g]

On 10/01/2018 04:29 AM, Manu wrote:
> struct Bob
> {
>    void setThing() shared;
> }
[...]
> void f(ref shared Bob a, ref Bob b)
> {
>    a.setThing(); // I have a shared object, can call shared method
> 
>    b.setThing(); // ERROR
> }
> 
> This is the bit of the design that doesn't make sense to me...
> The method is shared, which suggests that it must handle
> thread-safety. My instance `b` is NOT shared, that is, it is
> thread-local.
[...]
> I feel like I don't understand the design...
> mutable -> shared should work the same as mutable -> const... because
> surely that's safe?

`shared` isn't analogous to `const`. It's analogous to `immutable`. 
Functions dealing with `shared` data can assume that other threads also 
see the data as `shared`. If you allow calling `shared` methods on 
non-`shared` objects, you're breaking that.

Example:

----
struct Bob
{
   int* p;
   void doThing() shared
   {
     p = &s;
   }
}

shared int s;

void main()
{
   Bob bob;
   (cast(shared Bob)bob).doThing();/* You'd make the cast implicit. */

   import core.thread;
   import core.atomic;
   enum n = 1_000_000;
   auto t = new Thread(() { foreach (i; 0 .. n) atomicOp!"+="(s, 1); });
   t.start();
   foreach (i; 0 .. n) ++*bob.p;
   thread_joinAll();

   import std.stdio;
   writeln(s); /* usually not "2000000", because of race */
}
----