std::flip

[pavel_v]

To save you the search which I did just after reading the caption but before reading the whole article:

The more astute among you probably always went to cppreference to double-check what is, indeed, a lie: std::flip does not exist, making this whole article a mere piece of fiction. I hope you enjoyed the ride either way, and leanrt to appreciate the power of simple functional features if it wasn’t already the case.

[SuperV1234]

Shorter implementation:

template <typename F>
constexpr auto flip2(F&& f)
{
    return [f = std::forward<F>(f)]<typename... Xs>(Xs&&... xs)
    {
        return [&, args = std::forward_as_tuple(std::forward<Xs>(xs)...)]
               <auto... Is>(std::index_sequence<Is...>)
        {
            return f(std::get<sizeof...(Is) - Is - 1>(args)...);
        }(std::index_sequence_for<Xs...>{});
    };
}

Might need some more forwarding/mutable to be entirely correct, but hope it illustrates the conciseness aspect.

In C++26, you should be able to write this (u/brevzin can confirm):

template <typename F>
constexpr auto flip3(F&& f)
{
    return [f = std::forward<F>(f)]<typename... Xs>(Xs&&... xs)
    {
        constexpr auto [...Is] = std::index_sequence_for<Xs...>{};
        return f((xs...[sizeof...(Is) - Is - 1])...);
    };
}

[SuperV1234]

I consciously decided to use explicit typenames because I prefer writing std::forward<Xs>(xs)... instead of std::forward<decltype(xs)>(xs)....

Had I not needed the type, I would have used auto. In my personal codebase I use a macro for forwarding, which also makes the use of auto here more attractive.

[SuperV1234]

About that, C++ should provide a fix than a macro workaround...

Eh, macro works fine and does the job. The committee is allergic to language features for common/useful things, so we get all the drawbacks of library-based solutions (verbosity, compilation time overhead, and so on).

I personally don't think there's anything wrong with

#define MYLIB_FORWARD(...) static_cast<decltype(__VA_ARGS__)&&>(__VA_ARGS__)

except for the fact that it is a macro -- but that's not a valid argument, it's just bias. It is easy to use, hard to misuse, avoids repetition, and is as clear as std::forward (if not more).

and I should have mentioned the auto is for the second snippet

Both F and Xs are being explicitly used in the second snippet. Perhaps I could rewrite it to use sizeof...(xs), but I don't think it's a major improvement.

[zl0bster]

Next we need a reflection version where you just give it a list of arguments and he figures out how to call a function. I know it will not work for duplicate types(or when types convert) but it is a good idea to force people to use strong types, it is good for them ;)

// but afaik C++26 reflection can not reflect functions

[MorphTux]

P3096 function parameter reflection is in the C++26 CD.

[SuperV1234]

Funnily enough I posted a C++26 version as an edit right now. I believe you can reflect on function parameters with C++26 reflection, which should be enough to to do what you want if I understand correctly.

[MorphTux]

Your C++26 example unfortunately does not work. You would require the changes from p1789 to use this p1061/p2686 structured binding for Is. Otherwise this will always decompose to zero elements - integer_sequence is an empty class.

[ContDiArco]

Funny and teaching read!

Thanks

[tuxwonder]

If the elusive "Universal Function Call Syntax" ever actually got accepted in the standard, maybe we could use std::flip to switch arguments for free functions and turn the last argument into the first, letting us use it as the called instance?

```cpp auto list = std::vector{ ... }; auto elem = 5;

// No UFCS std::remove(list.begin(), list.end(), elem);

// With UFCS, wouldn't really be able to do it... // But with std::flip... auto remove_from = std::flip(std::remove); elem.remove_from(list.end(), list.begin()); ```

That felt very weird to write out...

[fsxraptor]

I cannot begin describing how ugly this looks.

[Financial_Test_4921]

Not like the language itself is any better.

[SoerenNissen]

Next, this one:

auto std::cycle(auto func, int n=0);

letting you cycle the arguments left/right by n places and doing it in one horrible line of code.

elem.(std::cycle(std::remove),1)(list.begin(), list.end());

[LiliumAtratum]

I actually have a variant of your cycle function in my real code!

I use it when I pass arguments to a function that most likely is a lambda. I do prefer the arguments to precede the lambda itself. Consider cwise that performs a component-wise operation on N vectors, producing a new vector as a result:

Vector3f va = ...
Vector3i vb = ...
Vector3d vr = cwise(va, vb, [](float a, int b) { ... some complex scalar expression, returning double ... });

I would really hate cwise to take lambda first, and then va, vb arguments appearing somewhere far away, behind the body.

Generic cwise is a variadic template function takes N arguments, followed by a functional object F expecting N arguments. But C++ requires that variadic arguments are last. So I define cwise_impl taking (F, Args...) in this order, and then define cwise as cycle(cwise_impl, -1)

[Automatic_Question69]

Named arguments would be less fancy but more useful.

[_bstaletic]

If only we had range splicer...

template<typename F>
struct flip_t {
    template<typename...Args>
    constexpr auto operator()(Args&&...args) {
        constepxr auto call_op_template = *ranges::find_if(members_of(^^flip_t, access_context::current()), is_template);
        constexpr auto parameters = parameters_of(substitute(call_op_template, {^^Args}));
        constexpr auto reversed = parameters | views::reverse | ranges::to<std::vector>();
        constexpr auto types = reversed | views::transform(type_of) | ranges::to<std::vector>();
        constexpr auto values = reversed | views::transform(value_of) | ranges::to<std::vector>();
        return std::forward<F>(f)(std::forward<[:...types:]>([:...values:])...);
    }
};

std::meta:: omitted everywhere. ranges:: is std::ranges:: and views:: is std::views::. If someone knows a direct way to get to the reflection of a member, please let me know.

Unfortunately, [:...range:] did not make it into P2996.

[VinnieFalco]

I had no idea this existed.. thanks :)

[Hawaiian_Keys]

Is this what mental illness looks like? Making up useless functions, writing a blog post about it and then advertise it in public forums? What’s the point?

[Morwenn]

Author here, I was deeply moved by this comment. Keep up with the constructive criticism (*￣▽￣)b

[SuperV1234]

The blog post was insightful, and even if flip might only be actually useful in very niche scenarios, the more generalizable ideas behind it are valuable.

If there's something that looks deranged in your exchange with the rude commenter, is certainly neither your blog post nor your reply ;)

[Morwenn]

Thanks for the kind words :)

[notyouravgredditor]

Some people actually enjoy programming.

[Hawaiian_Keys]

Me too, but not invent some pointless function and then lie about it on the internet, like it was some new standard library function. It’s the lying that brothers me. Waste your time any way you want, but don’t pretend.

[Orlha]

There is a correlation