Need tap and tap_error

[jessmorecroft]

Hello folks, loving this awesome piece of work but definitely not for the C++ light hearted! In particular adding new adaptors I'm finding a big challenge. Mostly the nuances around types and forwarding, expectations around lifetimes etc. I try very hard to stick to what's here but am really needing a couple of adaptors - tap and tap_error, for commiting and rolling back a db transaction task respectively - that I've had a partially successful crack at implementing, but as of right now buried in a type error that neither me nor the robot (Claude) can fathom. :) Is anyone able to point me to implementations of these adaptors? Are they able to be easily written as compositions of others, for example let_error etc.?

[jessmorecroft]

Folks as an FYI, here's my attempt at tap... tap_error proving to be a little harder.

#include <stdexec/execution.hpp>

namespace async
{

struct tap_t
{
    template <stdexec::sender_of<stdexec::set_value_t()> Sender1,
              stdexec::sender Sender2>
    auto operator()(Sender1&& s1, Sender2&& s2)
    {
        return s1 |
               stdexec::let_value(
                   [s2 = std::move(s2)]()
                   { return std::move(s2) | stdexec::then([](auto&&...) {}); });
    };

    template <stdexec::sender Sender1, stdexec::sender Sender2>
        requires(!stdexec::sender_of<Sender1, stdexec::set_value_t()>)
    auto operator()(Sender1&& s1, Sender2&& s2)
    {
        return s1 | stdexec::let_value(
                        [s2 = std::move(s2)](auto&& value)
                        {
                            return std::move(s2) |
                                   stdexec::then(
                                       [value = std::forward<decltype(value)>(
                                            value)](auto&&...) mutable
                                       { return std::move(value); });
                        });
    };

    // Curried version for pipe operator
    template <stdexec::sender Final> auto operator()(Final&& final) const
    {
        return stdexec::__binder_back<tap_t, std::decay_t<Final>>{
            {std::forward<Final>(final)}, {}, {}};
    }
};

constexpr inline tap_t tap{};

} // namespace async

[jessmorecroft]

And after rummaging around the type helpers a version of tap_error that seems to work, with simplifying assumptions made....

#include <stdexec/execution.hpp>

namespace async
{

struct tap_error_t
{
    template <stdexec::sender_of<stdexec::set_value_t(),
                                 stdexec::set_error_t(std::exception_ptr)>
                  Sender1,
              stdexec::sender Sender2>
    auto operator()(Sender1&& s1, Sender2&& s2) const
    {
        return s1 |
               stdexec::let_error(
                   [s2 = std::move(s2)](std::exception_ptr error)
                   {
                       return std::move(s2) |
                              stdexec::then([error](auto&&...)
                                            { std::rethrow_exception(error); });
                   });
    };

    template <
        stdexec::sender_of<stdexec::set_error_t(std::exception_ptr)> Sender1,
        stdexec::sender Sender2>
        requires(!stdexec::sender_of<Sender1, stdexec::set_value_t()>)
    auto operator()(Sender1&& s1, Sender2&& s2) const
    {
        using ValueType = std::tuple_element_t<
            0,
            std::variant_alternative_t<0, stdexec::value_types_of_t<Sender1>>>;

        return s1 | stdexec::let_error(
                        [s2 = std::move(s2)](std::exception_ptr error)
                        {
                            return std::move(s2) |
                                   stdexec::then(
                                       [error](auto&&...) -> ValueType
                                       {
                                           std::rethrow_exception(error);
                                           return ValueType{}; // never reached
                                       });
                        });
    };

    // Curried version for pipe operator
    template <stdexec::sender Final> auto operator()(Final&& final) const
    {
        return stdexec::__binder_back<tap_error_t, std::decay_t<Final>>{
            {std::forward<Final>(final)}, {}, {}};
    }
};

constexpr inline tap_error_t tap_error{};

} // namespace async

[jessmorecroft]

FYI, final impls, after greater study / insight: ;)

auto tap(auto&& f)
{
    return let_value(
        [f = std::forward<decltype(f)>(f)](auto&&... result) mutable
        { return sequence(f(result...), just(result...)); });
}

auto tap_error(auto&& f)
{
    return let_error([f = std::forward<decltype(f)>(f)](auto error) mutable
                     { return sequence(f(error), just_error(error)); });
}