If I've understood things correctly, by marking a delegate parameter with
'scope' you tell the compiler not to create a true closure for the
delegate. Effectively you're saying "I promise not to escape this
delegate, so you don't need to copy its context to the heap".
In brief, my question is: Why doesn't the compiler enforce this
promise? In particular, why is 'scope' not a type constructor?
(Note that this is mostly a question out of curiosity, and not really a
proposal for a new feature. I imagine it has been discussed in the past
and rejected for some reason.)
Considering that the compiler enforces proper use of pure, nothrow,
const, and all those other things, it doesn't seem much harder to do the
same with scope.
As an example, I really can't see a reason why obviously wrong code like
this should be allowed:
void delegate() globalDg;
void foo(scope void delegate() dg)
{
globalDg = dg;
}
Here's a slightly less obvious example, which also compiles successfully:
void foo(void delegate() dg); // Who knows what this does?
void bar(scope void delegate() dg)
{
foo(dg);
}
-Lars
