Problem

我有一个函数double subs(std::function<double(double)> func)，我想将它包装在一个如下所示的新函数中

template<typename... Args> double subsWrap(std::function<double(Args... args)> func)

适用subs某些需要更多输入的函数

subs( subs( subs( ... func(...) ) ) )

与每个subs仅适用于其中一个参数func一次。

最小的例子

假设我们有一个函数

auto subs = [] (std::function<double(double)> func){return func(2) + func(5.3);};

我们想把它应用到

auto f2=[](double x, double y){return std::sin(x*std::exp(x/y)); };

as

subs( [&f2](double y){ return  subs( [&y,&f2](double x){ return f2(x,y); } ); } ) 

For f2，这很简单，因此不需要包装器。但是，如果我们想对具有更多参数的函数执行相同的操作（例如double(double,double,double,double,double)）事情开始变得复杂。

必须有一种方法可以自动执行此操作，但我什至不知道如何开始。

与可变参数 lambda 一起使用怎么样？std::is_invocable输入特征来终止递归？

template<class Fn>
double subs_wrap(Fn func) {
    if constexpr (std::is_invocable_v<Fn, double>)
        return subs(func);
    else
        return subs([=](double x) {
            return subs_wrap(
                [=](auto... xs) -> decltype(func(x, xs...))
                { return func(x, xs...); }
            );
        });
}

这里需要 lambda 的显式返回类型规范来传播“可调用性”属性。[=](auto... xs) { return func(x, xs...); }可以用任意数量的参数正式调用，无论是否func(x, xs...)是否可调用。当使用显式指定返回类型时decltype，SFINAE 介入。

通过这个实现，两个表达式

subs([=](double y) { 
    return subs([=](double x) {
        return f2(x, y);
    });
});

and

subs_wrap(f2);

会产生相同的结果。

有趣的是，与-O3GCC 和 Clang 都可以优化优化所有这些代码 https://godbolt.org/z/z5TqrsnvM并替换subs_wrap(f2)带有编译时常量。使用类似的代码编写std::function他们不这样做的论点。

如果我们想将参数传递给 subs，我们如何进行解包（每个递归都不同）

这是通过稍微修改代码来实现此目的的方法：

template<class Fn, class P, class... Ps>
double subs_wrap(Fn func, P p, Ps... ps) {
    if constexpr (std::is_invocable_v<Fn, double>) {
        static_assert(sizeof...(Ps) == 0);
        return subs(func, p);
    }
    else {
        static_assert(sizeof...(Ps) > 0);
        return subs([=](double x) {
            return subs_wrap(
                [=](auto... xs) -> decltype(func(x, xs...))
                { return func(x, xs...); },
                ps...);
        }, p);
    }
}

subs_wrap(f2, p1, p2);