As my first template metaprogram I am trying to write a function that transforms an input vector to an output vector.

For instance, I want

```
vector<int> v={1,2,3};
auto w=v_transform(v,[](int x){return (float)(x*2)})

```

to set w to the vector of three floats, `{2.0, 4.0, 6.0}` .

I started with this stackoverflow question, [The std::transform-like function that returns transformed container](https://stackoverflow.com/questions/23871757/the-stdtransform-like-function-that-returns-transformed-container?rq=1) , which addresses a harder question of transforming arbitrary containers.

I now have two solutions:

1. A solution, `v_transform_doesntwork` that doesn’t work, but I don’t know why (which I wrote myself).
2. A solution, `v_transform` that works, but I don’t know why (based on Michael Urman's answer to the above question)

I am looking for simple explanations or pointers to literature that explains what is happening.

Here are the two solutions, `v_transform_doesntwork` and `v_transform`:

```
#include <type_traits>
#include <vector>

using namespace std;

template<typename T, typename Functor,
    typename U=typename std::result_of<Functor(T)>::type>
vector<U> v_transform(const std::vector<T> &v, Functor&& f){
    vector<U>ret;
    for(const auto & e:v)
        ret.push_back(f(e));
    return ret;
}

template<typename T, typename U> 
vector<U> v_transform_doesntwork(const std::vector<T> &v, U(*f)(const T &)){
    vector<U>ret;
    for(const auto & e:v)
        ret.push_back(f(e));
    return ret;
}

float foo(const int & i){
    return (float)(i+1);
}

int main(){
    vector<int>v{1,2,3,4,5};
    auto w=v_transform(v,foo);
    auto z=v_transform(v,[](const int &x){return (float)(x*2);});
    auto zz=v_transform(v,[](int x){return (float)(x*3);});
    auto zzz=v_transform_doesntwork(v,[](const int &x){return (float)(x*2);});
}

```

**Question 1**: why doesn’t the call to `v_transform_doesntwork` compile? (It gives a fail-to-match template error, c++11. I tried about 4 permutations of “const” and “&” and “\*” in the argument list, but nothing seemed to help.) 

I prefer the implementation of `v_transform_doesntwork` to that of `v_transform`, because it’s simpler, but it has the slight problem of not working.

**Question 2**: why does the call to `v_transform` work? I get the gist obviously of what is happening, but I don’t understand why all the typenames are needed in defining U, I don’t understand how this weird syntax of defining a template parameter that is relied on later in the same definition is even allowed, or where this is all specified. I tried looking up "dependent type names" in cppreference but saw nothing about this kind of syntax.

Further note: I am assuming that `v_transform` works, since it compiles. If it would fail or behave unexpectedly under some situations, please let me know.