delegates, functions, and literals confusion

[Mike Parker]

On Thursday, 4 July 2013 at 06:43:12 UTC, CJS wrote:
>
> In my case I'm trying to figure out the best way to pass 
> functions to other fundtions. So I wrote the following toy code 
> to see what the compiler would do. I'm trying to understand why 
> the compiler emitted errors on the code below (shown w/ 
> comments). Any insight/suggestions on better ways to pass 
> functions around would also be appreciated.

First, to clarify some terminology.

This is a function that takes a delegate as a parameter.
> void f(int delegate(int) h){
>     writefln("h(0)=%d", h(0));
> }

This is a function that takes a function *pointer*, not a 
function, as a parameter.
> void g(int function (int) h){
>     writefln("h(0)=%d", h(0));
> }
>

This one is an inner function.
>     int foo(int a){ return a+6;}

And this is a function literal which, in essence, is a function 
pointer.
>     auto bah = function int(int b){ return b+7;};

In D, functions are not first class objects as they are in some 
other languages, so you can't actually pass them around. But what 
you can pass around is a pointer to a function. Try this.

void g(int function (int) h) {
     writefln("h(0)=%d", h(0));
}

void gg( int i ) { return i + 6; }

void main() { g( &gg ); }

Here, I'm passing a function pointer to g, which is exactly what 
it wants.

In your code, g(bah) succeeds because when the compiler 
encounters a function literal, it creates a function somewhere 
and stores a pointer where you assign it. So your bah is a 
function pointer. Hence g(bah) succeeds. g(&bah) fails because 
&bah makes it a pointer to a function pointer, which is not the 
kind of parameter that g accepts.

Delegates and function pointers are quite similar in usage, but 
architecturally different. A function pointer consists of one 
thing, a pointer to a function. A delegate has a pointer to a 
function *and* a reference to the stack frame from whence it 
came. There are three ways to create a delegate: via a delegate 
literal, via taking a pointer to a class method, or via taking a 
pointer to an inner method. Consider this:

void main() {
    int i = 10;
    int foo( int a ) {
       i = a + 6;
       return i;
    }
    f( &foo );
    writeln( i );

    int j;
}

Because a delegate can reference the stackframe where it was 
created, you can use them to modify variables inside a function 
or to modify class member variables. Delegates declared inside a 
function can only modify variables declared before the inner 
function or delegate literal. So in my example above, foo can 
modify i, but trying to modify j will be a compiler error.

So f(foo) fails because just 'foo' doesn't do anything. A 
function can be called like foo(), or a pointer can be taken with 
&foo, but just 'foo' is meaningless. f(&foo) succeeds because 
taking a pointer to an inner function creates a delegate. f(bah) 
fails because bah is a function pointer and not a delegate. 
f(&bah) fails because &bah is a pointer to a function pointer. 
You should now also understand why g(foo) and g(&foo) fail as 
well.

>
>     f(foo); //error
>     f(&foo);
>     f(bah); //error
>     f(&bah); // error
>
>     g(foo); //error
>     g(&foo); //error
>     g(bah);
>     g(&bah); //error
>
> }