How to create from nested lambda expression Functor classes - c++

Question

I have started to learn about lambda expressions and nested lambda expressions:
auto Suma=[](int x)->function<int(int)>
{
return [x](int y)
{
return x+y;
};
};
auto Mult=[](function<int(int)>&f, int z)
{
return f(z)*2;
};
I would like to create 3 Functor classes (for better understanding how it works), it should be 3 classes Sum, Inner and Mult.
.h:
class Suma
{
public:
int operator()(int x);
};
class Inner
{
Suma function;
public:
Inner(int x);
int operator()(int k);
};
class Mult
{
public:
int operator()(Suma function,int z);
};
.cpp:
int Suma::operator()(int x)
{
return x;
}
Inner::Inner(int x)
{
function.operator()(x);
}
int Inner::operator()(int k)
{
return function.operator()+k;
}
int Mult::operator()(Suma function,int z)
{
return (function.operator())*(2);
}
The main issue I face is when trying to include the function from one related class to another. I dont fully understand the main idea of how it is connected through classes. Could please advice me how should it work.

Answer 1

Your classes do not reflect the structure of the lambdas.
The inner lambda returns a function with adds its paramter to the capture.
So your Inner class shall not depend on Suma, and be defined as follows:
// definition in .h
class Inner
{
int myx;
public:
Inner(int x); // this represents the capture of the lambda
int operator()(int k); // this is the function of adding k to the catpture
};
// implementation in .cpp
Inner::Inner(int x)
{
myx = x;
}
int Inner::operator()(int k)
{
return myx + k;
}
The Suma shall then return an Inner with an x set:
// definition in .h
class Suma
{
public:
Inner operator()(int x);
};
// implementation in .cpp
Inner Suma::operator()(int x)
{
return Inner(x);
};
With your lambdas, when you evaluate Suma(3), you'll obtain a function that takes an integer and adds 3 to it. If you evaluate Suma(3)(2) you therefore get 5.
With the classes emulating the lambdas, you would then do the same:
Suma f; // that is an object, like "auto suma"
cout << f(3)(2) <<endl; // f(3) is in fact an object Inner(3) wich is then exectued with argument 2.
Here you have an online demo.
You could even be closer to the structure of your lambdas by having Inner be a nested class of Suma.
Now looking at the Mult class, it appears that the first argument is not a Suma object, but the result of an invocation to Suma (i.e. return type of its operator()) . So it's an Inner. Hence, you can complete the code as follows:
// definition in .h
class Mult {
public:
int operator()(Inner& function, int z);
};
// implementation in .cpp
int Mult::operator()(Inner& function, int z)
{
return (function(z))*(2); // funtion(z) means function.operator()(z)
}
By the way, as you see above, you don't need to explicitely call operator(): just provide the arguments between parenthesis.