Programmation fonctionnelle en C++. Mise en œuvre de f(a)(b)(c)

Question

Je me suis lancé dans les bases de la programmation fonctionnelle avec C++. J'essaie de créer une fonction f(a)(b)(c) qui renverra a + b + c . J'ai implémenté avec succès la fonction f(a)(b) qui renvoie a + b. Voici le code correspondant :

std::function<double(double)> plus2(double a){
    return[a](double b){return a + b; };
}

Je n'arrive pas à comprendre comment implémenter la fonction f(a)(b)(c) qui, comme je l'ai dit précédemment, devrait retourner a + b + c .

Answer 1

Vous pouvez le faire en ayant votre fonction f retourner un foncteur c'est-à-dire un objet qui implémente operator() . Voici une façon de le faire :

struct sum 
{
    double val;

    sum(double a) : val(a) {}

    sum operator()(double a) { return val + a; }

    operator double() const { return val; }
};

sum f(double a)
{
    return a;
}

Exemple

Lien

int main()
{
    std::cout << f(1)(2)(3)(4) << std::endl;
}

---

Version du modèle

Vous pouvez même écrire une version modélisée qui laissera le compilateur déduire le type. Essayez-le aquí .

template <class T>
struct sum 
{
    T val;

    sum(T a) : val(a) {}

    template <class T2>
    auto operator()(T2 a) -> sum<decltype(val + a)> { return val + a; }

    operator T() const { return val; }
};

template <class T>
sum<T> f(T a)
{
    return a;
}

Exemple

Dans cet exemple, T se résoudra finalement à double :

std::cout << f(1)(2.5)(3.1f)(4) << std::endl;

Answer 2

Il suffit de prendre votre solution à deux éléments et de l'étendre, en l'entourant d'un autre lambda.

Puisque vous voulez retourner un lambda qui obtient un double et renvoie un double Tout ce que vous avez à faire est d'envelopper votre type de retour actuel avec une autre fonction, et d'ajouter un lambda imbriqué dans votre lambda actuel (un lambda qui renvoie un lambda) :

std::function<std::function<double(double)>(double)> plus3 (double a){
    return [a] (double b) {
        return [a, b] (double c) {
            return a + b + c;
        };
    };
}

---

• Comme @Ðn noté, vous pouvez sauter l'étape std::function<std::function<double(double)>(double)> et s'entendre avec auto :

  auto plus3 (double a){
      return [a] (double b) {
          return [a, b] (double c) { return a + b + c; };
      };
  }

• Vous pouvez étendre cette structure pour chaque nombre d'éléments, en utilisant des lambdas imbriquées plus profondes. Démonstration pour 4 éléments :

  auto plus4 (double a){
      return [a] (double b) {
          return [a, b] (double c) {
              return [a, b, c] (double d) {
                  return a + b + c + d;
              };
          };
      };
  }

Answer 3

Voici une approche légèrement différente, qui renvoie une référence à *this de operator() de sorte que vous n'avez pas de copies flottant autour. C'est une implémentation très simple d'un foncteur qui stocke l'état et se replie à gauche de manière récursive sur lui-même :

#include <iostream>

template<typename T>
class Sum
{
    T x_{};
public:
    Sum& operator()(T x)
    {
        x_ += x;
        return *this;
    }
    operator T() const
    {
        return x_;
    }
};

int main()
{
    Sum<int> s;
    std::cout << s(1)(2)(3);
}

Live on Coliru

Answer 4

Ce n'est pas f(a)(b)(c) mais plutôt curry(f)(a)(b)(c) . Nous emballons f de telle sorte que chaque argument supplémentaire renvoie soit un autre curry ou invoque effectivement la fonction avec empressement. C'est C++17, mais peut être implémenté en C++11 avec un tas de travail supplémentaire.

Notez qu'il s'agit d'une solution pour faire un curry d'une fonction - ce qui est l'impression que j'ai eue de la question - et non d'une solution pour replier une fonction binaire.

template <class F>
auto curry(F f) {
    return [f](auto... args) -> decltype(auto) {
        if constexpr(std::is_invocable<F&, decltype(args)...>{}) {
            return std::invoke(f, args...);
        }
        else {
            return curry([=](auto... new_args)
                    -> decltype(std::invoke(f, args..., new_args...))
                {
                    return std::invoke(f, args..., new_args...);
                });
        }
    };  
}

J'ai sauté les références de transmission pour plus de concision. Un exemple d'utilisation serait :

int add(int a, int b, int c) { return a+b+c; }

curry(add)(1,2,2);       // 5
curry(add)(1)(2)(2);     // also 5
curry(add)(1, 2)(2);     // still the 5th
curry(add)()()(1,2,2);   // FIVE

auto f = curry(add)(1,2);
f(2);                    // i plead the 5th

Answer 5

Le moyen le plus simple auquel je pense pour faire cela est de définir plus3() en termes de plus2() .

std::function<double(double)> plus2(double a){
    return[a](double b){return a + b; };
}

auto plus3(double a) {
    return [a](double b){ return plus2(a + b); };
}

Cela combine les deux premières listes d'arguments en une seule liste d'arguments, qui est utilisée pour appeler plus2() . Cela nous permet de réutiliser notre code préexistant avec un minimum de répétitions, et peut facilement être étendu à l'avenir ; plusN() a juste besoin de retourner un lambda qui appelle plusN-1() qui passera l'appel à la fonction précédente à son tour, jusqu'à ce qu'elle atteigne plus2() . Il peut être utilisé comme suit :

int main() {
    std::cout << plus2(1)(2)    << ' '
              << plus3(1)(2)(3) << '\n';
}
// Output: 3 6

---

Étant donné que nous ne faisons qu'appeler en bas de la ligne, nous pouvons facilement transformer ceci en un modèle de fonction, ce qui élimine le besoin de créer des versions pour des arguments supplémentaires.

template<int N>
auto plus(double a);

template<int N>
auto plus(double a) {
    return [a](double b){ return plus<N - 1>(a + b); };
}

template<>
auto plus<1>(double a) {
    return a;
}

int main() {
    std::cout << plus<2>(1)(2)          << ' '
              << plus<3>(1)(2)(3)       << ' '
              << plus<4>(1)(2)(3)(4)    << ' '
              << plus<5>(1)(2)(3)(4)(5) << '\n';
}
// Output: 3 6 10 15

Voir les deux en action aquí .