Pass template functor to a template std::function

Here is a code snippet:

#include <functional>
#include <iostream>
#include <memory>

template <typename T>
using Callback = std::function<void(const T)>;

template <typename T>
void Call(const T yyy, Callback<T>&& callback) {
    callback(yyy);
}

template <typename T>
class MyCallback {
public:
    explicit MyCallback(const T counter_init) : counter_{counter_init} {}
    void operator ()(const T xxx) {
        std::cout << counter_ << '\t' << xxx << std::endl;
        ++counter_;
    }
private:
    T counter_;
};

int main() {
    const auto callback = std::make_unique<MyCallback<int>>(0);
    Call(111, *callback);  // expected output is "0 \t 111"
    Call(222, *callback);  // expected output is "1 \t 222"
    return 0;
}

Clang says it couldn't match std::function against MyCallback and g++ is thinks that MyCallback is derived from Callback.

clang++ -std=c++14 main.cpp && ./a.out

g++ -std=c++14 main.cpp && ./a.out

The easiest way I know that will fix this issue is to use template instead of Callback, so that Call will be defined in the following manner:

template <typename T, typename F>
void Call(const T yyy, F&& callback) {
    callback(yyy);
}

But it would be unclear for the next developer which signature does callback has.

Can some one clarify what is going on in the first example from compiler point of view and how can I fix this without applying hack I described above?