On Tuesday, 7 February 2012 at 23:10:02 UTC, Manu wrote:
On 8 February 2012 00:33, Sean Kelly <s...@invisibleduck.org>
wrote:
On Feb 6, 2012, at 1:38 PM, Oliver Puerto wrote:
> Hello,
>
> I'm very new to D. Just started reading "The D programming
> language". I
should read it from beginning to end before posting questions
here. I know
... But I'm just too impatient. The issue seems not to be that
simple,
nevertheless. The code below compiles with Visual Studio.
>
> I want to have something like my actor class that I can
> start running in
it's own thread like in Scala or other languages that support
actors. So at
best, I would like to do something like this:
>
> MyActor myActor = new MyActor();
> auto tid = spawn(&start, &myActor.run());
This should work:
void runActor(shared MyActor a) { (cast(MyActor)a)).run(); }
MyActor myActor = new MyActor();
auto tid = spawn(cast(shared MyActor) myActor, &runActor);
See, my conclusion is, whenever using this API, you inevitably
have dog
ugly code. That code is barely readable through the casts... I
can only
draw this up to faulty API design.
I understand the premise of 'shared'-ness that the API is
trying to
assert/guarantee, but the concept is basically broken in the
language. You
can't use this API at all with out these blind casts, which is,
basically,
a hack, and I am yet to see an example of using this API
'properly'. The
casts are totally self defeating.
std.concurrency really should allow unique references to a
non-shared type
to be passed as well, using something similar to assumeUnique.
Something like that should exist in the language (... or shared
should just
not be broken). Using a template like assumeUnique is no better
than the
ugly cast. What does it offer over a cast?
IMO the shared *concept* itself is broken. I'd suggest to take a
look at languages such as chapel and x10 to see their designs.
E.g http://chapel.cray.com/tutorials/SC11/SC11-5-Locales.pdf
discusses the concept of locales and the "on" construct. This
allows to specify where each statement is performed and the
runtime automatically handles for you the implementation details
of migrating data.
