Boost Hana 实现自定义序列

Question

我面临的情况是，我通常会通过继承 boost::hana::tuple 来创建自定义 class。例如，通过使用以下代码，

template<typename ... args>
struct my_nonworking_custom_tuple_t : public boost::hana::tuple<args ...> //not working!!!
{
    using base = boost::hana::tuple<args ...>;
    //... all other stuff

    auto my_getter() const { return base::operator[](1_c); }
};

但是，这不起作用，因为 boost::hana::tuple 实现为 final。

看来我不得不使用组合，

template<typename ... args>
struct my_custom_tuple_t
{
    //... all other stuff
    boost::hana::tuple<args ...> tup;
    auto my_getter() const { return tup[1_c]; }
};

但是，一旦我这样做，生成的 class 就不再对 Hana 概念建模 "Sequence"，因此我无法应用所有方便的 Hana 方法。

我需要做什么才能将 my_custom_tuple_t 变成 Hana 序列？

Answer 1

通常您不需要这样做，但这里有一个指南，用于实现您自己的 Sequence 以及满足 Boost.Hana 中其他概念的要求。（后者应该对不提供自己的元组实现的最终用户有用。）

从 hana::Sequence

文档中的 最小完整定义 (MCD) 开始

您会看到要实现 Sequence，您的数据类型必须实现 make 功能并满足 Iterable and Foldable.

的要求

因此，您必须为其提供实现的 Hana 函数的完整列表如下：

at
drop_front
is_empty
make
unpack

此外，请注意 Boost.Hana 有两个元组类型 tuple 和 basic_tuple。 basic_tuple 重量更轻，因此您应该使用它来存放。

要使用 Boost.Hana 的标签分发，您可以实施 hana::tag_of 或简单地提供一个 hana_tag 类型别名作为 class.[=31= 的成员]

#include <boost/hana.hpp>
#include <utility>

namespace mine {
    struct my_custom_tuple_tag { };

    template<typename ... args>
    struct my_custom_tuple_t {
        using hana_tag = my_custom_tuple_tag;
        //... all other stuff
        boost::hana::basic_tuple<args ...> tup;

        auto my_getter() const {
            return boost::hana::at_c<1>(tup);
        }
    };
}

namespace boost::hana {
    // Iterable

    template <>
    struct at_impl<mine::my_custom_tuple_tag> {
        template <typename Xs, typename N>
        static constexpr decltype(auto) apply(Xs&& xs, N const&) {
            return at_impl<basic_tuple_tag>(std::forward<Xs>(xs).tup, N{});
        }
    };

    template <>
    struct drop_front_impl<mine::my_custom_tuple_tag> {
        template <typename Xs, typename N>
        static constexpr auto apply(Xs&& xs, N const&) {
            return drop_front_impl<basic_tuple_tag>(std::forward<Xs>(xs).tup);
        }
    };

    template <>
    struct is_empty_impl<mine::my_custom_tuple_tag> {
        template <typename Xs>
        static constexpr auto apply(Xs const& xs) {
            return is_empty_impl<basic_tuple_tag>(xs).tup;
        }
    };

    // Foldable

    template <>
    struct unpack_impl<mine::my_custom_tuple_tag> {
        template <typename Xs, typename F>
        static constexpr auto apply(Xs&& xs, F&& f) {
            return unpack_impl<basic_tuple_tag>(std::forward<Xs>(xs).tup,
                                                std::forward<F>(f));
        }
    };

    // Sequence

    template <>
    struct make_impl<mine::my_custom_tuple_tag> {
        template <typename ...Args>
        static constexpr auto apply(Args&& ...args) {
            return make_impl<basic_tuple_tag>(std::forward<Args>(args)...);
        }
    };

    template <>
    struct Sequence<mine::my_custom_tuple_tag> : std::true_type { };
}

值得注意的是，用于检查 Sequence 的模板只是一个可选的模板专业化。我确信这只是节省编译时计算的捷径，因为其他概念依赖于检查其所需函数的非默认实现。

https://godbolt.org/z/iaYBFq

Boost Hana 实现自定义序列

Boost Hana Implement a custom Sequence

c++

boost-hana