2

我正在寻找一种惯用的方法来为类型列表中的每个元素应用类型级转换。到目前为止，我想出了以下内容，它按预期工作：

namespace impl_
{
template <template <typename> typename, typename>
struct MapVariant;
template <template <typename> typename F, typename... Ts>
struct MapVariant<F, std::variant<Ts...>>
{
    using Result = std::variant<F<Ts>...>;
};
}

template <typename Variant, template <typename> typename Transform>
using MapVariant = typename impl_::MapVariant<Transform, Variant>::Result;

测试：

using TestVariant = std::variant<int, char, std::array<float, 0>>;

template <typename Arg>
using TypeTransform = std::array<Arg, 0>;

static_assert(
    std::is_same_v<MapVariant<TestVariant, TypeTransform>,                                             //
                   std::variant<std::array<int, 0>, std::array<char, 0>, std::array<std::array<float, 0>, 0>>  //
                   >);

现在我想概括MapVariant接受使用类型列表参数化的任意容器，而不仅仅是std::variant（例如，std::tuple）。我天真的解决方案不起作用：

template <template <typename...> class C, template <typename> typename F, typename... Ts>
using MapVariant = C<F<Ts>...>;

这是一种更接近原始方法的更详细的方法，但也是功能失调的：

namespace impl_
{
template <template <typename> typename, typename, template <typename...> class, typename>
struct MapVariant;
template <template <typename> typename F, typename Unused, template <typename...> class C, typename... Ts>
struct MapVariant<F, Unused, C, C<Ts...>>
{
    using Result = C<F<Ts>...>;
};
}
template <template <typename...> class Variant, template <typename> typename Transform, typename... Ts>
using MapVariant = typename impl_::MapVariant<Transform, Variant<Ts...>, Variant, Ts...>::Result;

Clang 说“模板模板参数的模板参数必须是类模板或类型别名模板”。我知道编译器无法解包TestVariant，因为在定义时，某些类型信息显然丢失了using，但我不明白如何解决这个问题。

有可能做到这一点吗？

4

2 回答 2

3

感谢Fureeish，我设法通过一个微不足道的改变来解决这个问题：

template <template <typename> typename, typename>
struct MapVariant;
template <template <typename...> class C, template <typename> typename F, typename... Ts>
struct MapVariant<F, C<Ts...>>
{
    using Result = C<F<Ts>...>;
};

外部别名不需要更改。关键的区别是模板参数的顺序不正确——如果我多注意它，我会注意到的。嗯。再次感谢，Fureeish。

于 2022-01-30T13:22:35.450 回答
1

我会用函数而不是模板来做到这一点。清洁器。

template<class T>struct tag_t{using type=T;};
template<class T>constexpr tag_t<T> tag{};
template<template<class...>class Z>
struct ztag_t{
  template<class...Ts>using result=Z<Ts...>;
  template<class...Ts>
  constexpr auto operator()(tag_t<Ts>...)const{ return tag<result<Ts...>>; }
};
template<template<class...>class Z>
constexpr ztag_t<Z> ztag{};
template<class Tag>
using type_t=typename Tag::type;
#define TYPE_T(...) type_t<decltype(__VA_ARGS__)>

template <template<class...>class Z,class...Ts>
constexpr auto fmap(auto f, tag_t<Z<Ts...>>){
  return f(tag<Ts>...);
};

采用：

using bob=std::tuple<int,double,char>;
using as_var=TYPE_T(fmap(ztag<std::variant>, tag<bob>));

是不是很漂亮。

大概有错别字。

于 2022-01-30T13:42:44.860 回答