¿Cómo se puede currar en C++?

stl functional-programming (10)

1. ¿Qué es currying?

Currying simplemente significa una transformación de una función de varios argumentos a una función de un solo argumento. Esto se ilustra más fácilmente usando un ejemplo:

Tome una función f que acepte tres argumentos:

int f(int a,std::string b,float c) { // do something with a, b, and c return 0; }

Si queremos llamar a f , tenemos que proporcionar todos sus argumentos f(1,"some string",19.7f) .

Entonces, una versión al curry de f , llamémoslo curried_f=curry(f) solo espera un único argumento, que corresponde al primer argumento de f , es decir, el argumento a . Además, f(1,"some string",19.7f) también se puede escribir usando la versión curried_f(1)("some string")(19.7f) como curried_f(1)("some string")(19.7f) . El valor de retorno de curried_f(1) por el contrario es simplemente otra función, que maneja el siguiente argumento de f . Al final, terminamos con una función o curried_f invocable que cumple la siguiente igualdad:

curried_f(first_arg)(second_arg)...(last_arg) == f(first_arg,second_arg,...,last_arg).

2. ¿Cómo se puede lograr el currying en C ++?

Lo siguiente es un poco más complicado, pero funciona muy bien para mí (usando c ++ 11) ... También permite currying de grado arbitrario como así: auto curried=curry(f)(arg1)(arg2)(arg3) y luego auto result=curried(arg4)(arg5) . Aquí va:

#include <functional> namespace _dtl { template <typename FUNCTION> struct _curry; // specialization for functions with a single argument template <typename R,typename T> struct _curry<std::function<R(T)>> { using type = std::function<R(T)>; const type result; _curry(type fun) : result(fun) {} }; // recursive specialization for functions with more arguments template <typename R,typename T,typename...Ts> struct _curry<std::function<R(T,Ts...)>> { using remaining_type = typename _curry<std::function<R(Ts...)> >::type; using type = std::function<remaining_type(T)>; const type result; _curry(std::function<R(T,Ts...)> fun) : result ( [=](const T& t) { return _curry<std::function<R(Ts...)>>( [=](const Ts&...ts){ return fun(t, ts...); } ).result; } ) {} }; } template <typename R,typename...Ts> auto curry(const std::function<R(Ts...)> fun) -> typename _dtl::_curry<std::function<R(Ts...)>>::type { return _dtl::_curry<std::function<R(Ts...)>>(fun).result; } template <typename R,typename...Ts> auto curry(R(* const fun)(Ts...)) -> typename _dtl::_curry<std::function<R(Ts...)>>::type { return _dtl::_curry<std::function<R(Ts...)>>(fun).result; } #include <iostream> void f(std::string a,std::string b,std::string c) { std::cout << a << b << c; } int main() { curry(f)("Hello ")("functional ")("world!"); return 0; }

Ver salida

De acuerdo, como comentó Samer, debería agregar algunas explicaciones sobre cómo funciona esto. La implementación real se realiza en el _dtl::_curry , mientras que las funciones de la plantilla curry son solo envoltorios de conveniencia. La implementación es recursiva sobre los argumentos del argumento de plantilla std::function FUNCTION .

Para una función con un solo argumento, el resultado es idéntico a la función original.

_curry(std::function<R(T,Ts...)> fun) : result ( [=](const T& t) { return _curry<std::function<R(Ts...)>>( [=](const Ts&...ts){ return fun(t, ts...); } ).result; } ) {}

Aquí lo difícil: para una función con más argumentos, devolvemos un lambda cuyo argumento está ligado al primer argumento de la llamada a la fun . Finalmente, el currying restante para los argumentos N-1 restantes se delega a la implementación de _curry<Ts...> con un argumento de plantilla menos.

Actualización para c ++ 14/17:

Una nueva idea para abordar el problema del currying acaba de llegar a mí ... Con la introducción de if constexpr en c + + + 17 (y con la ayuda de void_t para determinar si una función está completamente al curry), las cosas parecen obtener mucho más fácil:

template< class, class = std::void_t<> > struct needs_unapply : std::true_type { }; template< class T > struct needs_unapply<T, std::void_t<decltype(std::declval<T>()())>> : std::false_type { }; template <typename F> auto curry(F&& f) { /// Check if f() is a valid function call. If not we need /// to curry at least one argument: if constexpr (needs_unapply<decltype(f)>::value) { return [=](auto&& x) { return curry( [=](auto&&...xs) -> decltype(f(x,xs...)) { return f(x,xs...); } ); }; } else { /// If ''f()'' is a valid call, just call it, we are done. return f(); } } int main() { auto f = [](auto a, auto b, auto c, auto d) { return a * b * c * d; }; return curry(f)(1)(2)(3)(4); }

Vea el código en acción here . Con un enfoque similar, here es cómo curry funciones con un número arbitrario de argumentos.

La misma idea parece funcionar también en C ++ 14, si cambiamos el constexpr if con una selección de plantilla dependiendo de la prueba needs_unapply<decltype(f)>::value :

template <typename F> auto curry(F&& f); template <bool> struct curry_on; template <> struct curry_on<false> { template <typename F> static auto apply(F&& f) { return f(); } }; template <> struct curry_on<true> { template <typename F> static auto apply(F&& f) { return [=](auto&& x) { return curry( [=](auto&&...xs) -> decltype(f(x,xs...)) { return f(x,xs...); } ); }; } }; template <typename F> auto curry(F&& f) { return curry_on<needs_unapply<decltype(f)>::value>::template apply(f); }