能否将类模板可变参数包分组后用于成员模板？

我想编写一个包含可变模板参数包的类模板，需要将参数包拆分为两组，分别用于两个成员模板的实例化。预期的类结构如下：

template <class... Args>
class Foo {
public:
    Foo(const Args&... args) :gr1{/*...*/}, gr2{/*...*/} {} 
private:
    template_one<Group1...> gr1;
    template_two<Group2...> gr2;
};

我已经实现了两个辅助工具：

1. 类型排序器（type_sorter） #

用于在无实例参数时对类型进行分组，返回包含已排序类型的tuple对：

template <typename... Args>
struct type_sorter;

template <>
struct type_sorter<> {
    constexpr static auto sort() {return std::pair<std::tuple<>, std::tuple<>>{}; }
};

template <typename Arg, typename... Args>
struct type_sorter<Arg, Args...> {
    constexpr static auto sort() {
        auto ret = type_sorter<Args...>::sort();

        if constexpr (std::is_function_v<Arg>)
            return std::make_pair(std::tuple_cat(ret.first, std::tuple<Arg*>{}), ret.second);
        else
            return std::make_pair(ret.first, std::tuple_cat(ret.second, std::tuple<Arg>{}));
    }
};

2. 参数排序器（param_sorter） #

用于同时处理类型和实例参数，返回包含已排序类型与对应参数的tuple对：

template <class Arg>
constexpr auto param_sort(Arg&& arg) {
    if constexpr (std::is_function_v<typename std::remove_reference_t<Arg>>)
        return std::make_pair(std::tuple<Arg>(arg), std::tuple<>());
    else
        return std::make_pair(std::tuple<>(), std::tuple<Arg>(arg));
}

template <class Arg, class... Args>
constexpr auto param_sort(Arg&& arg, Args&&... args) {
    auto ret = param_sort(std::forward<Args>(args)...);

    if constexpr (std::is_function_v<typename std::remove_reference_t<Arg>>)
        return std::make_pair(std::tuple_cat(ret.first, std::tuple<Arg>(arg)), ret.second);
    else
        return std::make_pair(ret.first, std::tuple_cat(ret.second, std::tuple<Arg>(arg)));
}

目前我以std::is_function作为分组判断依据，现在希望从type_sorter生成的tuple中提取出参数包Group1...和Group2...，用于声明template_one和template_two的成员变量，但尝试的代码无法通过编译。想询问这种操作是否可行？

内容的提问来源于stack exchange，提问作者drzecki