Jaakko Jarvi <jajarvi@cs.indiana.edu> writes: | My example was a bit contrived too. | Here's another example (with imaginary syntax): | | auto foo() { | int i; | return auto(int x) { return i + x; } | } Is it different from int& f() { int i; return i; } ? In -a- model I discussed a while ago with the second author of decltype/auto proposal, lambdas are unnamed constants that can be implemented by local classes. The body of the lambda would be forwarded-to by the appropriate overload of the call operator, i.e. your example would be foo: () -> auto { int i; struct xxx { operator(): (int x) -> auto { return i + x; } }; }; That is a very simple model that just provides a syntactic sugar (modulo use of auto in return type) for what you can do in current C++. In particular, it is clear that the reference to "i" is a hard error by application of current rules governing local classes. I do not believe in local variables that silently escape their lexical scopes. If you really want your automatic variables to espace, you already have ways to say so; but I don't think they should be the common cases that should be "optimized for". Note that I want the lambdas to be constants, in particular I would like to be able to use them as template arguments. Note also the type inference that can refer to local classes :-) -- Gaby