On wrapping a callable in a lambda that just calls it with the same parameters
Summary
The article explains that wrapping a callable in a lambda is unnecessary when the inner lambda can be used directly, highlighting that C++ lambdas are syntactic sugar for classes with function call operators.
<p>Suppose you have a function that accepts a lambda and wants to use it when calling another function. I’ve seen people wrap the lambda inside another lambda:</p>
<pre>template<typename Lambda>
bool Widget::QueueToWorkerThread(Lambda&& lambda)
{
CreateWorkerThreadIfNeeded();
return m_dispatcherQueue.TryEnqueue(
<span style="border: solid 1px currentcolor;">[lambda = std::forward<Lambda>(lambda)]() { lambda(); }</span>);
}
</pre>
<p>But there’s no point in wrapping a lambda inside another lambda if you are just calling the inner lambda with the same parameters as the outer one. You can use the inner lambda’s function call operator directly.</p>
<pre>template<typename Lambda>
bool Widget::QueueToWorkerThread(Lambda&& lambda)
{
CreateWorkerThreadIfNeeded();
return m_dispatcherQueue.TryEnqueue(
<span style="border: solid 1px currentcolor;">std::forward<Lambda>(lambda)</span>);
}
</pre>
<p>My guess is that some people don’t realize that a lambda is not a special entity in the C++ language, where if somebody says that a function accepts a lambda, they think that it means that you must literally pass a lambda.</p>
<p>In C++, a lambda is just syntactic sugar for a class with a function call operator. And if you already have a class with a function call operator, there’s no need to wrap it inside another class with the same function call operator.</p>
<p>Wrapping a lambda is basically doing this:</p>
<pre>template<typename Lambda>
bool Widget::QueueToWorkerThread(Lambda&& lambda)
{
CreateWorkerThreadIfNeeded();
<span style="border: solid 1px currentcolor; border-bottom: none;">struct wrapper { </span>
<span style="border: 1px currentcolor; border-style: none solid;"> wrapper(Lambda&& lambda) : </span>
<span style="border: 1px currentcolor; border-style: none solid;"> m_lambda(std::forward<Lambda>(lambda)) {} </span>
<span style="border: 1px currentcolor; border-style: none solid;"> auto operator()() const { return m_lambda(); } </span>
<span style="border: 1px currentcolor; border-style: none solid;">private: </span>
<span style="border: 1px currentcolor; border-style: none solid;"> const std::remove_reference_t<Lambda> m_lambda;</span>
<span style="border: solid 1px currentcolor; border-top: none;">}; </span>
return m_dispatcherQueue.TryEnqueue(
wrapper(std::forward<Lambda>(lambda)));
}
</pre>
<p>There’s no need to introduce the extra level of indirection. The incoming lambda is already in the form you want. Just use it.</p>
<p><b>Bonus chatter</b>: Wrapping a lambda is significant if there is a transformation on the parameters, such as cocercing them to a particular type or forcing them to be passed by value.</p>
<p>The post <a href="https://devblogs.microsoft.com/oldnewthing/20260819-00/?p=112624">On wrapping a callable in a lambda that just calls it with the same parameters</a> appeared first on <a href="https://devblogs.microsoft.com/oldnewthing">The Old New Thing</a>.</p>
View Cached Full Text
Cached at: 08/20/26, 03:33 PM
# On wrapping a callable in a lambda that just calls it with the same parameters - The Old New Thing
Source: [https://devblogs.microsoft.com/oldnewthing/20260819-00?p=112624](https://devblogs.microsoft.com/oldnewthing/20260819-00?p=112624)
Suppose you have a function that accepts a lambda and wants to use it when calling another function\. I’ve seen people wrap the lambda inside another lambda:
```
template<typename Lambda>
bool Widget::QueueToWorkerThread(Lambda&& lambda)
{
CreateWorkerThreadIfNeeded();
return m_dispatcherQueue.TryEnqueue(
[lambda = std::forward<Lambda>(lambda)]() { lambda(); });
}
```
But there’s no point in wrapping a lambda inside another lambda if you are just calling the inner lambda with the same parameters as the outer one\. You can use the inner lambda’s function call operator directly\.
```
template<typename Lambda>
bool Widget::QueueToWorkerThread(Lambda&& lambda)
{
CreateWorkerThreadIfNeeded();
return m_dispatcherQueue.TryEnqueue(
std::forward<Lambda>(lambda));
}
```
My guess is that some people don’t realize that a lambda is not a special entity in the C\+\+ language, where if somebody says that a function accepts a lambda, they think that it means that you must literally pass a lambda\.
In C\+\+, a lambda is just syntactic sugar for a class with a function call operator\. And if you already have a class with a function call operator, there’s no need to wrap it inside another class with the same function call operator\.
Wrapping a lambda is basically doing this:
```
template<typename Lambda>
bool Widget::QueueToWorkerThread(Lambda&& lambda)
{
CreateWorkerThreadIfNeeded();
struct wrapper {
wrapper(Lambda&& lambda) :
m_lambda(std::forward<Lambda>(lambda)) {}
auto operator()() const { return m_lambda(); }
private:
const std::remove_reference_t<Lambda> m_lambda;
};
return m_dispatcherQueue.TryEnqueue(
wrapper(std::forward<Lambda>(lambda)));
}
```
There’s no need to introduce the extra level of indirection\. The incoming lambda is already in the form you want\. Just use it\.
**Bonus chatter**: Wrapping a lambda is significant if there is a transformation on the parameters, such as cocercing them to a particular type or forcing them to be passed by value\.
### Category
### Topics
## Author
Raymond has been involved in the evolution of Windows for more than 30 years\. In 2003, he began a Web site known as The Old New Thing which has grown in popularity far beyond his wildest imagination, a development which still gives him the heebie\-jeebies\. The Web site spawned a book, coincidentally also titled The Old New Thing \(Addison Wesley 2007\)\. He occasionally appears on the Windows Dev Docs Twitter account to tell stories which convey no useful information\.
Similar Articles
Implementation of GCC's Nested Functions (vs. C++ Lambdas)
This article explains GCC's implementation of nested functions by creating a synthetic structure for parent variable access, comparing it to C++ lambdas in a technical blog post.
Calling a function in C without naming it
A Lobsters discussion about techniques for calling a function in C without directly naming it, covering low-level language tricks and compiler/linker behavior.
C++26: More function wrappers
C++26 introduces two new function wrappers: std::copyable_function, which provides a copyable, const-correct alternative to std::function, and std::function_ref, a non-owning callable reference with reference semantics.
Reducing C++ template bloat by factoring out the type-dependent portions of the function, practical exam
The article explains how to reduce C++ template bloat by factoring out type-dependent portions of functions, using a practical example with Windows DispatcherQueueHandler to de-templatize code.
Code calling is all you need
Argues that using code generated by LLMs to call external tools (code calling) is more efficient and capable than traditional JSON-based function calling, but requires secure sandboxing. The author is building a framework for this approach.