What is :-) ?

[Antonio]

On Monday, 20 November 2023 at 13:25:48 UTC, Paul Backus wrote:
> On Monday, 20 November 2023 at 08:47:34 UTC, Antonio wrote:
>> - What is the way to do ```writeln``` work with ```Counter``` 
>> function the same way it works with ```next``` function?
>
> `writeln(&Counter)` should do it.

It does not do the same:  It shows an address, not the function 
signature.

Because I need to understand "why", I propose a second example 
(with some additional info based on @evilrat proposals :-) ):

```d
import std.stdio;

void main()
{
   auto createCounter = (int nextValue) => (int dummy) => 
nextValue++;
   auto getNext = createCounter(10);

   writeln( "'getNext' is ", getNext );
   writeln( "'createCounter' is ", createCounter );

   writeln( "'typeof(getNext).stringof' is ", 
typeof(getNext).stringof );
   writeln( "'typeof(createCounter).string' is ", 
typeof(createCounter).stringof );
}
```

The output is

```
'next' is int delegate(int) pure nothrow @nogc @safe
'createCounter' is 557FFCC00968
'typeof(getNext).stringof' is int delegate(int dummy) pure 
nothrow @nogc @safe
'typeof(createCounter).string' is int delegate(int dummy) pure 
nothrow @nogc @safe function(int nextValue) pure nothrow @safe
  ```


**Why ```writeln``` doesn't treat the same way ```getNext``` and 
```createCounter```?**

Because   ```getNext``` is a delegate and ```createCounter``` is 
a function.

**Why this is a function and not a delegate?**

```auto createCounter = (int nextValue) => (int dummy) => 
nextValue++;```

Syntactically I dont see any difference:

```auto name = "expression returning a delegate"```

The reason is **D compiler takes the decision**.

If you make ```createCounter``` to depend on an external 
variable, it will be treated as delegate (because it has context 
information associated to the function: a closure)

```d
import std.stdio;

void main()
{
   int diff = 1;
   auto createCounter = (int nextValue) => () { scope(exit) 
nextValue+=diff; return nextValue;};
   writeln( "'typeof(createCounter).string' is ", 
typeof(createCounter).stringof );
}
```

Will output that createCounter is a delegate:

```
'typeof(createCounter).string' is int delegate() pure nothrow 
@nogc @safe delegate(int nextValue) pure nothrow @safe
```


What "breaks" my mind is that a compiler decision (treat a piece 
of code as function or delegate) is not completely transparent 
causing "side" effects on your code  (writeln doesn't work the 
same way:  it shows the delegate signature, but not the function 
signature).

But the decision of the compiler is predictable and you can argue 
different effects are not side effects:   only something you 
should pay attention to.

**This long and winding road toke me to a third and crazzy 
question**

Is there any way to force D compiler to treat this 
"createCounter" declaration as **delegate** instead of 
**function**?

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