The Builder Lambda Pattern

The builder lambda pattern allows you to do multi-stage construction for objects that can't be copy-assigned without putting temporaries needed during that construction at function scope.

Suppose you have a class C with some deps, which you construct like this:

C foo;
{
  A a;
  a.set_property(value);
  foo = MakeC(a);
}

This requires that C has an "empty state" and is mutable. If you want to make C immutable, that won't work, but you can use the builder lambda pattern like this:

C foo = [&]() -> auto {
  A a;
  a.set_property(value);
  return MakeC(a);
}();

The anonymous lambda provides a block scope to constrain the temporary variable, and having the lambda default capture-by-reference provides the same ability to reference enclosing variables as a normal lexical block. Returning the result of MakeC() directly into foo allows avoiding mutating C.

Note that normally, default capture by reference is discouraged because it can create difficult lifetime problems. In this case, because the lambda can never escape the current scope and obviously is shorter-lived than any of the captured variables, default capture by reference is fine.