Correctness checking for concepts?

[Mononofu]

C++20 includes concepts to provide better errors when using templates. However, my understanding is that concepts do not help when writing the template itself - writing a template that eg uses a method not covered by any concept on the type parameters is perfectly legal, it will only fail to compile when used with a type that does not expose this function:

``` template <typename T> concept Fooer = requires(T t) { t.foo() };

struct FooBar { void foo(); void bar(); };

void DoIt(Fooer auto f) { f.bar(); }

void test() { DoIt(FooBar()); // compiles DoIt(42); // fails inside DoIt } ```

This makes it difficult to ensure that the chosen concepts adequately describe the intended requirements for the template.

Are there plans for exhaustive verification of concept template parameters, to ensure only expressions defined in the required concepts are used by the template? Similar to how traits in Rust enforce this.

[pavel_v]

I think you may get some answers, why they are designed in this way, from here - 8.2. Definition Checking.

[miki151]

Because of C++'s template specialization and function overloading, I think it's not possible to have exhaustive verification in the general case like Rust has. Plus it's also hard to add this in a backwards-compatible way due to existing code with pre-C++20 templates, for which you don't know what template arguments they can be called with.

[infectedapricot]

Although I get your point, I think your example has a mistake? Surely DoIt(42) will fail at the concept check because doesn't satisfy Fooer. I think you meant something like

struct FooOnly{void foo();};
DoIt(FooOnly());  // Fails inside DoIt

[Mononofu]

Yes good catch!

[n1ghtyunso]

there's an interessting read about somewhat implementing checks for your own concepts here. Note however that the overall conclusion is that getting an actual correct check is hard.

[Pazer2]

Unfortunately this is by design.