Return to Question

I would expect the last two lines of this code printing the same, i.e. the word "template". Obviously the type deduction works correctly everywhere.

But if I type qualify the called function overload it works in all cases except where the template argument is itself a template.

EDIT: Added further overload with two type parameters to make things clearer for myself. Now it is clear to me that print<R, int>(r) has one single template argument and not two just as in template<template<class> class R, class T>. (1) and (2) must either render the same or one of them must be an error. Anybody who thinks all compilers are doing correct would surely agree this is at least worth a compiler warning with -pedantic option.

When I replace function overloading with template specialization, then template pattern matching works as I would have expected. See next code example. I have some trouble believing that the pattern matching rules also differ between classes and functions. If that is really true then I would say that Walter is right when he says, avoid it.

I would expect the last two lines of the first code example to print the same.

The types are deducted as I expect and the the overload resolution is also as I expect. However, if I explicitly type qualify the function call, then I get a different result then when the type is deduced.

The second code example repeats the exercise replacing overload resolution with specialization. In that case everything works as anyone would expect.

Code Example 1: (function template overloading)

Code Example 2: (class template specialization).