Merge pull request #5 from mknejp/patch-1

Add C++14 initializiers for lambda captures

README.md

@@ -27,6 +27,7 @@ C++17 includes the following new library features:
 C++14 includes the following new language features:
 - [binary literals](#binary-literals)
 - [generic lambda expressions](#generic-lambda-expressions)
+- [lambda capture initializers](#lambda-capture-initializers)
 - [return type deduction](#return-type-deduction)
 - [decltype(auto)](#decltypeauto)
 - [relaxing constraints on constexpr functions](#relaxing-constraints-on-constexpr-functions)
@@ -385,6 +386,39 @@ int three = identity(3); // == 3
 std::string foo = identity("foo"); // == "foo"
 ```
 
+### Lambda capture initializers
+This allows creating lambda captures initialized with arbitrary expressions. The name given to the captured value does not need to be related to any variables in the enclosing scopes and introduces a new name inside the lambda body. The initializing expression is evaluated when the lambda is _created_ (not when it is _invoked_).
+```c++
+int factory(int i) { return i * 10; }
+auto f = [x = factory(2)] { return x; }; // returns 20
+
+auto generator = [x = 0] () mutable {
+  // this would no compile without 'mutable' as we are modifying x on each call
+  return x++;
+};
+auto a = generator(); // == 0
+auto b = generator(); // == 1
+auto c = generator(); // == 2
+```
+Because it is now possible to _move_ (or _forward_) values into a lambda that could previously be only captured by copy or reference we can now capture move-only types in a lambda by value. Note that in the below example the `p` in the capture-list of `task2` on the left-hand-side of `=` is a new variable private to the lambda body and does not refer to the original `p`.
+```c++
+auto p = std::make_unique<int>(1);
+
+auto task1 = [=] {*p = 5; }; // ERROR: std::unique_ptr cannot be copied
+// vs.
+auto task2 = [p = std::move(p)] { *p = 5; }; // OK: p is move-constructed into the closure object
+// the original p is empty after task2 is created
+```
+Using this reference-captures can have different names than the referenced variable.
+```c++
+auto x = 1;
+auto f = [&r = x, x = x * 10] {
+  ++r;
+  return r + x;
+};
+f(); // sets x to 2 and returns 12
+```
+
 ### Return type deduction
 Using an `auto` return type in C++14, the compiler will attempt to deduce the type for you. With lambdas, you can now deduce its return type using `auto`, which makes returning a deduced reference or rvalue reference possible.
 ```c++
@@ -600,6 +634,16 @@ addX(1); // == 2
 auto getXRef = [&]() -> int& { return x; };
 getXRef(); // int& to `x`
 ```
+By default value-captures cannot be modified inside the lambda because the compiler-generated method is marked as `const`. The `mutable` keyword allows modifying captured variables. The keyword is placed after the parameter-list (which must be present even if it is empty).
+```c++
+int x = 1;
+
+auto f1 = [&x] { x = 2; }; // OK: x is a reference and modifies the original
+
+auto f2 = [x] { x = 2; }; // ERROR: the lambda can only perform const-operations on the captured value
+// vs.
+auto f3 = [x] () mutable { x = 2; }; // OK: the lambda can perform any operations on the captured value
+```
 
 ### decltype
 `decltype` is an operator which returns the _declared type_ of an expression passed to it. Examples of `decltype`: