基于部分模板模板的专用化与显式部分模板专用化

给定一个模板，例如foo：

template<typename... ARGS>
struct foo {};

模板的两个部分专用化bar：

template<template<typename...> class T , typename... ARGS>
struct bar<T<ARGS...>>
{};
template<typename... ARGS>
struct bar<foo<ARGS...>>
{};

第二个部分专用化不是比第一个更专业，并且必须实例化而不是模板模板参数专用化吗？

一些背景：

我目前正在基于本文为模板元编程编写多变量 lambda 表达式。

正如论文所示，给定类似 Haskell 的 let 表达式，人们可以很容易地开发 tmp lambda 表达式。就我而言，我已经扩展了论文的内容，开发基于可变变量 let 表达式的可变模板(通过 curryfing 多个嵌套的一元 let 表达式(，然后实现多变量 lambda 表达式。

我的 lambda 表达式模板 tml::multi_lambda 定义如下：

template<typename BODY , typename... VARIABLES>
struct multi_lambda
{
    template<typename... ARGS>
    using result = tml::eval<tml::multi_let<VARIABLES...,
                                            ARGS...,
                                            BODY
                                           >>;
};

其中tml::eval是用于评估表达式的元函数，例如 Boost：：mpl mpl::apply(有关更多上下文，请参阅我之前的问题(。

评估函数tml::eval既专用于泛型函数表达式，也专门用于此 lambda 表达式。这是上述示例的两个专业。

当我尝试计算 lambda 表达式时，例如：

using lambda = tml::multi_lambda<_1,_2, f<_1,_2>>; //f is a function, 
                                                   //_1 _2 are placeholders
using result = tml::eval<lambda,int,int>; //Evaluate lambda with int int as parameters

tml::eval实例化通用模板模板专用化(专为通用可评估表达式设计(，而不是 lambda 的部分专用化。

编辑：实施tml::eval和SSCCE

tml::eval 是一个元函数，用于计算任何类型的表达式，返回结果。默认实现专用于三种情况：

表达式

1. 不是一个函数，只是一个值：计算此类表达式的结果是表达式本身：

   template<typename E>
   struct evaluate_impl<E>
   {
       using result = E;
   }; 
   

2. 表达式是一个函数：计算的结果是函数的result成员类型的值。函数的参数也被计算(照顾嵌套表达式(：

   template<template<typename...> class F , typename... ARGS>
   struct evaluate_impl<F<ARGS...>> : public F<tml::eval<ARGS>...>
   {};
   

3. 表达式是一个函数，并且将更多参数传递给tml::eval以使用该自定义参数计算表达式： 表达式的参数将被忽略，并传递和计算自定义：

   template<template<typename...> class F , typename... PLACEHOLDERS , typename... ARGS>
   struct evaluate_impl<F<PLACEHOLDERS...>,ARGS...> : public F<tml::eval<ARGS>...>
   {};
   

所以tml::eval只是一个模板别名来骑在typename ::result上：

template<typename... ARGS>
using eval = typename eval_impl<ARGS...>::result;

最后，用户可以专门化eval_impl来覆盖该默认行为，或使极端情况起作用。例如，我的单变量 lambda 表达式模板，定义如下：

template<typename VARIABLE , typename VALUE , typename BODY>
struct lambda
{
    template<typename ARG>
    using result = tml::eval<tml::let<VARIABLE , ARG , BODY>>;
};

专门eval_impl使 lambda 表达式的计算工作：

template<typename VARIABLE , typename BODY , typename ARG>
struct evaluate_impl<tml::lambda<VARIABLE,BODY>,ARG>
{
    using result = typename tml::lambda<VARIABLE,BODY>::template result<ARG>;
};

我遇到的多变量 lambda 表达式采用类似的方法：

template<typename... VARIABLES , typename BODY , typename... ARG>
struct evaluate_impl<tml::multi_lambda<BODY,VARIABLES...>,ARGS...>
{
    using result = typename tml::multi_lambda<BODY,VARIABLES...>::template result<ARGS...>;
};

但是，tml::eval不是工作(如一个变量对应项(，而是实例化默认evaluate_impl实现的第三种情况，或者由于不明确的专用化而失败(情况三与multi_lambda专用化(。

这是一个SSCCE：

//An example function:
template<typename... ARGS>
struct F
{
    using result = std::integral_constant<std::size_t,sizeof...(ARGS)>;
};

//This works fine:
using lambda_1 = tml::lambda<_1,F<_1,_1,_1,_1>>;
using result_1 = tml::eval<lambda_1,int>; //Call the lambda with int as parameter

//This doesn't work:
using lambda_2 = tml::multi_lambda<_1,_2,F<_1,_1,_2,_2>>;
using result_2 = tml::eval<lambda_2,int,int>; //Call the lambda with two int as parameters.

lambda_2的评估失败，并显示：

functional.hpp:167:76: error: ambiguous class template instantiation for 'struct tml::impl::evaluate_impl<tml::impl::multi_lambda<tml::placeholders::_1, tml::placeholders::_2, f<tml::placeholders::_1, tml::placeholders::_1, tml::placeholders::_2, tml::placeholders::_2> >, int, int>' using eval = typename impl::evaluate_impl<EXPRESSION , ARGS...>::result; ^ functional.hpp:116:16: error: candidates are: struct tml::impl::evaluate_impl<F<PLACEHOLDERS ...>, ARG, ARGS ...> struct evaluate_impl<F<PLACEHOLDERS...> , ARG , ARGS...> : ^ In file included from main.cpp:24:0: lambda.hpp:160:16: error: struct tml::impl::evaluate_impl<tml::impl::multi_lambda<BODY, VARIABLES ...>, ARGS ...> struct evaluate_impl<multi_lambda<BODY,VARIABLES...>,ARGS...> :

我正在使用GCC4.8.2