struct PolymorphicFunctionObject
{
    template<typename T> struct result;

    template<typename Arg>
    struct result< PolymorphicFunctionObject(Arg) >
    {
        typedef Arg type;
    };

    template<typename Arg1,typename Arg2>
    struct result< PolymorphicFunctionObject(Arg1,Arg2) >
    {
        typedef Arg2 type;
    };

    template<typename Arg>
    Arg operator()(Arg t) const
    {
        return t;
    }

    template<typename Arg1,typename Arg2>
    Arg2 operator()(Arg1 t1,Arg2 t2) const
    {
        return t2;
    }
};

 template<class T, int N>
 class Array {
 T data[N];
 public:
 T& operator[](int i);
 };

ну math::dcomplex::cos как то логичней меньше конфликтов возможных...

J>struct PolymorphicFunctionObject
J>{
J>    template<typename T> struct result;

J>    template<typename Arg>
J>    struct result< PolymorphicFunctionObject(Arg) >
J>    {
J>        typedef Arg type;
J>    };

J>    template<typename Arg1,typename Arg2>
J>    struct result< PolymorphicFunctionObject(Arg1,Arg2) >
J>    {
J>        typedef Arg2 type;
J>    };

J>    template<typename Arg>
J>    Arg operator()(Arg t) const
J>    {
J>        return t;
J>    }

J>    template<typename Arg1,typename Arg2>
J>    Arg2 operator()(Arg1 t1,Arg2 t2) const
J>    {
J>        return t2;
J>    }
J>};
J>

auto x = pfo(y,z);
// или даже круче
typedef typeof(pfo(y,z)) X;
X x1, x2; .....

template<class R, class A1, class A2>
shared_ptr<R> // чисто для примера - пусть foo возвращает некоторый тип, производный от искомого
foo( R(*f)(A1,A2) ) // здесь мы выполняем сопоставление
{
  return shared_ptr<R>(new f(0,0));
}

// там, где сопоставлять вот так неудобно, можем написать единожды метафункцию
template<class F> struct bin_fun_traits;
template<class R, class A1, class A2> struct bin_fun_traits< R(A1,A2) >
{
  typedef A1 a1_type;
  typedef A2 a2_type;
  typedef R  result_type;
};

template<class F> struct Foo // ну можно, конечно, написать struct Foo<R(A1,A2)>... 
{
  typedef typename bin_fun_traits<F>::result_type res_type;
  typedef shared_ptr<res_type> ptr_type;
  ptr_type p_, q_;
  .....
  void setup(Foo f)
  {
    p_ = ptr_type(new f(1,2));
    q_ = ptr_type(new f(3,4));
  }
  .....
};

struct multiply
{
  typedef int first_argument_type;
  typedef int second_argument_type;
  typedef int result_type;
  int operator()(int x, int y) const { return x*y; }
};

struct whatever_less
{
  typedef bool type;
  template<class X, class Y> bool operator()(X x, Y y) const { return x<y; }
};

boost::function<bool(char)> is_ctrl = boost::bind(whatever_less, _1, 32); // слишком простой пример, но наворачивать что-то реальное я не хочу

struct tararam
{
  // вот наши функции
  int operator()(int x, int y) const { return x-y; }
  short operator()(char x, char y) const { return (short)(x+y); }

  // а вот метафункция, описывающая их
  template<class X, class Y> struct result;
  template<> struct result<int,int>   { typedef int type; };
  template<> struct result<char,char> { typedef short type; };
};

template<class F, class X> void foo(F f, X x, X y)
{
  typedef typename F::template result<X,X>::type xx_type;
  shared_ptr<xx_type> r (new f(x,y));
  .....
}
...
foo(tararam, 'a', 'b');

struct tararam
{
  // вот наши функции
  int operator()(int x) const { return -x; }
  short operator()(char x, char y) const { return (short)(x+y); }

  // а вот метафункция, описывающая их
  template<class X> struct result1;
  template<> struct result1<int> { typedef int type; };

  template<class X, class Y> struct result2;
  template<> struct result2<char,char> { typedef short type; };
};

template<Args...> struct result;
template<> struct result<int> { ..... };
template<> struct result<char,char> { ..... };

template<class Tuple> struct result;
template<> struct result< tuple<int> > { ..... };
template<> struct result< tuple<char,char> > { ..... };

.....
typedef typename F::template result< tuple<X,X> >::type xx_type;

////////////////

template<class Fun> struct result;
template<> struct result< tararam(int) > { ..... };
template<> struct result< tararam(char,char) > { ..... };

.....
typedef typename F::template result< F(X,X) >::type xx_type;

template<class> class WhatAboutPointer;
template<class T> class WhatAboutPointer<T*> { .... T .... };
.....
WhatAboutPointer<int*> // в этом классе параметр T принял значение int

template<class> class WhatAboutBinaryFunction;
template<class R, class X, class Y> class WhatAboutBinaryFunction< R(X,Y) > { .... R .... X .... Y .... };
.....
typedef int foo_signature(char,short);
WhatAboutBinaryFunction< foo_signature > // выделили из сигнатуры, что она получает и что возвращает

int foo(char);
long foo(char,short);
..... foo('a') ..... // вызовем первую сигнатуру, как наиболее подходящую

template<class> struct Foo;
template<class R, class X> struct Foo<R(X)> { ..... }; // первая специализация
template<class R, class X, class Y> struct Foo<R(X,Y)> { ..... }; // вторая
..... Foo<int(char)> ..... // класс получен из первой специализации шаблона

template<class T> struct AddPointer { typedef T* type; };
typedef typename AddPointer<int>::type pint; // pint - это int*

int foo(int x) { return x+1; }

template<int X> struct F { static const value = X+1; }; // метафункция над числами
template<class T> struct P { typedef T* type; }; // метафункция над типами