# 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](https://google.github.io/styleguide/cppguide.html#Lambda_expressions)
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.