Concurrency Confusion

[Dicebot via Digitalmars-d-learn]

import std.concurrency;
import std.typecons : Unique;
import std.exception : assumeUnique;

struct Foo { }

struct Bar { }

void bar_generator (Tid ownerTid)
{
     receive(
         (shared(Foo)* input) {
             auto output = new Bar[100];
             // compute output ..
             // .. and cast to immutable via assumeUnique when
             // finished as it won't be mutated anymore and no
             // other pointers exist
             send(ownerTid, assumeUnique(output));
         }
     );
}

void main ()
{
     auto generator = spawn(&bar_generator, thisTid);

     // must be shared or immutable to be passed between threads
     auto input = new shared Foo;
     send(generator, input);

     // in real app use `receiveTimeout` to do useful stuff until
     // result message is received
     auto output = receiveOnly!(immutable(Bar)[]);

     import std.stdio;
     writeln(output.length);
}