Перегрузка оператора у вложенного класса шаблона

template <typename T>
class A
{
public:
    class B;
};
 
template <typename T>
class A<T>::B
{
 
};
 
template <typename T>
typename A<T>::B operator+(int n, typename A<T>::B b)
{
    return A<T>::B();
}
 
void main()
{
    1 + A<int>::B();
}

template<class T> struct bar
{
    using type = int;
};
 
template<class T> void foo(typename bar<T>::type)
{
}
 
int main()
{
    bar<double>::type val1 = 5;
    int val2 = 3;
    int val3=val1+val2 ;
    foo<char>(val1); // а это?
    foo<char>(val2); // а это?
    foo<char*>(val1); // а это?
    foo<char*>(val2); // а это?
    //foo(val1); // чем это
    //foo(val2); // отличается от этого? И какой тип T должен быть выведен тут?
}

#include <map>
 
template<typename T>
struct TMap
{
    typedef std::map<T, T> Type;
};
 
 TMap<double>::Type tmap1;//сам шаблонный тип компилятор видит
 
template<typename T>
T test(typename TMap <T>::Type &tmap_) { return 0.0; }//
 
//вот вариант прямого задания шаблонного типа аргумента
template<typename T>
T test1(typename std::map<T,T> &tmap_) { return 0.0; }
 
 
int main(int argc, char* argv[])
{
    TMap<double>::Type tmap;//и тут видит
    tmap[1.1] = 5.2;
   //а тут подстановка не получается!
   //double d = test(tmap); //Error: could not deduce template argument for T
   double d = test<double>(tmap);//ok
   d=test1(tmap);//ok )))
    return 0;
}