• =?UTF-8?B?Tm9yZGzDtnc=?= (17/17) Nov 30 2017 Are there any plans to D compilers to use recent DIP-1000 to
• Stefan Koch (4/22) Nov 30 2017 The problem with this; as with most types of inference is the
• =?UTF-8?B?Tm9yZGzDtnc=?= (3/29) Nov 30 2017 Is there a formal definition of the complexity of such an
• Nick Treleaven (4/6) Dec 04 2017 That would allow the compiler to avoid GC allocation for x. It
• =?UTF-8?B?Tm9yZGzDtnc=?= (2/8) Dec 04 2017 Nice. Thanks.

=?UTF-8?B?Tm9yZGzDtnc=?= <per.nordlow gmail.com> writes:

Are there any plans to D compilers to use recent DIP-1000 to 
infer scoped destruction of GC-allocated data such as in the 
following case:

T sum(T)(in T[] x) // x cannot escape scope of `sum`
{
     /// calculate and return sum of `x` ...
}

double f(size_t n)
{
     auto x = new int[n]; // scoped (deallocation) should be 
inferred
     auto y = sum(x); // cannot alias `x`
     return y;
}

I believe this would make D more competitive against Rust's and 
C++'s (more) deterministic RAII memory management.

How would this interact with explicit scope-qualification of `x`?

Stefan Koch <uplink.coder googlemail.com> writes:

On Thursday, 30 November 2017 at 16:31:25 UTC, Nordlöw wrote:
 Are there any plans to D compilers to use recent DIP-1000 to 
 infer scoped destruction of GC-allocated data such as in the 
 following case:

 T sum(T)(in T[] x) // x cannot escape scope of `sum`
 {
     /// calculate and return sum of `x` ...
 }

 double f(size_t n)
 {
     auto x = new int[n]; // scoped (deallocation) should be 
 inferred
     auto y = sum(x); // cannot alias `x`
     return y;
 }

 I believe this would make D more competitive against Rust's and 
 C++'s (more) deterministic RAII memory management.

 How would this interact with explicit scope-qualification of 
 `x`?

The problem with this; as with most types of inference is the 
time it can take.
And the number of false negatives.

=?UTF-8?B?Tm9yZGzDtnc=?= <per.nordlow gmail.com> writes:

On Thursday, 30 November 2017 at 16:50:02 UTC, Stefan Koch wrote:
 On Thursday, 30 November 2017 at 16:31:25 UTC, Nordlöw wrote:
 Are there any plans to D compilers to use recent DIP-1000 to 
 infer scoped destruction of GC-allocated data such as in the 
 following case:

 T sum(T)(in T[] x) // x cannot escape scope of `sum`
 {
     /// calculate and return sum of `x` ...
 }

 double f(size_t n)
 {
     auto x = new int[n]; // scoped (deallocation) should be 
 inferred
     auto y = sum(x); // cannot alias `x`
     return y;
 }

 I believe this would make D more competitive against Rust's 
 and C++'s (more) deterministic RAII memory management.

 How would this interact with explicit scope-qualification of 
 `x`?

 The problem with this; as with most types of inference is the 
 time it can take.
 And the number of false negatives.

Is there a formal definition of the complexity of such an 
inference?

Nick Treleaven <nick geany.org> writes:

On Thursday, 30 November 2017 at 16:31:25 UTC, Nordlöw wrote:
 How would this interact with explicit scope-qualification of 
 `x`?

That would allow the compiler to avoid GC allocation for x. It 
seems essentially the same case as Walter describes here:
http://forum.dlang.org/post/ofo9f5$2bt7$1 digitalmars.com

=?UTF-8?B?Tm9yZGzDtnc=?= <per.nordlow gmail.com> writes:

On Monday, 4 December 2017 at 16:03:50 UTC, Nick Treleaven wrote:
 On Thursday, 30 November 2017 at 16:31:25 UTC, Nordlöw wrote:
 How would this interact with explicit scope-qualification of 
 `x`?

 That would allow the compiler to avoid GC allocation for x. It 
 seems essentially the same case as Walter describes here:
 http://forum.dlang.org/post/ofo9f5$2bt7$1 digitalmars.com

Nice. Thanks.