Invoke callable object passing arguments in "groups of N" using C++17 fold expressions

I think my perfect forwarding is incorrect.

I think so too. All three functions accept mFn as a forwarding reference, but never attempt to forward it. The top-level forNArgs() can certainly do so, but the forwarding needs to stop there because forNArgsExpansion() uses it repeatedly.

asTpl is also a forwarding reference, but we don't forward it. As this is just a tuple of references, I think we should move it:

    auto asTpl(std::forward_as_tuple(std::forward<Ts>(mXs)...));

    forNArgsExpansion<TArity>(mFn, std::move(asTpl), SeqCalls{});

I recommend using std::invoke() on mFn rather than calling its operator() directly - that's a general good practice for invokables.

I think it helps to test with a variety of types. Here's some that stretch the boundaries of what I believe we intend to support:

#include <ostream>

class moveonly_string
{
    std::string s;
public:
    moveonly_string(std::string s)
        : s{std::move(s)}
    {}

    moveonly_string(const moveonly_string&) = delete;
    moveonly_string(moveonly_string&&) = default;

    moveonly_string& operator=(const moveonly_string&) = delete;
    moveonly_string& operator=(moveonly_string&&) = default;

    friend std::ostream& operator<<(std::ostream& os, const moveonly_string& s)
    {
        return os << s.s;
    }
};

moveonly_string operator""_mo(const char *s, unsigned long len) {
    return {{s,len}};
}

class immovable_string
{
    std::string s;
public:
    immovable_string(std::string s)
        : s{std::move(s)}
    {}

    immovable_string(const immovable_string&) = delete;

    immovable_string& operator=(const immovable_string&) = delete;

    friend std::ostream& operator<<(std::ostream& os, const immovable_string& s)
    {
        return os << s.s;
    }
};

immovable_string operator""_im(const char *s, unsigned long len) {
    return {{s,len}};
}

    // Test with move-only strings
    // Prints "abc def ghi":
    forNArgs<3> ([](auto... xyz) {
        (std::cout << ... << xyz);
        std::cout << ' ';
    },
        "a"_mo, "b"_mo, "c"_mo,
        "d"_mo, "e"_mo, "f"_mo,
        "g"_mo, "h"_mo, "i"_mo
        );
    std::cout << '\n';

    // Immovable strings; non-const function
    // Prints "abc 1 def 2 ghi 3":
    forNArgs<3>([i = 0](auto const&... xyz) mutable {
        (std::cout << ... << xyz);
        std::cout << ' ' << ++i << ' ';
    },
        "a"_im, "b"_im, "c"_im,
        "d"_im, "e"_im, "f"_im,
        "g"_im, "h"_im, "i"_im
        );
    std::cout << '\n';

I had to make a few small tweaks to argument types and moving/forwarding for these to all succeed:

#include <functional>
#include <tuple>
#include <utility>

// "Third step": call `mFn` once getting the correct elements from the
// forwarded tuple.
template<std::size_t TIStart, typename TF, typename TTpl, std::size_t... TIs>
void forNArgsStep(TF&& mFn, TTpl& mTpl, const std::index_sequence<TIs...>)
{
    std::invoke(mFn, std::move(std::get<TIStart + TIs>(mTpl))...);
}

// "Second step": use a comma operator fold expression to call the
// '"third step" `numberOfArgs / TArity` times.
template<std::size_t TArity, typename TF, typename TTpl, std::size_t... TIs>
void forNArgsExpansion(TF&& mFn, TTpl mTpl, const std::index_sequence<TIs...>)
{
    using SeqGet = std::make_index_sequence<TArity>;
    (forNArgsStep<TIs * TArity>(mFn, mTpl, SeqGet{}), ...);
}

// "First step / interface".
template<std::size_t TArity, typename TF, typename... Ts>
void forNArgs(TF&& mFn, Ts&&... mXs)
{
    constexpr auto numberOfArgs(sizeof...(Ts));

    static_assert(numberOfArgs % TArity == 0,
        "Invalid number of arguments");

    auto asTpl(std::forward_as_tuple(std::forward<Ts>(mXs)...));

    // We need to "convert" the `Ts...` pack into a "list" of packs
    // of size `TArity`.

    using SeqCalls = std::make_index_sequence<numberOfArgs / TArity>;
    forNArgsExpansion<TArity>(std::forward<TF>(mFn), std::move(asTpl), SeqCalls{});
}