Function composition from std::vector<std::function> - c++

Question

Expanding on #nes code (https://codereview.stackexchange.com/questions/67241/function-composition-using-stdbind), is there a way to edit the code, so that the input to make_composition_function could be a vector of functions instead of functions as separate arguments.
#include <iostream>
#include <functional>
#include <vector>
// traits to infer the return type of recursive binds
template<typename... Fn>
struct composite_function_traits;
// bind a single function with a placeholder
template<typename F1>
struct composite_function_traits<F1> { typedef decltype(std::bind(std::declval<F1>(), std::placeholders::_1)) type; };
template<typename F1>
typename composite_function_traits<F1>::type make_composite_function(F1&& f1)
{
return std::bind(std::forward<F1>(f1), std::placeholders::_1);
}
// recursively bind multiple functions
template<typename F1, typename... Fn>
struct composite_function_traits<F1, Fn...> { typedef decltype(std::bind(std::declval<F1>(), std::declval<typename composite_function_traits<Fn...>::type>())) type; };
template<typename F1, typename... Fn>
typename composite_function_traits<F1, Fn...>::type make_composite_function(F1&& f1, Fn&&... fn)
{
return std::bind(std::forward<F1>(f1), make_composite_function(std::forward<Fn>(fn)...));
}
int main() {
using namespace std;
auto f1 = [] (int x) { cout << "f1" << endl; return x; };
auto f2 = [] (int x) { cout << "f2" << endl; return x; };
auto f3 = [] (int x) { cout << "f3" << endl; return x; };
// this works -> int y = make_composite_function(f1, f2, f3)(1);
// what I would like to be able to do
std::vector<std::function<int(int)>> funvec;
funvec.push_back(f1);
funvec.push_back(f2);
funvec.push_back(f3);
int y = make_composite_function(funvec)(1);
// print result
cout << y << endl;
}

Answer 1

You might do something like:
template <typename T>
std::function<T(T)> make_composite_function(std::vector<std::function<T(T)>> v)
{
std::reverse(v.begin(), v.end());
return [=](T t) {
for (const auto& f : v) {
t = f(t);
}
return t;
};
}
Demo
You don't even have to use SFINAE for previous overloads by passing vector by value.