Lazy evaluation of apply function implemented with variate template in C++ - c++

Question

I'm trying to write my own apply function using variate template. Here is the code I have:
template<typename...>
struct types{
};
template<typename T, typename... Args>
struct Func{
template<typename F, typanem... Types>
T call(F f, std::tuple<Types...>& params, Args... args){
return _call(f, params, types<Types...>{}, args...);
}
template<typename F, typename Tuple, typename Head, typename... Tail, typename... Args>
T _call(F f, Tuple& t, types<Head, Tail...>, Args&&... args){
_call(f, t, types<Tail...>{}, std::forward<Args>(args)..., std::get<sizeof...(Arg)>(t).DrawSample()));
}
T _call(F f, Tuple& t, types<>, Args... vs){
return f(vs...)
}
};
I can compile and run the above code without any difficulty. Now I want to make the function call(...) being invoked lazily. In other words, I can first construct the function by passing in all parameters needed for the computation:
int getMax(float f1, float f2, float f3){
if(f1 >= f2 && f1 >= f3){
return 1;
}
if(f2 >= f1 && f2 >= f3){
return 2;
}
if(f3 >= f1 && f3 >= f2){
return 3;
}
}
Func<int> func;
//Gaussian(mu, sd) is an object which can generate random values based on Gaussian
//distribution described with mu(mean) and sd(standard deviation).
Gaussian *g1 = Gaussian(0.3, 0.2);
Gaussian *g2 = Gaussian(0.2, 0.3);
Gaussian *g3 = Gaussian(0.3, 0.3);
func.setCall(getMax, std::make_tuple(*g1, *g2, *g3);
cout<<func.DrawSample();
After constructing the function, I hope to get the result of the getMax() function lazily each time I make a query for func.DrawSample(). Under the hood, perhaps DrawSample() calls call(...). However, is there anyway for me to change the code above in order to create a setCall(...) whose purpose is to store everything needed for later function calls?
Please let me know if my question is still unclear. Thanks a lot for your help!

Answer 1

Try this:
template<class Func, class... Args>
int applyDrawSample(Func func, Args... args)
{
return func(args.DrawSample()...);
}
template<class Func, class... Args>
auto bind_helper(Func func, Args... args)
-> decltype(bind(applyDrawSample<Func, Args...>, func, args...))
{
return bind(applyDrawSample<Func, Args...>, func, args...);
}
Usage:
auto func = bind_helper(getMax, Gaussian(...), Gaussian(...), Gaussian(...));
func();
A trivial extra lambda can change the last call to look like func->DrawSample(), if you really want it, and is left as an exercise.
EDIT
If you need a type for func above, it can be std::function:
function<int()> func = bind_helper(...);
The function signature (in this case, a function with no arguments, returning an int) for std::function needs to be compatible with what you are assigning.

Answer 2

Use std::function<int()> and lambdas.
std::function<int()> func;
func = [=]()->int {
return getMax( Guassian(0.3,0.2), Guassian(0.2,0.3), Guassian(0.3,0.3) );
};
std::cout << func();
If you really, really need your interface, simply store a std::function<T()> within your class, and the setCall simply assigns to it.
But really, your object is some anonymous type that can be invoked to produce an int -- std::function solves the problem. You'll have to engage in type erasure anyhow, as the type of your class does not include the function signature, so you probably won't be any more efficient.

Answer 3

With the suggestion provided by DanielKO, I finally come up with a solution for my specific scenario.
Here is the final version of my compiled code.
template<class Func, class... Args>
int applyDrawSample(Func func, Args&&... args){
return func((*args).DrawSample()...);
}
template<class Func, class... Args>
auto bind_helper(Func func, Args&&... args) ->decltype(bind(applyDrawSample<Func, Args...>,
func, args...))
{
return bind(applyDrawSample<Func, Args...>, func, args...);
}
template<typename T>
struct UncertainFunc{
template<typename F, typename... Args>
void setFunc(F f, Args... args){
function = bind_helper(f, args...);
}
T DrawSample(){
return function();
}
std::function<T()> function;
};
UncertainFunc<int> ufunc;
ufunc.setFunc(getMax, &(Gaussian(0.3, 0.2), &Gaussian(0.2, 0.3), &Gaussian(0.2, 0.2));
ufunc.DrawSample();
Especially, it seems that I cannot put the bind_helper(...) function into my class definition for some reason (perhaps auto type?).