Creating Composable Callables in Contemporary C++

C++ took a huge step in the direction of composability when Ranges were introduced in C++20. C++23 improved it, and C++26 looks to improve it even more.

However, function objects, sometimes referred to as Niebloids, after Eric Niebler who pioneered their use in the Ranges library, are still few and rarely composable. With function objects we can send functions, and even complete overload sets, as arguments to other functions, return them, and combine them.

I will show you compositions I want, how to write them and with gradual scope creep end up with a very powerful set of utilities that are easy to use and require surprisingly little code when using recent additions to the C++ language.

Transcript

2. Björn Fahller Creating Composable Callables in Contemporary C++ or How I nerd sniped myself with a lightning talk https://www.youtube.com/watch?v=XKVyoWvPCCw
3. The goal
4. The goal auto i = find_if(values, &S::name | equal_to("foo"));
5. The goal auto i = find_if(values, &S::name | equal_to("foo")); sort(values, transform_args(&S::num, less_than));
6. The goal auto i = find_if(values, &S::name | equal_to("foo")); sort(values, transform_args(&S::num, less_than)); std::vector<int> producer(); sort(producer(), greater_than);
7. The goal auto i = find_if(values, &S::name | equal_to("foo")); sort(values, transform_args(&S::num, less_than)); std::vector<int> producer(); sort(producer(), greater_than); find_if(values, &S::name | equal_to("foo"));
11. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 11/176 A small example bool all_are_small(std::span<const int> numbers) { return std::ranges::all_of(numbers, [](int x){return x < 10;}); }
12. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 12/176 A small example bool all_are_small(std::span<const int> numbers) { return std::ranges::all_of(numbers, [](int x){return x < 10;}); }
13. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 13/176 A small example bool all_are_small(std::span<const int> numbers) { return std::ranges::all_of(numbers, [](int x){return x < 10;}); } Let’s make a function for this comparison
14. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 14/176 A small example constexpr auto less_than(auto rh) { return [rh](auto lh){return lh < rh;}; } bool all_are_small(std::span<const int> numbers) { return std::ranges::all_of(numbers, [](int x){return x < 10;}); }
15. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 15/176 A small example constexpr auto less_than(auto rh) { return [rh](auto lh){return lh < rh;}; } bool all_are_small(std::span<const int> numbers) { return std::ranges::all_of(numbers, [](int x){return x < 10;}); }
16. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 16/176 A small example constexpr auto less_than(auto rh) { return [rh](auto lh){return lh < rh;}; } bool all_are_small(std::span<const int> numbers) { return std::ranges::all_of(numbers, [](int x){return x < 10;}); } Return a lambda which binds the argument used on the right hand side
17. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 17/176 A small example constexpr auto less_than(auto rh) { return [rh](auto lh){return lh < rh;}; } bool all_are_small(std::span<const int> numbers) { return std::ranges::all_of(numbers, less_than(10)); }
18. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 18/176 A small example constexpr auto less_than(auto rh) { return [rh](auto lh){return lh < rh;}; } bool all_are_small(std::span<const int> numbers) { return std::ranges::all_of(numbers, less_than(10)); } https://godbolt.org/z/EPd97Kq9P
19. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 19/176 A first generalization constexpr auto less_than(auto rh) { return [rh](auto lh){return lh < rh;}; } bool all_are_small(std::span<const int> numbers) { return std::ranges::all_of(numbers, less_than(10)); } This has a name in the standard library. It is std::less<>
20. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 20/176 A first generalization constexpr auto less_than(auto rh) { return [rh](auto lh){return lh < rh;}; } bool all_are_small(std::span<const int> numbers) { return std::ranges::all_of(numbers, less_than(10)); } template <typename F> constexpr auto back_binding(F f = {}) { return [f](auto rh) { return [f,rh](auto lh) { return f(lh, rh); }; }; }
21. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 21/176 A first generalization constexpr auto less_than(auto rh) { return [rh](auto lh){return lh < rh;}; } bool all_are_small(std::span<const int> numbers) { return std::ranges::all_of(numbers, less_than(10)); } template <typename F> constexpr auto back_binding(F f = {}) { return [f](auto rh) { return [f,rh](auto lh) { return f(lh, rh); }; }; } A function to call
22. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 22/176 A first generalization constexpr auto less_than(auto rh) { return [rh](auto lh){return lh < rh;}; } bool all_are_small(std::span<const int> numbers) { return std::ranges::all_of(numbers, less_than(10)); } template <typename F> constexpr auto back_binding(F f = {}) { return [f](auto rh) { return [f,rh](auto lh) { return f(lh, rh); }; }; }
23. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 23/176 A first generalization constexpr auto less_than(auto rh) { return [rh](auto lh){return lh < rh;}; } bool all_are_small(std::span<const int> numbers) { return std::ranges::all_of(numbers, less_than(10)); } template <typename F> constexpr auto back_binding(F f = {}) { return [f](auto rh) { return [f,rh](auto lh) { return f(lh, rh); }; }; } Call function with the right hand argument bound
24. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 24/176 A first generalization constexpr auto less_than(auto rh) { return [rh](auto lh){return lh < rh;}; } bool all_are_small(std::span<const int> numbers) { return std::ranges::all_of(numbers, less_than(10)); } template <typename F> constexpr auto back_binding(F f = {}) { return [f](auto rh) { return [f,rh](auto lh) { return f(lh, rh); }; }; } Call function with the right hand argument bound Looks unnecessarily complicated
25. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 25/176 A first generalization constexpr auto less_than(auto rh) { return [rh](auto lh){return lh < rh;}; } bool all_are_small(std::span<const int> numbers) { return std::ranges::all_of(numbers, less_than(10)); } template <typename F> constexpr auto back_binding(F f = {}) { return [f](auto rh) { return std::bind_back(f,rh); }; }
26. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 26/176 A first generalization constexpr auto less_than(auto rh) { return [rh](auto lh){return lh < rh;}; } bool all_are_small(std::span<const int> numbers) { return std::ranges::all_of(numbers, less_than(10)); } template <typename F> constexpr auto back_binding(F f = {}) { return [f](auto rh) { return std::bind_back(f,rh); }; }
27. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 27/176 A first generalization constexpr auto less_than(auto rh) { return [rh](auto lh){return lh < rh;}; } bool all_are_small(std::span<const int> numbers) { return std::ranges::all_of(numbers, less_than(10)); } template <typename F> constexpr auto back_binding(F f = {}) { return [f](auto rh) { return std::bind_back(f,rh); }; } https://en.cppreference.com/cpp/utility/functional/bind_back
28. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 28/176 A first generalization constexpr auto less_than(auto rh) { return [rh](auto lh){return lh < rh;}; } bool all_are_small(std::span<const int> numbers) { return std::ranges::all_of(numbers, less_than(10)); } template <typename F> constexpr auto back_binding(F f = {}) { return [f](auto rh) { return std::bind_back(f,rh); }; } Better!
29. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 29/176 A first generalization constexpr auto less_than(auto rh) { return [rh](auto lh){return lh < rh;}; } bool all_are_small(std::span<const int> numbers) { return std::ranges::all_of(numbers, less_than(10)); } template <typename F> constexpr auto back_binding(F f = {}) { return [f](auto rh) { return std::bind_back(f,rh); }; } constexpr auto less_than = back_binding<std::less<>>(); Better!
30. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 30/176 A first generalization constexpr auto less_than(auto rh) { return [rh](auto lh){return lh < rh;}; } bool all_are_small(std::span<const int> numbers) { return std::ranges::all_of(numbers, less_than(10)); } template <typename F> constexpr auto back_binding(F f = {}) { return [f](auto rh) { return std::bind_back(f,rh); }; } constexpr auto less_than = back_binding<std::less<>>(); Better! https://godbolt.org/z/v97P76T11
31. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 31/176 pipes &S::num | less_than(10)
32. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 32/176 pipes &S::num | less_than(10) I want to be able to write this
33. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 33/176 pipes auto operator|(FL lh, FR rh)
34. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 34/176 pipes auto operator|(FL lh, FR rh) Need a way to identify the types as composable functions
35. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 35/176 pipes auto operator|(FL lh, FR rh) Need a way to identify the types as composable functions The lambdas will not suffice
36. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 36/176 pipes template <typename F> struct composable_function { F f; };
37. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 37/176 pipes template <typename F> struct composable_function { F f; }; The function to call
38. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 38/176 pipes template <typename F> struct composable_function { F f; template <typename ... Ts> decltype(auto) operator()(Ts&& ... ts) const { return f(std::forward<Ts>(ts)...); } };
39. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 39/176 pipes template <typename F> struct composable_function { F f; template <typename ... Ts> decltype(auto) operator()(Ts&& ... ts) const { return f(std::forward<Ts>(ts)...); } }; When called with arguments
40. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 40/176 pipes template <typename F> struct composable_function { F f; template <typename ... Ts> decltype(auto) operator()(Ts&& ... ts) const { return f(std::forward<Ts>(ts)...); } }; Call the wrapped function
41. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 41/176 pipes template <typename F> struct composable_function { F f; template <typename ... Ts> decltype(auto) operator()(Ts&& ... ts) const requires requires { f(std::forward<Ts>(ts)...);} { return f(std::forward<Ts>(ts)...); } }; But only if the function can be called
42. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 42/176 pipes template <typename F> struct composable_function { F f; template <typename ... Ts> decltype(auto) operator()(Ts&& ... ts) const requires requires { f(std::forward<Ts>(ts)...);} { return f(std::forward<Ts>(ts)...); } }; template <typename F> struct back_binding : composable_function<F> { };
43. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 43/176 pipes template <typename F> struct composable_function { F f; template <typename ... Ts> decltype(auto) operator()(Ts&& ... ts) const requires requires { f(std::forward<Ts>(ts)...);} { return f(std::forward<Ts>(ts)...); } }; template <typename F> struct back_binding : composable_function<F> { }; back_binding is a composable_function
44. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 44/176 pipes template <typename F> struct composable_function { F f; template <typename ... Ts> decltype(auto) operator()(Ts&& ... ts) const requires requires { f(std::forward<Ts>(ts)...);} { return f(std::forward<Ts>(ts)...); } }; template <typename F> struct back_binding : composable_function<F> { using composable_function<F>::operator(); template <typename ... Ts> auto operator()(Ts&& ... ts) const { } };
45. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 45/176 pipes template <typename F> struct composable_function { F f; template <typename ... Ts> decltype(auto) operator()(Ts&& ... ts) const requires requires { f(std::forward<Ts>(ts)...);} { return f(std::forward<Ts>(ts)...); } }; template <typename F> struct back_binding : composable_function<F> { using composable_function<F>::operator(); template <typename ... Ts> auto operator()(Ts&& ... ts) const { } }; It overloads the call operator
46. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 46/176 pipes template <typename F> struct composable_function { F f; template <typename ... Ts> decltype(auto) operator()(Ts&& ... ts) const requires requires { f(std::forward<Ts>(ts)...);} { return f(std::forward<Ts>(ts)...); } }; template <typename F> struct back_binding : composable_function<F> { using composable_function<F>::operator(); template <typename ... Ts> auto operator()(Ts&& ... ts) const { auto bound = std::bind_back( this->f, std::forward<Ts>(ts)...); using RT = back_binding<decltype(bound)>; return RT{std::move(bound)}; } };
47. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 47/176 pipes template <typename F> struct composable_function { F f; template <typename ... Ts> decltype(auto) operator()(Ts&& ... ts) const requires requires { f(std::forward<Ts>(ts)...);} { return f(std::forward<Ts>(ts)...); } }; template <typename F> struct back_binding : composable_function<F> { using composable_function<F>::operator(); template <typename ... Ts> auto operator()(Ts&& ... ts) const { auto bound = std::bind_back( this->f, std::forward<Ts>(ts)...); using RT = back_binding<decltype(bound)>; return RT{std::move(bound)}; } }; Bind the arguments at the back
48. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 48/176 pipes template <typename F> struct composable_function { F f; template <typename ... Ts> decltype(auto) operator()(Ts&& ... ts) const requires requires { f(std::forward<Ts>(ts)...);} { return f(std::forward<Ts>(ts)...); } }; template <typename F> struct back_binding : composable_function<F> { using composable_function<F>::operator(); template <typename ... Ts> auto operator()(Ts&& ... ts) const { auto bound = std::bind_back( this->f, std::forward<Ts>(ts)...); using RT = back_binding<decltype(bound)>; return RT{std::move(bound)}; } }; Return another back_binding
49. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 49/176 pipes template <typename F> struct composable_function { ... }; template <typename F> struct back_binding : composable_function<F> { ... }; constexpr auto less_than = back_binding<std::less<>>();
50. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 50/176 pipes template <typename F> struct composable_function { ... }; template <typename F> struct back_binding : composable_function<F> { ... }; constexpr auto less_than = back_binding<std::less<>>(); Usage is the same as before
51. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 51/176 pipes template <typename F> struct composable_function { ... }; template <typename F> struct back_binding : composable_function<F> { ... }; constexpr auto less_than = back_binding<std::less<>>(); https://godbolt.org/z/d89fqjsqn Usage is the same as before
52. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 52/176 pipes template <typename F> struct composable_function; template <typename F> concept composable_function_type = requires { };
53. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 53/176 pipes template <typename F> struct composable_function; template <typename F> concept composable_function_type = requires { }; Create a concept that can be used by the pipe operator
54. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 54/176 pipes template <typename F> struct composable_function; template <typename F> concept composable_function_type = requires { []<typename T>(composable_function<T>*){}( std::declval<std::remove_cvref_t<F>*>() ); };
55. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 55/176 pipes template <typename F> struct composable_function; template <typename F> concept composable_function_type = requires { []<typename T>(composable_function<T>*){}( std::declval<std::remove_cvref_t<F>*>() ); }; Require that a pointer to type F
56. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 56/176 pipes template <typename F> struct composable_function; template <typename F> concept composable_function_type = requires { []<typename T>(composable_function<T>*){}( std::declval<std::remove_cvref_t<F>*>() ); }; Can be passed to a function accepting a pointer to a composable_function
57. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 57/176 pipes template <typename F> struct composable_function; template <typename F> concept composable_function_type = requires { []<typename T>(composable_function<T>*){}( std::declval<std::remove_cvref_t<F>*>() ); }; This matches back_binding too since it models an is-A relationship through inheritance
58. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 58/176 pipes template < composable_function_type LH, composable_function_type RH> auto operator|(LH&& lh, RH&& rh) { }
59. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 59/176 pipes template < composable_function_type LH, composable_function_type RH> auto operator|(LH&& lh, RH&& rh) { } Now we can write the pipe between two composable functions.
60. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 60/176 pipes template < composable_function_type LH, composable_function_type RH> auto operator|(LH&& lh, RH&& rh) { auto pipe = [lh = std::forward<LH>(lh), rh = std::forward<RH>(rh)] <typename ... Ts>(Ts&& ... ts) { return rh(lh(std::forward<Ts>(ts)...)); }; return RT{std::move(pipe)}; }
61. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 61/176 pipes template < composable_function_type LH, composable_function_type RH> auto operator|(LH&& lh, RH&& rh) { auto pipe = [lh = std::forward<LH>(lh), rh = std::forward<RH>(rh)] <typename ... Ts>(Ts&& ... ts) { return rh(lh(std::forward<Ts>(ts)...)); }; return RT{std::move(pipe)}; } Capture the functions
62. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 62/176 pipes template < composable_function_type LH, composable_function_type RH> auto operator|(LH&& lh, RH&& rh) { auto pipe = [lh = std::forward<LH>(lh), rh = std::forward<RH>(rh)] <typename ... Ts>(Ts&& ... ts) { return rh(lh(std::forward<Ts>(ts)...)); }; return RT{std::move(pipe)}; } Call the left function with the arguments to the pipe
63. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 63/176 pipes template < composable_function_type LH, composable_function_type RH> auto operator|(LH&& lh, RH&& rh) { auto pipe = [lh = std::forward<LH>(lh), rh = std::forward<RH>(rh)] <typename ... Ts>(Ts&& ... ts) { return rh(lh(std::forward<Ts>(ts)...)); }; return RT{std::move(pipe)}; } Call the right function with the result of the left
64. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 64/176 pipes template < composable_function_type LH, composable_function_type RH> auto operator|(LH&& lh, RH&& rh) { auto pipe = [lh = std::forward<LH>(lh), rh = std::forward<RH>(rh)] <typename ... Ts>(Ts&& ... ts) { return rh(lh(std::forward<Ts>(ts)...)); }; return RT{std::move(pipe)}; } But what should the return type be?
65. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 65/176 pipes template < composable_function_type LH, composable_function_type RH> auto operator|(LH&& lh, RH&& rh) { auto pipe = [lh = std::forward<LH>(lh), rh = std::forward<RH>(rh)] <typename ... Ts>(Ts&& ... ts) { return rh(lh(std::forward<Ts>(ts)...)); }; return RT{std::move(pipe)}; } But what should the return type be? The pipe is called the same way as the left function, so it must be of the same kind.
66. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 66/176 pipes template < composable_function_type LH, composable_function_type RH> auto operator|(LH&& lh, RH&& rh) { auto pipe = [lh = std::forward<LH>(lh).f, rh = std::forward<RH>(rh).f] <typename ... Ts>(Ts&& ... ts) { return rh(lh(std::forward<Ts>(ts)...)); }; using RT = rebind_template_t<std::remove_cvref_t<LH>, decltype(pipe)>; return RT{std::move(pipe)}; } LH is a specialization of a composable function type. C<F> We need the same kind of template, but instantiated with our pipe.
67. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 67/176 pipes template < composable_function_type LH, composable_function_type RH> auto operator|(LH&& lh, RH&& rh) { auto pipe = [lh = std::forward<LH>(lh).f, rh = std::forward<RH>(rh).f] <typename ... Ts>(Ts&& ... ts) { return rh(lh(std::forward<Ts>(ts)...)); }; using RT = rebind_template_t<std::remove_cvref_t<LH>, decltype(pipe)>; return RT{std::move(pipe)}; } LH is a specialization of a composable function type. C<F> We need the same kind of template, but instantiated with our pipe. template <typename> struct rebind_template;
68. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 68/176 pipes template < composable_function_type LH, composable_function_type RH> auto operator|(LH&& lh, RH&& rh) { auto pipe = [lh = std::forward<LH>(lh).f, rh = std::forward<RH>(rh).f] <typename ... Ts>(Ts&& ... ts) { return rh(lh(std::forward<Ts>(ts)...)); }; using RT = rebind_template_t<std::remove_cvref_t<LH>, decltype(pipe)>; return RT{std::move(pipe)}; } LH is a specialization of a composable function type. C<F> We need the same kind of template, but instantiated with our pipe. template <typename> struct rebind_template; template <template <typename> class T, typename Original> struct rebind_template<T<Original>> { };
69. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 69/176 pipes template < composable_function_type LH, composable_function_type RH> auto operator|(LH&& lh, RH&& rh) { auto pipe = [lh = std::forward<LH>(lh).f, rh = std::forward<RH>(rh).f] <typename ... Ts>(Ts&& ... ts) { return rh(lh(std::forward<Ts>(ts)...)); }; using RT = rebind_template_t<std::remove_cvref_t<LH>, decltype(pipe)>; return RT{std::move(pipe)}; } LH is a specialization of a composable function type. C<F> We need the same kind of template, but instantiated with our pipe. template <typename> struct rebind_template; template <template <typename> class T, typename Original> struct rebind_template<T<Original>> { }; When instantiated with a template T, instantiated with type Original, i.e. T<Original>
70. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 70/176 pipes template < composable_function_type LH, composable_function_type RH> auto operator|(LH&& lh, RH&& rh) { auto pipe = [lh = std::forward<LH>(lh).f, rh = std::forward<RH>(rh).f] <typename ... Ts>(Ts&& ... ts) { return rh(lh(std::forward<Ts>(ts)...)); }; using RT = rebind_template_t<std::remove_cvref_t<LH>, decltype(pipe)>; return RT{std::move(pipe)}; } LH is a specialization of a composable function type. C<F> We need the same kind of template, but instantiated with our pipe. template <typename> struct rebind_template; template <template <typename> class T, typename Original> struct rebind_template<T<Original>> { template <typename Substitute> using with = T<Substitute>; };
71. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 71/176 pipes template < composable_function_type LH, composable_function_type RH> auto operator|(LH&& lh, RH&& rh) { auto pipe = [lh = std::forward<LH>(lh).f, rh = std::forward<RH>(rh).f] <typename ... Ts>(Ts&& ... ts) { return rh(lh(std::forward<Ts>(ts)...)); }; using RT = rebind_template_t<std::remove_cvref_t<LH>, decltype(pipe)>; return RT{std::move(pipe)}; } LH is a specialization of a composable function type. C<F> We need the same kind of template, but instantiated with our pipe. template <typename> struct rebind_template; template <template <typename> class T, typename Original> struct rebind_template<T<Original>> { template <typename Substitute> using with = T<Substitute>; }; We offer an alias which is the template T instantiated with a substitute
72. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 72/176 pipes template < composable_function_type LH, composable_function_type RH> auto operator|(LH&& lh, RH&& rh) { auto pipe = [lh = std::forward<LH>(lh).f, rh = std::forward<RH>(rh).f] <typename ... Ts>(Ts&& ... ts) { return rh(lh(std::forward<Ts>(ts)...)); }; using RT = rebind_template_t<std::remove_cvref_t<LH>, decltype(pipe)>; return RT{std::move(pipe)}; } LH is a specialization of a composable function type. C<F> We need the same kind of template, but instantiated with our pipe. template <typename> struct rebind_template; template <template <typename> class T, typename Original> struct rebind_template<T<Original>> { template <typename Substitute> using with = T<Substitute>; }; template <typename T, typename S> using rebind_template_t = rebind_template<T>::template with<S>; And, finally, an alias for less verbose use
73. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 73/176 pipes template < composable_function_type LH, composable_function_type RH> auto operator|(LH&& lh, RH&& rh) { auto pipe = [lh = std::forward<LH>(lh).f, rh = std::forward<RH>(rh).f] <typename ... Ts>(Ts&& ... ts) { return rh(lh(std::forward<Ts>(ts)...)); }; using RT = rebind_template_t<std::remove_cvref_t<LH>, decltype(pipe)>; return RT{std::move(pipe)}; }
74. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 74/176 pipes template < composable_function_type LH, composable_function_type RH> auto operator|(LH&& lh, RH&& rh) { auto pipe = [lh = std::forward<LH>(lh).f, rh = std::forward<RH>(rh).f] <typename ... Ts>(Ts&& ... ts) { return rh(lh(std::forward<Ts>(ts)...)); }; using RT = rebind_template_t<std::remove_cvref_t<LH>, decltype(pipe)>; return RT{std::move(pipe)}; } struct S { int num; std::string_view name; }; constexpr auto get_num = composable_function{std::mem_fn(&S::num)}; bool all_are_small(std::span<const S> numbers) { return std::ranges::all_of(numbers, get_num | less_than(10)); }
75. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 75/176 pipes template < composable_function_type LH, composable_function_type RH> auto operator|(LH&& lh, RH&& rh) { auto pipe = [lh = std::forward<LH>(lh).f, rh = std::forward<RH>(rh).f] <typename ... Ts>(Ts&& ... ts) { return rh(lh(std::forward<Ts>(ts)...)); }; using RT = rebind_template_t<std::remove_cvref_t<LH>, decltype(pipe)>; return RT{std::move(pipe)}; } struct S { int num; std::string_view name; }; constexpr auto get_num = composable_function{std::mem_fn(&S::num)}; bool all_are_small(std::span<const S> numbers) { return std::ranges::all_of(numbers, get_num | less_than(10)); } Composable function get_num, which when called with an S will return the member num
76. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 76/176 pipes template < composable_function_type LH, composable_function_type RH> auto operator|(LH&& lh, RH&& rh) { auto pipe = [lh = std::forward<LH>(lh).f, rh = std::forward<RH>(rh).f] <typename ... Ts>(Ts&& ... ts) { return rh(lh(std::forward<Ts>(ts)...)); }; using RT = rebind_template_t<std::remove_cvref_t<LH>, decltype(pipe)>; return RT{std::move(pipe)}; } struct S { int num; std::string_view name; }; constexpr auto get_num = composable_function{std::mem_fn(&S::num)}; bool all_are_small(std::span<const S> numbers) { return std::ranges::all_of(numbers, get_num | less_than(10)); } And it can be used in a pipe
77. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 77/176 pipes template < composable_function_type LH, composable_function_type RH> auto operator|(LH&& lh, RH&& rh) { auto pipe = [lh = std::forward<LH>(lh).f, rh = std::forward<RH>(rh).f] <typename ... Ts>(Ts&& ... ts) { return rh(lh(std::forward<Ts>(ts)...)); }; using RT = rebind_template_t<std::remove_cvref_t<LH>, decltype(pipe)>; return RT{std::move(pipe)}; } struct S { int num; std::string_view name; }; constexpr auto get_num = composable_function{std::mem_fn(&S::num)}; bool all_are_small(std::span<const S> numbers) { return std::ranges::all_of(numbers, get_num | less_than(10)); } https://godbolt.org/z/WKsdE6jaY
78. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 78/176 pipes template < composable_function_type LH, composable_function_type RH> auto operator|(LH&& lh, RH&& rh); template <typename T, typename C, composable_function_type F> auto operator|(T (C::*member), F&& f) { return composable_function{std::mem_fn(member)} | std::forward<F>(f); } template <composable_function_type F, typename T, typename C> auto operator|(F&& f, T (C::*member)) { return std::forward<F>(f) | composable_function{std::mem_fn(member)}; } Two tiny convenience functions
79. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 79/176 pipes template < composable_function_type LH, composable_function_type RH> auto operator|(LH&& lh, RH&& rh); template <typename T, typename C, composable_function_type F> auto operator|(T (C::*member), F&& f) { return composable_function{std::mem_fn(member)} | std::forward<F>(f); } template <composable_function_type F, typename T, typename C> auto operator|(F&& f, T (C::*member)) { return std::forward<F>(f) | composable_function{std::mem_fn(member)}; } struct S { int num; std::string_view name; }; bool all_are_small(std::span<const S> numbers) { return std::ranges::all_of(numbers, &S::num | less_than(10)); }
80. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 80/176 pipes template < composable_function_type LH, composable_function_type RH> auto operator|(LH&& lh, RH&& rh); template <typename T, typename C, composable_function_type F> auto operator|(T (C::*member), F&& f) { return composable_function{std::mem_fn(member)} | std::forward<F>(f); } template <composable_function_type F, typename T, typename C> auto operator|(F&& f, T (C::*member)) { return std::forward<F>(f) | composable_function{std::mem_fn(member)}; } struct S { int num; std::string_view name; }; bool all_are_small(std::span<const S> numbers) { return std::ranges::all_of(numbers, &S::num | less_than(10)); } More convenient short hand
81. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 81/176 pipes template < composable_function_type LH, composable_function_type RH> auto operator|(LH&& lh, RH&& rh); template <typename T, typename C, composable_function_type F> auto operator|(T (C::*member), F&& f) { return composable_function{std::mem_fn(member)} | std::forward<F>(f); } template <composable_function_type F, typename T, typename C> auto operator|(F&& f, T (C::*member)) { return std::forward<F>(f) | composable_function{std::mem_fn(member)}; } struct S { int num; std::string_view name; }; bool all_are_small(std::span<const S> numbers) { return std::ranges::all_of(numbers, &S::num | less_than(10)); }
82. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 82/176 transform_args How do I, e.g., sort on a member?
83. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 83/176 transform_args template <typename Proj, composable_function_type F> constexpr auto transform_args(Proj&& proj, F&& f) { }
84. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 84/176 transform_args template <typename Proj, composable_function_type F> constexpr auto transform_args(Proj&& proj, F&& f) { } Create transform_args, which takes a projection and a function, and applies the projection to each argument to thefunction
85. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 85/176 transform_args template <typename Proj, composable_function_type F> constexpr auto transform_args(Proj&& proj, F&& f) { auto transform = [proj = std::forward<Proj>(proj), f = std::forward<F>(f).f] <typename ... Ts>(Ts&& ... ts) { return f(proj(std::forward<Ts>(ts))...); }; using RT = rebind_template_t<std::remove_cvref_t<F>>, decltype(transform)>; return RT{std::move(transform)}; }
86. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 86/176 transform_args template <typename Proj, composable_function_type F> constexpr auto transform_args(Proj&& proj, F&& f) { auto transform = [proj = std::forward<Proj>(proj), f = std::forward<F>(f).f] <typename ... Ts>(Ts&& ... ts) { return f(proj(std::forward<Ts>(ts))...); }; using RT = rebind_template_t<std::remove_cvref_t<F>>, decltype(transform)>; return RT{std::move(transform)}; } Bind the projection and the function
87. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 87/176 transform_args template <typename Proj, composable_function_type F> constexpr auto transform_args(Proj&& proj, F&& f) { auto transform = [proj = std::forward<Proj>(proj), f = std::forward<F>(f).f] <typename ... Ts>(Ts&& ... ts) { return f(proj(std::forward<Ts>(ts))...); }; using RT = rebind_template_t<std::remove_cvref_t<F>>, decltype(transform)>; return RT{std::move(transform)}; } Transform each argument through the projection in the call
88. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 88/176 transform_args template <typename Proj, composable_function_type F> constexpr auto transform_args(Proj&& proj, F&& f) { auto transform = [proj = std::forward<Proj>(proj), f = std::forward<F>(f).f] <typename ... Ts>(Ts&& ... ts) { return f(proj(std::forward<Ts>(ts))...); }; using RT = rebind_template_t<std::remove_cvref_t<F>>, decltype(transform)>; return RT{std::move(transform)}; }
89. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 89/176 transform_args template <typename Proj, composable_function_type F> constexpr auto transform_args(Proj&& proj, F&& f) { auto transform = [proj = std::forward<Proj>(proj), f = std::forward<F>(f).f] <typename ... Ts>(Ts&& ... ts) { return f(proj(std::forward<Ts>(ts))...); }; using RT = rebind_template_t<std::remove_cvref_t<F>>, decltype(transform)>; return RT{std::move(transform)}; } Same as pipe?
90. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 90/176 transform_args template <typename Proj, composable_function_type F> constexpr auto transform_args(Proj&& proj, F&& f) { auto transform = [proj = std::forward<Proj>(proj), f = std::forward<F>(f).f] <typename ... Ts>(Ts&& ... ts) { return f(proj(std::forward<Ts>(ts))...); }; using RT = rebind_template_t<std::remove_cvref_t<F>>, decltype(transform)>; return RT{std::move(transform)}; } Same as pipe? auto pipe = [lh = std::forward<LH>(lh).f, rh = std::forward<RH>(rh).f] <typename ... Ts>(Ts&& ... ts) { return rh(lh(std::forward<Ts>(ts)...)); };
91. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 91/176 transform_args template <typename Proj, composable_function_type F> constexpr auto transform_args(Proj&& proj, F&& f) { auto transform = [proj = std::forward<Proj>(proj), f = std::forward<F>(f).f] <typename ... Ts>(Ts&& ... ts) { return f(proj(std::forward<Ts>(ts))...); }; using RT = rebind_template_t<std::remove_cvref_t<F>>, decltype(transform)>; return RT{std::move(transform)}; } auto pipe = [lh = std::forward<LH>(lh).f, rh = std::forward<RH>(rh).f] <typename ... Ts>(Ts&& ... ts) { return rh(lh(std::forward<Ts>(ts)...)); }; The pipe passes all arguments to the left hand side function
92. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 92/176 transform_args template <typename Proj, composable_function_type F> constexpr auto transform_args(Proj&& proj, F&& f) { auto transform = [proj = std::forward<Proj>(proj), f = std::forward<F>(f).f] <typename ... Ts>(Ts&& ... ts) { return f(proj(std::forward<Ts>(ts))...); }; using RT = rebind_template_t<std::remove_cvref_t<F>>, decltype(transform)>; return RT{std::move(transform)}; } auto pipe = [lh = std::forward<LH>(lh).f, rh = std::forward<RH>(rh).f] <typename ... Ts>(Ts&& ... ts) { return rh(lh(std::forward<Ts>(ts)...)); }; transform_args calls the projection function on each argument
93. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 93/176 transform_args template <typename Proj, composable_function_type F> constexpr auto transform_args(Proj&& proj, F&& f) {...} template <typename T, typename C, composable_function_type F> constexpr auto transform_args(T (C::*member), F&& f) { return transform_args(composable_function(member), std::forward<F>(f)); }
94. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 94/176 transform_args template <typename Proj, composable_function_type F> constexpr auto transform_args(Proj&& proj, F&& f) {...} template <typename T, typename C, composable_function_type F> constexpr auto transform_args(T (C::*member), F&& f) { return transform_args(composable_function(member), std::forward<F>(f)); } Create a convenience wrapper for pointer to member
95. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 95/176 transform_args template <typename Proj, composable_function_type F> constexpr auto transform_args(Proj&& proj, F&& f) {...} template <typename T, typename C, composable_function_type F> constexpr auto transform_args(T (C::*member), F&& f) { return transform_args(composable_function(member), std::forward<F>(f)); } But this overload set is not an object that can be passed
96. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 96/176 transform_args namespace impl { template <typename Proj, composable_function_type F> constexpr auto transform_args(Proj&& proj, F&& f) {...} template <typename T, typename C, composable_function_type F> constexpr auto transform_args(T (C::*member), F&& f) { return transform_args(composable_function(member), std::forward<F>(f)); } }
97. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 97/176 transform_args namespace impl { template <typename Proj, composable_function_type F> constexpr auto transform_args(Proj&& proj, F&& f) {...} template <typename T, typename C, composable_function_type F> constexpr auto transform_args(T (C::*member), F&& f) { return transform_args(composable_function(member), std::forward<F>(f)); } } Add another level of indirection
98. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 98/176 transform_args namespace impl { template <typename Proj, composable_function_type F> constexpr auto transform_args(Proj&& proj, F&& f) {...} template <typename T, typename C, composable_function_type F> constexpr auto transform_args(T (C::*member), F&& f) { return transform_args(composable_function(member), std::forward<F>(f)); } } inline constexpr auto transform_args = front_binding { []<typename ... Ts>(Ts&& ... ts) -> decltype(impl::transform_args(std::forward<Ts>(ts)...)) { return impl::transform_args(std::forward<Ts>(ts)...); } };
99. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 99/176 transform_args namespace impl { template <typename Proj, composable_function_type F> constexpr auto transform_args(Proj&& proj, F&& f) {...} template <typename T, typename C, composable_function_type F> constexpr auto transform_args(T (C::*member), F&& f) { return transform_args(composable_function(member), std::forward<F>(f)); } } inline constexpr auto transform_args = front_binding { []<typename ... Ts>(Ts&& ... ts) -> decltype(impl::transform_args(std::forward<Ts>(ts)...)) { return impl::transform_args(std::forward<Ts>(ts)...); } };
100. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 100/176 transform_args namespace impl { template <typename Proj, composable_function_type F> constexpr auto transform_args(Proj&& proj, F&& f) {...} template <typename T, typename C, composable_function_type F> constexpr auto transform_args(T (C::*member), F&& f) { return transform_args(composable_function(member), std::forward<F>(f)); } } inline constexpr auto transform_args = front_binding { []<typename ... Ts>(Ts&& ... ts) -> decltype(impl::transform_args(std::forward<Ts>(ts)...)) { return impl::transform_args(std::forward<Ts>(ts)...); } };
101. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 101/176 front_binding template <typename F> struct front_binding : composable_function<F> { using composable_function<F>::operator(); template <typename ... Ts> constexpr auto operator()(Ts&& ... ts) const requires(! requires{this->f(std::forward<Ts>(ts)...);}){ auto bound = std::bind_front( this->f, std::forward<Ts>(ts)...); using RT = front_binding<decltype(bound)>; return RT{std::move(bound)}; } };
102. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 102/176 front_binding template <typename F> struct front_binding : composable_function<F> { using composable_function<F>::operator(); template <typename ... Ts> constexpr auto operator()(Ts&& ... ts) const requires(! requires{this->f(std::forward<Ts>(ts)...);}){ auto bound = std::bind_front( this->f, std::forward<Ts>(ts)...); using RT = front_binding<decltype(bound)>; return RT{std::move(bound)}; } }; Same as back_binding, but calls std::bind_front instead of std::bind_back
103. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 103/176 front_binding template <typename F> struct front_binding : composable_function<F> { using composable_function<F>::operator(); template <typename ... Ts> constexpr auto operator()(Ts&& ... ts) const requires(! requires{this->f(std::forward<Ts>(ts)...);}){ auto bound = std::bind_front( this->f, std::forward<Ts>(ts)...); using RT = front_binding<decltype(bound)>; return RT{std::move(bound)}; } }; This disambiguation is useful also for back_binding
104. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 104/176 transform_args struct S { int num; std::string_view name; }; inline constexpr auto by_num = transform_args(&S::num); bool are_sorted_by_num(std::span<const S> numbers) { return std::ranges::is_sorted(numbers, by_num(less_than)); }
105. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 105/176 transform_args struct S { int num; std::string_view name; }; inline constexpr auto by_num = transform_args(&S::num); bool are_sorted_by_num(std::span<const S> numbers) { return std::ranges::is_sorted(numbers, by_num(less_than)); }
106. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 106/176 transform_args inline constexpr auto is_sorted = back_binding{[]<typename ... Ts>(Ts&& ... ts) -> decltype(std::ranges::is_sorted(std::forward<Ts>(ts)...)){ return std::ranges::is_sorted(std::forward<Ts>(ts)...); } }; inline constexpr auto is_sorted_by_num(composable_function_type auto order){ return is_sorted(by_num(order)); } bool are_sorted_by_num(std::span<const S> numbers) { return is_sorted_by_num(less_than)(numbers); }
107. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 107/176 transform_args inline constexpr auto is_sorted = back_binding{[]<typename ... Ts>(Ts&& ... ts) -> decltype(std::ranges::is_sorted(std::forward<Ts>(ts)...)){ return std::ranges::is_sorted(std::forward<Ts>(ts)...); } }; inline constexpr auto is_sorted_by_num(composable_function_type auto order){ return is_sorted(by_num(order)); } bool are_sorted_by_num(std::span<const S> numbers) { return is_sorted_by_num(less_than)(numbers); } back_binding wrapper for std::ranges::is_sorted
108. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 108/176 transform_args inline constexpr auto is_sorted = back_binding{[]<typename ... Ts>(Ts&& ... ts) -> decltype(std::ranges::is_sorted(std::forward<Ts>(ts)...)){ return std::ranges::is_sorted(std::forward<Ts>(ts)...); } }; inline constexpr auto is_sorted_by_num(composable_function_type auto order){ return is_sorted(by_num(order)); } bool are_sorted_by_num(std::span<const S> numbers) { return is_sorted_by_num(less_than)(numbers); } Sort on &S::num with order as argument
109. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 109/176 transform_args inline constexpr auto is_sorted = back_binding{[]<typename ... Ts>(Ts&& ... ts) -> decltype(std::ranges::is_sorted(std::forward<Ts>(ts)...)){ return std::ranges::is_sorted(std::forward<Ts>(ts)...); } }; inline constexpr auto is_sorted_by_num(composable_function_type auto order){ return is_sorted(by_num(order)); } bool are_sorted_by_num(std::span<const S> numbers) { return is_sorted_by_num(less_than)(numbers); } Sorted in increasing order using less_than
110. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 110/176 transform_args inline constexpr auto is_sorted = back_binding{[]<typename ... Ts>(Ts&& ... ts) -> decltype(std::ranges::is_sorted(std::forward<Ts>(ts)...)){ return std::ranges::is_sorted(std::forward<Ts>(ts)...); } }; inline constexpr auto is_sorted_by_num(composable_function_type auto order){ return is_sorted(by_num(order)); } bool are_sorted_by_num(std::span<const S> numbers) { return is_sorted_by_num(less_than)(numbers); }
111. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 111/176 transform_args inline constexpr auto is_sorted = back_binding{[]<typename ... Ts>(Ts&& ... ts) -> decltype(std::ranges::is_sorted(std::forward<Ts>(ts)...)){ return std::ranges::is_sorted(std::forward<Ts>(ts)...); } }; inline constexpr auto is_sorted_by_num(composable_function_type auto order){ return is_sorted(by_num(order)); } bool are_sorted_by_num(std::span<const S> numbers) { return is_sorted_by_num(less_than)(numbers); } https://godbolt.org/z/EvGe5xrYG
112. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 112/176 perfect(er) forwarding What if I want to bind something that is not copyable?
113. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 113/176 perfect(er) forwarding void consume(int, std::unique_ptr<int>); int main() { auto bc = back_binding{consume}; auto consume_ptr = bc(std::make_unique<int>(3)); consume_ptr(3); }
114. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 114/176 perfect(er) forwarding void consume(int, std::unique_ptr<int>); int main() { auto bc = back_binding{consume}; auto consume_ptr = bc(std::make_unique<int>(3)); consume_ptr(3); } Outrageous compilation error message!
115. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 115/176 perfect(er) forwarding void consume(int, std::unique_ptr<int>); int main() { auto bc = back_binding{consume}; auto consume_ptr = bc(std::make_unique<int>(3)); consume_ptr(3); } Outrageous compilation error message! clang: 97 lines
116. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 116/176 perfect(er) forwarding void consume(int, std::unique_ptr<int>); int main() { auto bc = back_binding{consume}; auto consume_ptr = bc(std::make_unique<int>(3)); consume_ptr(3); } Outrageous compilation error message! clang: 97 lines gcc: 34 lines
117. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 117/176 perfect(er) forwarding void consume(int, std::unique_ptr<int>); int main() { auto bc = back_binding{consume}; auto consume_ptr = bc(std::make_unique<int>(3)); consume_ptr(3); } Outrageous compilation error message! clang: 97 lines gcc: 34 lines MSVC: 11 lines
118. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 118/176 perfect(er) forwarding void consume(int, std::unique_ptr<int>); int main() { auto bc = back_binding{consume}; auto consume_ptr = bc(std::make_unique<int>(3)); consume_ptr(3); } Outrageous compilation error message! clang: 97 lines gcc: 34 lines MSVC: 11 lines All function call operators are const, so it passes a const unique_ptr in the call.
119. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 119/176 perfect(er) forwarding https://godbolt.org/z/1qGaEvjM6 template <typename F> struct composable_function { F f; template <typename Self, typename ... Ts> constexpr auto operator()(this Self&& self, Ts&&...ts) -> decltype(std::forward_like<Self>(self.f) (std::forward<Ts>(ts)...)) { return std::forward_like<Self>(self.f) (std::forward<Ts>(ts)...); } };
120. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 120/176 perfect(er) forwarding https://godbolt.org/z/1qGaEvjM6 template <typename F> struct composable_function { F f; template <typename Self, typename ... Ts> constexpr auto operator()(this Self&& self, Ts&&...ts) -> decltype(std::forward_like<Self>(self.f) (std::forward<Ts>(ts)...)) { return std::forward_like<Self>(self.f) (std::forward<Ts>(ts)...); } }; C++20 “deducing this” or “explicit object parameter”
121. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 121/176 perfect(er) forwarding https://godbolt.org/z/1qGaEvjM6 template <typename F> struct composable_function { F f; template <typename Self, typename ... Ts> constexpr auto operator()(this Self&& self, Ts&&...ts) -> decltype(std::forward_like<Self>(self.f) (std::forward<Ts>(ts)...)) { return std::forward_like<Self>(self.f) (std::forward<Ts>(ts)...); } }; Forwards f as: F&& or F& or const F&& or const F&
122. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 122/176 perfect(er) forwarding https://godbolt.org/z/1qGaEvjM6 template <typename F> struct composable_function { F f; template <typename Self, typename ... Ts> constexpr auto operator()(this Self&& self, Ts&&...ts) -> decltype(std::forward_like<Self>(self.f) (std::forward<Ts>(ts)...)) { return std::forward_like<Self>(self.f) (std::forward<Ts>(ts)...); } }; Repeat for every operator() and every lambda
123. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 123/176 perfect(er) forwarding void consume(int, std::unique_ptr<int>); int main() { auto bc = back_binding{consume}; auto consume_ptr = bc(std::make_unique<int>(3)); consume_ptr(3); }
124. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 124/176 perfect(er) forwarding void consume(int, std::unique_ptr<int>); int main() { auto bc = back_binding{consume}; auto consume_ptr = bc(std::make_unique<int>(3)); consume_ptr(3); } Outrageous compilation error message! clang: 97 lines gcc: 34 lines MSVC: 14 lines
125. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 125/176 perfect(er) forwarding void consume(int, std::unique_ptr<int>); int main() { auto bc = back_binding{consume}; auto consume_ptr = bc(std::make_unique<int>(3)); consume_ptr(3); } Only gcc give’s a reasonable hint, pointing to consume_ptr(3);
126. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 126/176 perfect(er) forwarding void consume(int, std::unique_ptr<int>); int main() { auto bc = back_binding{consume}; auto consume_ptr = bc(std::make_unique<int>(3)); std::move(consume_ptr)(3); } https://godbolt.org/z/s9qYPbWsc
127. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 127/176 perfect(er) forwarding void consume(int, std::unique_ptr<int>); int main() { auto bc = back_binding{consume}; auto consume_ptr = bc(std::make_unique<int>(3)); std::move(consume_ptr)(3); } https://godbolt.org/z/s9qYPbWsc
128. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 128/176 perfect(er) forwarding void consume(int, std::unique_ptr<int>); int main() { auto bc = back_binding{consume}; auto consume_ptr = bc(std::make_unique<int>(3)); std::move(consume_ptr)(3); } OK I guess... https://godbolt.org/z/s9qYPbWsc
129. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 129/176 Ban std::ranges::dangling Functions that return ranges::borrowed_iterator_t or ranges::borrowed_subrange_t will instead return std::ranges::dangling if they are called with an r-value range.
130. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 130/176 Ban std::ranges::dangling Functions that return ranges::borrowed_iterator_t or ranges::borrowed_subrange_t will instead return std::ranges::dangling if they are called with an r-value range. When did you last look at the return value from sort()?
131. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 131/176 template <typename T> inline constexpr bool not_dangling = true; template <> inline constexpr bool not_dangling<std::ranges::dangling> = false; Ban std::ranges::dangling
132. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 132/176 template <typename T> inline constexpr bool not_dangling = true; template <> inline constexpr bool not_dangling<std::ranges::dangling> = false; template <template <typename...> class T, typename ... Ts> inline constexpr bool not_dangling<T<Ts...>> = (not_dangling<Ts> && ...); Ban std::ranges::dangling
133. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 133/176 template <typename T> inline constexpr bool not_dangling = true; template <> inline constexpr bool not_dangling<std::ranges::dangling> = false; template <template <typename...> class T, typename ... Ts> inline constexpr bool not_dangling<T<Ts...>> = (not_dangling<Ts> && ...); std::ranges::mismatch() returns mismatch_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>> Ban std::ranges::dangling
134. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 134/176 template <typename T> inline constexpr bool not_dangling = true; template <> inline constexpr bool not_dangling<std::ranges::dangling> = false; template <template <typename...> class T, typename ... Ts> inline constexpr bool not_dangling<T<Ts...>> = (not_dangling<Ts> && ...); Ban std::ranges::dangling We can now use a concept to constraing the calls
135. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 135/176 template <typename T> inline constexpr bool not_dangling = true; template <> inline constexpr bool not_dangling<std::ranges::dangling> = false; template <template <typename...> class T, typename ... Ts> inline constexpr bool not_dangling<T<Ts...>> = (not_dangling<Ts> && ...); Ban std::ranges::dangling template <typename T> concept not_dangling_type = not_dangling<T>; struct composable_function { template <typename Self, typename ... Ts> constexpr decltype(auto) operator()(this Self&& self, Ts&& ... ts) requires requires {{ std::forward_like<Self>(self.f)( std::forward<Ts>(ts)...) } -> not_dangling_type;} ...
136. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 136/176 template <typename T> inline constexpr bool not_dangling = true; template <> inline constexpr bool not_dangling<std::ranges::dangling> = false; template <template <typename...> class T, typename ... Ts> inline constexpr bool not_dangling<T<Ts...>> = (not_dangling<Ts> && ...); Ban std::ranges::dangling template <typename T> concept not_dangling_type = not_dangling<T>; struct composable_function { template <typename Self, typename ... Ts> constexpr decltype(auto) operator()(this Self&& self, Ts&& ... ts) requires requires {{ std::forward_like<Self>(self.f)( std::forward<Ts>(ts)...) } -> not_dangling_type;} ... Only allow the call if the wrapped function does not return ‘dangling’.
137. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 137/176 template <typename T> inline constexpr bool not_dangling = true; template <> inline constexpr bool not_dangling<std::ranges::dangling> = false; template <template <typename...> class T, typename ... Ts> inline constexpr bool not_dangling<T<Ts...>> = (not_dangling<Ts> && ...); Ban std::ranges::dangling https://godbolt.org/z/ab7bT1EhK template <typename T> concept not_dangling_type = not_dangling<T>; struct composable_function { template <typename Self, typename ... Ts> constexpr decltype(auto) operator()(this Self&& self, Ts&& ... ts) requires requires {{ std::forward_like<Self>(self.f)( std::forward<Ts>(ts)...) } -> not_dangling_type;} ... Only allow the call if the wrapped function does not return ‘dangling’.
138. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 138/176 template <typename T> inline constexpr bool not_dangling = true; template <> inline constexpr bool not_dangling<std::ranges::dangling> = false; template <template <typename...> class T, typename ... Ts> inline constexpr bool not_dangling<T<Ts...>> = (not_dangling<Ts> && ...); Ban std::ranges::dangling template <typename T> concept not_dangling_type = not_dangling<T>; struct composable_function { template <typename Self, typename ... Ts> constexpr decltype(auto) operator()(this Self&& self, Ts&& ... ts) requires requires {{ std::forward_like<Self>(self.f)( std::forward<Ts>(ts)...) } -> not_dangling_type;} ... Error info is decent, but not great
139. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 139/176 template <typename T> inline constexpr bool not_dangling = true; template <> inline constexpr bool not_dangling<std::ranges::dangling> = false; template <template <typename...> class T, typename ... Ts> inline constexpr bool not_dangling<T<Ts...>> = (not_dangling<Ts> && ...); Ban std::ranges::dangling template <typename T> concept not_dangling_type = not_dangling<T>; struct composable_function { template <typename Self, typename ... Ts> constexpr decltype(auto) operator()(this Self&& self, Ts&& ... ts) requires requires {{ std::forward_like<Self>(self.f)( std::forward<Ts>(ts)...) } -> not_dangling_type;} ... Error info is decent, but not great Functions can be =delete(“message”) We can use that
140. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 140/176 template <typename T> inline constexpr bool not_dangling = true; template <> inline constexpr bool not_dangling<std::ranges::dangling> = false; template <template <typename...> class T, typename ... Ts> inline constexpr bool not_dangling<T<Ts...>> = (not_dangling<Ts> && ...); Ban std::ranges::dangling template <typename T> requires not_dangling<std::remove_cvref_t<T>> auto not_dangling_type(T&&) -> T; void not_dangling_type(auto&&) = delete("return value would refer to dangling data"); template <typename Self, typename ... Ts> constexpr auto operator()(this Self&& self, Ts&& ... ts) -> decltype(not_dangling_type( std::forward_like<Self>(self.f) (std::forward<Ts>(ts)…))) {
141. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 141/176 template <typename T> inline constexpr bool not_dangling = true; template <> inline constexpr bool not_dangling<std::ranges::dangling> = false; template <template <typename...> class T, typename ... Ts> inline constexpr bool not_dangling<T<Ts...>> = (not_dangling<Ts> && ...); Ban std::ranges::dangling template <typename T> requires not_dangling<std::remove_cvref_t<T>> auto not_dangling_type(T&&) -> T; void not_dangling_type(auto&&) = delete("return value would refer to dangling data"); template <typename Self, typename ... Ts> constexpr auto operator()(this Self&& self, Ts&& ... ts) -> decltype(not_dangling_type( std::forward_like<Self>(self.f) (std::forward<Ts>(ts)…))) { Matches anything that doesn’t dangle, and gites the type back
142. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 142/176 template <typename T> inline constexpr bool not_dangling = true; template <> inline constexpr bool not_dangling<std::ranges::dangling> = false; template <template <typename...> class T, typename ... Ts> inline constexpr bool not_dangling<T<Ts...>> = (not_dangling<Ts> && ...); Ban std::ranges::dangling template <typename T> requires not_dangling<std::remove_cvref_t<T>> auto not_dangling_type(T&&) -> T; void not_dangling_type(auto&&) = delete("return value would refer to dangling data"); template <typename Self, typename ... Ts> constexpr auto operator()(this Self&& self, Ts&& ... ts) -> decltype(not_dangling_type( std::forward_like<Self>(self.f) (std::forward<Ts>(ts)…))) { Matches anything dangling things, with a message
143. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 143/176 template <typename T> inline constexpr bool not_dangling = true; template <> inline constexpr bool not_dangling<std::ranges::dangling> = false; template <template <typename...> class T, typename ... Ts> inline constexpr bool not_dangling<T<Ts...>> = (not_dangling<Ts> && ...); Ban std::ranges::dangling template <typename T> requires not_dangling<std::remove_cvref_t<T>> auto not_dangling_type(T&&) -> T; void not_dangling_type(auto&&) = delete("return value would refer to dangling data"); template <typename Self, typename ... Ts> constexpr auto operator()(this Self&& self, Ts&& ... ts) -> decltype(not_dangling_type( std::forward_like<Self>(self.f) (std::forward<Ts>(ts)…))) { Return type of the wrapped function, or fails to compile, with a message.
144. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 144/176 template <typename T> inline constexpr bool not_dangling = true; template <> inline constexpr bool not_dangling<std::ranges::dangling> = false; template <template <typename...> class T, typename ... Ts> inline constexpr bool not_dangling<T<Ts...>> = (not_dangling<Ts> && ...); Ban std::ranges::dangling template <typename T> requires not_dangling<std::remove_cvref_t<T>> auto not_dangling_type(T&&) -> T; void not_dangling_type(auto&&) = delete("return value would refer to dangling data"); template <typename Self, typename ... Ts> constexpr auto operator()(this Self&& self, Ts&& ... ts) -> decltype(not_dangling_type( std::forward_like<Self>(self.f) (std::forward<Ts>(ts)…))) { Return type of the wrapped function, or fails to compile, with a message. https://godbolt.org/z/r3dfzr6T1
145. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 145/176 Transitive [[nodiscard]] If you return a value from a [[nodiscard]] function, that is not discarding the value, even if caller ignores the result. Let’s add an optional transitive [[nodiscard]] to composable_function<F>
146. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 146/176 Transitive [[nodiscard]] template <typename F> struct nodiscard : F {};
147. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 147/176 Transitive [[nodiscard]] template <typename F> struct nodiscard : F {}; Let’s create a simple wrapper for functions that are to have the [[nodiscard]] attribute
148. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 148/176 Transitive [[nodiscard]] template <typename F> struct nodiscard : F {}; template <typename F> concept nodiscard_function = requires { []<typename T>(nodiscard<T>*){}( std::declval<std::remove_cvref_t<F>*>() ); };
149. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 149/176 Transitive [[nodiscard]] template <typename F> struct nodiscard : F {}; template <typename F> concept nodiscard_function = requires { []<typename T>(nodiscard<T>*){}( std::declval<std::remove_cvref_t<F>*>() ); }; And a concept for it, similar to the concept for composable_function<F>
150. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 150/176 Transitive [[nodiscard]] template <typename F> struct composable_function { F f; template <typename Self, typename ... Ts> constexpr auto operator()(this Self&& self, Ts&&...ts) -> decltype(std::forward_like<Self>(self.f) (std::forward<Ts>(ts)...)) ... template <typename Self, typename ... Ts> [[nodiscard]] constexpr auto operator()(this Self&& self, Ts&&...ts) -> decltype(std::forward_like<Self>(self.f) (std::forward<Ts>(ts)...)) requires nodiscard_function<F> ...
151. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 151/176 Transitive [[nodiscard]] template <typename F> struct composable_function { F f; template <typename Self, typename ... Ts> constexpr auto operator()(this Self&& self, Ts&&...ts) -> decltype(std::forward_like<Self>(self.f) (std::forward<Ts>(ts)...)) ... template <typename Self, typename ... Ts> [[nodiscard]] constexpr auto operator()(this Self&& self, Ts&&...ts) -> decltype(std::forward_like<Self>(self.f) (std::forward<Ts>(ts)...)) requires nodiscard_function<F> ... Keep the operator() that we had before
152. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 152/176 Transitive [[nodiscard]] template <typename F> struct composable_function { F f; template <typename Self, typename ... Ts> constexpr auto operator()(this Self&& self, Ts&&...ts) -> decltype(std::forward_like<Self>(self.f) (std::forward<Ts>(ts)...)) ... template <typename Self, typename ... Ts> [[nodiscard]] constexpr auto operator()(this Self&& self, Ts&&...ts) -> decltype(std::forward_like<Self>(self.f) (std::forward<Ts>(ts)...)) requires nodiscard_function<F> ... And create a new one that is identical
153. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 153/176 Transitive [[nodiscard]] template <typename F> struct composable_function { F f; template <typename Self, typename ... Ts> constexpr auto operator()(this Self&& self, Ts&&...ts) -> decltype(std::forward_like<Self>(self.f) (std::forward<Ts>(ts)...)) ... template <typename Self, typename ... Ts> [[nodiscard]] constexpr auto operator()(this Self&& self, Ts&&...ts) -> decltype(std::forward_like<Self>(self.f) (std::forward<Ts>(ts)...)) requires nodiscard_function<F> ... Except that it is has the [[nodiscard]] attribute
154. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 154/176 Transitive [[nodiscard]] template <typename F> struct composable_function { F f; template <typename Self, typename ... Ts> constexpr auto operator()(this Self&& self, Ts&&...ts) -> decltype(std::forward_like<Self>(self.f) (std::forward<Ts>(ts)...)) ... template <typename Self, typename ... Ts> [[nodiscard]] constexpr auto operator()(this Self&& self, Ts&&...ts) -> decltype(std::forward_like<Self>(self.f) (std::forward<Ts>(ts)...)) requires nodiscard_function<F> ... Except that it is has the [[nodiscard]] attribute If the function F is a nodiscard_function.
155. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 155/176 Transitive [[nodiscard]] template <typename F> struct composable_function { F f; template <typename Self, typename ... Ts> constexpr auto operator()(this Self&& self, Ts&&...ts) -> decltype(std::forward_like<Self>(self.f) (std::forward<Ts>(ts)...)) ... template <typename Self, typename ... Ts> [[nodiscard]] constexpr auto operator()(this Self&& self, Ts&&...ts) -> decltype(std::forward_like<Self>(self.f) (std::forward<Ts>(ts)...)) requires nodiscard_function<F> ... Functions that returns new functions, partial application, pipes and transform_args, needs to respect nodiscard.
156. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 156/176 Transitive [[nodiscard]] template <typename ... Ts> constexpr auto operator()(Ts&& ... ts) const requires (! requires{ this->f(std::forward<Ts>(ts)...);}){ auto bound = std::bind_back(this->f, std::forward<Ts>(ts)...); if constexpr (nodiscard_function<F>) { using RT=back_binding<nodiscard<decltype(bound)>>; return RT{std::move(bound)}; } else { using RT=back_binding<decltype(bound)>; return RT{std::move(bound)}; } }
157. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 157/176 Transitive [[nodiscard]] template <typename ... Ts> constexpr auto operator()(Ts&& ... ts) const requires (! requires{ this->f(std::forward<Ts>(ts)...);}){ auto bound = std::bind_back(this->f, std::forward<Ts>(ts)...); if constexpr (nodiscard_function<F>) { using RT=back_binding<nodiscard<decltype(bound)>>; return RT{std::move(bound)}; } else { using RT=back_binding<decltype(bound)>; return RT{std::move(bound)}; } } If the function F is a nodiscard_function.
158. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 158/176 Transitive [[nodiscard]] template <typename ... Ts> constexpr auto operator()(Ts&& ... ts) const requires (! requires{ this->f(std::forward<Ts>(ts)...);}){ auto bound = std::bind_back(this->f, std::forward<Ts>(ts)...); if constexpr (nodiscard_function<F>) { using RT=back_binding<nodiscard<decltype(bound)>>; return RT{std::move(bound)}; } else { using RT=back_binding<decltype(bound)>; return RT{std::move(bound)}; } } We return a nodiscard version of the partial binding
159. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 159/176 Transitive [[nodiscard]] template <typename ... Ts> constexpr auto operator()(Ts&& ... ts) const requires (! requires{ this->f(std::forward<Ts>(ts)...);}){ auto bound = std::bind_back(this->f, std::forward<Ts>(ts)...); if constexpr (nodiscard_function<F>) { using RT=back_binding<nodiscard<decltype(bound)>>; return RT{std::move(bound)}; } else { using RT=back_binding<decltype(bound)>; return RT{std::move(bound)}; } } Otherwise the same partial binding as before
160. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 160/176 Transitive [[nodiscard]] constexpr auto operator|(LH&& lh, RH&& rh) { auto pipe = ... using LHU = std::remove_cvref_t<LH>; if constexpr (nodiscard_function<decltype(rh.f)>) { using RT = rebind_template_t<LHU, decltype(nodiscard{pipe})>; return RT{std::move(pipe)}; } else { using RT = rebind_template_t<LHU, decltype(pipe)>; return RT{std::move(pipe)}; } }
161. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 161/176 Transitive [[nodiscard]] constexpr auto operator|(LH&& lh, RH&& rh) { auto pipe = ... using LHU = std::remove_cvref_t<LH>; if constexpr (nodiscard_function<decltype(rh.f)>) { using RT = rebind_template_t<LHU, decltype(nodiscard{pipe})>; return RT{std::move(pipe)}; } else { using RT = rebind_template_t<LHU, decltype(pipe)>; return RT{std::move(pipe)}; } } If the function on the right hand side of the pipe is a nodiscard_function
162. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 162/176 Transitive [[nodiscard]] constexpr auto operator|(LH&& lh, RH&& rh) { auto pipe = ... using LHU = std::remove_cvref_t<LH>; if constexpr (nodiscard_function<decltype(rh.f)>) { using RT = rebind_template_t<LHU, decltype(nodiscard{pipe})>; return RT{std::move(pipe)}; } else { using RT = rebind_template_t<LHU, decltype(pipe)>; return RT{std::move(pipe)}; } } Then the return type is the same kind as the LH, rebound with a nodiscard version of the pipe
163. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 163/176 Transitive [[nodiscard]] constexpr auto operator|(LH&& lh, RH&& rh) { auto pipe = ... using LHU = std::remove_cvref_t<LH>; if constexpr (nodiscard_function<decltype(rh.f)>) { using RT = rebind_template_t<LHU, decltype(nodiscard{pipe})>; return RT{std::move(pipe)}; } else { using RT = rebind_template_t<LHU, decltype(pipe)>; return RT{std::move(pipe)}; } } Otherwise rebind as before
164. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 164/176 Transitive [[nodiscard]] constexpr auto operator|(LH&& lh, RH&& rh) { auto pipe = ... using LHU = std::remove_cvref_t<LH>; if constexpr (nodiscard_function<decltype(rh.f)>) { using RT = rebind_template_t<LHU, decltype(nodiscard{pipe})>; return RT{std::move(pipe)}; } else { using RT = rebind_template_t<LHU, decltype(pipe)>; return RT{std::move(pipe)}; } } Otherwise rebind as before https://godbolt.org/z/hGsdxhqhb
165. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 165/176 Observations
166. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 166/176 Observations • Functional composition is powerful
167. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 167/176 Observations • Functional composition is powerful – It can be abused to the detriment of readability
168. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 168/176 Observations • Functional composition is powerful – It can be abused to the detriment of readability – It can be used to improve expressive power and readability
169. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 169/176 Observations • Functional composition is powerful – It can be abused to the detriment of readability – It can be used to improve expressive power and readability • Error messages are horrendous
170. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 170/176 Observations • Functional composition is powerful – It can be abused to the detriment of readability – It can be used to improve expressive power and readability • Error messages are horrendous • Compilers are awesome!
171. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 171/176 Observations • Functional composition is powerful – It can be abused to the detriment of readability – It can be used to improve expressive power and readability • Error messages are horrendous • Compilers are awesome! • The code size is surprisingly small
172. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 172/176 Observations • Functional composition is powerful – It can be abused to the detriment of readability – It can be used to improve expressive power and readability • Error messages are horrendous • Compilers are awesome! • The code size is surprisingly small • It is not always obvious that a function should be back_binding or front_binding
173. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 173/176 Observations • Functional composition is powerful – It can be abused to the detriment of readability – It can be used to improve expressive power and readability • Error messages are horrendous • Compilers are awesome! • The code size is surprisingly small • It is not always obvious that a function should be back_binding or front_binding – Named arguments could solve this
174. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 174/176 Observations • Functional composition is powerful – It can be abused to the detriment of readability – It can be used to improve expressive power and readability • Error messages are horrendous • Compilers are awesome! • The code size is surprisingly small • It is not always obvious that a function should be back_binding or front_binding – Named arguments could solve this • Reflection can (probably) help
175. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 175/176 bjorn@fahller.se @rollbear @rollbear@fosstodon.org Creating Composable Callables in Contemporary C++ @rollbear.bsky.social
176. Creating Composable Callables in Contemporary C++ ACCU on Sea 2026 © Björn Fahller @rollbear@fosstodon.org 176/176 bjorn@fahller.se @rollbear @rollbear@fosstodon.org Creating Composable Callables in Contemporary C++ @rollbear.bsky.social Furthermore - I think it is important that you understand your code