The first-class function is just a normal class. We can treat the first-class function like any other data type. However, in the language that supports the first-class function, we can do the following tasks without invoking the compiler recursively:

• Passing a function as another function's parameter
• Assigning functions to variables
• Storing functions in collections
• Creating new functions from the existing functions at runtime

Fortunately, C++ can be used to solve the preceding tasks. We will discuss it in depth in the following topics.

Let's start to pass a function as the function parameter. We will choose...

We discussed that in the first-class function, the C++ language treats the functions as the value, which means we can pass them to the other functions, assign to variables, and so on. However, we have another term in functional programming, that is, a higher-order function, which are functions that work on other functions. It means the higher-order function can pass functions as the argument and can also return a function.

The higher-order function concept can be applied to the function in general, like in a mathematical function, instead of the first-class function concept that can only be applied in the functional programming language. Now, let's examine the three most useful higher-order functions in functional programming--map, filter, and fold.

A pure function is a function that will always return the same result every time it is given the same input. The result doesn't depend on any information or state and won't produce a side effect, or a change of the system state outside of the function. Let's take a look at the following piece of code:

    /* pure_function_1.cpp */
    #include <iostream>

    using namespace std;

    float circleArea(float r)
    {
      return 3.14 * r * r;
    }

    auto main() -> int
    {
      cout << "[pure_function_1.cpp]" << endl;

      // Initializing a float variable
      float f = 2.5f;

      // Invoking the circleArea() function
      // passing the f variable five times
      for(int i = 1; i <= 5; ++i)
      {
        cout << "Invocation " << i << " -> ";
        cout...

Currying is a technique to split a function that takes multiple arguments into evaluating a sequence of functions, each with a single argument. In other words, we create other functions based on a current function by reducing the current function. Let's suppose we have a function named areaOfRectangle(), which takes two parameters, length and width. The code will be like this:

    /* curry_1.cpp */

    #include <functional>
    #include <iostream>

    using namespace std;

    // Variadic template for currying
    template<typename Func, typename... Args>
    auto curry(Func func, Args... args)
    {
      return [=](auto... lastParam)
      {
        return func(args..., lastParam...);
      };
    }

    int areaOfRectangle(int length, int width)
    {
      return length * width;
    }

    auto main() -> int
    {
 ...

We have discussed that there are some techniques to manipulate a function. We will gain many advantages from it. Since we can implement the first-class function in the C++ language, we can pass a function as another function's parameter. We can treat a function as a data object so we can assign it to a variable and store it in the container. Also, we can compose a new function from the existing one. Moreover, by using map, filter, and fold, we can implement the higher-order function in every function we create.

Another technique we have to implement in gaining a better functional code is a pure function to avoid a side effect. We can refactor all the functions we have so it won't talk to outside variables or states and won't change and retrieve the value from the outside state. Also, to reduce the multiple arguments function so we can evaluate its sequence...