#include <cassert>
#include <string>
#include <type_traits>

template <typename T>
class Payload
{
public:

    Payload(T data)
        : argument { data }
    {
    }

    operator T() const { return argument; }

private:

    T argument;

};

template <typename T>
Payload<T> payload(T&& data)
{
    return { std::forward<T>(data) };
}

template <typename T, typename Callable>
Payload<std::invoke_result_t<Callable, T>> operator|(Payload<T> const& payload,
                                                     Callable   const& callable)
{
    return { callable(static_cast<T>(payload)) };
}

// alternatively using decltype:
//
// template <typename T, typename Callable>
// auto operator|(Payload<T> const& payload,
//                Callable   const& callable)
//     -> Payload<decltype(callable(static_cast<T>(payload)))>
// {
//     return { callable(static_cast<T>(payload)) };
// }

/** TESTCASES **/

int fun1(std::string const& str)
{
    return std::stoi(str);
}

char fun2(int x)
{
    return static_cast<char>(x);
}

struct NextCharacter
{
    char operator()(char c) const { return c + 1; }
};

int main()
{

    assert((payload(1) | [](int    x) -> double { return 1.5f + x; }
                       | [](double y) -> int    { return 2*y; }) == 5);

    assert((payload("67") | fun1 | fun2) == 'C');

    char c { 'a' };
    assert((payload(c) | NextCharacter{}) == 'b');
}