Lest be charitable and assume you mean this code:


```
template<typename T>
void foo() { cout <<typeid(T).name()<<endl;}

auto useType(effdecltype(foo)  f)
{
  using T = __get_ortho_at__<0>(f);
  f();
  return T(0);
}

template<typename T>
void consumeType(T t)
{  cout << typeid(t).name(); }

int main()
{
    vector<effdecltype(foo)> vec;
    vec.push_back(&foo<int>);
    vec.push_back(&foo<double>);
    vec.push_back(&foo<float>);
    for(int i=0; i<5; ++i)
        vec.push_back(&foo<char>);
    for(const auto& F: vec)
       consumeType(useType(F));
}
```


It can be easy fixed by helper:


```
template<typename T>
void consumeTypeHelper()
{
    foo<T>();
    return consumeType(T{});
}

int main()
{
    vector<void(*)()> vec;
    vec.push_back(&consumeTypeHelper<int>);
    vec.push_back(&consumeTypeHelper<double>);
    vec.push_back(&consumeTypeHelper<float>);
    for(int i=0; i<5; ++i)
        vec.push_back(&consumeTypeHelper<char>);
    for(const auto& F: vec)
       F();
}
```

Done. Problem fixed in C++11

Very good... nice try.

Unfortunately you miss the point.

I showed a loop over a set of functions returning many types.

Imagine you have a container of slots, which returns different types ( i already said that many times)

Given the current state of C++ you can store them only as. Let say.

vector<std::any(*)(int, double)>

How can you tell what type the called function returned before it was hiden inside std::any?

Is it clear?