The full version for Mac OS X I 'm using is 11.1.058.

Quoting - tim18 g++ zc.cpp
zc.cpp: In function void lambdaTest(LAMBDA):
zc.cpp:9:10: error: ISO C++ forbids declaration of result with no type
zc.cpp:9:20: error: expected primary-expression before [ token
zc.cpp:9:21: error: expected primary-expression before ] token
zc.cpp:9:23: error: expected primary-expression before void
zc.cpp:9:29: error: expected ) before { token
zc.cpp:24:1: error: expected , or ; at end of input
zc.cpp:24:1: error: expected } at end of input

icpc zc.cpp
zc.cpp(23): error: expected an expression
lambdaTest([](void)->void{});
^

zc.cpp(9): error #303: explicit type is missing ("int" assumed)
auto result = ([](void) { return [](LAMBDA l) -> void { }; })(); // OK
^
....

I can provoke an internal error by setting icpc -std=c++0x which I suppose would justify a bug report, but this doesn't appear to reproduce your finding. Short of that, g++ and icpc appear in basic agreement about the demerits of my copy of your case.

Hi tim18.
Thank you for reply.

I suppose the GCC version you used does not support lambda expression syntax although you have turn on c++0x option. I may have described the situation more detailedly as following:

void Dummy(void)   
{   
       
}   
  
template    
void lambdaTest(LAMBDA lam)   
{   
    auto result = ([](void) { return [](LAMBDA l) -> void { }; })();    //OK for in both versions
    ([](LAMBDA l) -> void { l(); })(lam);  //OK in both versions
    ([&lam](void) -> void { lam(); })();   //OK in both versions
       
    void (*p)(void) = Dummy;   
    ([p](void) { return [p](void) -> void { (*p)(); }; })()();  //OK in both version  
       
    //ERROR in ver 11.1 for Mac but OK in ver 11.0 for Win
    ([&lam](void) { return [&lam](void) -> void { lam(); }; })();

    //ERROR in ver 11.1 for Mac but OK in ver 11.0 for Win
    ([](LAMBDA l) { return [&l](void) -> void { l(); }; })(lam); 
}   


int main(void)    
{   
    lambdaTest([](void)->void{});   
}  

Hi, Om. I'm glad you could reply to this.

I will provide the equivalent code with pleasure.

#define COMMENT(type_expr)

static void Dummy(void)      
{

}

//Original Code
template   COMMENT(support( void(void) ))
static void lambdaTest(LAMBDA lam)      
{
    //OK in both versions
    auto result = ([](void) { return [](LAMBDA l) -> void { }; })();  //Test1

    //OK in both versions
    ([](LAMBDA l) -> void { l(); })(lam);   //Test2

    //OK in both versions
    ([&lam](void) -> void { lam(); })();    //Test3
          
    void (*p)(void) = &Dummy;
    //OK in both versions
    ([p](void) { return [p](void) -> void { (*p)(); }; })()();  //Test4

    //ERROR in ver 11.1 for Mac but OK in ver 11.0 for Win   
    ([&lam](void) { return [&lam](void) -> void { lam(); }; })();   //Test5  
  
    //ERROR in ver 11.1 for Mac but OK in ver 11.0 for Win
    ([](LAMBDA l) { return [&l](void) -> void { l(); }; })(lam);    //Test6

    result(lam);
}


//< equivalent code
template   COMMENT(support( void(void) ))
static void LambdaTest(LAMBDA lam)
{
    //< Test1 equivalent
    struct
    {
        struct InnerLambda
        {
            void operator () (LAMBDA l)
            {

            }
        }innerLambda;

        InnerLambda operator () (void)
        {
            return innerLambda;
        }
    }lambda2;

    auto result = lambda2();
    // Test1 equivalent >

    //< Test2 equivalent
    struct
    {
        void operator () (LAMBDA l)
        {
            l();
        }
    }lambda3;

    lambda3(lam);
    // Test2 equivalent >

    //< Test3 equivalent
    class Lambda1
    {
    private:
        LAMBDA  val;
    public:
        Lambda1(LAMBDA l) : val(l)
        {

        }

        void operator () (void)
        {
            val();
        }
    }lambda4(lam);

    lambda4();
    // Test3 equivalent >

    void (*p)(void) = &Dummy;
    //< Test4 equivalent
    class Lambda2
    {
    private:

        void (*pFunc)(void);

        class InnerLambda
        {
        private:

            void (*pFunc)(void);

        public:

            InnerLambda(void (*p)(void)) : pFunc(p)
            {

            }

            void operator () (void)
            {
                (*pFunc)();
            }
        }innerLambda;

    public:
        Lambda2(void (*p)(void)) : pFunc(p), innerLambda(pFunc)
        {

        }

        InnerLambda operator () (void)
        {
            return innerLambda;
        }
    }lambda5(p);

    lambda5()();
    // Test4 equivalent >

    //< Test5 equivalent
    class Lambda3
    {
    private:

        LAMBDA lambda;

        class InnerLambda
        {
        private:

            LAMBDA lambda;

        public:

            InnerLambda(LAMBDA l) : lambda(l)
            {

            }

            void operator () (void)
            {
                lambda();
            }
        }innerLambda;

    public:

        Lambda3(LAMBDA l) : lambda(l), innerLambda(lambda)
        {

        }

        InnerLambda operator () (void)
        {
            return innerLambda;
        }
    }lambda6(lam);
    // Test5 equivalent >

    //< Test6 equivalent
    class Lambda4
    {
    private:

        class InnerLambda
        {
        private:

            LAMBDA lambda;

        public:

            InnerLambda(LAMBDA l) : lambda(l)
            {

            }

            void operator () (void)
            {
                lambda();
            }
        };

    public:

        InnerLambda operator () (LAMBDA l)
        {
            return InnerLambda(l);
        }
    }lambda7;

    lambda7(lam);
    // Test7 equivalent >

    result(lam);
}
// equivalent code > 


int main(void)
{
    lambdaTest([](void)->void{});

    //< equivalent code
    struct
    {
        void operator () (void)
        {

        }

    }lambda1;

    LambdaTest(lambda1);
    // equivalent code >
}

Wish that'll be helpful.

Thank you Om.

But have you copied the macro definition of #define COMMENT(type_expr)

?

Quoting - Zenny Chen Thank you Om.

But have you copied the macro definition of #define COMMENT(type_expr)

?

Without the definition, there will be 24 error messages during compiling.

I don't know how you have copied the source code. Because it is not available to use "copy to clipboard" for mac OS X Leopard, I have to use "view plain" and then select all to copy. But this will be safer. And the color of macro definition highlight is not so attractive.

Anyway, thank you for your try, Om and tim.

What's strange is that I've just downloaded a version 11.1.038on Windows for evaluation. It is no problem.

I don't know whether the compiling error is relevant to the environment of Mac OS X Leopard.

However,only a few situations will generate an error for lambda expression.

The error message is:

Compilation aborted for /User/xxx/xxx.cpp (code 4) Location: Line Location Tool: 0

Well, should I report it to Intel Compiler Development Team?

Quoting - Om Sachan (Intel) It seems there is an issue with Intel compiler for Linux.

The issue has been fixed in latest Intel C++ compiler for Linux version 11.1.046.

Could you please download and try the latest Intel C++ compiler 11.1?

OK, I will try it. Thank you, Om.

Thanks, Om and Tim. I'll close this question. After all, expression is working well on Windows. I'm going to have a overall test on ICC for Mac OS X about C++0x features after C++0x has been issued.

Quoting - Qale (Intel)
Regarding the test case above that works with Intel compiler on Windows, but fail with Intel compiler on Mac OS X using version 11.1.058. That is a bug.You can reference it as Premier support issue #562598.

I'll update this thread when the issue is resolved.

Thanks, Qale.