{"id":10404,"date":"2024-12-09T10:25:34","date_gmt":"2024-12-09T10:25:34","guid":{"rendered":"https:\/\/www.modernescpp.com\/?p=10404"},"modified":"2025-07-04T15:54:27","modified_gmt":"2025-07-04T15:54:27","slug":"stdexecution-composition-of-senders","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/stdexecution-composition-of-senders\/","title":{"rendered":"std::execution: Composition of Senders"},"content":{"rendered":"\n

Most sender adaptors are composable using the pipe operator.<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

Let me start with a simple example of composition with the pipe operator.<\/p>\n\n\n\n

Instead of the nested function calls<\/p>\n\n\n\n

call1(call2(input))\n<\/pre><\/div>\n\n\n\n
you can write<\/p>\n\n\n\n
call1 |<\/span> call2(input)\n<\/pre><\/div>\n\n\n\n
or even:<\/p>\n\n\n\n
 input |<\/span> call1 |<\/span> call2\n<\/pre><\/div>\n\n\n\n
Function composition<\/h2>\n\n\n\n
Okay, this example was straightforward. Let’s do something more complicated. Proposal P2300R10<\/a> compares nested function invocation with function invocation using a temporary and composition using the pipe operator. <\/p>\n\n\n\n
All three function compositions calculate 610 = (123*5)-5 using a thread_pool <\/code>and cuda<\/code>.  Consider, in particular, the lambda  []{ return 123; })<\/code>.  This lambda is not evaluated. Why?<\/p>\n\n\n\n
Nested Function Invocation<\/h3>\n\n\n\n
auto<\/span> snd =<\/span> execution::<\/span>then(\n             execution::<\/span>continues_on(\n               execution::<\/span>then(\n                 execution::<\/span>continues_on(\n                   execution::<\/span>then(\n                     execution::<\/span>schedule(thread_pool.scheduler())\n                     []{ return<\/span> 123<\/span>; }),\n                   cuda::<\/span>new_stream_scheduler()),\n                 [](int<\/span> i){ return<\/span> 123<\/span> *<\/span> 5<\/span>; }),\n               thread_pool.scheduler()),\n             [](int<\/span> i){ return<\/span> i -<\/span> 5<\/span>; });\nauto<\/span> [result] =<\/span> this_thread::<\/span>sync_wait(snd).value();\n\/\/ result == 610<\/span>\n<\/pre><\/div>\n\n\n\n
It isn’t easy to understand this nesting of function calls, to see which function bodies belong together, or to understand why the lambda is not executed. Nor is it fun to debug this composition or change it.<\/p>\n\n\n\n
 Function Invocation with Temporaries<\/h3>\n\n\n\n
auto<\/span> snd0 =<\/span> execution::<\/span>schedule(thread_pool.scheduler());\nauto<\/span> snd1 =<\/span> execution::<\/span>then(snd0, []{ return<\/span> 123<\/span>; });\nauto<\/span> snd2 =<\/span> execution::<\/span>continues_on(snd1, cuda::<\/span>new_stream_scheduler());\nauto<\/span> snd3 =<\/span> execution::<\/span>then(snd2, [](int<\/span> i){ return<\/span> 123<\/span> *<\/span> 5<\/span>; })\nauto<\/span> snd4 =<\/span> execution::<\/span>continues_on(snd3, thread_pool.scheduler())\nauto<\/span> snd5 =<\/span> execution::<\/span>then(snd4, [](int<\/span> i){ return<\/span> i -<\/span> 5<\/span>; });\nauto<\/span> [result] =<\/span> *<\/span>this_thread::<\/span>sync_wait(snd4);\n\/\/ result == 610<\/span>\n<\/pre><\/div>\n\n\n\n
Using temporaries may help a lot in understanding the composition’s structure. Now, it is easy to see the sequence of function calls. You may also see why the lambda  []{ return 123; }<\/code>. There is no sender consumer, such as this_thread::sync_wait(snd4)<\/code>. The sender adaptors, such as then<\/code> and continue_on<\/code>, are lazy. They only produce a value if asked for it.<\/p>\n\n\n\n
I like this solution from a readability point of view, but it has a severe downside: many temporaries are created.<\/p>\n\n\n\n
Function Composition  with the Pipe Operator <\/h3>\n\n\n\n
auto<\/span> snd =<\/span> execution::<\/span>schedule(thread_pool.scheduler())\n         |<\/span> execution::<\/span>then([]{ return<\/span> 123<\/span>; })\n         |<\/span> execution::<\/span>continues_on(cuda::<\/span>new_stream_scheduler())\n         |<\/span> execution::<\/span>then([](int<\/span> i){ return<\/span> 123<\/span> *<\/span> 5<\/span>; })\n         |<\/span> execution:: Double quote <\/span>continues_on(thread_pool.scheduler())\n         |<\/span> execution::<\/span>then([](int<\/span> i){ return<\/span> i -<\/span> 5<\/span>; });\nauto<\/span> [result] =<\/span> this_thread::<\/span>sync_wait(snd).value();\n\/\/ result == 610<\/span>\n<\/pre><\/div>\n\n\n\n
Function composition with the pipe operator overcomes both issues. First, it is readable, and second, it doesn’t need unnecessary temporaries.<\/p>\n\n\n\n
Not all sender adaptors are pipeable. Specifically, the following sender adaptors are not pipeable.<\/p>\n\n\n\n
    \n
  • execution::when_all<\/code> and execution::when_all_with_variant<\/code>: Both sender adaptors take an arbitrary number of senders. It would, therefore, be unclear which sender should be adapted.<\/li>\n\n\n\n
  • execution::starts_on<\/code>: This sender adaptor changes the execution resource on which the sender runs. It does not adapt the sender.<\/li>\n<\/ul>\n\n\n\n
    Layout is Important<\/h3>\n\n\n\n
    It is essential to layout it in a readable way for function composition. So, don’t make a smart one-liner out of it:<\/p>\n\n\n\n
    auto<\/span> snd =<\/span> execution::<\/span>schedule(thread_pool.scheduler()) |<\/span> execution::<\/span>then([]{ return<\/span> 123<\/span>; }) |<\/span> execution::<\/span>continues_on(cuda::<\/span>new_stream_scheduler()) |<\/span> execution::<\/span>then([](int<\/span> i){ return<\/span> 123<\/span> *<\/span> 5<\/span>; }) |<\/span> execution::<\/span> Double quote continues_on(thread_pool.scheduler()) |<\/span> execution::<\/span>then([](int<\/span> i){ return<\/span> i -<\/span> 5<\/span>; });\n<\/pre><\/div>\n\n\n\n
    What’s Next?<\/h2>\n\n\n\n
    std::execution<\/code> offers a few sender factories, particularly many senders, to model your concurrent workflow. I will present them in my next post.<\/p>\n\n\n\n
    <\/p>\n","protected":false},"excerpt":{"rendered":"
    Most sender adaptors are composable using the pipe operator. Let me start with a simple example of composition with the pipe operator. Instead of the nested function calls call1(call2(input)) you can write call1 | call2(input) or even: input | call1 | call2 Function composition Okay, this example was straightforward. Let’s do something more complicated. Proposal […]<\/p>\n","protected":false},"author":21,"featured_media":10406,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[559],"tags":[561],"class_list":["post-10404","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c26-blog","tag-execution"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/10404","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=10404"}],"version-history":[{"count":19,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/10404\/revisions"}],"predecessor-version":[{"id":10489,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/10404\/revisions\/10489"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/10406"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=10404"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=10404"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=10404"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}