I don't see a great need for this in normal (clear, obvious) code;
I believe that most C++ users would expect an ordinary function (in the pattern of
std::for_each(), perhaps), rather than overloading the
| operator. In the future,
| become recognised as a composition operator, but that is not the case in 2021, and so it will be harder for readers to comprehend than the plain function. This is clearly a matter of opinion where reasonable folk may differ, of course, and will likely change as time passes.
I suppose it's arguably similar to
| std::views::transform() - except that it can only be a sink of values, because it returns
void instead of a tuple of the results. If
void, that may be appropriate, but when
f() is a value-returning function, we'll want access to those results (perhaps to pipe into another transform).
Why are we not perfect-forwarding the tuple elements? I'm not convinced that this will work with functions that accept (mutable) references and update the values.
No unit tests are presented. I would expect quite a large suite of tests for a template function such as this, and they should have been in the review request. I certainly wouldn't accept this code into a project unless the tests were in the same submission.