template<class T> T operator+(T a, T b)
{
   T out;
   transform(a.begin(),a.end(),b.begin(),back_inserter(out),
             p<typename T::value_type>);
   return out;
}

template T operator+(T a, T b)
{
   T out;
   transform(a.begin(),a.end(),b.begin(),back_inserter(out),
             p);
   return out;
}

#include<iostream>
#include<list>
#include<iterator>

using namespace std;

template<class T> T p(T a, T b){ return a+b; }
template<class T> list<T> operator+(list<T> a, list<T> b)
{
   list<T> out;
   transform(a.begin(),a.end(),b.begin(),back_inserter(out),p<T>);
   return out;
}

int main(int argc, char* argv[])
{
    double x[] = { 1.0, 2.0, 3.0};
    double y[] = {10.0,11.0,12.0};
    list<double> a(x,x+sizeof(x)/sizeof(double));
    list<double> b(y,y+sizeof(y)/sizeof(double));
    list<double> c;

    c = a+b;

    copy(c.begin(),c.end(),ostream_iterator<double>(cout, "\n"));

    return 0;
}

In short, your example is exactly what I meant. Thanks.

If by “type compatibility” you mean types that can substitute for one another everywhere, then no. In Haskell, for example, you can create a function…

double x = x+x

…which can be passed anything that understands the plus operator. So lets make lists of numbers understand “plus”…

instance Num a => Num [a] where (+) = zipWith (+)

…now let’s try it out at the REPL…

$ ghci type_compat.hs 
   ___         ___ _
  / _ \ /\  /\/ __(_)
 / /_\// /_/ / /  | |      GHC Interactive, 6.6, for Haskell 98.
/ /_\\/ __  / /___| |      http://www.haskell.org/ghc/
\____/\/ /_/\____/|_|      Type :? for help.

Loading package base ... linking ... done.
[1 of 1] Compiling Main          ( type_compat.hs, interpreted )

Ok, modules loaded: Main.
*Main> double 4.0
8.0
*Main> double 42
84
*Main> double [1,2,3]
[2,4,6]
*Main>

…so you can use floating point numbers and lists of integers in some of the same places, but I don’t think they’d be called compatible types.

Yes. I don’t think I’ve ever seen a formal definition of duck typing, but C++ templates certainly allow you to treat anything that quacks and waddles as a duck, while still making sure your type mismatches are detected at compile time. Same goes for Haskell, Clean, etc.

In your C++ example, is the type of the function still checked statically?