On Wednesday, 17 October 2018 at 20:41:24 UTC, Ali Çehreli wrote:
On 10/17/2018 01:24 PM, Vijay Nayar wrote:
I have a snippet of code like this:
scope chordAngle = new S1ChordAngle(_center,
other._center);
return _radius + other._radius >= chordAngle;
The reason the "scope" temporary variable exists is to avoid a
heap allocation and instead prefer a value be created on the
stack. Is there a way to do this inline?
Something like:
return _radius + other._radius >= scope new
S1ChordAngle(_center, other._center);
I think it's possible but what you're looking for is
std.typecons.scoped. 'scope' does not do what you think it does.
import std.typecons : scoped;
class C {
int i;
this(int i) {
this.i = i;
}
int foo() {
return i;
}
}
bool bar() {
auto c = scoped!C(42);
return 42 == c.foo();
}
bool bar_2() {
return 42 == scoped!C(42).foo();
}
void main() {
bar();
bar_2();
}
Ali
This particular use of "scope" I overheard at the last DConf, and
I believe it has been added to the official documentation here:
https://dlang.org/spec/expression.html#new_expressions
If a NewExpression is used as an initializer for a function
local variable with
scope storage class, and the ArgumentList to new is empty,
then the instance is
allocated on the stack rather than the heap or using the
class specific allocator.
I didn't know about the std.typecons scoped, it looks really
useful, especially when you want to only create the object when
short-circuiting fails, like in the middle of an "||" expression.
One drawback of "scoped", however, is that it doesn't appear to
warn you if you accidentally let the reference escape out of the
function, unlike a scope variable.