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;
}

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)
{.....}

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');
}

... 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 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
}