Why are scope variables being deprecated?

[Chad J]

On 07/26/2012 09:19 PM, Jonathan M Davis wrote:
> On Thursday, July 26, 2012 21:09:09 Chad J wrote:
>> I keep hearing that scope variables are going away.  I missed the
>> discussion on it.  Why is this happening?
>>
>> When I read about this, I have these in mind:
>>
>> void someFunc()
>> {
>> 	// foo is very likely to get stack allocated
>> 	scope foo = new SomeClass();
>> 	foo.use();
>> 	// ~foo is called.
>> }
>
> It's inherently unsafe. What happens if you returned a reference to foo from
> someFunc? Or if you assigned a reference to foo to anything and then tried to
> use it after someFunc has returned? You get undefined behavior, because foo
> doesn't exist anymore. If you really need foo to be on the stack, then maybe
> you should make it a struct. However, if you really do need scope for some
> reason, then you can use std.typecons.scoped, and it'll do the same thing.
>

OK, so std.typecons.scoped will completely replace the use-case for the 
scope keyword.  That makes it OK ;)

Just making things structs isn't always sufficient because the data type 
in question might be in a 3rd party's code and cannot be simply 
redesigned.  The scope keyword gave us a way to force stack-allocation 
in cases that would be otherwise inaccessible.  But it seems like 
std.typecons.scoped can be used for this, so 'scope' isn't need anymore. 
  And it simplifies the compiler.  Cool.

Erm, yeah I'm sure you've probably seen this discussed to death already. 
  I know how these things go ;)

> scope on local variables is going away for pretty much the same reason that
> delete is. They're unsafe, and the fact that they're in the core language
> encourages their use. So, they're being removed and put into the standard
> library instead.
>
> - Jonathan M Davis

Alright.  Thanks for the good explanation!