Re: Syntax question about inlined functions/delegates/lambdas

[Ali Çehreli]

On 12/30/2013 11:00 AM, Gordon wrote:
Hello,
I have a syntax question regarding the correct usage of
function/delegates/lambdas, arising after a used it incorrectly and it
took a long time to debug and see what's going on.
I found out there's a syntax which compiles OK but doesn't work (as I
naively expected).

The following is a concise example:
===
import std.stdio;
import std.functional;

void call_function(FUNC...)()
{
         alias unaryFun!FUNC _Fun;
         _Fun(42);
}

void main()
{
         call_function!( function(x)    { writeln("funcion,  case 1. X =
",x); } )();
         call_function!( function(x) => { writeln("funcion,  case 2. X =
",x); } )();
         call_function!( delegate(x)    { writeln("delegate, case 3. X =
",x); } )();
         call_function!( delegate(x) => { writeln("delegate, case 4. X =
",x); } )();
         call_function!( (x)            { writeln("funcion,  case 5. X =
",x); } )();
         call_function!( (x)         => { writeln("lambda,   case 6. X =
",x); } )();
         call_function!( (x)         =>   writeln("lambda,   case 7. X =
",x)    )();
}
===

The output is:
===
$ rdmd ./delegate_question.d
funcion,  case 1. X = 42
delegate, case 3. X = 42
funcion,  case 5. X = 42
lambda,   case 7. X = 42
===

So I've learned that syntaxes in cases 2,4,6 are wrong, but they still
compile.
May question is - what do they do? what usage do they have (since they
do not trigger a compilation warning)?

Thanks,
  -gordon


(Note: This thread is more suited to the D.learn newsgroup.)

Once we move the incompatible ones away, the function literals work as 
expected:

import std.stdio;
import std.functional;

void call_function(FUNC...)()
{
    foreach (func; FUNC) {
        auto f = func(42);
        f();
    }
    // alias unaryFun!FUNC _Fun;
    // _Fun(42);
}

void main()
{
    // call_function!( function(x)    { writeln("funcion,  case 1. X = 
",x); } )();
    call_function!( function(x) => { writeln("funcion,  case 2. X = 
",x); } )();
    // call_function!( delegate(x)    { writeln("delegate, case 3. X = 
",x); } )();
    call_function!( delegate(x) => { writeln("delegate, case 4. X = 
",x); } )();
    // call_function!( (x)            { writeln("funcion,  case 5. X = 
",x); } )();
    call_function!( (x)         => { writeln("lambda,   case 6. X = 
",x); } )();
    // call_function!( (x)         =>   writeln("lambda,   case 7. X = 
",x)    )();
}

The output:

funcion,  case 2. X = 42
delegate, case 4. X = 42
lambda,   case 6. X = 42

Ali