具有可变参数模板的功能组合

我的目标是获得使用以下确切语法的函数组合：

int main() {
    Function<std::string, int> f([](const std::string& s) {return s.length();});
    Function<int, double> g([](int x) {return x + 0.5;});
    Function<double, int> h([](double d) {return int(d+1);});
    std::cout << compose(g, f, "hello") << 'n';  // g(f("hello")) = 5.5
    std::cout << compose(h, g, f, "hello") << 'n';  // h(g(f("hello"))) = 6
}

通过稍微更改语法以使"hello"参数首先出现，我可以轻松地使用以下代码：

#include <iostream>
#include <functional>
#include <tuple>
#include <string>
template <typename D, typename R>
struct Function {
    using domain = const D&;
    using range = R;
    using function = std::function<range(domain)>;
    const function& f;
    Function (const function& f) : f(f) {}
    range operator()(domain x) const {return f(x);}
};
template <typename... Ts>
struct LastType {
    using Tuple = std::tuple<Ts...>;
    using type = typename std::tuple_element<std::tuple_size<Tuple>::value - 1, Tuple>::type;
};
template <typename F, typename G>
typename G::range compose (const typename F::domain& x, const G& g, const F& f) {
    return g(f(x));
}
template <typename F, typename... Rest>
auto compose (const typename LastType<Rest...>::type::domain& x, const F& f, const Rest&... rest) {
    return f(compose(x, rest...));
}
int main() {
    Function<std::string, int> f([](const std::string& s) {return s.length();});
    Function<int, double> g([](int x) {return x + 0.5;});
    Function<double, int> h([](double d) {return int(d+1);});
    std::cout << compose("hello", g, f) << 'n';  // g(f("hello")) = 5.5
    std::cout << compose("hello", h, g, f) << 'n';  // h(g(f("hello"))) = 6
}

这样做之后，我认为调整上面的代码以便获得我想要的确切语法（即"hello"位于列表末尾）是一项微不足道的任务，但它变得比我想象的要困难得多。 我尝试了以下操作，但无法编译：

#include <iostream>
#include <functional>
#include <tuple>
#include <string>
template <typename D, typename R>
struct Function {
    using domain = const D&;
    using range = R;
    using function = std::function<range(domain)>;
    const function& f;
    Function (const function& f) : f(f) {}
    range operator()(domain x) const {return f(x);}
};
template <typename F, typename G>
typename G::range compose (const G& g, const F& f, const typename F::domain& x) {
    return g(f(x));
}
template <typename F, typename... Rest>
auto compose (const F& f, const Rest&... rest) {
    return f(compose(rest...));
}
int main() {
    Function<std::string, int> f([](const std::string& s) {return s.length();});
    Function<int, double> g([](int x) {return x + 0.5;});
    Function<double, int> h([](double d) {return int(d+1);});
    std::cout << compose(g, f, "hello") << 'n';  // g(f("hello")) = 5.5
    std::cout << compose(h, g, f, "hello") << 'n';  // h(g(f("hello"))) = 6
}

而且我不知道如何解决它。有人可以帮我解决这个问题吗？

我想出的一个新想法是定义compose_，这将重新排序args...的参数（通过一些std::tuple操作），以便第一个元素排在最后，然后将该参数包传递给compose。 不过，这看起来非常混乱，即使它有效，也必须有一个更直接（和更短）的解决方案。