Perché C++ 1 * ha ancora bisogno della parola chiave template al posto della duck Full Typing

Question

Molti anni fa, (almeno per me) il polimorfismo statico del C++ sembrava coerente. Linguaggi come Python fatto affidamento su duck typing, dove si hanno:

def fn(foo, bar): 
    foo.baz(bar.bo()) 

e l'idea era che se "starnazzò" in modo appropriato, è andato tutto bene dal linguaggio.

In C++, al contrario, che avrebbe dovuto spiegare che cosa "animale" era:

void fn(foo_type foo, bar_type bar); 

e per "regni di famiglie", si sarebbe esplicitamente necessario utilizzare la parola chiave template:

template<class Foo, class Bar> 
void fn(Foo foo, Bar bar); 

---

Con nuove caratteristiche come auto ...() -> decltype tipi di ritorno, ma soprattutto generic lambdas, sembra che ci sia qualcosa di molto più simile non-modello di Python-like du ck digitazione:

[] (auto container) { return container.size(); }; 

---

La mia domanda, allora, è per questo che è la parola template ancora bisogno? Perché non abbracciare solo completamente (opzionale) duck typing:

// Takes a foo_type and a bar_type 
void fn(foo_type foo, bar_type bar); 

// Takes some "foo-quacking" type, and a bar_type 
void fn(auto foo, bar_type bar); 

// Etc. 

Answer 1

In realtà è quasi alla porta come parte della funzione Concepts, e alcuni compilatori già applicarla! Ad esempio, con GCC 4.9, se si specifica -std=c++1y, si può effettivamente compilare ed eseguire il seguente:

auto print_arg(auto arg) { 
    std::cout << arg; 
}