Use template to apply a function template - c++

Question

If the following example were C++ it would contain non-sensical gibberish so I'll define the example to be written in pseudocode (and hence correct). It strongly hints at what I want to do in C++.
#include <vector>
template<class T>
void increment(T& x)
{
++x;
}
template<template<class> class F>
struct Apply
{
template<class T>
void operator()(std::vector<T>& v)
{
for (auto& x : v)
F<T>(x);
}
};
template<template<class> class F, class T>
void apply(F<T> f, std::vector<T>& v)
{
for (auto& x : v)
f(x);
}
int main()
{
std::vector<int> v{1,2,3};
// apply increment function to v
// maybe this?
Apply<increment> a;
a(v);
// hmm... or this?
apply(increment, v);
}
I don't know how to turn this into C++ such that:
increment is a function and not a function object.
The parameter of increment is either deduced or supplied by Apply/apply.
Apply/apply does not know about the name increment.
I can satisfy two out of the three but I'm not sure how to satisfy all three at once. The problem I run into is the apparent need for using a function template as a template template parameter which my compiler doesn't like. Still, it certainly seems possible to get this to work even if that particular route is off limits.
How can it be done?
Edit: I hate to change the problem but I didn't do a great job of trying to formally state requirements. Just pretend you're the author of apply but you're not the author of increment. You're stuck with increment as is.

Answer 1

You seem to be mixing up the type of a function and the function itself.
Writing Apply<increment> in this case does not make sense since increment is the name of the function and not its type.
Furthermore you cannot use a templated function like this without specifying its templated types. But a workaround is to use a generic lambda instead.
Here is a working example
#include <vector>
#include <iostream>
using std::cout;
using std::vector;
template<class T>
void increment(T& x)
{
++x;
}
template<class T>
void print(const T& t) {
for(auto&& v : t)
cout << v << " ";
cout << std::endl;
}
template<typename T, typename F>
void apply(T& container, F function) {
for(auto& v : container) {
function(v);
}
}
int main()
{
vector<int> v{1,2,3};
print(v);
// To retrieve a function pointer you must specify the type
apply(v, &increment<int>);
print(v);
// If your using c++14 you can use a generic lambda
apply(v, [](auto& t) { increment(t); });
print(v);
}

Answer 2

Simple: Drop the whole lot.
template<class F, class T>
void apply(T& v, F f)
{
for (auto& x : v)
f(x);
}
int main()
{
std::vector<int> v{1,2,3};
apply(v, [](int& i) { ++i; });
auto a = [](std::vector<int>& v) {
apply(v, [](int& i) { ++i; });
};
a(v);
}
You're just reinventing lambdas but worse. Functional programming in C++ is best done with function objects because regular functions have shit semantics, and we have language features explicitly for the purpose of making function objects easily, so use them.
As a commenter pointed out, this is also basically just std::transform but overly specific, and std::transform can also take a lambda.
Don't bother trying to functional with passing functions- it can't be done, at least not with a competitive code quality and volume. Use function objects and especially lambdas. This is literally what they're for.