When Gabriel Dos Reis and Bjarne Stroustrup first introduced C++ concepts, they did so in the hope of making the C++ template facility more expressive (Specifying C++ Concepts [PDF file]):

We consider the problem of how to express concepts in a precise way that is simple enough to be usable by ordinary programmers. In doing so, we expose a few weakness of the current specification of the C++ standard library and suggest a far more precise and complete specification. We also present a systematic way of translating our proposed concept definitions, based on use-patterns rather than function signatures, into constraint sets that can serve as convenient basis for concept checking in a compiler.

Concepts received a fair amount of attention in the intervening years, with the expectation that they would eventually be included in the C++0x standard. This week, however, the C++ standards committee voted against including Concepts in the core language. In a recent article, The Removal of Concepts From C++0x, Danny Kalev speculates about the reasons for this rejection and what the future may hold for Concepts, or a similar idea, in C++:

Concepts were supposed to be the most important addition to core C++ since 1998. Tremendous efforts and discussions were dedicated to Concepts in every committee meeting during the past five years. After dozens of official papers, tutorials and articles -- all of which were dedicated to presenting and evangelizing Concepts -- it seemed very unlikely that just before the finishing line, Concepts would be dropped in a dramatic voting.

Kalev summarizes the significance of Concepts as follows:

Concepts introduce a type system for templates, enabling you to specify template constraints clearly and intuitively, while improving the compiler’s capability to detect and diagnose violations of these constraints...

Concepts rely on the notion of separate type checking for templates. Template declarations are augmented with a set of constraints. When a template is instantiated, the compiler checks that the instantiation meets all of the constraints, or requirements, of the said template. If all is well, the template is instantiated successfully. Otherwise, a compilation error stating which constraints(s) were violated is issued.

In his article, Kalev speculates that both the Concepts proposal, as well as relative lack of practical experience with Concepts, led to its rejection:

Committee members claimed that it was too early to adopt such a radical change to the Standard Library without real world experience. Apart from that, there were still too many unresolved issues. As a compromise, the committee decided to pursue the refinement of Concepts while leaving the Standard Library unconceptualized for the time being. This was an ominous sign -- if the committee is wary of conceptualizing the Standard Library, why should Joe Code trust Concepts? (...)

A total overhaul of Concepts is one possibility, however unlikely. This could take up to five years and no one is certain that the redesigned Concepts will not have introduced other problems. A second approach is to leave the door open for a drastically reduced and diluted Concepts proposal. The third approach is to refine the current Concepts proposal further, knowing that it will not be integrated into C++0x. I'm willing to bet on the following -- Concepts are dead for good.

What do you think about C++ Concepts, and what is your take on the committee's rejection of Concepts from the upcoming standard?

#include <vector>

class Foo {
};

template <class T> const T &max(const T &a, const T &b) {
    return a > b ? a : b;
}

template <class T> class SortedVector {
public:
    void insert(const T &a) {
        for(std::vector<T>::iterator it = m_data.begin(); it != m_data.end(); ++it) {
            const T &b = *it;
            if (&max(a, b) == &b) {
                m_data.insert(it, a);
                break;
            }
        }
    }

private:
    std::vector<T> m_data;
};

int main() {
    SortedVector<Foo> f;
    Foo a;
    f.insert(a);
    return 0;
}

1>e:\temp\test_mod\main.cpp(9) : error C2676: binary '>' : 'const Foo' does not define this operator or a conversion to a type acceptable to the predefined operator
1>        e:\temp\test_mod\main.cpp(18) : see reference to function template instantiation 'const T &max<T>(const T &,const T &)' being compiled
1>        with
1>        [
1>            T=Foo
1>        ]
1>        e:\temp\test_mod\main.cpp(15) : while compiling class template member function 'void SortedVector<T>::insert(const T &)'
1>        with
1>        [
1>            T=Foo
1>        ]
1>        e:\temp\test_mod\main.cpp(31) : see reference to class template instantiation 'SortedVector<T>' being compiled
1>        with
1>        [
1>            T=Foo
1>        ]

1> e:\temp\test_mod\main.cpp(31) : SortedVector<Foo> can not be compiled because Foo does not implement the operator >. Details:
1> e:\temp\test_mod\main.cpp(15) : while compiling class template member function 'void SortedVector<T>::insert(const T &)'
1> e:\temp\test_mod\main.cpp(9) : while compiling template function 'const T &max(const T &a, const T &b)'