templates | YML templates

You need to add "compat" like this

The ambiguity is that std::string and std::string_view are both constructible from const char *. That makes things like

There is no UB here. The template GetID is instantiated once for each unique template argument, but GCC wrongly treats the alias templates as the template they alias itself, because they are equivalent here, as Davis Herring pointed out.

I think the simplest general solution is to pass the argument types in the alias templates through another alias template that makes them dependent names.

in command prompt type where.exe dotnet if display like this:

C:\Program Files (x86)\dotnet\dotnet.exe

C:\Program Files\dotnet\dotnet.exe

you need move up C:\Program Files\dotnet\dotnet.exe in Start Menu - Edit the System Environment variables - Environment Variables - Path - Edit

after maybe need create certificate dotnet dev-certs https --trust

There's a simple question whose answer explains this:

Is the return value of make_reverse_iterator a reverse_iterator?

See, a reverse iterator is not just an iterator that runs backwards. It's a type. Or rather, it's a template which generates a family of types. And that template is expected to provide certain behavior; that behavior is what makes it a reverse iterator.

And this is behavior that is not required to be provided by a non-reverse_iterator type. A reverse_iterator> is not the same thing as I. You can't get the base of I, for example.

The non language lawyer answer is that there is a tie breaker rule for exactly this case.

Understanding standard wording well enough to decode it would require a short book chapter. But when deduced T&& vs T& overloads are options being chosen between for an lvalue and everything else ties, the T& wins.

This was done intentionally to (a) make universal references work, while (b) allowing you to overload on lvalue references if you want to handle them seperately.

The tie breaker comes from the template function overload "more specialized" ordering rules. The same reason why T* is preferred over T for pointers, even though both T=Foo* and T=Foo give the same function parameters. A secondary ordering on template parameters occurs, and the fact that T can emulate T* means T* is more specialized (or rather not not, the wording in the standard is awkward). An extra rule stating that T& beats T&& for lvalues is in the same section.

Well, since you explicitly say macros may be ok:

Why does the language make such exception for the templates?

You mean this?

signature [defns.signature.templ]

⟨function template⟩ name, parameter-type-list, enclosing namespace (if any), return type, template-head, and trailing requires-clause (if any)

Yes, the return type is there. It's what always made possible things like

Your demo uses void begin() const; to test the following

... instead does add the requirement that the return type of the call is complete ...

But a void return type is not the same as an incomplete return type. For that you could try