Как мне сделать функцию карри?

Вот моя попытка использовать нетерпеливую семантику, то есть возврат, как только набрано достаточное количество аргументов для правильного вызова исходной функции (Демо в Колиру):

namespace detail {
template <unsigned I>
struct priority_tag : priority_tag<I-1> {};
template <> struct priority_tag<0> {};

// High priority overload.
// If f is callable with zero args, return f()
template <typename F>
auto curry(F&& f, priority_tag<1>) -> decltype(std::forward<F>(f)()) {
return std::forward<F>(f)();
}

// Low priority overload.
// Return a partial application
template <typename F>
auto curry(F f, priority_tag<0>) {
return [f](auto&& t) {
return curry([f,t=std::forward<decltype(t)>(t)](auto&&...args) ->
decltype(f(t, std::forward<decltype(args)>(args)...)) {
return f(t, std::forward<decltype(args)>(args)...);
}, priority_tag<1>{});
};
}
} // namespace detail

// Dispatch to the implementation overload set in namespace detail.
template <typename F>
auto curry(F&& f) {
return detail::curry(std::forward<F>(f), detail::priority_tag<1>{});
}

и альтернативная реализация без энергичной семантики, которая требует дополнительной () вызвать частичное приложение, позволяющее получить доступ, например, к и то и другое f(int) а также f(int, int) из того же набора перегрузки:

template <typename F>
class partial_application {
F f_;
public:
template <typename T>
explicit partial_application(T&& f) :
f_(std::forward<T>(f)) {}

auto operator()() { return f_(); }

template <typename T>
auto operator()(T&&);
};

template <typename F>
auto curry_explicit(F&& f) {
return partial_application<F>{std::forward<F>(f)};
}

template <typename F>
template <typename T>
auto partial_application<F>::operator()(T&& t) {
return curry_explicit([f=f_,t=std::forward<T>(t)](auto&&...args) ->
decltype(f_(t, std::forward<decltype(args)>(args)...)) {
return f(t, std::forward<decltype(args)>(args)...);
});
}

Это не тривиальная проблема. Получить право собственности на семантику сложно. Для сравнения давайте рассмотрим несколько лямбд и как они выражают право собственности:

[=]() {}         // capture by value, can't modify values of captures
[=]() mutable {} // capture by value, can modify values of captures

[&]() {}     // capture by reference, can modify values of captures

[a, &b, c = std::move(foo)]() {} // mixture of value and reference, move-only if foo is
// can't modify value of a or c, but can b

Моя реализация по умолчанию захватывает по значению, захватывает по ссылке при передаче std::reference_wrapper<> (такое же поведение как std::make_tuple() с std::ref()) и пересылает вызывающие аргументы как есть (lvalues ​​остаются lvalues, rvalues ​​остаются rvalues). Я не мог выбрать удовлетворительное решение для mutableТаким образом, все значения захвата фактически const,

Захват типа только для перемещения делает функтор только для перемещения. Это в свою очередь означает, что если c это curry_t а также d тип только для перемещения, и c(std::move(d)) не вызывает захваченный функтор, затем связывание c(std::move(d)) значение lvalue означает, что последующие вызовы либо должны содержать достаточно аргументов для вызова захваченного функтора, либо значение lvalue должно быть преобразовано в значение rvalue (возможно, через std::move()). Это позаботилось о ссылочных квалификаторах. Имейте в виду, что *this всегда lvalue, поэтому ref-квалификаторы должны были применяться к operator(),

Нет никакого способа узнать, сколько аргументов требуется захваченному функтору, поскольку может быть любое количество перегрузок, поэтому будьте осторожны. нет static_assertс этим sizeof...(Captures) < max(N_ARGS),

В целом реализация занимает около 70 строк кода. Как обсуждалось в комментариях, я следовал соглашению curry(foo)(a, b, c, d) а также foo(a, b, c, d) быть (примерно) эквивалентным, предоставляя доступ к каждой перегрузке.

#include <cstddef>
#include <functional>
#include <type_traits>
#include <tuple>
#include <utility>

template<typename Functor>
auto curry(Functor&& f);

namespace curry_impl
{
/* helper: typing using type = T; is tedious */
template<typename T> struct identity { using type = T; };

/* helper: SFINAE magic :) */
template<typename...> struct void_t_impl : identity<void> {};
template<typename... Ts> using void_t = typename void_t_impl<Ts...>::type;

/* helper: true iff F(Args...) is invokable */
template<typename Signature, typename = void> struct is_invokable                                                                    : std::false_type {};
template<typename F, typename... Args> struct is_invokable<F(Args...), void_t<decltype(std::declval<F>()(std::declval<Args>()...))>> : std::true_type  {};

/* helper: unwraps references wrapped by std::ref() */
template<typename T> struct unwrap_reference                            : identity<T>  {};
template<typename T> struct unwrap_reference<std::reference_wrapper<T>> : identity<T&> {};
template<typename T> using unwrap_reference_t = typename unwrap_reference<T>::type;

/* helper: same transformation as applied by std::make_tuple() *
*         decays to value type unless wrapped with std::ref() *
*    use: modeling value & reference captures                 *
*         e.g. c(a) vs c(std::ref(a))                         */
template<typename T> struct decay_reference : unwrap_reference<std::decay_t<T>> {};
template<typename T> using decay_reference_t = typename decay_reference<T>::type;

/* helper: true iff all template arguments are true */
template<bool...> struct all : std::true_type {};
template<bool... Booleans> struct all<false, Booleans...> : std::false_type {};
template<bool... Booleans> struct all<true, Booleans...> : all<Booleans...> {};

/* helper: std::move(u) iff T is not an lvalue                       *
*    use: save on copies when curry_t is an rvalue                  *
*         e.g. c(a)(b)(c) should only copy functor, a, b, etc. once */
template<bool = false> struct move_if_value_impl       { template<typename U> auto&& operator()(U&& u) { return std::move(u); } };
template<>             struct move_if_value_impl<true> { template<typename U> auto&  operator()(U&  u) { return u; } };
template<typename T, typename U> auto&& move_if_value(U&& u) { return move_if_value_impl<std::is_lvalue_reference<T>{}>{}(std::forward<U>(u)); }

/* the curry wrapper/functor */
template<typename Functor, typename... Captures>
struct curry_t {
/* unfortunately, ref qualifiers don't change *this (always lvalue),   *
* so qualifiers have to be on operator(),                             *
* even though only invoke_impl(std::false_type, ...) needs qualifiers */
#define OPERATOR_PARENTHESES(X, Y) \
template<typename... Args> \
auto operator()(Args&&... args) X { \
return invoke_impl_##Y(is_invokable<Functor(Captures..., Args...)>{}, std::index_sequence_for<Captures...>{}, std::forward<Args>(args)...); \
}

OPERATOR_PARENTHESES(&,  lv)
OPERATOR_PARENTHESES(&&, rv)
#undef OPERATOR_PARENTHESES

Functor functor;
std::tuple<Captures...> captures;

private:
/* tag dispatch for when Functor(Captures..., Args...) is an invokable expression *
* see above comment about duplicate code                             */
#define INVOKE_IMPL_TRUE(X) \
template<typename... Args, std::size_t... Is> \
auto invoke_impl_##X(std::true_type, std::index_sequence<Is...>, Args&&... args) { \
return functor(std::get<Is>(captures)..., std::forward<Args>(args)...); \
}

INVOKE_IMPL_TRUE(lv)
INVOKE_IMPL_TRUE(rv)
#undef INVOKE_IMPL_TRUE

/* tag dispatch for when Functor(Capture..., Args...) is NOT an invokable expression *
* lvalue ref qualifier version copies all captured values/references     */
template<typename... Args, std::size_t... Is>
auto invoke_impl_lv(std::false_type, std::index_sequence<Is...>, Args&&... args) {
static_assert(all<std::is_copy_constructible<Functor>{}, std::is_copy_constructible<Captures>{}...>{}, "all captures must be copyable or curry_t must an rvalue");
return curry_t<Functor, Captures..., decay_reference_t<Args>...>{
functor,
std::tuple<Captures..., decay_reference_t<Args>...>{
std::get<Is>(captures)...,
std::forward<Args>(args)...
}
};
}

/* tag dispatch for when F(As..., Args...) is NOT an invokable expression        *
* rvalue ref qualifier version moves all captured values, copies all references */
template<typename... Args, std::size_t... Is>
auto invoke_impl_rv(std::false_type, std::index_sequence<Is...>, Args&&... args) {
return curry_t<Functor, Captures..., decay_reference_t<Args>...>{
move_if_value<Functor>(functor),
std::tuple<Captures..., decay_reference_t<Args>...>{
move_if_value<Captures>(std::get<Is>(captures))...,
std::forward<Args>(args)...
}
};
}
};
}

/* helper function for creating curried functors */
template<typename Functor>
auto curry(Functor&& f) {
return curry_impl::curry_t<curry_impl::decay_reference_t<Functor>>{std::forward<Functor>(f), {}};
}

Живая демоверсия на Coliru демонстрация семантики ссылочного классификатора.

Вот код, с которым я играл, изучая различные шаблоны.
Это игрушечный пример для ATD для указателей на функции и ATD для std :: function.
Я привел пример с лямбдами, но пока не могу найти способ извлечения арументов, поэтому нет ATD для ламнды (пока)

#include <iostream>
#include <tuple>
#include <type_traits>
#include <functional>
#include <algorithm>//this is helper class for calling (variadic) func from std::tuple
template <typename F,typename ...Args>
struct TupleCallHelper
{
template<int ...> struct seq {};
template<int N, int ...S> struct gens : gens<N-1, N-1, S...> {};
template<int ...S> struct gens<0, S...>{ typedef seq<S...> type; };
template<int ...S>
static inline auto callFunc(seq<S...>,std::tuple<Args...>& params, F f) ->
decltype(f(std::get<S>(params) ...))
{
return f(std::get<S>(params) ... );
}

static inline auto delayed_dispatch(F& f, std::tuple<Args... >&  args) ->
decltype(callFunc(typename gens<sizeof...(Args)>::type(),args , f))
{
return callFunc(typename gens<sizeof...(Args)>::type(),args , f);
}
};template <int Depth,typename F,typename ... Args>
struct CurriedImpl;

//curried base class, when all args are consumed
template <typename F,typename ... Args>
struct CurriedImpl<0,F,Args...>
{
std::tuple<Args...> m_tuple;
F m_func;

CurriedImpl(const F& a_func):m_func(a_func)
{
}
auto operator()() ->
decltype(TupleCallHelper<F,Args...>::delayed_dispatch(m_func,m_tuple))
{
return TupleCallHelper<F,Args...>::delayed_dispatch(m_func,m_tuple);
}
};

template <typename F,typename ... Args>
struct CurriedImpl<-1,F,Args ... > ; //this is against weird gcc bug

//curried before all args are consumed (stores arg in tuple)
template <int Depth,typename F,typename ... Args>
struct CurriedImpl : public CurriedImpl<Depth-1,F,Args...>
{
using parent_t = CurriedImpl<Depth-1,F,Args...>;

CurriedImpl(const F& a_func): parent_t(a_func)
{
}
template <typename First>
auto operator()(const First& a_first) -> CurriedImpl<Depth-1,F,Args...>
{
std::get<sizeof...(Args)-Depth>(parent_t::m_tuple) = a_first;
return *this;
}

template <typename First, typename... Rem>
auto operator()(const First& a_first,Rem ... a_rem) ->
CurriedImpl<Depth-1-sizeof...(Rem),F,Args...>
{
CurriedImpl<Depth-1,F,Args...> r = this->operator()(a_first);
return r(a_rem...);
}
};template <typename F, typename ... Args>
struct Curried: public CurriedImpl<sizeof...(Args),F,Args...>
{
Curried(F a_f):
CurriedImpl<sizeof...(Args),F,Args...>(a_f)
{
}
};template<typename A>
int varcout( A a_a)
{
std::cout << a_a << "\n" ;
return 0;
}

template<typename A,typename ... Var>
int varcout( A a_a, Var ... a_var)
{
std::cout << a_a << "\n" ;
return varcout(a_var ...);
}

template <typename F, typename ... Args>
auto curried(F(*a_f)(Args...)) -> Curried<F(*)(Args...),Args...>
{
return Curried<F(*)(Args...),Args...>(a_f);
}

template <typename R, typename ... Args>
auto curried(std::function<R(Args ... )> a_f) -> Curried<std::function<R(Args ... )>,Args...>
{
return Curried<std::function<R(Args ... )>,Args...>(a_f);
}

int main()
{

//function pointers
auto f = varcout<int,float>;
auto curried_funcp = curried(f);
curried_funcp(1)(10)();

//atd for std::function
std::function<int(int,float)> fun(f);
auto curried_func = curried(fun);
curried_func(2)(5)();
curried_func(2,5)();//works too

//example with std::lambda using  Curried
auto  lamb = [](int a , int b , std::string& s){
std::cout << a + b << s ;
};

Curried<decltype(lamb),int,int,std::string> co(lamb);

auto var1 = co(2);
auto var2 = var1(1," is sum\n");
var2(); //prints -> "3 is sum"}