Greetings.

The following code works:

void main() {
    passfunc(&func);
}

void passfunc(void function(string) f) {
    f("Hello");
}

void func(string str) {
    import std.stdio : writeln;
    writeln(str);
}

Now if I change passfunc's signature to "void passfunc(lazy void function(string) f)" I would get the compiler error "Delegate f () is not callable using argument types (string)". I can lazily pass a void function() -- it seems that there is only a problem when the function contains parameters.

The only difference should be when the pointer is evaluated, so why does lazy evaluation matter here?

Thank you for your time
--Ryan

On Sunday, 10 April 2016 at 18:08:58 UTC, Ryan Frame wrote:
> Greetings.
>
> The following code works:
>
> void main() {
>     passfunc(&func);
> }
>
> void passfunc(void function(string) f) {
>     f("Hello");
> }
>
> void func(string str) {
>     import std.stdio : writeln;
>     writeln(str);
> }
>
> Now if I change passfunc's signature to "void passfunc(lazy void function(string) f)" I would get the compiler error "Delegate f () is not callable using argument types (string)". I can lazily pass a void function() -- it seems that there is only a problem when the function contains parameters.
>
> The only difference should be when the pointer is evaluated, so why does lazy evaluation matter here?
>
> Thank you for your time
> --Ryan

A parameter declared as `lazy T` has the type `T delegate()`, which, when called, evaluates the expression that was passed into the function.

So effectively, this:

void foo(lazy int x) { auto i = x(); }
foo(a+b);

Is the same as this:

void foo(int delegate() x) { auto i = x(); }
foo(() => a+b);

T in your case is `void function(string)`. So you can do `auto func = f()` to get the function you passed in. It's not very useful in your example to lazily evaluate getting a function pointer, considering it's usually a constant expression after compiling.