On Thursday, 30 September 2021 at 12:55:48 UTC, Max Samukha wrote:

int i = 1;
dgList ~= { writeln(i); };

while (i < 4) {
   immutable int n = i++;
   dgList ~= { writeln(i, " ", n); };
}

static struct __C0
{
    int i;
    void call() { writeln(i); }
}

auto c0 = new __C0(1);
dgList ~= &c0.call;

while (c0.i < 4) {
   static struct __C1 {
      __C0* c0;
      immutable int n;
      void call() { writeln(c0.i, " ", n); }
   }

   dgList ~= &(new __C1(c0, c0.i++)).call;
}

That is indeed the most expected behavior that is consistent with D's semantic in other areas of the language - notably construction/destruction and immutability.

On Thursday, 30 September 2021 at 11:32:28 UTC, Sebastiaan Koppe wrote:

I'm not sure what that buys. If you undercapture, you get an error, if you overcapture, you get suboptimal code.

On the other hand,t he compiler always exactly knows what you capture and what you do not capture, so it can make the optimal choice without you having to state anything.

On Thursday, 30 September 2021 at 13:55:53 UTC, deadalnix wrote:

The upside with explicit capture is that you can specify you want a move/copy instead of a reference, side-stepping the OT's decade long problem.

On 9/30/21 9:55 AM, deadalnix wrote:

You may want to capture variables that would normally be referenced. The compiler can't possibly know what you want exactly.

Consider:

void delegate() dg;
for(int i = 0; i < 100; ++i)
{
   dg = { writeln(i); };
}

dg();

What i is printed? Note that there is only one i variable over the entire loop.

-Steve

On 9/30/21 10:42 AM, Steven Schveighoffer wrote:

void delegate() dg;
for(int i = 0; i < 100; ++i)
{
    dg = { writeln(i); };
}

dg();

Haha of course, I shouldn't overwrite the same delegate.

It should have been an array of delegates, but the point still stands.

-Steve

On Thursday, 30 September 2021 at 14:42:34 UTC, Steven Schveighoffer wrote:

void delegate() dg;
for(int i = 0; i < 100; ++i)
{
   dg = { writeln(i); };
}

dg();

It's a good example of things that the optimizer shoudl handle. In that specific case, you shouldn't expect any memory allocation because the delegate never escape.

On Thursday, 30 September 2021 at 14:44:52 UTC, Steven Schveighoffer wrote:

void delegate() dg;
for(int i = 0; i < 100; ++i)
{
    dg = { writeln(i); };
}

dg();

In that case, you should expect all the delegates to print the same value. There is one i variable accross all loop iterations.

On Thursday, 30 September 2021 at 14:07:18 UTC, Sebastiaan Koppe wrote:

You can create a copy in a local variable though, if you need a capture by value.

Now, one thing that we might want are delegates with a strongly typed closure, as in C++. There are obvious downsides. To begin with, each delegate is of a different type and ABI.

If that is ever added to D, it should probably need to be a new feature, different from current delegates.