#include <iostream>
#include <algorithm>
#include <vector>

int main()
{   
    double arr[]={1,2.5,3,4,5};
    std::vector<double> v(arr,arr+5);
    typedef decltype(v[0]) ElemType;
    std::for_each(v.begin(),v.end(),[&](ElemType e){std::cout << e << " " ;});  
    std::cout << std::endl;
    for (auto it = v.begin(),end=v.end(); it !=end; ++it)    
    {
        std::cout << *it << " " ;
    }
    std::cout << std::endl;  
    return 0;
}

    std::for_each(v.begin(),v.end(),[&](auto e){std::cout << e << " " ;});

auto f = [&](auto e){double t=1.01; e=t; std::cout << e << " " ;};

struct PrintElement
{
template<class T>
void operator()(const T& e){std::cout << e << " ";}
};
...
std::for_each(v.begin(),v.end(),PrintElement());

D14>А так нельзя

D14>    std::for_each(v.begin(),v.end(),[&](auto e){std::cout << e << " " ;});  
D14>

   for (auto e: v) { std::cout << e << " "; }

7.1.6.4/1
The auto type-specifier signifies that the type of an object being declared shall be deduced from its initializer or specified explicitly at the end of a function declarator.

7.1.6.4/3
… The decl-specifier-seq shall be followed by one or more init-declarators, each of which shall have a non-empty initializer of either of the following forms:
= assignment-expression
( assignment-expression )

    auto id=[](int x){return x;};
    typedef decltype(id) inttoint;
    auto compose=[](inttoint f, inttoint g){return [=](int x){ return f(g(x));}; };
    inttoint cid(compose(id,id)); //Тут не едут лыжи!
    std::cout << cid(10) << std::endl;

template <typename F>
F id()
{
    return [=](int x){return x;};
}

B>Во-вторых, не виден контекст кода, и получилось что-то вроде мудрёного регулярного выражения (regexp), непонятно, что хотели сделать

D14>А так нельзя

D14>    std::for_each(v.begin(),v.end(),[&](auto e){std::cout << e << " " ;});  
D14>

This document provides wording for monomorphic (non-generic) lambda functions, which we propose
for the committee to move forward with for C++0X. The discussion on polymorphic (generic) lambda
functions is not included in this document. Following the committee’s recommendation from the
Toronto meeting (July 2007), we separate the specification of polymorphic lambda functions into a
separate (later) document. Polymorphic lambda functions can be made upwards compatible with the
non-generic lambda functions proposed here.

D14>А так нельзя

D14>    std::for_each(v.begin(),v.end(),[&](auto e){std::cout << e << " " ;});  
D14>

std::for_each(v.begin(), v.end(), [] (decltype(*v.begin()) e) { std::cout << e << " "; });

D14>Так обстоят дела с параметрами на вход. Но мне пока не ясно, как вернуть лямбду из функции?

D14>template <typename F>
D14>F id()
D14>{
D14>    return [=](int x){return x;};
D14>}
D14>

function<int(int)> id()
{
    return [](int x) { return x; };
}

...
std::for_each(v.begin(),v.end(),struct 
                                {
                                    template<class T>
                                    void operator()(const T& e){std::cout << e << " ";}
                                };
);

template <class T> void f(T t)
{
f(struct{template<class T> void operator()(){t();t();}});
}

A>function<int(int)> id()
A>{
A>    return [](int x) { return x; };
A>}
A>

#include <boost/function.hpp>
#include <iostream>

typedef boost::function<int(int)> inttoint;

inttoint id()
{
    return [=](int x) { return x; };
}

int main()
{       
    auto compose=[](inttoint f, inttoint g){return [=](int x){ return f(g(x));}; };
    inttoint cid(compose(id(),id())); 
    std::cout << cid(10) << std::endl;

    return 0;
}

PK>   for (auto e: v) { std::cout << e << " "; }
PK>

#define foreach(it,cont)    for (auto it = (cont).begin(), foreach_end_##it = (cont).end();it != foreach_end_##it;++it)

foreach(it, container)    {std::cout << *it << " ";}

CC>#define foreach(it,cont)    for (auto it = (cont).begin(), foreach_end_##it = (cont).end();it != foreach_end_##it;++it)

CC>foreach(it, container)    {std::cout << *it << " ";}
CC>

#define foreach BOOST_FOREACH

#include <functional>
#include <iostream>
#include <string>

typedef std::tr1::function<int(int)> inttoint;

inttoint id(){return [](int x) { return x; };}

int main()
{
    auto compose=[](const inttoint& f, const inttoint& g)
    {
        return [&](int x) { return f(g(x)); };
    };
    std::cout << compose(id(),id())(1234) << std::endl;
    return 0;
}

return [=](int x) { return f(g(x)); };

#define foreach(decl,it,cont) if (false) {} else for (decl::iterator it = (cont).begin(), c_foreach_end_##it = (cont).end();it != c_foreach_end_##it;++it)
#define c_foreach(decl,it,cont) if (false) {} else for (decl::const_iterator it = (cont).begin(), c_foreach_end_##it = (cont).end();it != c_foreach_end_##it;++it)