What is :-) ?

[Antonio]

On Monday, 20 November 2023 at 16:32:22 UTC, evilrat wrote:

>
> ```d
> // this is a function returning a delegate
> auto createCounter(int nextValue) => auto delegate() => 
> nextValue++;
>

Thank you!!!.

Compiler forces me to omit "auto" keyword

```d
auto createCounter(int nextValue) => delegate () => nextValue++ ;
```

Explicit return must be specified after "delegate" keyword

```d
auto createCounter(int nextValue) => delegate int () => 
nextValue++ ;
```

When declaring a type (variable or parameter) is when keywords 
order must be "inverted"

```d
import std.stdio;
int callWith10( int delegate (int) x) =>x(10);
void main(){
   int j=100;
   // Explicit
   writeln( callWith10( delegate int (int i)=>i+j ) );
   // Inferred
   writeln( callWith10( i=>i+j ) );
   // OMG
   writeln( ( i=>i+j ).callWith10 );
}
```



> // this is a function returning a function
> auto createCounter(int nextValue) => auto function() => 
> nextValue++;
> ```

I think this will not work, because nextValue is defined out of 
the returned function scope:  you must return a closure 
(delegate).

Thanks a lot evilrat!!!

**From your answer (and other ones too) I have to say that...**

* **D Closures rocks!!!**  It is hard to find something so 
powerful in other natively compiled languages:  **Heap + GC** has 
it's advantages.

* **D offers nice syntax features**:  you can declare arrow 
methods very similar to dart, or assign an arrow 
function/delegate to a variable like Javascript/Typescript 
lambdas.