namespace bmpl = boost::mpl;

typedef bmpl::set<Type1,Type2,...,TypeN> GoodTypes;

// эти метафункции можно запихать прямо в enable_if - я их вынес для читаемости
template<class T>
struct is_good_type : bmpl::has_key<GoodTypes,T>::type {};

template<class T1, class T2>
struct are_good_types : bmpl::and_< is_good_type<T1>, is_good_type<T2> >::type {};

// перегрузки
template<class T1, class T2>
typename boost::enable_if< are_good_types<T1,T2>, void >::type
f(T1& t1, T2& t2)
{.....}

void f(DefaultType1& t1, DefaultType2& t2)
{.....}

template<class T>
void g(T,    long); 
void g(long, char);

int main()
{
  g('a', '1');
}

... a viable function F1 is defined to be a better function than another viable function
F2 if for all arguments i, ICSi(F1) is not a worse conversion sequence than ICSi(F2), and then
— for some argument j, ICSj(F1) is a better conversion sequence than ICSj(F2), or, if not that,
— F1 is a non-template function and F2 is a function template specialization
...

template<class T1, class T2> void f(T1 &t1, T2 &t2)

template<class T1, class T2> void f(T1 &t1, T2 &t2)//T1, T2 из набора Type1...TypeN
void f(OutListType1 &t1, OutListType2 &t2)
void f(OutListType3 &t1, OutListType4 &t2)

template<class T1, class T2> void f(T1 &t1, T2 &t2)

template<class T1, class T2>
void f_impl_tmpl(T1 &t1, T2 &t2);
void f_impl(OutListType1 &t1, OutListType2 &t2);
void f_impl(OutListType3 &t1, OutListType4 &t2);

template<class T1, class T2> void f(T1 &t1, T2 &t2)
{

  if(<T1 из набора Type1...TypeN> || <T2 из набора Type1...TypeN>)
  {
    return f_impl_tmpl(t1,t2);
  }

  return f_impl(t1,t2);
}

#include <iostream>

template<typename T>
class is_from_type_collection
{
    typedef char true_type;
    struct false_type{ true_type _[2]; };

    //////////////////////////////////////////////////////////////////////////
    // Набор типов.
    template <typename U>
    static true_type is_from_type_collection_checker(int*);

    template <typename U>
    static true_type is_from_type_collection_checker(double*);
    //////////////////////////////////////////////////////////////////////////

    template <typename U>
    static false_type is_from_type_collection_checker(...);
public:
    enum { value = (sizeof(is_from_type_collection_checker<T>((T*) 0)) == sizeof(true_type)) };
};

template <bool Cond, class T = void>
struct enable_if
{
    typedef T type;
};

template <class T>
struct enable_if<false, T>
{};

template <typename T1, typename T2>
typename enable_if<is_from_type_collection<T1>::value && is_from_type_collection<T2>::value>::type foo(T1 const &t1, T2 const &t2)
{
    std::cout << "General function." << std::endl;
}

void foo(float const &t1, float const &t2)
{
    std::cout << "Float function." << std::endl;
}

int main()
{
    {
        int a = 1;
        double b = 1;
        foo(a, b);
    }

    {
        float a = 1;
        float b = 1;
        foo(a, b);
    }

    return 0;
}

V>Это и предложено дорешать

namespace bmpl = boost::mpl;
...
bmpl::or_< typename bmpl::has_key< bmpl::set<Type1,Type2,TypeN>, T1 >::type, typename bmpl::has_key< bmpl::set<Type1,Type2,TypeN>, T2 >::type >
...

13.3.1/7
In each case where a candidate is a function template, candidate function template specializations are generated using template argument deduction (14.8.3, 14.8.2). Those candidates are then handled as candidate functions in the usual way (^113) A given name can refer to one or more function templates and also to a set of overloaded non-template functions. In such a case, the candidate functions generated from each function template are combined with the set of non-template candidate functions.
----------------
^113 The process of argument deduction fully determines the parameter types of the function template specializations, i.e., the parameters of function template specializations contain no template parameter types. Therefore the function template specializations can be treated as normal (non-template) functions for the remainder of overload resolution.

ЮЖ>template<class T>
ЮЖ>void g(T,    long); 
ЮЖ>void g(long, char);

ЮЖ>int main()
ЮЖ>{
ЮЖ>  g('a', '1');
ЮЖ>}
ЮЖ>

template<class T>
void g(T,char)
{
  printf("1\n");
}

void g(char,long)
{
  printf("2\n");
}

int main()
{
  g('a','1'); //Ok

  return 0;
}

V>А как вы объясните это?

V>template<class T>
V>void g(T,char)
V>{
V>  printf("1\n");
V>}

V>void g(char,long)
V>{
V>  printf("2\n");
V>}

V>int main()
V>{
V>  g('a','1'); //Ok

V>  return 0;
V>}
V>

void g(char, char);
void g(char, long);

int main()
{
  g('a','1'); //Ok
}

template<class T>
int g(T);
void g(int);

int main()
{
  sizeof(g(1)); // error
}

V>>А как вы объясните это?

V>>template<class T>
V>>void g(T,char)
V>>{
V>>  printf("1\n");
V>>}

V>>void g(char,long)
V>>{
V>>  printf("2\n");
V>>}

V>>int main()
V>>{
V>>  g('a','1'); //Ok

V>>  return 0;
V>>}
V>>

g<char>(char,char)

g(char,long)

template<class T>
void g(T,char)
{
  printf("1\n");
}

void g(char,char)
{
  printf("2\n");
}

int main()
{
  g('a','1'); //2

  return 0;
}

template<class T>
void g(T,T)
{
  printf("1\n");
}

template<class T>
void g(T,char)
{
  printf("2\n");
}

int main()
{
  g('a','1'); //Error
}

template<class T>
void g(T,T)
{
  printf("1\n");
}

template<class T>
void g(T,char)
{
  printf("2\n");
}

void g(char,char)
{
  printf("3\n");
}

int main()
{
  g('a','1'); //3
}

template<class T, class U> void f(T,U) { cout <<__PRETTY_FUNCTION__<<endl; }
template<class T> void f(T,T)          { cout <<__PRETTY_FUNCTION__<<endl; }
template<class T> void f(T,char)       { cout <<__PRETTY_FUNCTION__<<endl; }
//void f(char,char)                    { cout <<__PRETTY_FUNCTION__<<endl; }

int main()
{
int x=0; char c=0;
f(x,c); // T,char T=int
f(x,x); // T,T    T=int
f(c,x); // T,U    T=char,U=int
f(c,c); // неоднозначность между T,T и T,char, лечится раскомментированием f(char,char)
...

...
f<char,char>(x,x); // T,U    T=char,U=char
f<int>(x,c);       // T,char T=int
f<int>(c,x);       // T,T    T=int
f<int>(c,c);       // T,char T=int - вот здесь я затрудняюсь объяснить, почему так.
}

#include <stdio.h>

template<class T>
void g(T,T)
{
  static int a[sizeof(T)-sizeof(T) ? 1 : -1];
  printf("1\n");
}

template<class T>
void g(T,char)
{
  static int a[sizeof(T)-sizeof(T) ? 1 : -1];
  printf("2\n");
}

int main()
{
  g('a','1'); //1 error, not 3.
}

#include <stdio.h>

template<class T> struct X {};

template<class T>
void g(X<T>,char)
{
  printf("1\n");
}

template<class T>
void g(T,char)
{
  printf("2\n");
}

int main()
{
  g(X<char>(),'1'); //Ok
}

V>А в этом случае выборка делается вообще из 2х функций, а не из трёх.

V>template<class T>
V>void g(X<T>,char);

V>template<class T>
V>void g(T,char);

V>  g(X<char>(),'1'); //Ok
V>

void boo( void(*f)(char,char) );
....
boo(g);

V>>А в этом случае выборка делается вообще из 2х функций, а не из трёх.

"ComeauTest.c", line 23: error: more than one instance of overloaded function "g"
          matches the argument list, the choices that match are:
            function template "void g(T, T)"
            function template "void g(T, char)"
            The argument types that you used are: (char, char)
    g('a','1');
    ^

1 error detected in the compilation of "ComeauTest.c".

V>>template<class T>
V>>void g(X<T>,char);

V>>template<class T>
V>>void g(T,char);

V>>  g(X<char>(),'1'); //Ok
V>>

V>>"ComeauTest.c", line 23: error: more than one instance of overloaded function "g"
V>>          matches the argument list, the choices that match are:
V>>            function template "void g(T, T)"
V>>            function template "void g(T, char)"
V>>            The argument types that you used are: (char, char)
V>>    g('a','1');
V>>    ^
V>>1 error detected in the compilation of "ComeauTest.c".
V>>

Специализации шаблонов функций участвуют в процессе разрешениия перегрузки наравне с non-template функциями.

template<class T> void g(T) { cout << "general" << __PRETTY_FUNCTION__ << endl; }
template<> void g<int>(int) { cout << "special" << __PRETTY_FUNCTION__ << endl; }

V>Т.е. вы подтвердили что оно участвует не наравне.

14.7.1/8
If a function template or a member function template specialization is used in a way that involves overload resolution, a declaration of the specialization is implicitly instantiated

14.8.3/6
Only the signature of a function template specialization is needed to enter the specialization in a set of candidate functions. Therefore only the function template declaration is needed to resolve a call for which a template specialization is a candidate.

13.3.1/7
In each case where a candidate is a function template, candidate function template specializations are generated using template argument deduction (14.8.3, 14.8.2). Those candidates are then handled as candidate functions in the usual way. A given name can refer to one or more function templates and also to a set of overloaded non-template functions. In such a case, the candidate functions generated from each function template are combined with the set of non-template candidate functions.

13.3.3/1
...
a viable function F1 is defined to be a better function than another viable function F2 if for all arguments i, ICSi(F1) is not a worse conversion sequence than ICSi(F2), and then
— for some argument j, ICSj(F1) is a better conversion sequence than ICSj(F2), or, if not that,
— F1 is a non-template function and F2 is a function template specialization, ...

14.8.3/2
...
The function template specializations are treated like any other functions in the remainder of overload resolution, except as explicitly noted in 13.3.3.

...Therefore the function template specializations can be treated as normal (non-template) functions for the remainder of overload resolution.