Default template arguments when using template template parameters - c++

Question

The following code compiles using gcc 5.2, gcc 4.9, and clang 3.7 at C++11 standard:
template <typename T, typename U, template<typename...> class M>
U * find_item(M<T, U> & m, const T & t) {
auto it = m.find(t);
if (it != m.end()) { return &it->second; }
return nullptr;
}
template <typename T, typename U, template<typename...> class M>
const U * find_item(const M<T, U> & m, const T & t) {
auto it = m.find(t);
if (it != m.end()) { return &it->second; }
return nullptr;
}
#include <map>
#include <unordered_map>
#include <string>
#include <iostream>
int main() {
std::map<std::string, int> foo;
foo["asdf"] = 5;
if (find_item(foo, std::string{"bar"})) { std::cerr << "hmm\n"; }
}
However, when I compile it with the latest version of emscripten, I get a compiler error stemming from too few arguments for class template 'map':
main.cpp:24:7: error: no matching function for call to 'find_item'
if (find_item(foo, std::string{"bar"})) { std::cerr << "hmm\n"; }
^~~~~~~~~
main.cpp:2:5: note: candidate template ignored: substitution failure [with T =
std::__1::basic_string<char>, U = int, M = map]: too few template
arguments for class template 'map'
U * find_item(M<T, U> & m, const T & t) {
^ ~
main.cpp:9:11: note: candidate template ignored: substitution failure [with T =
std::__1::basic_string<char>, U = int, M = map]: too few template
arguments for class template 'map'
const U * find_item(const M<T, U> & m, const T & t) {
^ ~
1 error generated.
ERROR:root:compiler frontend failed to generate LLVM bitcode, halting
This is a bit odd because my emscripten claims to be based on clang-3.7. Regardless, it seems to have difficulty deducing the default parameters while instantiating the find_item template.
If the code is changed in the following way, then all compilers seem to be happy with it:
template <typename T, typename U, template<typename...> class M, typename... dummy>
U * find_item(M<T, U, dummy...> & m, const T & t) {
auto it = m.find(t);
if (it != m.end()) { return &it->second; }
return nullptr;
}
template <typename T, typename U, template<typename...> class M, typename... dummy>
const U * find_item(const M<T, U, dummy...> & m, const T & t) {
auto it = m.find(t);
if (it != m.end()) { return &it->second; }
return nullptr;
}
#include <map>
#include <unordered_map>
#include <string>
#include <iostream>
int main() {
std::map<std::string, int> foo;
foo["asdf"] = 5;
if (find_item(foo, std::string{"bar"})) { std::cerr << "hmm\n"; }
}
The question is, should the "dummy" part actually be necessary according to the C++11 standard, or is emscripten defective in not figuring out the default template parameters here?
My reading of section [temp.deduct.type] 14.8.2.6.8 is that it should be able to bind std::map to a template template parameter of the form M<T, U> because of the wording "at least one" in this sentence:
Similarly, <T> represents template argument
lists where at least one argument contains a T
But, I'm not sure about that.

Answer 1

I hit this problem and found that I didn't need the dummy template parameter, specifying the template template as variadic was enough (this is on clang 3.6):
template <typename T, typename U, template<typename...> class M>
U * find_item(M<T, U> & m, const T & t) {
auto it = m.find(t);
if (it != m.end()) { return &it->second; }
return nullptr;
}
template <typename T, typename U, template<typename...> class M>
const U * find_item(const M<T, U> & m, const T & t) {
auto it = m.find(t);
if (it != m.end()) { return &it->second; }
return nullptr;
}