Use a templated variadic template parameter as specialized parameter

Question

My title might be wrong - if so, please do correct me, but at some point its hard for me to keep track of what meta thingy I'm actually trying to achieve ;)

I have a class function template like this:

template<template<typename...> class MapType>
    Expression Expression::substitute(MapType<std::string, Expression> const& identifierToExpressionMap) const {
        return SubstitutionVisitor<MapType>(identifierToExpressionMap).substitute(something);
    }

The important part is the MapType. The idea is to allow either std::map or std::unordered_map to be plugged in at will. With GCC and Clang, this works, but Visual Studio 2013 throws a compilation error:

error C2664: 'Expression Expression::substitute<std::map>(const MapType &) const' :

cannot convert argument 1 from 'std::map<std::string,Expression,std::less<_Kty>,std::allocator<std::pair<const _Kty,_Ty>>>' to 'const std::map &'

1>          with
1>          [
1>              MapType=std::map
1>          ]
1>          and
1>          [
1>              _Kty=std::string
1>  ,            _Ty=Expression
1>          ]

1>          Reason: cannot convert from 'std::map<std::string,Expression,std::less<_Kty>,std::allocator<std::pair<const _Kty,_Ty>>>' to 'const std::map'

1>          with
1>          [
1>              _Kty=std::string
1>  ,            _Ty=Expression
1>          ]

1>          No user-defined-conversion operator available that can perform this conversion, or the operator cannot be called

It seems that MSVC does not put MapType and <std::string, Expression> together as a type, am I missing something here?

So my question is

1. is this possible and just a bug in MSVC, or
2. is there an easier way to do this. Please keep in mind that there are many other classes which receive the MapType parameter and instantiate their own version with different key/value Types.

Answer 1

It probably boils down to this:

template<class T, class U = int>
struct cat {};

template< template<class...> class Animal >
void foo()
{
    Animal<int> x; (void)x; // (A)
}

int main()
{
    foo<cat>();
}

This little innocent-looking program is accepted by clang++ and g++, but not by MSVC2013 Update 1.

---

Line (A) is the problematic one: I think in this example it's clear that the template template-parameter Animal should have two template parameters, when passing the class template cat.

It seems that clang++ and g++ support the use of default template arguments for this template template-parameter in line (A), while MSVC does not.

I do not know if the Standard requires either of them; see for example

• this answer by Richard Smith
• CWG active issue #150

It certainly appears to me that supporting the default template arguments is useful, since (as said in the active issue) the class templates of the Standard Library may have additional template parameters (with default arguments); and you'd need to know those implementation-details if you wanted to use them (directly) as template template-arguments.

Answer 2

Given the discussion which has happened I think maybe it would be time to consider a work-around. Since deducing the template template arguments seems to be the issue at hand, perhaps relaxing the requirements for MapType might be helpful.

template< typename MapType>
Expression Expression::substitute( MapType const& identifierToExpressionMap) const {
    return SubstitutionVisitor<MapType>(identifierToExpressionMap).substitute(something);
}

The caller is going to be compiled code calling a function and so the compiler will deduce the template arguments so basically you're pushing the responsibility of using the proper std::map or std::unordered_map onto the caller.

Now at least for most cases this may work. However it is possible to pass in some kind of container which compiles but doesn't actually have the right types. So ideally you'd still be wanting some kind of compile-time check to ensure MapType is supported (ie: either a std::map or std::unordered_map).

This could be via Boost concepts, or even just having two templated alias declarations - using enable_if you can ensure that the alias declaration is only available in two flavors: map or unordered_map.