
C++14 lambda tutorial - AlexeyBrin
https://solarianprogrammer.com/2014/08/28/cpp-14-lambda-tutorial/
======
michaelx386
As someone currently learning C++ the biggest surprise was finding out about
C++11/14\. I'd assumed that the language hadn't changed for decades so it's
great to see it still being updated.

~~~
skriticos2
Yes. C++ is in an active standard update process. Here is a short history of
notable versions:

Year Version Year-Delta

1983; 1.0; 0

1989; 2.0; +6 years

1998; C++98; +9 years (first ISO standard)

2003; C++03; +5 years (minor update)

2011; C++11; +8 years (major update)

2014; C++14; +3 years (minor update)

The C++14 version was the first that arrived on schedule. The next major
version is planned for 2017. The future looks quite promising for C++.

------
tdsamardzhiev
I work as a C++ developer, but damn, C++ has the ugliest lambda syntax ever.

~~~
claudius
Do you have an alternative suggestion? It seems reasonably straightforward to
me and I don’t find it all that impossible. Not having to muck around with a
specific lambda() factory-like function with horrible inputs (as is needed in
LPC where I sort-of learnt to code) is a plus :)

~~~
repsilat
I don't mind C++'s lambdas, but in some other languages they use "arrows",
like

    
    
       square = (x) -> x * x
    

C++ won't want to give up the different kinds of capturing, though, so it's
hard to see anything much better than what's available now.

In imaginary, never-to-be-implemented language daydreams I toy with the idea
of using curly braces and implicit positional arguments to have lambdas look
like

    
    
        square = { _1 * _1 }
    

and

    
    
        factorial = { (_1 < 2) ? 1 : _0(_1 - 1) }
    

and with explicit captures and arguments,

    
    
        partial_sort = [&lt_vec, &ge_vec, pivot](item){
            if (item < pivot) lt_vec.add(item)
            else ge_vec.add(item)
        }
    

I suspect, though, those ideas are just horrible shortcuts to a Perl-like hell
:-)

~~~
claudius
Hrm, I don’t quite like the arrows. C++ lambdas can contain arbitrary code and
these arrows always remind me of “pure” functions (in a sense), or at least
functions whose main purpose it is to map input arguments to output arguments.

For example, consider something like this relatively common block to do some
complex operation on the elements of a vector using some (naive) threading (it
might be nicer to first create some lambdas, push them into a queue and then
spawn threads to work on that queue, but the syntax is essentially the same):

    
    
      for(std::size_t i(0); i != somevec.size(); ++i) {
        workers.push_back(std::thread([&somevec, i]() mutable { calc(somevec, i); }));
      }
    

That is, we want an anonymous lambda which captures some elements of its
environment (by both reference and value, also it’s essentially a closure by
now) and call some function on these elements. That lambda doesn’t have any
return value and doesn’t take any input arguments. Sure one could throw in an
extra _lambda_ somewhere or put an arrow between _mutable_ and _{_ , but I
have to admit I don’t see the value.

------
jason_slack
I've never been a good at Templates. After reading this it seems that a lot of
Template uses can be replaced with the generic lambdas using auto as the types
going in.

Am I wrong or misunderstanding? I'm not saying completely but I feel like when
I have used Templates I can now use this.

~~~
Iftheshoefits
Templates are the C++ implementation of "generics". Their utility extends far
beyond lambdas-as-callables. The entire STL library is built using the
Template feature of C++. Templates are far more important than the ability to
do "true" object-oriented programming using other features, in my opinion.

For a more concrete example that doesn't rely on the "authority" of an
externally developed template library, consider that templates are also useful
for static/compile-time polymorphism (see: Curiously Recurring Template
Pattern).

------
cengizkrbck
In python, lambda usage extremly beautiful. Also, 'lambda' keyword solves
readibility problem. I expected a keyword. Is there any challenge to add
keyword?

~~~
leni536
I don't like that in python you are enforced to only use a single expression
in lambda. Sure, writing long lambda functions is ugly but I don't think
python should enforce a given coding style in the language level.

~~~
crazypyro
Isn't that literally a core principal of Python? They enforce all kind of
coding styles within the language, not the mention all the PEPs.

~~~
leni536
But PEPs are not enforced in the language level. Also there are cases where
there could fit two simple expression in a lambda. Also the language still
doesn't stop you from abusing lambdas, you can nest them. It could be stated
in one of the PEPs that "no overly complicated lambdas" and that's it, there
is no need for the language to enforce this.

~~~
crazypyro
PEPs are literally the language, in my opinion. It may not be enforced on an
implementation level, but some have been. You can't mix spaces and tabs now.
That seems like a style choice being enforced on every level.

