?????????? ????????? - ??????????????? - /home/agenciai/public_html/cd38d8/hana.zip
???????
PK �\�[|:X repeat.hppnu �[��� /*! @file Defines `boost::hana::repeat`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_REPEAT_HPP #define BOOST_HANA_REPEAT_HPP #include <boost/hana/fwd/repeat.hpp> #include <boost/hana/concept/integral_constant.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN template <typename I, bool condition> struct repeat_impl<I, when<condition>> : default_ { template <typename F, std::size_t ...i> static constexpr void repeat_helper(F&& f, std::index_sequence<i...>) { using Swallow = std::size_t[]; (void)Swallow{0, ((void)f(), i)...}; } template <typename N, typename F> static constexpr auto apply(N const&, F&& f) { static_assert(N::value >= 0, "hana::repeat(n, f) requires 'n' to be non-negative"); constexpr std::size_t n = N::value; repeat_helper(static_cast<F&&>(f), std::make_index_sequence<n>{}); } }; //! @cond template <typename N, typename F> constexpr void repeat_t::operator()(N const& n, F&& f) const { using I = typename hana::tag_of<N>::type; using Repeat = BOOST_HANA_DISPATCH_IF(repeat_impl<I>, hana::IntegralConstant<I>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::IntegralConstant<I>::value, "hana::repeat(n, f) requires 'n' to be an IntegralConstant"); #endif return Repeat::apply(n, static_cast<F&&>(f)); } //! @endcond BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_REPEAT_HPP PK �\�[^��A A count_if.hppnu �[��� /*! @file Defines `boost::hana::count_if`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_COUNT_IF_HPP #define BOOST_HANA_COUNT_IF_HPP #include <boost/hana/fwd/count_if.hpp> #include <boost/hana/concept/foldable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/algorithm.hpp> #include <boost/hana/detail/fast_and.hpp> #include <boost/hana/integral_constant.hpp> #include <boost/hana/unpack.hpp> #include <cstddef> #include <type_traits> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Pred> constexpr auto count_if_t::operator()(Xs&& xs, Pred&& pred) const { using S = typename hana::tag_of<Xs>::type; using CountIf = BOOST_HANA_DISPATCH_IF(count_if_impl<S>, hana::Foldable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Foldable<S>::value, "hana::count_if(xs, pred) requires 'xs' to be Foldable"); #endif return CountIf::apply(static_cast<Xs&&>(xs), static_cast<Pred&&>(pred)); } //! @endcond namespace detail { template <typename Pred> struct count_pred { Pred pred; template <typename ...Xs, typename = typename std::enable_if< detail::fast_and< Constant<decltype((*pred)(std::declval<Xs&&>()))>::value... >::value >::type> constexpr auto operator()(Xs&& ...xs) const { constexpr bool results[] = {false, // <-- avoid empty array static_cast<bool>(hana::value<decltype((*pred)(static_cast<Xs&&>(xs)))>())... }; constexpr std::size_t total = detail::count( results, results + sizeof(results), true ); return hana::size_c<total>; } template <typename ...Xs, typename = void, typename = typename std::enable_if< !detail::fast_and< Constant<decltype((*pred)(std::declval<Xs&&>()))>::value... >::value >::type> constexpr auto operator()(Xs&& ...xs) const { std::size_t total = 0; using Swallow = std::size_t[]; (void)Swallow{0, ((*pred)(static_cast<Xs&&>(xs)) ? ++total : 0)...}; return total; } }; } template <typename T, bool condition> struct count_if_impl<T, when<condition>> : default_ { template <typename Xs, typename Pred> static constexpr decltype(auto) apply(Xs&& xs, Pred&& pred) { // We use a pointer instead of a reference to avoid a Clang ICE. return hana::unpack(static_cast<Xs&&>(xs), detail::count_pred<decltype(&pred)>{&pred} ); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_COUNT_IF_HPP PK �\�[F�!�� � group.hppnu �[��� /*! @file Defines `boost::hana::group`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_GROUP_HPP #define BOOST_HANA_GROUP_HPP #include <boost/hana/fwd/group.hpp> #include <boost/hana/at.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/detail/algorithm.hpp> #include <boost/hana/detail/array.hpp> #include <boost/hana/detail/nested_by.hpp> // required by fwd decl #include <boost/hana/equal.hpp> #include <boost/hana/length.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs> constexpr auto group_t::operator()(Xs&& xs) const { using S = typename hana::tag_of<Xs>::type; using Group = BOOST_HANA_DISPATCH_IF(group_impl<S>, hana::Sequence<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Sequence<S>::value, "hana::group(xs) requires 'xs' to be a Sequence"); #endif return Group::apply(static_cast<Xs&&>(xs)); } template <typename Xs, typename Predicate> constexpr auto group_t::operator()(Xs&& xs, Predicate&& pred) const { using S = typename hana::tag_of<Xs>::type; using Group = BOOST_HANA_DISPATCH_IF(group_impl<S>, hana::Sequence<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Sequence<S>::value, "hana::group(xs, predicate) requires 'xs' to be a Sequence"); #endif return Group::apply(static_cast<Xs&&>(xs), static_cast<Predicate&&>(pred)); } //! @endcond namespace detail { template <typename Xs, std::size_t ...i> constexpr auto get_subsequence_(Xs&& xs, std::index_sequence<i...>) { using S = typename hana::tag_of<Xs>::type; return hana::make<S>(hana::at_c<i>(static_cast<Xs&&>(xs))...); } template <std::size_t offset, typename Indices> struct offset_by; template <std::size_t offset, std::size_t ...i> struct offset_by<offset, std::index_sequence<i...>> { using type = std::index_sequence<(offset + i)...>; }; template <bool ...b> struct group_indices { static constexpr bool bs[sizeof...(b)] = {b...}; static constexpr std::size_t n_groups = detail::count(bs, bs + sizeof(bs), false) + 1; static constexpr auto compute_info() { detail::array<std::size_t, n_groups> sizes{}, offsets{}; for (std::size_t g = 0, i = 0, offset = 0; g < n_groups; ++g) { offsets[g] = offset; sizes[g] = 1; while (i < sizeof...(b) && bs[i++]) ++sizes[g]; offset += sizes[g]; } return std::make_pair(offsets, sizes); } static constexpr auto info = compute_info(); static constexpr auto group_offsets = info.first; static constexpr auto group_sizes = info.second; template <typename S, typename Xs, std::size_t ...i> static constexpr auto finish(Xs&& xs, std::index_sequence<i...>) { return hana::make<S>( detail::get_subsequence_( static_cast<Xs&&>(xs), typename offset_by< group_offsets[i], std::make_index_sequence<group_sizes[i]> >::type{} )... ); } }; } // end namespace detail template <typename S, bool condition> struct group_impl<S, when<condition>> : default_ { template <typename Xs, typename Pred, std::size_t ...i> static constexpr auto group_helper(Xs&& xs, Pred&& pred, std::index_sequence<0, i...>) { using info = detail::group_indices<static_cast<bool>(decltype( pred(hana::at_c<i - 1>(static_cast<Xs&&>(xs)), hana::at_c<i>(static_cast<Xs&&>(xs))) )::value)...>; return info::template finish<S>(static_cast<Xs&&>(xs), std::make_index_sequence<info::n_groups>{} ); } template <typename Xs, typename Pred> static constexpr auto group_helper(Xs&& xs, Pred&&, std::index_sequence<0>) { return hana::make<S>(static_cast<Xs&&>(xs)); } template <typename Xs, typename Pred> static constexpr auto group_helper(Xs&&, Pred&&, std::index_sequence<>) { return hana::make<S>(); } template <typename Xs, typename Pred> static constexpr auto apply(Xs&& xs, Pred&& pred) { constexpr std::size_t len = decltype(hana::length(xs))::value; return group_helper(static_cast<Xs&&>(xs), static_cast<Pred&&>(pred), std::make_index_sequence<len>{}); } template <typename Xs> static constexpr auto apply(Xs&& xs) { return group_impl::apply(static_cast<Xs&&>(xs), hana::equal); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_GROUP_HPP PK �\�[�Z# # front.hppnu �[��� /*! @file Defines `boost::hana::front`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FRONT_HPP #define BOOST_HANA_FRONT_HPP #include <boost/hana/fwd/front.hpp> #include <boost/hana/at.hpp> #include <boost/hana/concept/iterable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs> constexpr decltype(auto) front_t::operator()(Xs&& xs) const { using It = typename hana::tag_of<Xs>::type; using Front = BOOST_HANA_DISPATCH_IF(front_impl<It>, hana::Iterable<It>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Iterable<It>::value, "hana::front(xs) requires 'xs' to be an Iterable"); #endif return Front::apply(static_cast<Xs&&>(xs)); } //! @endcond template <typename It, bool condition> struct front_impl<It, when<condition>> : default_ { template <typename Xs> static constexpr decltype(auto) apply(Xs&& xs) { return hana::at_c<0>(static_cast<Xs&&>(xs)); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FRONT_HPP PK �\�[ġz� scan_right.hppnu �[��� /*! @file Defines `boost::hana::scan_right`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_SCAN_RIGHT_HPP #define BOOST_HANA_SCAN_RIGHT_HPP #include <boost/hana/fwd/scan_right.hpp> #include <boost/hana/at.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/empty.hpp> #include <boost/hana/front.hpp> #include <boost/hana/length.hpp> #include <boost/hana/prepend.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename F> constexpr auto scan_right_t::operator()(Xs&& xs, F const& f) const { using S = typename hana::tag_of<Xs>::type; using ScanRight = BOOST_HANA_DISPATCH_IF(scan_right_impl<S>, hana::Sequence<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Sequence<S>::value, "hana::scan_right(xs, f) requires 'xs' to be a Sequence"); #endif return ScanRight::apply(static_cast<Xs&&>(xs), f); } template <typename Xs, typename State, typename F> constexpr auto scan_right_t::operator()(Xs&& xs, State&& state, F const& f) const { using S = typename hana::tag_of<Xs>::type; using ScanRight = BOOST_HANA_DISPATCH_IF(scan_right_impl<S>, hana::Sequence<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Sequence<S>::value, "hana::scan_right(xs, state, f) requires 'xs' to be a Sequence"); #endif return ScanRight::apply(static_cast<Xs&&>(xs), static_cast<State&&>(state), f); } //! @endcond template <typename S, bool condition> struct scan_right_impl<S, when<condition>> : default_ { // Without initial state template <typename Xs, typename F, std::size_t n1, std::size_t n2, std::size_t ...ns> static constexpr auto apply1_impl(Xs&& xs, F const& f, std::index_sequence<n1, n2, ns...>) { auto rest = scan_right_impl::apply1_impl(static_cast<Xs&&>(xs), f, std::index_sequence<n2, ns...>{}); auto element = f(hana::at_c<n1>(static_cast<Xs&&>(xs)), hana::front(rest)); return hana::prepend(std::move(rest), std::move(element)); } template <typename Xs, typename F, std::size_t n> static constexpr auto apply1_impl(Xs&& xs, F const&, std::index_sequence<n>) { return hana::make<S>(hana::at_c<n>(static_cast<Xs&&>(xs))); } template <typename Xs, typename F> static constexpr auto apply1_impl(Xs&&, F const&, std::index_sequence<>) { return hana::empty<S>(); } template <typename Xs, typename F> static constexpr auto apply(Xs&& xs, F const& f) { constexpr std::size_t Len = decltype(hana::length(xs))::value; return scan_right_impl::apply1_impl(static_cast<Xs&&>(xs), f, std::make_index_sequence<Len>{}); } // With initial state template <typename Xs, typename State, typename F, std::size_t n1, std::size_t n2, std::size_t ...ns> static constexpr auto apply_impl(Xs&& xs, State&& state, F const& f, std::index_sequence<n1, n2, ns...>) { auto rest = scan_right_impl::apply_impl(static_cast<Xs&&>(xs), static_cast<State&&>(state), f, std::index_sequence<n2, ns...>{}); auto element = f(hana::at_c<n1>(static_cast<Xs&&>(xs)), hana::front(rest)); return hana::prepend(std::move(rest), std::move(element)); } template <typename Xs, typename State, typename F, std::size_t n> static constexpr auto apply_impl(Xs&& xs, State&& state, F const& f, std::index_sequence<n>) { auto element = f(hana::at_c<n>(static_cast<Xs&&>(xs)), state); return hana::make<S>(std::move(element), static_cast<State&&>(state)); } template <typename Xs, typename State, typename F> static constexpr auto apply_impl(Xs&&, State&& state, F const&, std::index_sequence<>) { return hana::make<S>(static_cast<State&&>(state)); } template <typename Xs, typename State, typename F> static constexpr auto apply(Xs&& xs, State&& state, F const& f) { constexpr std::size_t Len = decltype(hana::length(xs))::value; return scan_right_impl::apply_impl(static_cast<Xs&&>(xs), static_cast<State&&>(state), f, std::make_index_sequence<Len>{}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_SCAN_RIGHT_HPP PK �\�[!f�� � adapt_struct.hppnu �[��� /*! @file Defines the `BOOST_HANA_ADAPT_STRUCT` macro. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_ADAPT_STRUCT_HPP #define BOOST_HANA_ADAPT_STRUCT_HPP #include <boost/hana/fwd/adapt_struct.hpp> #include <boost/hana/detail/struct_macros.hpp> #endif // !BOOST_HANA_ADAPT_STRUCT_HPP PK �\�[y��� fuse.hppnu �[��� /*! @file Defines `boost::hana::fuse`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FUSE_HPP #define BOOST_HANA_FUSE_HPP #include <boost/hana/fwd/fuse.hpp> #include <boost/hana/config.hpp> #include <boost/hana/detail/decay.hpp> #include <boost/hana/unpack.hpp> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <typename F> struct fused { F f; template <typename Xs> constexpr decltype(auto) operator()(Xs&& xs) const& { return hana::unpack(static_cast<Xs&&>(xs), f); } template <typename Xs> constexpr decltype(auto) operator()(Xs&& xs) & { return hana::unpack(static_cast<Xs&&>(xs), f); } template <typename Xs> constexpr decltype(auto) operator()(Xs&& xs) && { return hana::unpack(static_cast<Xs&&>(xs), static_cast<F&&>(f)); } }; } //! @cond template <typename F> constexpr auto fuse_t::operator()(F&& f) const { return detail::fused<typename detail::decay<F>::type>{static_cast<F&&>(f)}; } //! @endcond BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FUSE_HPP PK �\�[�Dck k any_of.hppnu �[��� /*! @file Defines `boost::hana::any_of`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_ANY_OF_HPP #define BOOST_HANA_ANY_OF_HPP #include <boost/hana/fwd/any_of.hpp> #include <boost/hana/accessors.hpp> #include <boost/hana/at.hpp> #include <boost/hana/bool.hpp> #include <boost/hana/concept/searchable.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/concept/struct.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/drop_front.hpp> #include <boost/hana/first.hpp> #include <boost/hana/front.hpp> #include <boost/hana/functional/compose.hpp> #include <boost/hana/if.hpp> #include <boost/hana/is_empty.hpp> #include <boost/hana/length.hpp> #include <cstddef> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Pred> constexpr auto any_of_t::operator()(Xs&& xs, Pred&& pred) const { using S = typename hana::tag_of<Xs>::type; using AnyOf = BOOST_HANA_DISPATCH_IF(any_of_impl<S>, hana::Searchable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Searchable<S>::value, "hana::any_of(xs, pred) requires 'xs' to be a Searchable"); #endif return AnyOf::apply(static_cast<Xs&&>(xs), static_cast<Pred&&>(pred)); } //! @endcond template <typename S, bool condition> struct any_of_impl<S, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; template <typename S> struct any_of_impl<S, when<Sequence<S>::value>> { //! @cond template <std::size_t k, std::size_t Len> struct any_of_helper { template <typename Xs, typename Pred> static constexpr auto apply(bool prev_cond, Xs&& xs, Pred&& pred) { return prev_cond ? hana::true_c : any_of_impl::any_of_helper<k + 1, Len>::apply( hana::if_(pred(hana::at_c<k>(xs)), hana::true_c, hana::false_c), static_cast<Xs&&>(xs), static_cast<Pred&&>(pred) ); } template <typename Xs, typename Pred> static constexpr auto apply(hana::true_, Xs&&, Pred&&) { return hana::true_c; } template <typename Xs, typename Pred> static constexpr auto apply(hana::false_, Xs&& xs, Pred&& pred) { auto cond = hana::if_(pred(hana::at_c<k>(xs)), hana::true_c, hana::false_c); return any_of_impl::any_of_helper<k + 1, Len>::apply(cond, static_cast<Xs&&>(xs), static_cast<Pred&&>(pred)); } }; template <std::size_t Len> struct any_of_helper<Len, Len> { template <typename Cond, typename Xs, typename Pred> static constexpr auto apply(Cond cond, Xs&&, Pred&&) { return cond; } }; template <typename Xs, typename Pred> static constexpr auto apply(Xs&& xs, Pred&& pred) { constexpr std::size_t len = decltype(hana::length(xs))::value; return any_of_impl::any_of_helper<0, len>::apply(hana::false_c, static_cast<Xs&&>(xs), static_cast<Pred&&>(pred)); } //! @endcond }; template <typename It> struct any_of_impl<It, when< hana::Iterable<It>::value && !Sequence<It>::value >> { template <typename Xs, typename Pred> static constexpr auto lazy_any_of_helper(hana::false_, bool prev_cond, Xs&& xs, Pred&& pred) { decltype(auto) tail = hana::drop_front(static_cast<Xs&&>(xs)); constexpr bool done = decltype(hana::is_empty(tail))::value; return prev_cond ? hana::true_c : lazy_any_of_helper(hana::bool_<done>{}, hana::if_(pred(hana::front(xs)), hana::true_{}, hana::false_{}), static_cast<decltype(tail)&&>(tail), static_cast<Pred&&>(pred) ); } template <typename Xs, typename Pred> static constexpr auto lazy_any_of_helper(hana::false_, hana::true_, Xs&&, Pred&&) { return hana::true_c; } template <typename Xs, typename Pred> static constexpr auto lazy_any_of_helper(hana::false_, hana::false_, Xs&& xs, Pred&& pred) { constexpr bool done = decltype(hana::is_empty(hana::drop_front(xs)))::value; return lazy_any_of_helper(hana::bool_c<done>, hana::if_(pred(hana::front(xs)), hana::true_c, hana::false_c), hana::drop_front(static_cast<Xs&&>(xs)), static_cast<Pred&&>(pred) ); } template <typename Cond, typename Xs, typename Pred> static constexpr auto lazy_any_of_helper(hana::true_, Cond cond, Xs&&, Pred&&) { return cond; } template <typename Xs, typename Pred> static constexpr auto apply(Xs&& xs, Pred&& pred) { constexpr bool done = decltype(hana::is_empty(xs))::value; return lazy_any_of_helper(hana::bool_c<done>, hana::false_c, static_cast<Xs&&>(xs), static_cast<Pred&&>(pred)); } }; template <typename T, std::size_t N> struct any_of_impl<T[N]> { template <typename Xs, typename Pred> static constexpr bool any_of_helper(bool cond, Xs&& xs, Pred&& pred) { if (cond) return true; for (std::size_t i = 1; i < N; ++i) if (pred(static_cast<Xs&&>(xs)[i])) return true; return false; } // Since an array contains homogeneous data, if the predicate returns // a compile-time logical at any index, it must do so at every index // (because the type of the elements won't change)! In this case, we // then only need to evaluate the predicate on the first element. template <typename Xs, typename Pred> static constexpr auto any_of_helper(hana::true_, Xs&& /*xs*/, Pred&&) { return hana::true_c; } template <typename Xs, typename Pred> static constexpr auto any_of_helper(hana::false_, Xs&&, Pred&&) { return hana::false_c; } template <typename Xs, typename Pred> static constexpr auto apply(Xs&& xs, Pred&& pred) { auto cond = hana::if_(pred(static_cast<Xs&&>(xs)[0]), hana::true_c, hana::false_c); return any_of_helper(cond, static_cast<Xs&&>(xs), static_cast<Pred&&>(pred)); } }; template <typename S> struct any_of_impl<S, when<hana::Struct<S>::value>> { template <typename X, typename Pred> static constexpr decltype(auto) apply(X const&, Pred&& pred) { return hana::any_of(hana::accessors<S>(), hana::compose(static_cast<Pred&&>(pred), hana::first)); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_ANY_OF_HPP PK �\�[�� lazy.hppnu �[��� /*! @file Defines `boost::hana::lazy`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_LAZY_HPP #define BOOST_HANA_LAZY_HPP #include <boost/hana/fwd/lazy.hpp> #include <boost/hana/basic_tuple.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/detail/decay.hpp> #include <boost/hana/detail/operators/adl.hpp> #include <boost/hana/detail/operators/monad.hpp> #include <boost/hana/functional/apply.hpp> #include <boost/hana/functional/compose.hpp> #include <boost/hana/functional/on.hpp> #include <boost/hana/fwd/ap.hpp> #include <boost/hana/fwd/duplicate.hpp> #include <boost/hana/fwd/eval.hpp> #include <boost/hana/fwd/extend.hpp> #include <boost/hana/fwd/extract.hpp> #include <boost/hana/fwd/flatten.hpp> #include <boost/hana/fwd/lift.hpp> #include <boost/hana/fwd/transform.hpp> #include <cstddef> #include <type_traits> #include <utility> BOOST_HANA_NAMESPACE_BEGIN ////////////////////////////////////////////////////////////////////////// // lazy ////////////////////////////////////////////////////////////////////////// template <typename Indices, typename F, typename ...Args> struct lazy_apply_t; namespace detail { struct lazy_secret { }; } template <std::size_t ...n, typename F, typename ...Args> struct lazy_apply_t<std::index_sequence<n...>, F, Args...> : detail::operators::adl<> { template <typename ...T> constexpr lazy_apply_t(detail::lazy_secret, T&& ...t) : storage_{static_cast<T&&>(t)...} { } basic_tuple<F, Args...> storage_; using hana_tag = lazy_tag; }; template <typename X> struct lazy_value_t : detail::operators::adl<> { template <typename Y> constexpr lazy_value_t(detail::lazy_secret, Y&& y) : storage_{static_cast<Y&&>(y)} { } basic_tuple<X> storage_; using hana_tag = lazy_tag; // If this is called, we assume that `X` is in fact a function. template <typename ...Args> constexpr lazy_apply_t< std::make_index_sequence<sizeof...(Args)>, X, typename detail::decay<Args>::type... > operator()(Args&& ...args) const& { return {detail::lazy_secret{}, hana::at_c<0>(storage_), static_cast<Args&&>(args)...}; } template <typename ...Args> constexpr lazy_apply_t< std::make_index_sequence<sizeof...(Args)>, X, typename detail::decay<Args>::type... > operator()(Args&& ...args) && { return {detail::lazy_secret{}, static_cast<X&&>(hana::at_c<0>(storage_)), static_cast<Args&&>(args)... }; } }; ////////////////////////////////////////////////////////////////////////// // make<lazy_tag> ////////////////////////////////////////////////////////////////////////// template <> struct make_impl<lazy_tag> { template <typename X> static constexpr lazy_value_t<typename detail::decay<X>::type> apply(X&& x) { return {detail::lazy_secret{}, static_cast<X&&>(x)}; } }; ////////////////////////////////////////////////////////////////////////// // Operators ////////////////////////////////////////////////////////////////////////// namespace detail { template <> struct monad_operators<lazy_tag> { static constexpr bool value = true; }; } ////////////////////////////////////////////////////////////////////////// // eval for lazy_tag ////////////////////////////////////////////////////////////////////////// template <> struct eval_impl<lazy_tag> { // lazy_apply_t template <std::size_t ...n, typename F, typename ...Args> static constexpr decltype(auto) apply(lazy_apply_t<std::index_sequence<n...>, F, Args...> const& expr) { return hana::at_c<0>(expr.storage_)( hana::at_c<n+1>(expr.storage_)... ); } template <std::size_t ...n, typename F, typename ...Args> static constexpr decltype(auto) apply(lazy_apply_t<std::index_sequence<n...>, F, Args...>& expr) { return hana::at_c<0>(expr.storage_)( hana::at_c<n+1>(expr.storage_)... ); } template <std::size_t ...n, typename F, typename ...Args> static constexpr decltype(auto) apply(lazy_apply_t<std::index_sequence<n...>, F, Args...>&& expr) { return static_cast<F&&>(hana::at_c<0>(expr.storage_))( static_cast<Args&&>(hana::at_c<n+1>(expr.storage_))... ); } // lazy_value_t template <typename X> static constexpr X const& apply(lazy_value_t<X> const& expr) { return hana::at_c<0>(expr.storage_); } template <typename X> static constexpr X& apply(lazy_value_t<X>& expr) { return hana::at_c<0>(expr.storage_); } template <typename X> static constexpr X apply(lazy_value_t<X>&& expr) { return static_cast<X&&>(hana::at_c<0>(expr.storage_)); } }; ////////////////////////////////////////////////////////////////////////// // Functor ////////////////////////////////////////////////////////////////////////// template <> struct transform_impl<lazy_tag> { template <typename Expr, typename F> static constexpr auto apply(Expr&& expr, F&& f) { return hana::make_lazy(hana::compose(static_cast<F&&>(f), hana::eval))( static_cast<Expr&&>(expr) ); } }; ////////////////////////////////////////////////////////////////////////// // Applicative ////////////////////////////////////////////////////////////////////////// template <> struct lift_impl<lazy_tag> { template <typename X> static constexpr lazy_value_t<typename detail::decay<X>::type> apply(X&& x) { return {detail::lazy_secret{}, static_cast<X&&>(x)}; } }; template <> struct ap_impl<lazy_tag> { template <typename F, typename X> static constexpr decltype(auto) apply(F&& f, X&& x) { return hana::make_lazy(hana::on(hana::apply, hana::eval))( static_cast<F&&>(f), static_cast<X&&>(x) ); } }; ////////////////////////////////////////////////////////////////////////// // Monad ////////////////////////////////////////////////////////////////////////// template <> struct flatten_impl<lazy_tag> { template <typename Expr> static constexpr decltype(auto) apply(Expr&& expr) { return hana::make_lazy(hana::compose(hana::eval, hana::eval))( static_cast<Expr&&>(expr) ); } }; ////////////////////////////////////////////////////////////////////////// // Comonad ////////////////////////////////////////////////////////////////////////// template <> struct extract_impl<lazy_tag> { template <typename Expr> static constexpr decltype(auto) apply(Expr&& expr) { return hana::eval(static_cast<Expr&&>(expr)); } }; template <> struct duplicate_impl<lazy_tag> { template <typename Expr> static constexpr decltype(auto) apply(Expr&& expr) { return hana::make_lazy(static_cast<Expr&&>(expr)); } }; template <> struct extend_impl<lazy_tag> { template <typename Expr, typename F> static constexpr decltype(auto) apply(Expr&& expr, F&& f) { return hana::make_lazy(static_cast<F&&>(f))(static_cast<Expr&&>(expr)); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_LAZY_HPP PK �\�[?��Tb b core.hppnu �[��� /*! @file Defines the @ref group-core module. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CORE_HPP #define BOOST_HANA_CORE_HPP #include <boost/hana/core/common.hpp> #include <boost/hana/core/to.hpp> #include <boost/hana/core/default.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/is_a.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/core/when.hpp> #endif // !BOOST_HANA_CORE_HPP PK �\�[�1�� � unfold_left.hppnu �[��� /*! @file Defines `boost::hana::unfold_left`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_UNFOLD_LEFT_HPP #define BOOST_HANA_UNFOLD_LEFT_HPP #include <boost/hana/fwd/unfold_left.hpp> #include <boost/hana/append.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/empty.hpp> #include <boost/hana/first.hpp> #include <boost/hana/functional/partial.hpp> #include <boost/hana/optional.hpp> #include <boost/hana/second.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename S> struct unfold_left_t { #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Sequence<S>::value, "hana::unfold_left<S> requires 'S' to be a Sequence"); #endif template <typename State, typename F> constexpr auto operator()(State&& state, F&& f) const { return unfold_left_impl<S>::apply( static_cast<State&&>(state), static_cast<F&&>(f) ); } }; //! @endcond template <typename S, bool condition> struct unfold_left_impl<S, when<condition>> : default_ { struct unfold_left_helper { template <typename F, typename P> constexpr auto operator()(F&& f, P&& p) const { return hana::append( unfold_left_impl::apply( hana::first(static_cast<P&&>(p)), static_cast<F&&>(f) ), hana::second(static_cast<P&&>(p)) ); } }; template <typename Init, typename F> static constexpr auto apply(Init&& init, F&& f) { decltype(auto) elt = f(static_cast<Init&&>(init)); return hana::maybe(empty<S>(), hana::partial(unfold_left_helper{}, static_cast<F&&>(f)), static_cast<decltype(elt)&&>(elt) ); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_UNFOLD_LEFT_HPP PK �\�[�$�`� � one.hppnu �[��� /*! @file Defines `boost::hana::one`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_ONE_HPP #define BOOST_HANA_ONE_HPP #include <boost/hana/fwd/one.hpp> #include <boost/hana/concept/constant.hpp> #include <boost/hana/concept/ring.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/to.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/canonical_constant.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename R> constexpr decltype(auto) one_t<R>::operator()() const { #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Ring<R>::value, "hana::one<R>() requires 'R' to be a Ring"); #endif using One = BOOST_HANA_DISPATCH_IF(one_impl<R>, hana::Ring<R>::value ); return One::apply(); } //! @endcond template <typename R, bool condition> struct one_impl<R, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; ////////////////////////////////////////////////////////////////////////// // Model for non-boolean arithmetic data types ////////////////////////////////////////////////////////////////////////// template <typename T> struct one_impl<T, when<std::is_arithmetic<T>::value && !std::is_same<bool, T>::value>> { static constexpr T apply() { return static_cast<T>(1); } }; ////////////////////////////////////////////////////////////////////////// // Model for Constants over a Ring ////////////////////////////////////////////////////////////////////////// namespace detail { template <typename C> struct constant_from_one { static constexpr auto value = hana::one<typename C::value_type>(); using hana_tag = detail::CanonicalConstant<typename C::value_type>; }; } template <typename C> struct one_impl<C, when< hana::Constant<C>::value && Ring<typename C::value_type>::value >> { static constexpr decltype(auto) apply() { return hana::to<C>(detail::constant_from_one<C>{}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_ONE_HPP PK �\�[� �� � monadic_fold_left.hppnu �[��� /*! @file Defines `boost::hana::monadic_fold_left`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_MONADIC_FOLD_LEFT_HPP #define BOOST_HANA_MONADIC_FOLD_LEFT_HPP #include <boost/hana/fwd/monadic_fold_left.hpp> #include <boost/hana/chain.hpp> #include <boost/hana/concept/foldable.hpp> #include <boost/hana/concept/monad.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/decay.hpp> #include <boost/hana/fold_right.hpp> #include <boost/hana/functional/curry.hpp> #include <boost/hana/functional/partial.hpp> #include <boost/hana/lift.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename M> template <typename Xs, typename State, typename F> constexpr decltype(auto) monadic_fold_left_t<M>::operator()(Xs&& xs, State&& state, F&& f) const { using S = typename hana::tag_of<Xs>::type; using MonadicFoldLeft = BOOST_HANA_DISPATCH_IF(monadic_fold_left_impl<S>, hana::Foldable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Monad<M>::value, "hana::monadic_fold_left<M> requires 'M' to be a Monad"); static_assert(hana::Foldable<S>::value, "hana::monadic_fold_left<M>(xs, state, f) requires 'xs' to be Foldable"); #endif return MonadicFoldLeft::template apply<M>(static_cast<Xs&&>(xs), static_cast<State&&>(state), static_cast<F&&>(f)); } //! @endcond //! @cond template <typename M> template <typename Xs, typename F> constexpr decltype(auto) monadic_fold_left_t<M>::operator()(Xs&& xs, F&& f) const { using S = typename hana::tag_of<Xs>::type; using MonadicFoldLeft = BOOST_HANA_DISPATCH_IF(monadic_fold_left_impl<S>, hana::Foldable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Monad<M>::value, "hana::monadic_fold_left<M> requires 'M' to be a Monad"); static_assert(hana::Foldable<S>::value, "hana::monadic_fold_left<M>(xs, f) requires 'xs' to be Foldable"); #endif return MonadicFoldLeft::template apply<M>(static_cast<Xs&&>(xs), static_cast<F&&>(f)); } //! @endcond namespace detail { struct foldlM_helper { template <typename F, typename X, typename K, typename Z> constexpr decltype(auto) operator()(F&& f, X&& x, K&& k, Z&& z) const { return hana::chain( static_cast<F&&>(f)( static_cast<Z&&>(z), static_cast<X&&>(x) ), static_cast<K&&>(k) ); } }; template <typename End, typename M, typename F> struct monadic_foldl1_helper { F f; template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) const { return f(static_cast<X&&>(x), static_cast<Y&&>(y)); } template <typename Y> constexpr decltype(auto) operator()(End, Y&& y) const { return hana::lift<M>(static_cast<Y&&>(y)); } }; } template <typename T, bool condition> struct monadic_fold_left_impl<T, when<condition>> : default_ { // with state template <typename M, typename Xs, typename S, typename F> static constexpr decltype(auto) apply(Xs&& xs, S&& s, F&& f) { return hana::fold_right( static_cast<Xs&&>(xs), hana::lift<M>, hana::curry<3>(hana::partial( detail::foldlM_helper{}, static_cast<F&&>(f) )) )(static_cast<S&&>(s)); } // without state template <typename M, typename Xs, typename F> static constexpr decltype(auto) apply(Xs&& xs, F&& f) { struct end { }; using G = detail::monadic_foldl1_helper<end, M, typename detail::decay<F>::type>; decltype(auto) result = hana::monadic_fold_left<M>( static_cast<Xs&&>(xs), end{}, G{static_cast<F&&>(f)} ); static_assert(!std::is_same< std::remove_reference_t<decltype(result)>, decltype(hana::lift<M>(end{})) >{}, "hana::monadic_fold_left<M>(xs, f) requires 'xs' to be non-empty"); return result; } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_MONADIC_FOLD_LEFT_HPP PK �\�[�ݤ� � zip_with.hppnu �[��� /*! @file Defines `boost::hana::zip_with`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_ZIP_WITH_HPP #define BOOST_HANA_ZIP_WITH_HPP #include <boost/hana/fwd/zip_with.hpp> #include <boost/hana/at.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/detail/fast_and.hpp> #include <boost/hana/length.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename F, typename Xs, typename ...Ys> constexpr auto zip_with_t::operator()(F&& f, Xs&& xs, Ys&& ...ys) const { #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(detail::fast_and< hana::Sequence<Xs>::value, hana::Sequence<Ys>::value... >::value, "hana::zip_with(f, xs, ys...) requires 'xs' and 'ys...' to be Sequences"); #endif return zip_with_impl<typename hana::tag_of<Xs>::type>::apply( static_cast<F&&>(f), static_cast<Xs&&>(xs), static_cast<Ys&&>(ys)... ); } //! @endcond template <typename S> struct zip_with_impl<S, when<Sequence<S>::value>> { template <std::size_t N, typename F, typename ...Xs> static constexpr decltype(auto) transverse(F&& f, Xs&& ...xs) { return static_cast<F&&>(f)(hana::at_c<N>(static_cast<Xs&&>(xs))...); } template <std::size_t ...N, typename F, typename ...Xs> static constexpr auto zip_helper(std::index_sequence<N...>, F&& f, Xs&& ...xs) { return hana::make<S>(transverse<N>(f, xs...)...); } template <typename F, typename X, typename ...Xs> static constexpr auto apply(F&& f, X&& x, Xs&& ...xs) { constexpr std::size_t N = decltype(hana::length(x))::value; return zip_helper(std::make_index_sequence<N>{}, static_cast<F&&>(f), static_cast<X&&>(x), static_cast<Xs&&>(xs)...); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_ZIP_WITH_HPP PK �\�[�$��5 5 append.hppnu �[��� /*! @file Defines `boost::hana::append`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_APPEND_HPP #define BOOST_HANA_APPEND_HPP #include <boost/hana/fwd/append.hpp> #include <boost/hana/at.hpp> #include <boost/hana/concat.hpp> #include <boost/hana/concept/monad_plus.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/length.hpp> #include <boost/hana/lift.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename X> constexpr auto append_t::operator()(Xs&& xs, X&& x) const { using M = typename hana::tag_of<Xs>::type; using Append = BOOST_HANA_DISPATCH_IF(append_impl<M>, hana::MonadPlus<M>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::MonadPlus<M>::value, "hana::append(xs, x) requires 'xs' to be a MonadPlus"); #endif return Append::apply(static_cast<Xs&&>(xs), static_cast<X&&>(x)); } //! @endcond template <typename M, bool condition> struct append_impl<M, when<condition>> : default_ { template <typename Xs, typename X> static constexpr auto apply(Xs&& xs, X&& x) { return hana::concat(static_cast<Xs&&>(xs), hana::lift<M>(static_cast<X&&>(x))); } }; template <typename S> struct append_impl<S, when<Sequence<S>::value>> { template <typename Xs, typename X, std::size_t ...i> static constexpr auto append_helper(Xs&& xs, X&& x, std::index_sequence<i...>) { return hana::make<S>( hana::at_c<i>(static_cast<Xs&&>(xs))..., static_cast<X&&>(x) ); } template <typename Xs, typename X> static constexpr auto apply(Xs&& xs, X&& x) { constexpr std::size_t N = decltype(hana::length(xs))::value; return append_helper(static_cast<Xs&&>(xs), static_cast<X&&>(x), std::make_index_sequence<N>{}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_APPEND_HPP PK �\�[�h� � flatten.hppnu �[��� /*! @file Defines `boost::hana::flatten`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FLATTEN_HPP #define BOOST_HANA_FLATTEN_HPP #include <boost/hana/fwd/flatten.hpp> #include <boost/hana/concept/monad.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/detail/unpack_flatten.hpp> #include <boost/hana/functional/id.hpp> #include <boost/hana/fwd/chain.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs> constexpr auto flatten_t::operator()(Xs&& xs) const { using M = typename hana::tag_of<Xs>::type; using Flatten = BOOST_HANA_DISPATCH_IF(flatten_impl<M>, hana::Monad<M>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Monad<M>::value, "hana::flatten(xs) requires 'xs' to be a Monad"); #endif return Flatten::apply(static_cast<Xs&&>(xs)); } //! @endcond template <typename M, bool condition> struct flatten_impl<M, when<condition>> : default_ { template <typename Xs> static constexpr auto apply(Xs&& xs) { return hana::chain(static_cast<Xs&&>(xs), hana::id); } }; template <typename S> struct flatten_impl<S, when<Sequence<S>::value>> { template <typename Xs> static constexpr auto apply(Xs&& xs) { return detail::unpack_flatten(static_cast<Xs&&>(xs), hana::make<S>); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FLATTEN_HPP PK �\�[ �'� � fill.hppnu �[��� /*! @file Defines `boost::hana::fill`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FILL_HPP #define BOOST_HANA_FILL_HPP #include <boost/hana/fwd/fill.hpp> #include <boost/hana/concept/functor.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/functional/always.hpp> #include <boost/hana/transform.hpp> #include <boost/hana/unpack.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Value> constexpr auto fill_t::operator()(Xs&& xs, Value&& value) const { using S = typename hana::tag_of<Xs>::type; using Fill = BOOST_HANA_DISPATCH_IF(fill_impl<S>, hana::Functor<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Functor<S>::value, "hana::fill(xs, value) requires 'xs' to be a Functor"); #endif return Fill::apply(static_cast<Xs&&>(xs), static_cast<Value&&>(value)); } //! @endcond template <typename Fun, bool condition> struct fill_impl<Fun, when<condition>> : default_ { template <typename Xs, typename Value> static constexpr auto apply(Xs&& xs, Value&& v) { return hana::transform(static_cast<Xs&&>(xs), hana::always(static_cast<Value&&>(v)) ); } }; template <typename S> struct fill_impl<S, when<Sequence<S>::value>> { //! @cond template <typename V> struct filler { V const& v; template <typename ...Xs> constexpr auto operator()(Xs const& ...xs) const { return hana::make<S>(((void)xs, v)...); } }; //! @endcond template <typename Xs, typename V> static constexpr auto apply(Xs const& xs, V const& v) { return hana::unpack(xs, filler<V>{v}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FILL_HPP PK �\�[�)G�L L intersection.hppnu �[��� /*! @file Defines `boost::hana::intersection`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_INTERSECTION_HPP #define BOOST_HANA_INTERSECTION_HPP #include <boost/hana/fwd/intersection.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Ys> constexpr auto intersection_t::operator()(Xs&& xs, Ys&& ys) const { using S = typename hana::tag_of<Xs>::type; using Intersection = BOOST_HANA_DISPATCH_IF(intersection_impl<S>, true ); return Intersection::apply(static_cast<Xs&&>(xs), static_cast<Ys&&>(ys)); } //! @endcond template <typename S, bool condition> struct intersection_impl<S, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_INTERSECTION_HPP PK �\�['u��� � functional.hppnu �[��� /*! @file Defines the @ref group-functional module. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FUNCTIONAL_HPP #define BOOST_HANA_FUNCTIONAL_HPP #include <boost/hana/functional/always.hpp> #include <boost/hana/functional/apply.hpp> #include <boost/hana/functional/arg.hpp> #include <boost/hana/functional/capture.hpp> #include <boost/hana/functional/compose.hpp> #include <boost/hana/functional/curry.hpp> #include <boost/hana/functional/demux.hpp> #include <boost/hana/functional/fix.hpp> #include <boost/hana/functional/flip.hpp> #include <boost/hana/functional/id.hpp> #include <boost/hana/functional/infix.hpp> #include <boost/hana/functional/iterate.hpp> #include <boost/hana/functional/lockstep.hpp> #include <boost/hana/functional/on.hpp> #include <boost/hana/functional/overload.hpp> #include <boost/hana/functional/overload_linearly.hpp> #include <boost/hana/functional/partial.hpp> #include <boost/hana/functional/placeholder.hpp> #include <boost/hana/functional/reverse_partial.hpp> #endif // !BOOST_HANA_FUNCTIONAL_HPP PK �\�[����x x empty.hppnu �[��� /*! @file Defines `boost::hana::empty`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EMPTY_HPP #define BOOST_HANA_EMPTY_HPP #include <boost/hana/fwd/empty.hpp> #include <boost/hana/concept/monad_plus.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename M> constexpr auto empty_t<M>::operator()() const { #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::MonadPlus<M>::value, "hana::empty<M>() requires 'M' to be a MonadPlus"); #endif using Empty = BOOST_HANA_DISPATCH_IF(empty_impl<M>, hana::MonadPlus<M>::value ); return Empty::apply(); } //! @endcond template <typename M, bool condition> struct empty_impl<M, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; template <typename S> struct empty_impl<S, when<Sequence<S>::value>> { static constexpr auto apply() { return hana::make<S>(); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_EMPTY_HPP PK �\�[G�B}� � min.hppnu �[��� /*! @file Defines `boost::hana::min`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_MIN_HPP #define BOOST_HANA_MIN_HPP #include <boost/hana/fwd/min.hpp> #include <boost/hana/concept/orderable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/if.hpp> #include <boost/hana/less.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename X, typename Y> constexpr decltype(auto) min_t::operator()(X&& x, Y&& y) const { using T = typename hana::tag_of<X>::type; using U = typename hana::tag_of<Y>::type; using Min = BOOST_HANA_DISPATCH_IF(decltype(min_impl<T, U>{}), hana::Orderable<T>::value && hana::Orderable<U>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Orderable<T>::value, "hana::min(x, y) requires 'x' to be Orderable"); static_assert(hana::Orderable<U>::value, "hana::min(x, y) requires 'y' to be Orderable"); #endif return Min::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); } //! @endcond template <typename T, typename U, bool condition> struct min_impl<T, U, when<condition>> : default_ { template <typename X, typename Y> static constexpr decltype(auto) apply(X&& x, Y&& y) { decltype(auto) cond = hana::less(x, y); return hana::if_(static_cast<decltype(cond)&&>(cond), static_cast<X&&>(x), static_cast<Y&&>(y) ); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_MIN_HPP PK �\�[:r^]� � integral_constant.hppnu �[��� /*! @file Defines `boost::hana::integral_constant`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_INTEGRAL_CONSTANT_HPP #define BOOST_HANA_INTEGRAL_CONSTANT_HPP #include <boost/hana/bool.hpp> #endif // !BOOST_HANA_INTEGRAL_CONSTANT_HPP PK �\�[?�9k k transform.hppnu �[��� /*! @file Defines `boost::hana::transform`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_TRANSFORM_HPP #define BOOST_HANA_TRANSFORM_HPP #include <boost/hana/fwd/transform.hpp> #include <boost/hana/bool.hpp> #include <boost/hana/concept/functor.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/functional/always.hpp> #include <boost/hana/fwd/adjust_if.hpp> #include <boost/hana/unpack.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename F> constexpr auto transform_t::operator()(Xs&& xs, F&& f) const { using S = typename hana::tag_of<Xs>::type; using Transform = BOOST_HANA_DISPATCH_IF(transform_impl<S>, hana::Functor<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Functor<S>::value, "hana::transform(xs, f) requires 'xs' to be a Functor"); #endif return Transform::apply(static_cast<Xs&&>(xs), static_cast<F&&>(f)); } //! @endcond template <typename Fun, bool condition> struct transform_impl<Fun, when<condition>> : default_ { template <typename Xs, typename F> static constexpr auto apply(Xs&& xs, F&& f) { return hana::adjust_if(static_cast<Xs&&>(xs), hana::always(hana::true_c), static_cast<F&&>(f)); } }; template <typename S> struct transform_impl<S, when<Sequence<S>::value>> { //! @cond template <typename F> struct transformer { F f; template <typename ...Xs> constexpr auto operator()(Xs&& ...xs) const { return hana::make<S>((*f)(static_cast<Xs&&>(xs))...); } }; //! @endcond template <typename Xs, typename F> static constexpr auto apply(Xs&& xs, F&& f) { // We use a pointer to workaround a Clang 3.5 ICE return hana::unpack(static_cast<Xs&&>(xs), transformer<decltype(&f)>{&f}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_TRANSFORM_HPP PK �\�[#v9� � replicate.hppnu �[��� /*! @file Defines `boost::hana::replicate`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_REPLICATE_HPP #define BOOST_HANA_REPLICATE_HPP #include <boost/hana/fwd/replicate.hpp> #include <boost/hana/concept/integral_constant.hpp> #include <boost/hana/concept/monad_plus.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/cycle.hpp> #include <boost/hana/lift.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename M> template <typename X, typename N> constexpr auto replicate_t<M>::operator()(X&& x, N const& n) const { using Replicate = BOOST_HANA_DISPATCH_IF(replicate_impl<M>, hana::MonadPlus<M>::value && hana::IntegralConstant<N>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::MonadPlus<M>::value, "hana::replicate<M>(x, n) requires 'M' to be a MonadPlus"); static_assert(hana::IntegralConstant<N>::value, "hana::replicate<M>(x, n) requires 'n' to be an IntegralConstant"); #endif return Replicate::apply(static_cast<X&&>(x), n); } //! @endcond template <typename M, bool condition> struct replicate_impl<M, when<condition>> : default_ { template <typename X, typename N> static constexpr auto apply(X&& x, N const& n) { return hana::cycle(hana::lift<M>(static_cast<X&&>(x)), n); } }; template <typename S> struct replicate_impl<S, when<Sequence<S>::value>> { template <typename X, std::size_t ...i> static constexpr auto replicate_helper(X&& x, std::index_sequence<i...>) { return hana::make<S>(((void)i, x)...); } template <typename X, typename N> static constexpr auto apply(X&& x, N const&) { constexpr std::size_t n = N::value; return replicate_helper(static_cast<X&&>(x), std::make_index_sequence<n>{}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_REPLICATE_HPP PK �\�[�W�Ҷ& �& range.hppnu �[��� /*! @file Defines `boost::hana::range`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_RANGE_HPP #define BOOST_HANA_RANGE_HPP #include <boost/hana/fwd/range.hpp> #include <boost/hana/bool.hpp> #include <boost/hana/concept/integral_constant.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/common.hpp> #include <boost/hana/core/to.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/detail/operators/adl.hpp> #include <boost/hana/detail/operators/comparable.hpp> #include <boost/hana/detail/operators/iterable.hpp> #include <boost/hana/fwd/at.hpp> #include <boost/hana/fwd/back.hpp> #include <boost/hana/fwd/contains.hpp> #include <boost/hana/fwd/drop_front.hpp> #include <boost/hana/fwd/drop_front_exactly.hpp> #include <boost/hana/fwd/equal.hpp> #include <boost/hana/fwd/find.hpp> #include <boost/hana/fwd/front.hpp> #include <boost/hana/fwd/is_empty.hpp> #include <boost/hana/fwd/length.hpp> #include <boost/hana/fwd/maximum.hpp> #include <boost/hana/fwd/minimum.hpp> #include <boost/hana/fwd/product.hpp> #include <boost/hana/fwd/sum.hpp> #include <boost/hana/fwd/unpack.hpp> #include <boost/hana/integral_constant.hpp> // required by fwd decl and below #include <boost/hana/optional.hpp> #include <boost/hana/value.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN ////////////////////////////////////////////////////////////////////////// // range<> ////////////////////////////////////////////////////////////////////////// //! @cond template <typename T, T From, T To> struct range : detail::operators::adl<range<T, From, To>> , detail::iterable_operators<range<T, From, To>> { static_assert(From <= To, "hana::make_range(from, to) requires 'from <= to'"); using value_type = T; static constexpr value_type from = From; static constexpr value_type to = To; }; //! @endcond template <typename T, T From, T To> struct tag_of<range<T, From, To>> { using type = range_tag; }; ////////////////////////////////////////////////////////////////////////// // make<range_tag> ////////////////////////////////////////////////////////////////////////// template <> struct make_impl<range_tag> { template <typename From, typename To> static constexpr auto apply(From const&, To const&) { #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::IntegralConstant<From>::value, "hana::make_range(from, to) requires 'from' to be an IntegralConstant"); static_assert(hana::IntegralConstant<To>::value, "hana::make_range(from, to) requires 'to' to be an IntegralConstant"); #endif using T = typename common< typename hana::tag_of<From>::type::value_type, typename hana::tag_of<To>::type::value_type >::type; constexpr T from = hana::to<T>(From::value); constexpr T to = hana::to<T>(To::value); return range<T, from, to>{}; } }; ////////////////////////////////////////////////////////////////////////// // Operators ////////////////////////////////////////////////////////////////////////// namespace detail { template <> struct comparable_operators<range_tag> { static constexpr bool value = true; }; } ////////////////////////////////////////////////////////////////////////// // Comparable ////////////////////////////////////////////////////////////////////////// template <> struct equal_impl<range_tag, range_tag> { template <typename R1, typename R2> static constexpr auto apply(R1 const&, R2 const&) { return hana::bool_c< (R1::from == R1::to && R2::from == R2::to) || (R1::from == R2::from && R1::to == R2::to) >; } }; ////////////////////////////////////////////////////////////////////////// // Foldable ////////////////////////////////////////////////////////////////////////// template <> struct unpack_impl<range_tag> { template <typename T, T from, typename F, T ...v> static constexpr decltype(auto) unpack_helper(F&& f, std::integer_sequence<T, v...>) { return static_cast<F&&>(f)(integral_constant<T, from + v>{}...); } template <typename T, T from, T to, typename F> static constexpr decltype(auto) apply(range<T, from, to> const&, F&& f) { return unpack_helper<T, from>(static_cast<F&&>(f), std::make_integer_sequence<T, to - from>{}); } }; template <> struct length_impl<range_tag> { template <typename T, T from, T to> static constexpr auto apply(range<T, from, to> const&) { return hana::size_c<static_cast<std::size_t>(to - from)>; } }; template <> struct minimum_impl<range_tag> { template <typename T, T from, T to> static constexpr auto apply(range<T, from, to> const&) { return integral_c<T, from>; } }; template <> struct maximum_impl<range_tag> { template <typename T, T from, T to> static constexpr auto apply(range<T, from, to> const&) { return integral_c<T, to-1>; } }; template <> struct sum_impl<range_tag> { // Returns the sum of `[m, n]`, where `m <= n` always hold. template <typename I> static constexpr I sum_helper(I m, I n) { if (m == n) return m; // 0 == m < n else if (0 == m) return n * (n+1) / 2; // 0 < m < n else if (0 < m) return sum_helper(0, n) - sum_helper(0, m-1); // m < 0 <= n else if (0 <= n) return sum_helper(0, n) - sum_helper(0, -m); // m < n < 0 else return -sum_helper(-n, -m); } template <typename, typename T, T from, T to> static constexpr auto apply(range<T, from, to> const&) { return integral_c<T, from == to ? 0 : sum_helper(from, to-1)>; } }; template <> struct product_impl<range_tag> { // Returns the product of `[m, n)`, where `m <= n` always hold. template <typename I> static constexpr I product_helper(I m, I n) { if (m <= 0 && 0 < n) return 0; else { I p = 1; for (; m != n; ++m) p *= m; return p; } } template <typename, typename T, T from, T to> static constexpr auto apply(range<T, from, to> const&) { return integral_c<T, product_helper(from, to)>; } }; ////////////////////////////////////////////////////////////////////////// // Searchable ////////////////////////////////////////////////////////////////////////// template <> struct find_impl<range_tag> { template <typename T, T from, typename N> static constexpr auto find_helper(hana::true_) { constexpr T n = N::value; return hana::just(hana::integral_c<T, n>); } template <typename T, T from, typename N> static constexpr auto find_helper(hana::false_) { return hana::nothing; } template <typename T, T from, T to, typename N> static constexpr auto apply(range<T, from, to> const&, N const&) { constexpr auto n = N::value; return find_helper<T, from, N>(hana::bool_c<(n >= from && n < to)>); } }; template <> struct contains_impl<range_tag> { template <typename T, T from, T to, typename N> static constexpr auto apply(range<T, from, to> const&, N const&) { constexpr auto n = N::value; return bool_c<(n >= from && n < to)>; } }; ////////////////////////////////////////////////////////////////////////// // Iterable ////////////////////////////////////////////////////////////////////////// template <> struct front_impl<range_tag> { template <typename T, T from, T to> static constexpr auto apply(range<T, from, to> const&) { return integral_c<T, from>; } }; template <> struct is_empty_impl<range_tag> { template <typename T, T from, T to> static constexpr auto apply(range<T, from, to> const&) { return bool_c<from == to>; } }; template <> struct at_impl<range_tag> { template <typename T, T from, T to, typename N> static constexpr auto apply(range<T, from, to> const&, N const&) { constexpr auto n = N::value; return integral_c<T, from + n>; } }; template <> struct back_impl<range_tag> { template <typename T, T from, T to> static constexpr auto apply(range<T, from, to> const&) { return integral_c<T, to - 1>; } }; template <> struct drop_front_impl<range_tag> { template <typename T, T from, T to, typename N> static constexpr auto apply(range<T, from, to> const&, N const&) { constexpr auto n = N::value; return range<T, (to < from + n ? to : from + n), to>{}; } }; template <> struct drop_front_exactly_impl<range_tag> { template <typename T, T from, T to, typename N> static constexpr auto apply(range<T, from, to> const&, N const&) { constexpr auto n = N::value; return range<T, from + n, to>{}; } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_RANGE_HPP PK �\�[OJ�{� � scan_left.hppnu �[��� /*! @file Defines `boost::hana::scan_left`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_SCAN_LEFT_HPP #define BOOST_HANA_SCAN_LEFT_HPP #include <boost/hana/fwd/scan_left.hpp> #include <boost/hana/at.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/empty.hpp> #include <boost/hana/length.hpp> #include <boost/hana/prepend.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename F> constexpr auto scan_left_t::operator()(Xs&& xs, F const& f) const { using S = typename hana::tag_of<Xs>::type; using ScanLeft = BOOST_HANA_DISPATCH_IF(scan_left_impl<S>, hana::Sequence<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Sequence<S>::value, "hana::scan_left(xs, f) requires 'xs' to be a Sequence"); #endif return ScanLeft::apply(static_cast<Xs&&>(xs), f); } template <typename Xs, typename State, typename F> constexpr auto scan_left_t::operator()(Xs&& xs, State&& state, F const& f) const { using S = typename hana::tag_of<Xs>::type; using ScanLeft = BOOST_HANA_DISPATCH_IF(scan_left_impl<S>, hana::Sequence<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Sequence<S>::value, "hana::scan_left(xs, state, f) requires 'xs' to be a Sequence"); #endif return ScanLeft::apply(static_cast<Xs&&>(xs), static_cast<State&&>(state), f); } //! @endcond template <typename S, bool condition> struct scan_left_impl<S, when<condition>> : default_ { // Without initial state template <typename Xs, typename F, std::size_t n1, std::size_t n2, std::size_t ...ns> static constexpr auto apply1_impl(Xs&& xs, F const& f, std::index_sequence<n1, n2, ns...>) { static_assert(n1 == 0, "logic error in Boost.Hana: file a bug report"); // Use scan_left with the first element as an initial state. return scan_left_impl::apply_impl( static_cast<Xs&&>(xs), hana::at_c<0>(static_cast<Xs&&>(xs)), f, std::index_sequence<n2, ns...>{} ); } template <typename Xs, typename F, std::size_t n> static constexpr auto apply1_impl(Xs&& xs, F const&, std::index_sequence<n>) { return hana::make<S>(hana::at_c<n>(static_cast<Xs&&>(xs))); } template <typename Xs, typename F> static constexpr auto apply1_impl(Xs&&, F const&, std::index_sequence<>) { return hana::empty<S>(); } template <typename Xs, typename F> static constexpr auto apply(Xs&& xs, F const& f) { constexpr std::size_t Len = decltype(hana::length(xs))::value; return scan_left_impl::apply1_impl(static_cast<Xs&&>(xs), f, std::make_index_sequence<Len>{}); } // With initial state template <typename Xs, typename State, typename F, std::size_t n1, std::size_t n2, std::size_t ...ns> static constexpr auto apply_impl(Xs&& xs, State&& state, F const& f, std::index_sequence<n1, n2, ns...>) { auto rest = scan_left_impl::apply_impl( static_cast<Xs&&>(xs), f(state, hana::at_c<n1>(static_cast<Xs&&>(xs))), f, std::index_sequence<n2, ns...>{}); return hana::prepend(std::move(rest), static_cast<State&&>(state)); } template <typename Xs, typename State, typename F, std::size_t n> static constexpr auto apply_impl(Xs&& xs, State&& state, F const& f, std::index_sequence<n>) { auto new_state = f(state, hana::at_c<n>(static_cast<Xs&&>(xs))); return hana::make<S>(static_cast<State&&>(state), std::move(new_state)); } template <typename Xs, typename State, typename F> static constexpr auto apply_impl(Xs&&, State&& state, F const&, std::index_sequence<>) { return hana::make<S>(static_cast<State&&>(state)); } template <typename Xs, typename State, typename F> static constexpr auto apply(Xs&& xs, State&& state, F const& f) { constexpr std::size_t Len = decltype(hana::length(xs))::value; return scan_left_impl::apply_impl(static_cast<Xs&&>(xs), static_cast<State&&>(state), f, std::make_index_sequence<Len>{}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_SCAN_LEFT_HPP PK �\�[���< < none.hppnu �[��� /*! @file Defines `boost::hana::none`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_NONE_HPP #define BOOST_HANA_NONE_HPP #include <boost/hana/fwd/none.hpp> #include <boost/hana/concept/searchable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/functional/id.hpp> #include <boost/hana/none_of.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs> constexpr auto none_t::operator()(Xs&& xs) const { using S = typename hana::tag_of<Xs>::type; using None = BOOST_HANA_DISPATCH_IF(none_impl<S>, hana::Searchable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Searchable<S>::value, "hana::none(xs) requires 'xs' to be a Searchable"); #endif return None::apply(static_cast<Xs&&>(xs)); } //! @endcond template <typename S, bool condition> struct none_impl<S, when<condition>> : default_ { template <typename Xs> static constexpr auto apply(Xs&& xs) { return hana::none_of(static_cast<Xs&&>(xs), hana::id); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_NONE_HPP PK �\�[{�� � find_if.hppnu �[��� /*! @file Defines `boost::hana::find_if`. @copyright Louis Dionne 2013-2017 @copyright Jason Rice 2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FIND_IF_HPP #define BOOST_HANA_FIND_IF_HPP #include <boost/hana/fwd/find_if.hpp> #include <boost/hana/accessors.hpp> #include <boost/hana/at.hpp> #include <boost/hana/bool.hpp> #include <boost/hana/concept/iterable.hpp> #include <boost/hana/concept/searchable.hpp> #include <boost/hana/concept/struct.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/first.hpp> #include <boost/hana/functional/compose.hpp> #include <boost/hana/index_if.hpp> #include <boost/hana/second.hpp> #include <boost/hana/transform.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Pred> constexpr auto find_if_t::operator()(Xs&& xs, Pred&& pred) const { using S = typename hana::tag_of<Xs>::type; using FindIf = BOOST_HANA_DISPATCH_IF(find_if_impl<S>, hana::Searchable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Searchable<S>::value, "hana::find_if(xs, pred) requires 'xs' to be a Searchable"); #endif return FindIf::apply(static_cast<Xs&&>(xs), static_cast<Pred&&>(pred)); } //! @endcond template <typename S, bool condition> struct find_if_impl<S, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; namespace detail { template <typename Xs> struct partial_at { Xs const& xs; template <typename I> constexpr decltype(auto) operator()(I i) const { return hana::at(xs, i); } }; } template <typename Tag> struct find_if_impl<Tag, when<Iterable<Tag>::value>> { template <typename Xs, typename Pred> static constexpr auto apply(Xs&& xs, Pred&& pred) { using Result = decltype(hana::index_if( static_cast<Xs&&>(xs), static_cast<Pred&&>(pred))); return hana::transform(Result{}, detail::partial_at<std::decay_t<Xs>>{static_cast<Xs&&>(xs)}); } }; template <typename T, std::size_t N> struct find_if_impl<T[N]> { template <typename Xs> static constexpr auto find_if_helper(Xs&&, hana::false_) { return hana::nothing; } template <typename Xs> static constexpr auto find_if_helper(Xs&& xs, hana::true_) { return hana::just(static_cast<Xs&&>(xs)[0]); } template <typename Xs, typename Pred> static constexpr auto apply(Xs&& xs, Pred&& pred) { return find_if_helper(static_cast<Xs&&>(xs), hana::bool_c<decltype( static_cast<Pred&&>(pred)(static_cast<Xs&&>(xs)[0]) )::value> ); } }; namespace struct_detail { template <typename X> struct get_member { X x; template <typename Member> constexpr decltype(auto) operator()(Member&& member) && { return hana::second(static_cast<Member&&>(member))( static_cast<X&&>(x) ); } }; } template <typename S> struct find_if_impl<S, when<hana::Struct<S>::value>> { template <typename X, typename Pred> static constexpr decltype(auto) apply(X&& x, Pred&& pred) { return hana::transform( hana::find_if(hana::accessors<S>(), hana::compose(static_cast<Pred&&>(pred), hana::first) ), struct_detail::get_member<X>{static_cast<X&&>(x)} ); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FIND_IF_HPP PK �\�[��� � index_if.hppnu �[��� /*! @file Defines `boost::hana::index_if`. @copyright Louis Dionne 2013-2017 @copyright Jason Rice 2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_INDEX_IF_HPP #define BOOST_HANA_INDEX_IF_HPP #include <boost/hana/concept/foldable.hpp> #include <boost/hana/concept/iterable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/detail/decay.hpp> #include <boost/hana/detail/index_if.hpp> #include <boost/hana/fwd/at.hpp> #include <boost/hana/fwd/basic_tuple.hpp> #include <boost/hana/fwd/index_if.hpp> #include <boost/hana/integral_constant.hpp> #include <boost/hana/length.hpp> #include <boost/hana/optional.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Pred> constexpr auto index_if_t::operator()(Xs&& xs, Pred&& pred) const { using S = typename hana::tag_of<Xs>::type; using IndexIf = BOOST_HANA_DISPATCH_IF(index_if_impl<S>, hana::Iterable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Iterable<S>::value, "hana::index_if(xs, pred) requires 'xs' to be a Iterable"); #endif return IndexIf::apply(static_cast<Xs&&>(xs), static_cast<Pred&&>(pred)); } //! @endcond namespace detail { template <std::size_t i, std::size_t N, bool Done> struct iterate_while; template <std::size_t i, std::size_t N> struct iterate_while<i, N, false> { template <typename Xs, typename Pred> using f = typename iterate_while<i + 1, N, static_cast<bool>(detail::decay<decltype( std::declval<Pred>()( hana::at(std::declval<Xs>(), hana::size_c<i>)))>::type::value) >::template f<Xs, Pred>; }; template <std::size_t N> struct iterate_while<N, N, false> { template <typename Xs, typename Pred> using f = hana::optional<>; }; template <std::size_t i, std::size_t N> struct iterate_while<i, N, true> { template <typename Xs, typename Pred> using f = hana::optional<hana::size_t<i - 1>>; }; } template <typename Tag> struct index_if_impl<Tag, when<Foldable<Tag>::value>> { template <typename Xs, typename Pred> static constexpr auto apply(Xs const& xs, Pred const&) -> typename detail::iterate_while<0, decltype(hana::length(xs))::value, false> ::template f<Xs, Pred> { return {}; } }; template <typename It> struct index_if_impl<It, when<!Foldable<It>::value>> { template <typename Xs, typename Pred> static constexpr auto apply(Xs const&, Pred const&) -> typename detail::iterate_while<0, static_cast<std::size_t>(-1), false> ::template f<Xs, Pred> { return {}; } }; // basic_tuple is implemented here to solve circular dependency issues. template <> struct index_if_impl<basic_tuple_tag> { template <typename ...Xs, typename Pred> static constexpr auto apply(basic_tuple<Xs...> const&, Pred const&) -> typename detail::index_if<Pred, Xs...>::type { return {}; } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_INDEX_IF_HPP PK �\�[���� � take_while.hppnu �[��� /*! @file Defines `boost::hana::take_while`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_TAKE_WHILE_HPP #define BOOST_HANA_TAKE_WHILE_HPP #include <boost/hana/fwd/take_while.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/first_unsatisfied_index.hpp> #include <boost/hana/take_front.hpp> #include <boost/hana/unpack.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Pred> constexpr auto take_while_t::operator()(Xs&& xs, Pred&& pred) const { using S = typename hana::tag_of<Xs>::type; using TakeWhile = BOOST_HANA_DISPATCH_IF(take_while_impl<S>, hana::Sequence<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Sequence<S>::value, "hana::take_while(xs, pred) requires 'xs' to be a Sequence"); #endif return TakeWhile::apply(static_cast<Xs&&>(xs), static_cast<Pred&&>(pred)); } //! @endcond template <typename S, bool condition> struct take_while_impl<S, when<condition>> : default_ { template <typename Xs, typename Pred> static constexpr auto apply(Xs&& xs, Pred&&) { using FirstUnsatisfied = decltype( hana::unpack(static_cast<Xs&&>(xs), detail::first_unsatisfied_index<Pred&&>{}) ); return hana::take_front(static_cast<Xs&&>(xs), FirstUnsatisfied{}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_TAKE_WHILE_HPP PK �\�[�^1�� � adapt_adt.hppnu �[��� /*! @file Defines the `BOOST_HANA_ADAPT_ADT` macro. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_ADAPT_ADT_HPP #define BOOST_HANA_ADAPT_ADT_HPP #include <boost/hana/fwd/adapt_adt.hpp> #include <boost/hana/detail/struct_macros.hpp> #endif // !BOOST_HANA_ADAPT_ADT_HPP PK �\�[�C�>< >< optional.hppnu �[��� /*! @file Defines `boost::hana::optional`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_OPTIONAL_HPP #define BOOST_HANA_OPTIONAL_HPP #include <boost/hana/fwd/optional.hpp> #include <boost/hana/bool.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/detail/decay.hpp> #include <boost/hana/detail/operators/adl.hpp> #include <boost/hana/detail/operators/comparable.hpp> #include <boost/hana/detail/operators/monad.hpp> #include <boost/hana/detail/operators/orderable.hpp> #include <boost/hana/detail/wrong.hpp> #include <boost/hana/functional/partial.hpp> #include <boost/hana/fwd/any_of.hpp> #include <boost/hana/fwd/ap.hpp> #include <boost/hana/fwd/concat.hpp> #include <boost/hana/fwd/core/make.hpp> #include <boost/hana/fwd/empty.hpp> #include <boost/hana/fwd/equal.hpp> #include <boost/hana/fwd/find_if.hpp> #include <boost/hana/fwd/flatten.hpp> #include <boost/hana/fwd/less.hpp> #include <boost/hana/fwd/lift.hpp> #include <boost/hana/fwd/transform.hpp> #include <boost/hana/fwd/type.hpp> #include <boost/hana/fwd/unpack.hpp> #include <cstddef> // std::nullptr_t #include <type_traits> #include <utility> BOOST_HANA_NAMESPACE_BEGIN ////////////////////////////////////////////////////////////////////////// // optional<> ////////////////////////////////////////////////////////////////////////// namespace detail { template <typename T, typename = typename hana::tag_of<T>::type> struct nested_type { }; template <typename T> struct nested_type<T, type_tag> { using type = typename T::type; }; } template <typename T> struct optional<T> : detail::operators::adl<>, detail::nested_type<T> { // 5.3.1, Constructors constexpr optional() = default; constexpr optional(optional const&) = default; constexpr optional(optional&&) = default; constexpr optional(T const& t) : value_(t) { } constexpr optional(T&& t) : value_(static_cast<T&&>(t)) { } // 5.3.3, Assignment constexpr optional& operator=(optional const&) = default; constexpr optional& operator=(optional&&) = default; // 5.3.5, Observers constexpr T const* operator->() const { return &value_; } constexpr T* operator->() { return &value_; } constexpr T& value() & { return value_; } constexpr T const& value() const& { return value_; } constexpr T&& value() && { return static_cast<T&&>(value_); } constexpr T const&& value() const&& { return static_cast<T const&&>(value_); } constexpr T& operator*() & { return value_; } constexpr T const& operator*() const& { return value_; } constexpr T&& operator*() && { return static_cast<T&&>(value_); } constexpr T const&& operator*() const&& { return static_cast<T const&&>(value_); } template <typename U> constexpr T& value_or(U&&) & { return value_; } template <typename U> constexpr T const& value_or(U&&) const& { return value_; } template <typename U> constexpr T&& value_or(U&&) && { return static_cast<T&&>(value_); } template <typename U> constexpr T const&& value_or(U&&) const&& { return static_cast<T const&&>(value_); } // We leave this public because it simplifies the implementation, but // this should be considered private by users. T value_; }; //! @cond template <typename ...dummy> constexpr auto optional<>::value() const { static_assert(detail::wrong<dummy...>{}, "hana::optional::value() requires a non-empty optional"); } template <typename ...dummy> constexpr auto optional<>::operator*() const { static_assert(detail::wrong<dummy...>{}, "hana::optional::operator* requires a non-empty optional"); } template <typename U> constexpr U&& optional<>::value_or(U&& u) const { return static_cast<U&&>(u); } template <typename T> constexpr auto make_just_t::operator()(T&& t) const { return hana::optional<typename detail::decay<T>::type>(static_cast<T&&>(t)); } //! @endcond template <typename ...T> struct tag_of<optional<T...>> { using type = optional_tag; }; ////////////////////////////////////////////////////////////////////////// // make<optional_tag> ////////////////////////////////////////////////////////////////////////// template <> struct make_impl<optional_tag> { template <typename X> static constexpr auto apply(X&& x) { return hana::just(static_cast<X&&>(x)); } static constexpr auto apply() { return hana::nothing; } }; ////////////////////////////////////////////////////////////////////////// // Operators ////////////////////////////////////////////////////////////////////////// namespace detail { template <> struct comparable_operators<optional_tag> { static constexpr bool value = true; }; template <> struct orderable_operators<optional_tag> { static constexpr bool value = true; }; template <> struct monad_operators<optional_tag> { static constexpr bool value = true; }; } ////////////////////////////////////////////////////////////////////////// // is_just and is_nothing ////////////////////////////////////////////////////////////////////////// //! @cond template <typename ...T> constexpr auto is_just_t::operator()(optional<T...> const&) const { return hana::bool_c<sizeof...(T) != 0>; } template <typename ...T> constexpr auto is_nothing_t::operator()(optional<T...> const&) const { return hana::bool_c<sizeof...(T) == 0>; } //! @endcond ////////////////////////////////////////////////////////////////////////// // sfinae ////////////////////////////////////////////////////////////////////////// namespace detail { struct sfinae_impl { template <typename F, typename ...X, typename = decltype( std::declval<F>()(std::declval<X>()...) )> constexpr decltype(auto) operator()(int, F&& f, X&& ...x) const { using Return = decltype(static_cast<F&&>(f)(static_cast<X&&>(x)...)); static_assert(!std::is_same<Return, void>::value, "hana::sfinae(f)(args...) requires f(args...) to be non-void"); return hana::just(static_cast<F&&>(f)(static_cast<X&&>(x)...)); } template <typename F, typename ...X> constexpr auto operator()(long, F&&, X&& ...) const { return hana::nothing; } }; } //! @cond template <typename F> constexpr decltype(auto) sfinae_t::operator()(F&& f) const { return hana::partial(detail::sfinae_impl{}, int{}, static_cast<F&&>(f)); } //! @endcond ////////////////////////////////////////////////////////////////////////// // Comparable ////////////////////////////////////////////////////////////////////////// template <> struct equal_impl<optional_tag, optional_tag> { template <typename T, typename U> static constexpr auto apply(hana::optional<T> const& t, hana::optional<U> const& u) { return hana::equal(t.value_, u.value_); } static constexpr hana::true_ apply(hana::optional<> const&, hana::optional<> const&) { return {}; } template <typename T, typename U> static constexpr hana::false_ apply(T const&, U const&) { return {}; } }; ////////////////////////////////////////////////////////////////////////// // Orderable ////////////////////////////////////////////////////////////////////////// template <> struct less_impl<optional_tag, optional_tag> { template <typename T> static constexpr hana::true_ apply(hana::optional<> const&, hana::optional<T> const&) { return {}; } static constexpr hana::false_ apply(hana::optional<> const&, hana::optional<> const&) { return {}; } template <typename T> static constexpr hana::false_ apply(hana::optional<T> const&, hana::optional<> const&) { return {}; } template <typename T, typename U> static constexpr auto apply(hana::optional<T> const& x, hana::optional<U> const& y) { return hana::less(x.value_, y.value_); } }; ////////////////////////////////////////////////////////////////////////// // Functor ////////////////////////////////////////////////////////////////////////// template <> struct transform_impl<optional_tag> { template <typename F> static constexpr auto apply(optional<> const&, F&&) { return hana::nothing; } template <typename T, typename F> static constexpr auto apply(optional<T> const& opt, F&& f) { return hana::just(static_cast<F&&>(f)(opt.value_)); } template <typename T, typename F> static constexpr auto apply(optional<T>& opt, F&& f) { return hana::just(static_cast<F&&>(f)(opt.value_)); } template <typename T, typename F> static constexpr auto apply(optional<T>&& opt, F&& f) { return hana::just(static_cast<F&&>(f)(static_cast<T&&>(opt.value_))); } }; ////////////////////////////////////////////////////////////////////////// // Applicative ////////////////////////////////////////////////////////////////////////// template <> struct lift_impl<optional_tag> { template <typename X> static constexpr auto apply(X&& x) { return hana::just(static_cast<X&&>(x)); } }; template <> struct ap_impl<optional_tag> { template <typename F, typename X> static constexpr auto ap_helper(F&&, X&&, ...) { return hana::nothing; } template <typename F, typename X> static constexpr auto ap_helper(F&& f, X&& x, hana::true_, hana::true_) { return hana::just(static_cast<F&&>(f).value_(static_cast<X&&>(x).value_)); } template <typename F, typename X> static constexpr auto apply(F&& f, X&& x) { return ap_impl::ap_helper(static_cast<F&&>(f), static_cast<X&&>(x), hana::is_just(f), hana::is_just(x)); } }; ////////////////////////////////////////////////////////////////////////// // Monad ////////////////////////////////////////////////////////////////////////// template <> struct flatten_impl<optional_tag> { static constexpr auto apply(optional<> const&) { return hana::nothing; } static constexpr auto apply(optional<optional<>> const&) { return hana::nothing; } template <typename T> static constexpr auto apply(optional<optional<T>> const& opt) { return hana::just(opt.value_.value_); } template <typename T> static constexpr auto apply(optional<optional<T>>&& opt) { return hana::just(static_cast<T&&>(opt.value_.value_)); } }; ////////////////////////////////////////////////////////////////////////// // MonadPlus ////////////////////////////////////////////////////////////////////////// template <> struct concat_impl<optional_tag> { template <typename Y> static constexpr auto apply(hana::optional<>&, Y&& y) { return static_cast<Y&&>(y); } template <typename Y> static constexpr auto apply(hana::optional<>&&, Y&& y) { return static_cast<Y&&>(y); } template <typename Y> static constexpr auto apply(hana::optional<> const&, Y&& y) { return static_cast<Y&&>(y); } template <typename X, typename Y> static constexpr auto apply(X&& x, Y&&) { return static_cast<X&&>(x); } }; template <> struct empty_impl<optional_tag> { static constexpr auto apply() { return hana::nothing; } }; ////////////////////////////////////////////////////////////////////////// // Foldable ////////////////////////////////////////////////////////////////////////// template <> struct unpack_impl<optional_tag> { template <typename T, typename F> static constexpr decltype(auto) apply(optional<T>&& opt, F&& f) { return static_cast<F&&>(f)(static_cast<T&&>(opt.value_)); } template <typename T, typename F> static constexpr decltype(auto) apply(optional<T> const& opt, F&& f) { return static_cast<F&&>(f)(opt.value_); } template <typename T, typename F> static constexpr decltype(auto) apply(optional<T>& opt, F&& f) { return static_cast<F&&>(f)(opt.value_); } template <typename F> static constexpr decltype(auto) apply(optional<> const&, F&& f) { return static_cast<F&&>(f)(); } }; ////////////////////////////////////////////////////////////////////////// // Searchable ////////////////////////////////////////////////////////////////////////// namespace detail { template <bool> struct optional_find_if { template <typename T> static constexpr auto apply(T const&) { return hana::nothing; } }; template <> struct optional_find_if<true> { template <typename T> static constexpr auto apply(T&& t) { return hana::just(static_cast<T&&>(t)); } }; } template <> struct find_if_impl<optional_tag> { template <typename T, typename Pred> static constexpr auto apply(hana::optional<T> const& opt, Pred&& pred) { constexpr bool found = decltype(static_cast<Pred&&>(pred)(opt.value_))::value; return detail::optional_find_if<found>::apply(opt.value_); } template <typename T, typename Pred> static constexpr auto apply(hana::optional<T>& opt, Pred&& pred) { constexpr bool found = decltype(static_cast<Pred&&>(pred)(opt.value_))::value; return detail::optional_find_if<found>::apply(opt.value_); } template <typename T, typename Pred> static constexpr auto apply(hana::optional<T>&& opt, Pred&& pred) { constexpr bool found = decltype( static_cast<Pred&&>(pred)(static_cast<T&&>(opt.value_)) )::value; return detail::optional_find_if<found>::apply(static_cast<T&&>(opt.value_)); } template <typename Pred> static constexpr auto apply(hana::optional<> const&, Pred&&) { return hana::nothing; } }; template <> struct any_of_impl<optional_tag> { template <typename T, typename Pred> static constexpr auto apply(hana::optional<T> const& opt, Pred&& pred) { return static_cast<Pred&&>(pred)(opt.value_); } template <typename Pred> static constexpr hana::false_ apply(hana::optional<> const&, Pred&&) { return {}; } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_OPTIONAL_HPP PK �\�[+x� � at_key.hppnu �[��� /*! @file Defines `boost::hana::at_key`. @copyright Louis Dionne 2013-2017 @copyright Jason Rice 2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_AT_KEY_HPP #define BOOST_HANA_AT_KEY_HPP #include <boost/hana/fwd/at_key.hpp> #include <boost/hana/accessors.hpp> #include <boost/hana/at.hpp> #include <boost/hana/concept/searchable.hpp> #include <boost/hana/concept/struct.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/decay.hpp> #include <boost/hana/equal.hpp> #include <boost/hana/find.hpp> #include <boost/hana/find_if.hpp> #include <boost/hana/first.hpp> #include <boost/hana/functional/on.hpp> #include <boost/hana/index_if.hpp> #include <boost/hana/length.hpp> #include <boost/hana/optional.hpp> #include <boost/hana/second.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Key> constexpr decltype(auto) at_key_t::operator()(Xs&& xs, Key const& key) const { using S = typename hana::tag_of<Xs>::type; using AtKey = BOOST_HANA_DISPATCH_IF(at_key_impl<S>, hana::Searchable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Searchable<S>::value, "hana::at_key(xs, key) requires 'xs' to be Searchable"); #endif return AtKey::apply(static_cast<Xs&&>(xs), key); } //! @endcond template <typename S, bool condition> struct at_key_impl<S, when<condition>> : default_ { template <typename Xs, typename Key> static constexpr auto apply(Xs&& xs, Key const& key) { return hana::find(static_cast<Xs&&>(xs), key).value(); } }; namespace at_key_detail { template <typename T> struct equal_to { T const& t; template <typename U> constexpr auto operator()(U const& u) const { return hana::equal(t, u); } }; } template <typename S> struct at_key_impl<S, when<hana::Sequence<S>::value>> { template <typename Xs, typename Key> static constexpr decltype(auto) apply(Xs&& xs, Key const& key) { using Result = decltype(hana::index_if( static_cast<Xs&&>(xs), at_key_detail::equal_to<Key>{key})); return hana::at(static_cast<Xs&&>(xs), Result{}.value()); } }; template <typename S> struct at_key_impl<S, when<hana::Struct<S>::value>> { template <typename X, typename Key> static constexpr decltype(auto) apply(X&& x, Key const& key) { auto accessor = hana::second(*hana::find_if(hana::accessors<S>(), hana::equal.to(key) ^hana::on^ hana::first )); return accessor(static_cast<X&&>(x)); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_AT_KEY_HPP PK �\�[�Ky�� � drop_front_exactly.hppnu �[��� /*! @file Defines `boost::hana::drop_front_exactly`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DROP_FRONT_EXACTLY_HPP #define BOOST_HANA_DROP_FRONT_EXACTLY_HPP #include <boost/hana/fwd/drop_front_exactly.hpp> #include <boost/hana/bool.hpp> #include <boost/hana/concept/integral_constant.hpp> #include <boost/hana/concept/iterable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/drop_front.hpp> #include <boost/hana/integral_constant.hpp> #include <boost/hana/is_empty.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename N> constexpr auto drop_front_exactly_t::operator()(Xs&& xs, N const& n) const { using It = typename hana::tag_of<Xs>::type; using DropFrontExactly = BOOST_HANA_DISPATCH_IF(drop_front_exactly_impl<It>, hana::Iterable<It>::value && hana::IntegralConstant<N>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Iterable<It>::value, "hana::drop_front_exactly(xs, n) requires 'xs' to be an Iterable"); static_assert(hana::IntegralConstant<N>::value, "hana::drop_front_exactly(xs, n) requires 'n' to be an IntegralConstant"); #endif static_assert(N::value >= 0, "hana::drop_front_exactly(xs, n) requires 'n' to be non-negative"); return DropFrontExactly::apply(static_cast<Xs&&>(xs), n); } template <typename Xs> constexpr auto drop_front_exactly_t::operator()(Xs&& xs) const { return (*this)(static_cast<Xs&&>(xs), hana::size_c<1>); } //! @endcond namespace detail { template <typename Xs, typename N> constexpr void check_dfe_overflow(Xs const& xs, N const&, hana::true_) { constexpr bool n_overflew_length = decltype( hana::is_empty(hana::drop_front(xs, hana::size_c<N::value - 1>)) )::value; static_assert(!n_overflew_length, "hana::drop_front_exactly(xs, n) requires 'n' to be less than or " "equal to the number of elements in 'xs'"); } template <typename Xs, typename N> constexpr void check_dfe_overflow(Xs const&, N const&, hana::false_) { } } template <typename It, bool condition> struct drop_front_exactly_impl<It, when<condition>> : default_ { template <typename Xs, typename N> static constexpr auto apply(Xs&& xs, N const& n) { auto result = hana::drop_front(static_cast<Xs&&>(xs), n); constexpr bool check_for_overflow = decltype(hana::is_empty(result))::value && N::value != 0; detail::check_dfe_overflow(xs, n, hana::bool_c<check_for_overflow>); return result; // NRVO applied } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DROP_FRONT_EXACTLY_HPP PK �\�[U� 4r r symmetric_difference.hppnu �[��� /*! @file Defines `boost::hana::symmetric_difference`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_SYMMETRIC_DIFFERENCE_HPP #define BOOST_HANA_SYMMETRIC_DIFFERENCE_HPP #include <boost/hana/fwd/symmetric_difference.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/difference.hpp> #include <boost/hana/union.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Ys> constexpr auto symmetric_difference_t::operator()(Xs&& xs, Ys&& ys) const { using S = typename hana::tag_of<Xs>::type; using SymmetricDifference = BOOST_HANA_DISPATCH_IF(symmetric_difference_impl<S>, true ); return SymmetricDifference::apply(static_cast<Xs&&>(xs), static_cast<Ys&&>(ys)); } //! @endcond template <typename S, bool condition> struct symmetric_difference_impl<S, when<condition>> : default_ { template <typename Xs, typename Ys> static constexpr auto apply(Xs&& xs, Ys&& ys) { return hana::union_( hana::difference(xs, ys), hana::difference(ys, xs) ); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_SYMMETRIC_DIFFERENCE_HPP PK �\�[j�bb' b' type.hppnu �[��� /*! @file Defines `boost::hana::type` and related utilities. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_TYPE_HPP #define BOOST_HANA_TYPE_HPP #include <boost/hana/fwd/type.hpp> #include <boost/hana/bool.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/operators/adl.hpp> #include <boost/hana/detail/operators/comparable.hpp> #include <boost/hana/fwd/concept/metafunction.hpp> #include <boost/hana/fwd/core/make.hpp> #include <boost/hana/fwd/equal.hpp> #include <boost/hana/fwd/hash.hpp> #include <boost/hana/integral_constant.hpp> #include <type_traits> #include <utility> BOOST_HANA_NAMESPACE_BEGIN ////////////////////////////////////////////////////////////////////////// // basic_type ////////////////////////////////////////////////////////////////////////// //! @cond template <typename T> struct basic_type : detail::operators::adl<basic_type<T>> { using hana_tag = type_tag; using type = T; constexpr auto operator+() const { return *this; } }; //! @endcond ////////////////////////////////////////////////////////////////////////// // type ////////////////////////////////////////////////////////////////////////// template <typename T> struct type_impl { struct _ : basic_type<T> { }; }; ////////////////////////////////////////////////////////////////////////// // decltype_ ////////////////////////////////////////////////////////////////////////// namespace detail { template <typename T, typename = type_tag> struct decltype_t { using type = typename std::remove_reference<T>::type; }; template <typename T> struct decltype_t<T, typename hana::tag_of<T>::type> { using type = typename std::remove_reference<T>::type::type; }; } //! @cond template <typename T> constexpr auto decltype_t::operator()(T&&) const { return hana::type_c<typename detail::decltype_t<T>::type>; } //! @endcond ////////////////////////////////////////////////////////////////////////// // typeid_ ////////////////////////////////////////////////////////////////////////// namespace detail { template <typename T, typename = type_tag> struct typeid_t { using type = typename std::remove_cv< typename std::remove_reference<T>::type >::type; }; template <typename T> struct typeid_t<T, typename hana::tag_of<T>::type> { using type = typename std::remove_reference<T>::type::type; }; } //! @cond template <typename T> constexpr auto typeid_t::operator()(T&&) const { return hana::type_c<typename detail::typeid_t<T>::type>; } //! @endcond ////////////////////////////////////////////////////////////////////////// // make<type_tag> ////////////////////////////////////////////////////////////////////////// template <> struct make_impl<type_tag> { template <typename T> static constexpr auto apply(T&& t) { return hana::typeid_(static_cast<T&&>(t)); } }; ////////////////////////////////////////////////////////////////////////// // sizeof_ ////////////////////////////////////////////////////////////////////////// //! @cond template <typename T> constexpr auto sizeof_t::operator()(T&&) const { return hana::size_c<sizeof(typename detail::decltype_t<T>::type)>; } //! @endcond ////////////////////////////////////////////////////////////////////////// // alignof_ ////////////////////////////////////////////////////////////////////////// //! @cond template <typename T> constexpr auto alignof_t::operator()(T&&) const { return hana::size_c<alignof(typename detail::decltype_t<T>::type)>; } //! @endcond ////////////////////////////////////////////////////////////////////////// // is_valid ////////////////////////////////////////////////////////////////////////// namespace type_detail { template <typename F, typename ...Args, typename = decltype( std::declval<F&&>()(std::declval<Args&&>()...) )> constexpr auto is_valid_impl(int) { return hana::true_c; } template <typename F, typename ...Args> constexpr auto is_valid_impl(...) { return hana::false_c; } template <typename F> struct is_valid_fun { template <typename ...Args> constexpr auto operator()(Args&& ...) const { return is_valid_impl<F, Args&&...>(int{}); } }; } //! @cond template <typename F> constexpr auto is_valid_t::operator()(F&&) const { return type_detail::is_valid_fun<F&&>{}; } template <typename F, typename ...Args> constexpr auto is_valid_t::operator()(F&&, Args&& ...) const { return type_detail::is_valid_impl<F&&, Args&&...>(int{}); } //! @endcond ////////////////////////////////////////////////////////////////////////// // template_ ////////////////////////////////////////////////////////////////////////// // Note: We have to use the very complicated trick below instead of just // mentionning `F<T...>` in a SFINAE-able context because of CWG 1430 // (http://www.open-std.org/Jtc1/sc22/wg21/docs/cwg_active.html#1430). namespace template_detail { template <typename ...T> struct args; template <typename ...> using always_void = void; template <template <typename ...> class F, typename Args, typename = void> struct specialization_is_valid : std::false_type { }; template <template <typename ...> class F, typename ...T> struct specialization_is_valid<F, args<T...>, always_void<F<T...>>> : std::true_type { }; } // end namespace detail template <template <typename ...> class F> struct template_t { template <typename ...T> struct apply { using type = F<T...>; }; template <typename ...T, typename = std::enable_if_t< template_detail::specialization_is_valid<F, template_detail::args<typename T::type...>>::value >> constexpr auto operator()(T const& ...) const { return hana::type<F<typename T::type...>>{}; } }; ////////////////////////////////////////////////////////////////////////// // metafunction ////////////////////////////////////////////////////////////////////////// template <template <typename ...> class F> struct metafunction_t { template <typename ...T> using apply = F<T...>; template <typename ...T> constexpr hana::type<typename F<typename T::type...>::type> operator()(T const& ...) const { return {}; } }; ////////////////////////////////////////////////////////////////////////// // metafunction_class ////////////////////////////////////////////////////////////////////////// namespace detail { template <typename F, typename ...T> struct always_first { using type = F; }; } template <typename F> struct metafunction_class_t { template <typename ...T> using apply = typename detail::always_first<F, T...>::type::template apply<T...>; template <typename ...T> constexpr hana::type<typename detail::always_first<F, T...>::type::template apply<typename T::type...>::type> operator()(T const& ...) const { return {}; } }; ////////////////////////////////////////////////////////////////////////// // Metafunction ////////////////////////////////////////////////////////////////////////// template <template <typename ...> class F> struct Metafunction<template_t<F>> { static constexpr bool value = true; }; template <template <typename ...> class F> struct Metafunction<metafunction_t<F>> { static constexpr bool value = true; }; template <typename F> struct Metafunction<metafunction_class_t<F>> { static constexpr bool value = true; }; ////////////////////////////////////////////////////////////////////////// // integral ////////////////////////////////////////////////////////////////////////// template <typename F> struct integral_t { template <typename ...T, typename Result = typename detail::always_first<F, T...>::type::template apply<typename T::type...>::type > constexpr Result operator()(T const& ...) const { return Result{}; } }; ////////////////////////////////////////////////////////////////////////// // Operators ////////////////////////////////////////////////////////////////////////// namespace detail { template <> struct comparable_operators<type_tag> { static constexpr bool value = true; }; } ////////////////////////////////////////////////////////////////////////// // Comparable ////////////////////////////////////////////////////////////////////////// template <> struct equal_impl<type_tag, type_tag> { template <typename T, typename U> static constexpr auto apply(basic_type<T> const&, basic_type<U> const&) { return hana::false_c; } template <typename T> static constexpr auto apply(basic_type<T> const&, basic_type<T> const&) { return hana::true_c; } }; ////////////////////////////////////////////////////////////////////////// // Hashable ////////////////////////////////////////////////////////////////////////// template <> struct hash_impl<hana::type_tag> { template <typename T> static constexpr T apply(T const& t) { return t; } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_TYPE_HPP PK �\�[���& & bool.hppnu �[��� /*! @file Defines the `Logical` and `Comparable` models of `boost::hana::integral_constant`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_BOOL_HPP #define BOOST_HANA_BOOL_HPP #include <boost/hana/fwd/bool.hpp> #include <boost/hana/concept/integral_constant.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/to.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/operators/arithmetic.hpp> #include <boost/hana/detail/operators/comparable.hpp> #include <boost/hana/detail/operators/logical.hpp> #include <boost/hana/detail/operators/orderable.hpp> #include <boost/hana/eval.hpp> #include <boost/hana/fwd/core/tag_of.hpp> #include <boost/hana/fwd/eval_if.hpp> #include <boost/hana/fwd/if.hpp> #include <boost/hana/fwd/value.hpp> #include <cstddef> #include <type_traits> #include <utility> BOOST_HANA_NAMESPACE_BEGIN ////////////////////////////////////////////////////////////////////////// // integral_constant ////////////////////////////////////////////////////////////////////////// //! @cond namespace ic_detail { template <typename T, T N, typename = std::make_integer_sequence<T, N>> struct go; template <typename T, T N, T ...i> struct go<T, N, std::integer_sequence<T, i...>> { using swallow = T[]; template <typename F> static constexpr void with_index(F&& f) { (void)swallow{T{}, ((void)f(integral_constant<T, i>{}), i)...}; } template <typename F> static constexpr void without_index(F&& f) { (void)swallow{T{}, ((void)f(), i)...}; } }; template <typename T, T v> template <typename F> constexpr void with_index_t<T, v>::operator()(F&& f) const { go<T, ((void)sizeof(&f), v)>::with_index(static_cast<F&&>(f)); } template <typename T, T v> template <typename F> constexpr void times_t<T, v>::operator()(F&& f) const { go<T, ((void)sizeof(&f), v)>::without_index(static_cast<F&&>(f)); } // avoid link-time error template <typename T, T v> constexpr with_index_t<T, v> times_t<T, v>::with_index; } // avoid link-time error template <typename T, T v> constexpr ic_detail::times_t<T, v> integral_constant<T, v>::times; template <typename T, T v> struct tag_of<integral_constant<T, v>> { using type = integral_constant_tag<T>; }; //! @endcond ////////////////////////////////////////////////////////////////////////// // Operators ////////////////////////////////////////////////////////////////////////// namespace detail { template <typename T> struct comparable_operators<integral_constant_tag<T>> { static constexpr bool value = true; }; template <typename T> struct orderable_operators<integral_constant_tag<T>> { static constexpr bool value = true; }; template <typename T> struct arithmetic_operators<integral_constant_tag<T>> { static constexpr bool value = true; }; template <typename T> struct logical_operators<integral_constant_tag<T>> { static constexpr bool value = true; }; } #define BOOST_HANA_INTEGRAL_CONSTANT_BINARY_OP(op) \ template <typename U, U u, typename V, V v> \ constexpr integral_constant<decltype(u op v), (u op v)> \ operator op(integral_constant<U, u>, integral_constant<V, v>) \ { return {}; } \ /**/ #define BOOST_HANA_INTEGRAL_CONSTANT_UNARY_OP(op) \ template <typename U, U u> \ constexpr integral_constant<decltype(op u), (op u)> \ operator op(integral_constant<U, u>) \ { return {}; } \ /**/ // Arithmetic BOOST_HANA_INTEGRAL_CONSTANT_UNARY_OP(+) // Bitwise BOOST_HANA_INTEGRAL_CONSTANT_UNARY_OP(~) BOOST_HANA_INTEGRAL_CONSTANT_BINARY_OP(&) BOOST_HANA_INTEGRAL_CONSTANT_BINARY_OP(|) BOOST_HANA_INTEGRAL_CONSTANT_BINARY_OP(^) BOOST_HANA_INTEGRAL_CONSTANT_BINARY_OP(<<) BOOST_HANA_INTEGRAL_CONSTANT_BINARY_OP(>>) #undef BOOST_HANA_INTEGRAL_CONSTANT_UNARY_OP #undef BOOST_HANA_INTEGRAL_CONSTANT_BINARY_OP ////////////////////////////////////////////////////////////////////////// // User-defined literal ////////////////////////////////////////////////////////////////////////// namespace ic_detail { constexpr int to_int(char c) { int result = 0; if (c >= 'A' && c <= 'F') { result = static_cast<int>(c) - static_cast<int>('A') + 10; } else if (c >= 'a' && c <= 'f') { result = static_cast<int>(c) - static_cast<int>('a') + 10; } else { result = static_cast<int>(c) - static_cast<int>('0'); } return result; } template<std::size_t N> constexpr long long parse(const char (&arr)[N]) { long long base = 10; std::size_t offset = 0; if (N > 2) { bool starts_with_zero = arr[0] == '0'; bool is_hex = starts_with_zero && arr[1] == 'x'; bool is_binary = starts_with_zero && arr[1] == 'b'; if (is_hex) { //0xDEADBEEF (hexadecimal) base = 16; offset = 2; } else if (is_binary) { //0b101011101 (binary) base = 2; offset = 2; } else if (starts_with_zero) { //012345 (octal) base = 8; offset = 1; } } long long number = 0; long long multiplier = 1; for (std::size_t i = 0; i < N - offset; ++i) { char c = arr[N - 1 - i]; if (c != '\'') { // skip digit separators number += to_int(c) * multiplier; multiplier *= base; } } return number; } } namespace literals { template <char ...c> constexpr auto operator"" _c() { return hana::llong<ic_detail::parse<sizeof...(c)>({c...})>{}; } } ////////////////////////////////////////////////////////////////////////// // Model of Constant/IntegralConstant ////////////////////////////////////////////////////////////////////////// template <typename T> struct IntegralConstant<integral_constant_tag<T>> { static constexpr bool value = true; }; template <typename T, typename C> struct to_impl<integral_constant_tag<T>, C, when<hana::IntegralConstant<C>::value>> : embedding<is_embedded<typename C::value_type, T>::value> { template <typename N> static constexpr auto apply(N const&) { return integral_constant<T, N::value>{}; } }; ////////////////////////////////////////////////////////////////////////// // Optimizations ////////////////////////////////////////////////////////////////////////// template <typename T> struct eval_if_impl<integral_constant_tag<T>> { template <typename Cond, typename Then, typename Else> static constexpr decltype(auto) apply(Cond const&, Then&& t, Else&& e) { constexpr bool cond = static_cast<bool>(Cond::value); return eval_if_impl::apply(hana::bool_<cond>{}, static_cast<Then&&>(t), static_cast<Else&&>(e)); } template <typename Then, typename Else> static constexpr decltype(auto) apply(hana::true_ const&, Then&& t, Else&&) { return hana::eval(static_cast<Then&&>(t)); } template <typename Then, typename Else> static constexpr decltype(auto) apply(hana::false_ const&, Then&&, Else&& e) { return hana::eval(static_cast<Else&&>(e)); } }; template <typename T> struct if_impl<integral_constant_tag<T>> { template <typename Cond, typename Then, typename Else> static constexpr decltype(auto) apply(Cond const&, Then&& t, Else&& e) { constexpr bool cond = static_cast<bool>(Cond::value); return if_impl::apply(hana::bool_<cond>{}, static_cast<Then&&>(t), static_cast<Else&&>(e)); } //! @todo We could return `Then` instead of `auto` to sometimes save //! a copy, but that would break some code that would return a //! reference to a `type` object. I think the code that would be //! broken should be changed, but more thought needs to be given. template <typename Then, typename Else> static constexpr auto apply(hana::true_ const&, Then&& t, Else&&) { return static_cast<Then&&>(t); } template <typename Then, typename Else> static constexpr auto apply(hana::false_ const&, Then&&, Else&& e) { return static_cast<Else&&>(e); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_BOOL_HPP PK �\�[� ��D D or.hppnu �[��� /*! @file Defines `boost::hana::or_`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_OR_HPP #define BOOST_HANA_OR_HPP #include <boost/hana/fwd/or.hpp> #include <boost/hana/concept/logical.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/variadic/foldl1.hpp> #include <boost/hana/if.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename X, typename Y> constexpr decltype(auto) or_t::operator()(X&& x, Y&& y) const { using Bool = typename hana::tag_of<X>::type; using Or = BOOST_HANA_DISPATCH_IF(or_impl<Bool>, hana::Logical<Bool>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Logical<Bool>::value, "hana::or_(x, y) requires 'x' to be a Logical"); #endif return Or::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); } template <typename X, typename ...Y> constexpr decltype(auto) or_t::operator()(X&& x, Y&& ...y) const { return detail::variadic::foldl1( *this, static_cast<X&&>(x), static_cast<Y&&>(y)... ); } //! @endcond template <typename L, bool condition> struct or_impl<L, when<condition>> : hana::default_ { template <typename X, typename Y> static constexpr decltype(auto) apply(X&& x, Y&& y) { //! @todo How to forward `x` here? Since the arguments to `if_` //! can be evaluated in any order, we have to be careful not to //! use `x` in a moved-from state. return hana::if_(x, x, static_cast<Y&&>(y)); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_OR_HPP PK �\�[mmH:� � experimental/printable.hppnu �[��� /* @file Defines `boost::hana::experimental::print`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EXPERIMENTAL_PRINTABLE_HPP #define BOOST_HANA_EXPERIMENTAL_PRINTABLE_HPP #include <boost/hana/concept/constant.hpp> #include <boost/hana/concept/product.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/to.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/first.hpp> #include <boost/hana/for_each.hpp> #include <boost/hana/intersperse.hpp> #include <boost/hana/second.hpp> #include <boost/hana/transform.hpp> #include <boost/hana/tuple.hpp> // models for different containers #include <boost/hana/fwd/map.hpp> #include <boost/hana/fwd/optional.hpp> #include <boost/hana/fwd/set.hpp> #include <boost/hana/fwd/string.hpp> #include <boost/hana/fwd/type.hpp> #include <boost/core/demangle.hpp> #include <iostream> #include <regex> #include <sstream> #include <string> #include <typeinfo> #include <utility> BOOST_HANA_NAMESPACE_BEGIN namespace experimental { template <typename T> struct Printable; //! @cond template <typename T, typename = void> struct print_impl : print_impl<T, hana::when<true>> { }; template <typename T, bool condition> struct print_impl<T, hana::when<condition>> : hana::default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; //! @endcond //! @ingroup group-experimental //! Returns a string representation of the given object. //! //! This function is defined for most containers provided by Hana, and //! also for objects that define an `operator<<` that can be used with //! a `std::basic_ostream`. It can recursively print containers within //! containers, but do not expect any kind of proper indentation. //! //! This function requires (the rest of) Boost to be available on the //! system. It also requires RTTI to be enabled. #ifdef BOOST_HANA_DOXYGEN_INVOKED auto print = [](auto const& x) -> std::string { return tag-dispatched; }; #else struct print_t { template <typename T> std::string operator()(T const& t) const { using Tag = typename hana::tag_of<T>::type; using Print = BOOST_HANA_DISPATCH_IF(print_impl<Tag>, hana::experimental::Printable<Tag>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::experimental::Printable<Tag>::value, "hana::experimental::print(t) requires 't' to be Printable"); #endif return Print::apply(t); } }; constexpr print_t print{}; #endif // Define the `Printable` concept template <typename T> struct Printable { using Tag = typename hana::tag_of<T>::type; static constexpr bool value = !hana::is_default<print_impl<Tag>>::value; }; namespace print_detail { inline std::string strip_type_junk(std::string const& str) { return std::regex_replace(str, std::regex("(?:struct )?([a-z_]+::)*([a-z_]*)_t<((?:struct )?[a-z:<>_]*)>"), "$2<$3>"); } } // model for Sequences template <typename S> struct print_impl<S, hana::when<hana::Sequence<S>::value>> { template <typename Xs> static std::string apply(Xs const& xs) { std::string result = "("; auto comma_separated = hana::intersperse(xs, ", "); hana::for_each(comma_separated, [&result](auto const& x) { result += hana::experimental::print(x); }); result += ")"; return result; } }; // model for OutputStreamable types //! @cond template <typename S> struct print_impl<S, hana::when_valid<decltype( std::declval<std::ostringstream&>() << std::declval<S const&>() )>> { template <typename T> static std::string apply(T const& t) { std::ostringstream os; os << t; return os.str(); } }; //! @endcond // model for hana::optional template <> struct print_impl<hana::optional_tag> { template <typename O> static std::string apply(O const& optional) { return hana::maybe("nothing", [](auto const& x) { return "just(" + hana::experimental::print(x) + ")"; }, optional); } }; // model for hana::maps template <> struct print_impl<hana::map_tag> { template <typename M> static std::string apply(M const& map) { std::string result = "{"; auto pairs = hana::transform(hana::to_tuple(map), [](auto const& pair) { return hana::experimental::print(hana::first(pair)) + " => " + hana::experimental::print(hana::second(pair)); }); auto comma_separated = hana::intersperse(pairs, ", "); hana::for_each(comma_separated, [&result](auto const& element) { result += element; }); result += "}"; return result; } }; // model for hana::metafunctions template <template <typename ...> class F> struct print_impl<hana::metafunction_t<F>> { template <typename T> static std::string apply(T const&) { return print_detail::strip_type_junk(boost::core::demangle(typeid(T).name())); } }; // model for hana::metafunction_classes template <typename F> struct print_impl<hana::metafunction_class_t<F>> { template <typename T> static std::string apply(T const&) { return print_detail::strip_type_junk(boost::core::demangle(typeid(T).name())); } }; // model for Constants holding a `Printable` template <typename C> struct print_impl<C, hana::when< hana::Constant<C>::value && Printable<typename C::value_type>::value >> { template <typename T> static std::string apply(T const&) { constexpr auto value = hana::value<T>(); return hana::experimental::print(value); } }; // model for Products template <typename P> struct print_impl<P, hana::when<hana::Product<P>::value>> { template <typename T> static std::string apply(T const& t) { return '(' + hana::experimental::print(hana::first(t)) + ", " + hana::experimental::print(hana::second(t)) + ')'; } }; // model for hana::strings template <> struct print_impl<hana::string_tag> { template <typename S> static std::string apply(S const& s) { return '"' + std::string{hana::to<char const*>(s)} + '"'; } }; // model for hana::sets template <> struct print_impl<hana::set_tag> { template <typename S> static std::string apply(S const& set) { std::string result = "{"; auto as_tuple = hana::transform(hana::to_tuple(set), hana::experimental::print); auto comma_separated = hana::intersperse(as_tuple, ", "); hana::for_each(comma_separated, [&result](auto const& element) { result += element; }); result += "}"; return result; } }; // model for hana::templates template <template <typename ...> class F> struct print_impl<template_t<F>> { template <typename T> static std::string apply(T const&) { return print_detail::strip_type_junk(boost::core::demangle(typeid(T).name())); } }; // model for hana::types template <> struct print_impl<hana::type_tag> { template <typename T> static std::string apply(T const&) { using Type = typename T::type; return "type<" + boost::core::demangle(typeid(Type).name()) + '>'; } }; } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_EXPERIMENTAL_PRINTABLE_HPP PK �\�[&�˓ � experimental/types.hppnu �[��� /*! @file Defines `boost::hana::experimental::types`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EXPERIMENTAL_TYPES_HPP #define BOOST_HANA_EXPERIMENTAL_TYPES_HPP #include <boost/hana/bool.hpp> #include <boost/hana/concept/metafunction.hpp> #include <boost/hana/config.hpp> #include <boost/hana/detail/any_of.hpp> #include <boost/hana/detail/type_at.hpp> #include <boost/hana/fwd/at.hpp> #include <boost/hana/fwd/contains.hpp> #include <boost/hana/fwd/core/tag_of.hpp> #include <boost/hana/fwd/equal.hpp> #include <boost/hana/fwd/is_empty.hpp> #include <boost/hana/fwd/transform.hpp> #include <boost/hana/fwd/unpack.hpp> #include <boost/hana/type.hpp> #include <cstddef> #include <type_traits> #include <utility> BOOST_HANA_NAMESPACE_BEGIN namespace experimental { //! @ingroup group-experimental //! Container optimized for holding types. //! //! It is often useful to manipulate a sequence that contains types //! only, without any associated runtime value. This container allows //! storing and manipulating pure types in a much more compile-time //! efficient manner than using `hana::tuple`, which must assume that //! its contents might have runtime values. template <typename ...T> struct types; struct types_tag; template <typename ...T> struct types { }; } // end namespace experimental template <typename ...T> struct tag_of<experimental::types<T...>> { using type = experimental::types_tag; }; // Foldable template <> struct unpack_impl<hana::experimental::types_tag> { template <typename ...T, typename F, typename = typename std::enable_if< !hana::Metafunction<F>::value >::type> static constexpr decltype(auto) apply(hana::experimental::types<T...> const&, F&& f) { return static_cast<F&&>(f)(hana::type<T>{}...); } template <typename ...T, typename F, typename = typename std::enable_if< hana::Metafunction<F>::value >::type> static constexpr hana::type<typename F::template apply<T...>::type> apply(hana::experimental::types<T...> const&, F const&) { return {}; } }; // Functor template <> struct transform_impl<hana::experimental::types_tag> { template <typename ...T, typename F, typename = typename std::enable_if< !hana::Metafunction<F>::value >::type> static constexpr auto apply(hana::experimental::types<T...> const&, F&& f) -> hana::experimental::types<typename decltype(+f(hana::type<T>{}))::type...> { return {}; } template <typename ...T, typename F, typename = typename std::enable_if< hana::Metafunction<F>::value >::type> static constexpr hana::experimental::types<typename F::template apply<T>::type...> apply(hana::experimental::types<T...> const&, F const&) { return {}; } }; // Iterable template <> struct at_impl<hana::experimental::types_tag> { template <typename ...T, typename N> static constexpr auto apply(hana::experimental::types<T...> const&, N const&) { using Nth = typename detail::type_at<N::value, T...>::type; return hana::type<Nth>{}; } }; template <> struct is_empty_impl<hana::experimental::types_tag> { template <typename ...T> static constexpr hana::bool_<sizeof...(T) == 0> apply(hana::experimental::types<T...> const&) { return {}; } }; template <> struct drop_front_impl<hana::experimental::types_tag> { template <std::size_t n, typename ...T, std::size_t ...i> static hana::experimental::types<typename detail::type_at<i + n, T...>::type...> helper(std::index_sequence<i...>); template <typename ...T, typename N> static constexpr auto apply(hana::experimental::types<T...> const&, N const&) { constexpr std::size_t n = N::value > sizeof...(T) ? sizeof...(T) : N::value; using Indices = std::make_index_sequence<sizeof...(T) - n>; return decltype(helper<n, T...>(Indices{})){}; } }; // Searchable template <> struct contains_impl<hana::experimental::types_tag> { template <typename U> struct is_same_as { template <typename T> struct apply { static constexpr bool value = std::is_same<U, T>::value; }; }; template <typename ...T, typename U> static constexpr auto apply(hana::experimental::types<T...> const&, U const&) -> hana::bool_< detail::any_of<is_same_as<typename U::type>::template apply, T...>::value > { return {}; } static constexpr hana::false_ apply(...) { return {}; } }; // Comparable template <> struct equal_impl<hana::experimental::types_tag, hana::experimental::types_tag> { template <typename Types> static constexpr hana::true_ apply(Types const&, Types const&) { return {}; } template <typename Ts, typename Us> static constexpr hana::false_ apply(Ts const&, Us const&) { return {}; } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_EXPERIMENTAL_TYPES_HPP PK �\�[)p�E �E experimental/view.hppnu �[��� /* @file Defines experimental views. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EXPERIMENTAL_VIEW_HPP #define BOOST_HANA_EXPERIMENTAL_VIEW_HPP #include <boost/hana/and.hpp> #include <boost/hana/at.hpp> #include <boost/hana/bool.hpp> #include <boost/hana/detail/decay.hpp> #include <boost/hana/fold_left.hpp> #include <boost/hana/functional/compose.hpp> #include <boost/hana/functional/on.hpp> #include <boost/hana/fwd/ap.hpp> #include <boost/hana/fwd/concat.hpp> #include <boost/hana/fwd/drop_front.hpp> #include <boost/hana/fwd/empty.hpp> #include <boost/hana/fwd/equal.hpp> #include <boost/hana/fwd/flatten.hpp> #include <boost/hana/fwd/is_empty.hpp> #include <boost/hana/fwd/less.hpp> #include <boost/hana/fwd/lift.hpp> #include <boost/hana/fwd/transform.hpp> #include <boost/hana/integral_constant.hpp> #include <boost/hana/length.hpp> #include <boost/hana/lexicographical_compare.hpp> #include <boost/hana/range.hpp> #include <boost/hana/tuple.hpp> #include <boost/hana/unpack.hpp> #include <cstddef> #include <type_traits> #include <utility> // Pros of views // - No temporary container created between algorithms // - Lazy, so only the minimum is required // // Cons of views // - Reference semantics mean possibility for dangling references // - Lose the ability to move from temporary containers // - When fetching the members of a view multiple times, no caching is done. // So for example, `t = transform(xs, f); at_c<0>(t); at_c<0>(t)` will // compute `f(at_c<0>(xs))` twice. // - push_back creates a joint_view and a single_view. The single_view holds // the value as a member. When doing multiple push_backs, we end up with a // joint_view<xxx, joint_view<single_view<T>, joint_view<single_view<T>, ....>>> // which contains a reference to `xxx` and all the `T`s by value. Such a // "view" is not cheap to copy, which is inconsistent with the usual // expectations about views. BOOST_HANA_NAMESPACE_BEGIN namespace experimental { struct view_tag; namespace detail { template <typename Sequence> struct is_view { static constexpr bool value = false; }; template <typename Sequence> using view_storage = typename std::conditional< detail::is_view<Sequence>::value, Sequence, Sequence& >::type; } ////////////////////////////////////////////////////////////////////////// // sliced_view ////////////////////////////////////////////////////////////////////////// template <typename Sequence, std::size_t ...indices> struct sliced_view_t { detail::view_storage<Sequence> sequence_; using hana_tag = view_tag; }; template <typename Sequence, typename Indices> constexpr auto sliced(Sequence& sequence, Indices const& indices) { return hana::unpack(indices, [&](auto ...i) { return sliced_view_t<Sequence, decltype(i)::value...>{sequence}; }); } namespace detail { template <typename Sequence, std::size_t ...i> struct is_view<sliced_view_t<Sequence, i...>> { static constexpr bool value = true; }; } ////////////////////////////////////////////////////////////////////////// // transformed_view ////////////////////////////////////////////////////////////////////////// template <typename Sequence, typename F> struct transformed_view_t { detail::view_storage<Sequence> sequence_; F f_; using hana_tag = view_tag; }; template <typename Sequence, typename F> constexpr transformed_view_t<Sequence, typename hana::detail::decay<F>::type> transformed(Sequence& sequence, F&& f) { return {sequence, static_cast<F&&>(f)}; } namespace detail { template <typename Sequence, typename F> struct is_view<transformed_view_t<Sequence, F>> { static constexpr bool value = true; }; } ////////////////////////////////////////////////////////////////////////// // filtered_view ////////////////////////////////////////////////////////////////////////// #if 0 template <typename Sequence, typename Pred> using filtered_view_t = sliced_view_t<Sequence, detail::filtered_indices<...>>; template <typename Sequence, typename Pred> constexpr filtered_view_t<Sequence, Pred> filtered(Sequence& sequence, Pred&& pred) { return {sequence}; } #endif ////////////////////////////////////////////////////////////////////////// // joined_view ////////////////////////////////////////////////////////////////////////// template <typename Sequence1, typename Sequence2> struct joined_view_t { detail::view_storage<Sequence1> sequence1_; detail::view_storage<Sequence2> sequence2_; using hana_tag = view_tag; }; struct make_joined_view_t { template <typename Sequence1, typename Sequence2> constexpr joined_view_t<Sequence1, Sequence2> operator()(Sequence1& s1, Sequence2& s2) const { return {s1, s2}; } }; constexpr make_joined_view_t joined{}; namespace detail { template <typename Sequence1, typename Sequence2> struct is_view<joined_view_t<Sequence1, Sequence2>> { static constexpr bool value = true; }; } ////////////////////////////////////////////////////////////////////////// // single_view ////////////////////////////////////////////////////////////////////////// template <typename T> struct single_view_t { T value_; using hana_tag = view_tag; }; template <typename T> constexpr single_view_t<typename hana::detail::decay<T>::type> single_view(T&& t) { return {static_cast<T&&>(t)}; } namespace detail { template <typename T> struct is_view<single_view_t<T>> { static constexpr bool value = true; }; } ////////////////////////////////////////////////////////////////////////// // empty_view ////////////////////////////////////////////////////////////////////////// struct empty_view_t { using hana_tag = view_tag; }; constexpr empty_view_t empty_view() { return {}; } namespace detail { template <> struct is_view<empty_view_t> { static constexpr bool value = true; }; } } // end namespace experimental ////////////////////////////////////////////////////////////////////////// // Foldable ////////////////////////////////////////////////////////////////////////// template <> struct unpack_impl<experimental::view_tag> { // sliced_view template <typename Sequence, std::size_t ...i, typename F> static constexpr decltype(auto) apply(experimental::sliced_view_t<Sequence, i...> view, F&& f) { (void)view; // Remove spurious unused variable warning with GCC return static_cast<F&&>(f)(hana::at_c<i>(view.sequence_)...); } // transformed_view template <typename Sequence, typename F, typename G> static constexpr decltype(auto) apply(experimental::transformed_view_t<Sequence, F> view, G&& g) { return hana::unpack(view.sequence_, hana::on(static_cast<G&&>(g), view.f_)); } // joined_view template <typename View, typename F, std::size_t ...i1, std::size_t ...i2> static constexpr decltype(auto) unpack_joined(View view, F&& f, std::index_sequence<i1...>, std::index_sequence<i2...>) { (void)view; // Remove spurious unused variable warning with GCC return static_cast<F&&>(f)(hana::at_c<i1>(view.sequence1_)..., hana::at_c<i2>(view.sequence2_)...); } template <typename S1, typename S2, typename F> static constexpr decltype(auto) apply(experimental::joined_view_t<S1, S2> view, F&& f) { constexpr auto N1 = decltype(hana::length(view.sequence1_))::value; constexpr auto N2 = decltype(hana::length(view.sequence2_))::value; return unpack_joined(view, static_cast<F&&>(f), std::make_index_sequence<N1>{}, std::make_index_sequence<N2>{}); } // single_view template <typename T, typename F> static constexpr decltype(auto) apply(experimental::single_view_t<T> view, F&& f) { return static_cast<F&&>(f)(view.value_); } // empty_view template <typename F> static constexpr decltype(auto) apply(experimental::empty_view_t, F&& f) { return static_cast<F&&>(f)(); } }; ////////////////////////////////////////////////////////////////////////// // Iterable ////////////////////////////////////////////////////////////////////////// template <> struct at_impl<experimental::view_tag> { // sliced_view template <typename Sequence, std::size_t ...i, typename N> static constexpr decltype(auto) apply(experimental::sliced_view_t<Sequence, i...> view, N const&) { constexpr std::size_t indices[] = {i...}; constexpr std::size_t n = indices[N::value]; return hana::at_c<n>(view.sequence_); } // transformed_view template <typename Sequence, typename F, typename N> static constexpr decltype(auto) apply(experimental::transformed_view_t<Sequence, F> view, N const& n) { return view.f_(hana::at(view.sequence_, n)); } // joined_view template <std::size_t Left, typename View, typename N> static constexpr decltype(auto) at_joined_view(View view, N const&, hana::true_) { return hana::at_c<N::value>(view.sequence1_); } template <std::size_t Left, typename View, typename N> static constexpr decltype(auto) at_joined_view(View view, N const&, hana::false_) { return hana::at_c<N::value - Left>(view.sequence2_); } template <typename S1, typename S2, typename N> static constexpr decltype(auto) apply(experimental::joined_view_t<S1, S2> view, N const& n) { constexpr auto Left = decltype(hana::length(view.sequence1_))::value; return at_joined_view<Left>(view, n, hana::bool_c<(N::value < Left)>); } // single_view template <typename T, typename N> static constexpr decltype(auto) apply(experimental::single_view_t<T> view, N const&) { static_assert(N::value == 0, "trying to fetch an out-of-bounds element in a hana::single_view"); return view.value_; } // empty_view template <typename N> static constexpr decltype(auto) apply(experimental::empty_view_t, N const&) = delete; }; template <> struct length_impl<experimental::view_tag> { // sliced_view template <typename Sequence, std::size_t ...i> static constexpr auto apply(experimental::sliced_view_t<Sequence, i...>) { return hana::size_c<sizeof...(i)>; } // transformed_view template <typename Sequence, typename F> static constexpr auto apply(experimental::transformed_view_t<Sequence, F> view) { return hana::length(view.sequence_); } // joined_view template <typename S1, typename S2> static constexpr auto apply(experimental::joined_view_t<S1, S2> view) { return hana::size_c< decltype(hana::length(view.sequence1_))::value + decltype(hana::length(view.sequence2_))::value >; } // single_view template <typename T> static constexpr auto apply(experimental::single_view_t<T>) { return hana::size_c<1>; } // empty_view static constexpr auto apply(experimental::empty_view_t) { return hana::size_c<0>; } }; template <> struct is_empty_impl<experimental::view_tag> { // sliced_view template <typename Sequence, std::size_t ...i> static constexpr auto apply(experimental::sliced_view_t<Sequence, i...>) { return hana::bool_c<sizeof...(i) == 0>; } // transformed_view template <typename Sequence, typename F> static constexpr auto apply(experimental::transformed_view_t<Sequence, F> view) { return hana::is_empty(view.sequence_); } // joined_view template <typename S1, typename S2> static constexpr auto apply(experimental::joined_view_t<S1, S2> view) { return hana::and_(hana::is_empty(view.sequence1_), hana::is_empty(view.sequence2_)); } // single_view template <typename T> static constexpr auto apply(experimental::single_view_t<T>) { return hana::false_c; } // empty_view static constexpr auto apply(experimental::empty_view_t) { return hana::true_c; } }; template <> struct drop_front_impl<experimental::view_tag> { template <typename View, typename N> static constexpr auto apply(View view, N const&) { constexpr auto n = N::value; constexpr auto Length = decltype(hana::length(view))::value; return experimental::sliced(view, hana::range_c<std::size_t, n, Length>); } }; ////////////////////////////////////////////////////////////////////////// // Functor ////////////////////////////////////////////////////////////////////////// template <> struct transform_impl<experimental::view_tag> { template <typename Sequence, typename F, typename G> static constexpr auto apply(experimental::transformed_view_t<Sequence, F> view, G&& g) { return experimental::transformed(view.sequence_, hana::compose(static_cast<G&&>(g), view.f_)); } template <typename View, typename F> static constexpr auto apply(View view, F&& f) { return experimental::transformed(view, static_cast<F&&>(f)); } }; ////////////////////////////////////////////////////////////////////////// // Applicative ////////////////////////////////////////////////////////////////////////// template <> struct lift_impl<experimental::view_tag> { template <typename T> static constexpr auto apply(T&& t) { return experimental::single_view(static_cast<T&&>(t)); } }; template <> struct ap_impl<experimental::view_tag> { template <typename F, typename X> static constexpr auto apply(F&& f, X&& x) { // TODO: Implement cleverly; we most likely need a cartesian_product // view or something like that. return hana::ap(hana::to_tuple(f), hana::to_tuple(x)); } }; ////////////////////////////////////////////////////////////////////////// // Monad ////////////////////////////////////////////////////////////////////////// template <> struct flatten_impl<experimental::view_tag> { template <typename View> static constexpr auto apply(View view) { // TODO: Implement a flattened_view instead return hana::fold_left(view, experimental::empty_view(), experimental::joined); } }; ////////////////////////////////////////////////////////////////////////// // MonadPlus ////////////////////////////////////////////////////////////////////////// template <> struct concat_impl<experimental::view_tag> { template <typename View1, typename View2> static constexpr auto apply(View1 view1, View2 view2) { return experimental::joined(view1, view2); } }; template <> struct empty_impl<experimental::view_tag> { static constexpr auto apply() { return experimental::empty_view(); } }; ////////////////////////////////////////////////////////////////////////// // Comparable ////////////////////////////////////////////////////////////////////////// template <> struct equal_impl<experimental::view_tag, experimental::view_tag> { template <typename View1, typename View2> static constexpr auto apply(View1 v1, View2 v2) { // TODO: Use a lexicographical comparison algorithm. return hana::equal(hana::to_tuple(v1), hana::to_tuple(v2)); } }; template <typename S> struct equal_impl<experimental::view_tag, S, hana::when<hana::Sequence<S>::value>> { template <typename View1, typename Seq> static constexpr auto apply(View1 v1, Seq const& s) { // TODO: Use a lexicographical comparison algorithm. return hana::equal(hana::to_tuple(v1), hana::to_tuple(s)); } }; template <typename S> struct equal_impl<S, experimental::view_tag, hana::when<hana::Sequence<S>::value>> { template <typename Seq, typename View2> static constexpr auto apply(Seq const& s, View2 v2) { // TODO: Use a lexicographical comparison algorithm. return hana::equal(hana::to_tuple(s), hana::to_tuple(v2)); } }; ////////////////////////////////////////////////////////////////////////// // Orderable ////////////////////////////////////////////////////////////////////////// template <> struct less_impl<experimental::view_tag, experimental::view_tag> { template <typename View1, typename View2> static constexpr auto apply(View1 v1, View2 v2) { return hana::lexicographical_compare(v1, v2); } }; template <typename S> struct less_impl<experimental::view_tag, S, hana::when<hana::Sequence<S>::value>> { template <typename View1, typename Seq> static constexpr auto apply(View1 v1, Seq const& s) { return hana::lexicographical_compare(v1, s); } }; template <typename S> struct less_impl<S, experimental::view_tag, hana::when<hana::Sequence<S>::value>> { template <typename Seq, typename View2> static constexpr auto apply(Seq const& s, View2 v2) { return hana::lexicographical_compare(s, v2); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_EXPERIMENTAL_VIEW_HPP PK �\�[�*� � experimental/type_name.hppnu �[��� /* @file Defines `boost::hana::experimental::type_name`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EXPERIMENTAL_TYPE_NAME_HPP #define BOOST_HANA_EXPERIMENTAL_TYPE_NAME_HPP #include <boost/hana/config.hpp> #include <boost/hana/string.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN namespace experimental { namespace detail { struct cstring { char const* ptr; std::size_t length; }; // Note: We substract the null terminator from the string sizes below. template <typename T> constexpr cstring type_name_impl2() { #if defined(__clang__) constexpr char const* pretty_function = __PRETTY_FUNCTION__; constexpr std::size_t total_size = sizeof(__PRETTY_FUNCTION__) - 1; constexpr std::size_t prefix_size = sizeof("boost::hana::experimental::detail::cstring boost::hana::experimental::detail::type_name_impl2() [T = ") - 1; constexpr std::size_t suffix_size = sizeof("]") - 1; #else #error "No support for this compiler." #endif return {pretty_function + prefix_size, total_size - prefix_size - suffix_size}; } template <typename T, std::size_t ...i> auto type_name_impl1(std::index_sequence<i...>) { constexpr auto name = detail::type_name_impl2<T>(); return hana::string<*(name.ptr + i)...>{}; } } // end namespace detail //! @ingroup group-experimental //! Returns a `hana::string` representing the name of the given type, at //! compile-time. //! //! This only works on Clang (and apparently MSVC, but Hana does not work //! there as of writing this). Original idea taken from //! https://github.com/Manu343726/ctti. template <typename T> auto type_name() { constexpr auto name = detail::type_name_impl2<T>(); return detail::type_name_impl1<T>(std::make_index_sequence<name.length>{}); } } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_EXPERIMENTAL_TYPE_NAME_HPP PK �\�[#��[' ' permutations.hppnu �[��� /*! @file Defines `boost::hana::permutations`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_PERMUTATIONS_HPP #define BOOST_HANA_PERMUTATIONS_HPP #include <boost/hana/fwd/permutations.hpp> #include <boost/hana/at.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/detail/array.hpp> #include <boost/hana/length.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs> constexpr auto permutations_t::operator()(Xs&& xs) const { using S = typename hana::tag_of<Xs>::type; using Permutations = BOOST_HANA_DISPATCH_IF(permutations_impl<S>, hana::Sequence<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Sequence<S>::value, "hana::permutations(xs) requires 'xs' to be a Sequence"); #endif return Permutations::apply(static_cast<Xs&&>(xs)); } //! @endcond namespace detail { template <std::size_t N> struct permutation_indices { static constexpr auto value = detail::array<std::size_t, N>{}.iota(0).permutations(); }; } template <typename S, bool condition> struct permutations_impl<S, when<condition>> : default_ { template <std::size_t n, typename Xs, std::size_t ...i> static constexpr auto nth_permutation(Xs const& xs, std::index_sequence<i...>) { constexpr auto indices = detail::permutation_indices<sizeof...(i)>::value; (void)indices; // workaround GCC warning when sizeof...(i) == 0 return hana::make<S>(hana::at_c<indices[n][i]>(xs)...); } template <std::size_t N, typename Xs, std::size_t ...n> static constexpr auto permutations_helper(Xs const& xs, std::index_sequence<n...>) { return hana::make<S>(nth_permutation<n>(xs, std::make_index_sequence<N>{})...); } template <typename Xs> static constexpr auto apply(Xs const& xs) { constexpr std::size_t N = decltype(hana::length(xs))::value; constexpr std::size_t total_perms = detail::factorial(N); return permutations_helper<N>(xs, std::make_index_sequence<total_perms>{}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_PERMUTATIONS_HPP PK �\�[G�/� � greater_equal.hppnu �[��� /*! @file Defines `boost::hana::greater_equal`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_GREATER_EQUAL_HPP #define BOOST_HANA_GREATER_EQUAL_HPP #include <boost/hana/fwd/greater_equal.hpp> #include <boost/hana/concept/orderable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/common.hpp> #include <boost/hana/core/to.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/concepts.hpp> #include <boost/hana/detail/has_common_embedding.hpp> #include <boost/hana/detail/nested_than.hpp> // required by fwd decl #include <boost/hana/if.hpp> #include <boost/hana/not.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename X, typename Y> constexpr decltype(auto) greater_equal_t::operator()(X&& x, Y&& y) const { using T = typename hana::tag_of<X>::type; using U = typename hana::tag_of<Y>::type; using GreaterEqual = BOOST_HANA_DISPATCH_IF( decltype(greater_equal_impl<T, U>{}), hana::Orderable<T>::value && hana::Orderable<U>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Orderable<T>::value, "hana::greater_equal(x, y) requires 'x' to be Orderable"); static_assert(hana::Orderable<U>::value, "hana::greater_equal(x, y) requires 'y' to be Orderable"); #endif return GreaterEqual::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); } //! @endcond template <typename T, typename U, bool condition> struct greater_equal_impl<T, U, when<condition>> : default_ { template <typename X, typename Y> static constexpr decltype(auto) apply(X x, Y y) { return hana::not_(hana::less(static_cast<X&&>(x), static_cast<Y&&>(y))); } }; // Cross-type overload template <typename T, typename U> struct greater_equal_impl<T, U, when< detail::has_nontrivial_common_embedding<Orderable, T, U>::value >> { using C = typename hana::common<T, U>::type; template <typename X, typename Y> static constexpr decltype(auto) apply(X&& x, Y&& y) { return hana::greater_equal(hana::to<C>(static_cast<X&&>(x)), hana::to<C>(static_cast<Y&&>(y))); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_GREATER_EQUAL_HPP PK �\�[ �� � config.hppnu �[��� /*! @file Defines configuration macros used throughout the library. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CONFIG_HPP #define BOOST_HANA_CONFIG_HPP #include <boost/hana/version.hpp> ////////////////////////////////////////////////////////////////////////////// // Detect the compiler ////////////////////////////////////////////////////////////////////////////// #if defined(_MSC_VER) && !defined(__clang__) // MSVC // This must be checked first, because otherwise it produces a fatal // error due to unrecognized #warning directives used below. # if _MSC_VER < 1915 # pragma message("Warning: the native Microsoft compiler is not supported due to lack of proper C++14 support.") # else // 1. Active issues // Multiple copy/move ctors # define BOOST_HANA_WORKAROUND_MSVC_MULTIPLECTOR_106654 // 2. Issues fixed in the development branch of MSVC // Forward declaration of class template member function returning decltype(auto) # define BOOST_HANA_WORKAROUND_MSVC_DECLTYPEAUTO_RETURNTYPE_662735 // 3. Issues fixed conditionally // Requires __declspec(empty_bases) // Empty base optimization # define BOOST_HANA_WORKAROUND_MSVC_EMPTYBASE // Requires /experimental:preprocessor // Variadic macro expansion # if !defined(_MSVC_TRADITIONAL) || _MSVC_TRADITIONAL # define BOOST_HANA_WORKAROUND_MSVC_PREPROCESSOR_616033 # endif # endif #elif defined(__clang__) && defined(_MSC_VER) // Clang-cl (Clang for Windows) # define BOOST_HANA_CONFIG_CLANG BOOST_HANA_CONFIG_VERSION( \ __clang_major__, __clang_minor__, __clang_patchlevel__) #elif defined(__clang__) && defined(__apple_build_version__) // Apple's Clang # if __apple_build_version__ >= 6020049 # define BOOST_HANA_CONFIG_CLANG BOOST_HANA_CONFIG_VERSION(3, 6, 0) # endif #elif defined(__clang__) // genuine Clang # define BOOST_HANA_CONFIG_CLANG BOOST_HANA_CONFIG_VERSION( \ __clang_major__, __clang_minor__, __clang_patchlevel__) #elif defined(__GNUC__) // GCC # define BOOST_HANA_CONFIG_GCC BOOST_HANA_CONFIG_VERSION( \ __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__) #endif ////////////////////////////////////////////////////////////////////////////// // Check the compiler for general C++14 capabilities ////////////////////////////////////////////////////////////////////////////// #if (__cplusplus < 201400) # if defined(_MSC_VER) # if _MSC_VER < 1915 # pragma message("Warning: Your compiler doesn't provide C++14 or higher capabilities. Try adding the compiler flag '-std=c++14' or '-std=c++1y'.") # endif # else # warning "Your compiler doesn't provide C++14 or higher capabilities. Try adding the compiler flag '-std=c++14' or '-std=c++1y'." # endif #endif ////////////////////////////////////////////////////////////////////////////// // Caveats and other compiler-dependent options ////////////////////////////////////////////////////////////////////////////// // `BOOST_HANA_CONFIG_HAS_CONSTEXPR_LAMBDA` enables some constructs requiring // `constexpr` lambdas, which are in the language starting with C++17. // // Always disabled for now because Clang only has partial support for them // (captureless lambdas only). #if defined(__cplusplus) && __cplusplus > 201402L # define BOOST_HANA_CONSTEXPR_STATELESS_LAMBDA constexpr // # define BOOST_HANA_CONFIG_HAS_CONSTEXPR_LAMBDA #else # define BOOST_HANA_CONSTEXPR_STATELESS_LAMBDA /* nothing */ #endif // `BOOST_HANA_CONSTEXPR_LAMBDA` expands to `constexpr` if constexpr lambdas // are supported and to nothing otherwise. #if defined(BOOST_HANA_CONFIG_HAS_CONSTEXPR_LAMBDA) # define BOOST_HANA_CONSTEXPR_LAMBDA constexpr #else # define BOOST_HANA_CONSTEXPR_LAMBDA /* nothing */ #endif ////////////////////////////////////////////////////////////////////////////// // Namespace macros ////////////////////////////////////////////////////////////////////////////// #define BOOST_HANA_NAMESPACE_BEGIN namespace boost { namespace hana { #define BOOST_HANA_NAMESPACE_END }} ////////////////////////////////////////////////////////////////////////////// // Library features and options that can be tweaked by users ////////////////////////////////////////////////////////////////////////////// #if defined(BOOST_HANA_DOXYGEN_INVOKED) || \ (defined(NDEBUG) && !defined(BOOST_HANA_CONFIG_DISABLE_ASSERTIONS)) //! @ingroup group-config //! Disables the `BOOST_HANA_*_ASSERT` macro & friends. //! //! When this macro is defined, the `BOOST_HANA_*_ASSERT` macro & friends //! are disabled, i.e. they expand to nothing. //! //! This macro is defined automatically when `NDEBUG` is defined. It can //! also be defined by users before including this header or defined on //! the command line. # define BOOST_HANA_CONFIG_DISABLE_ASSERTIONS #endif #if defined(BOOST_HANA_DOXYGEN_INVOKED) //! @ingroup group-config //! Disables concept checks in interface methods. //! //! When this macro is not defined (the default), tag-dispatched methods //! will make sure the arguments they are passed are models of the proper //! concept(s). This can be very helpful in catching programming errors, //! but it is also slightly less compile-time efficient. You should //! probably always leave the checks enabled (and hence never define this //! macro), except perhaps in translation units that are compiled very //! often but whose code using Hana is modified very rarely. # define BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS #endif #if defined(BOOST_HANA_DOXYGEN_INVOKED) //! @ingroup group-config //! Enables usage of the "string literal operator template" GNU extension. //! //! That operator is not part of the language yet, but it is supported by //! both Clang and GCC. This operator allows Hana to provide the nice `_s` //! user-defined literal for creating compile-time strings. //! //! When this macro is not defined, the GNU extension will be not used //! by Hana. Because this is a non-standard extension, the macro is not //! defined by default. # define BOOST_HANA_CONFIG_ENABLE_STRING_UDL #endif #if defined(BOOST_HANA_DOXYGEN_INVOKED) //! @ingroup group-config //! Enables additional assertions and sanity checks to be done by Hana. //! //! When this macro is defined (it is __not defined__ by default), //! additional sanity checks may be done by Hana. These checks may //! be costly to perform, either in terms of compilation time or in //! terms of execution time. These checks may help debugging an //! application during its initial development, but they should not //! be enabled as part of the normal configuration. # define BOOST_HANA_CONFIG_ENABLE_DEBUG_MODE #endif #endif // !BOOST_HANA_CONFIG_HPP PK �\�[w��/ / all.hppnu �[��� /*! @file Defines `boost::hana::all`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_ALL_HPP #define BOOST_HANA_ALL_HPP #include <boost/hana/fwd/all.hpp> #include <boost/hana/all_of.hpp> #include <boost/hana/concept/searchable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/functional/id.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs> constexpr auto all_t::operator()(Xs&& xs) const { using S = typename hana::tag_of<Xs>::type; using All = BOOST_HANA_DISPATCH_IF(all_impl<S>, hana::Searchable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Searchable<S>::value, "hana::all(xs) requires 'xs' to be a Searchable"); #endif return All::apply(static_cast<Xs&&>(xs)); } //! @endcond template <typename S, bool condition> struct all_impl<S, when<condition>> : default_ { template <typename Xs> static constexpr auto apply(Xs&& xs) { return hana::all_of(static_cast<Xs&&>(xs), hana::id); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_ALL_HPP PK �\�[�G�a a greater.hppnu �[��� /*! @file Defines `boost::hana::greater`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_GREATER_HPP #define BOOST_HANA_GREATER_HPP #include <boost/hana/fwd/greater.hpp> #include <boost/hana/concept/orderable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/common.hpp> #include <boost/hana/core/to.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/concepts.hpp> #include <boost/hana/detail/has_common_embedding.hpp> #include <boost/hana/detail/nested_than.hpp> // required by fwd decl #include <boost/hana/if.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename X, typename Y> constexpr decltype(auto) greater_t::operator()(X&& x, Y&& y) const { using T = typename hana::tag_of<X>::type; using U = typename hana::tag_of<Y>::type; using Greater = BOOST_HANA_DISPATCH_IF(decltype(greater_impl<T, U>{}), hana::Orderable<T>::value && hana::Orderable<U>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Orderable<T>::value, "hana::greater(x, y) requires 'x' to be Orderable"); static_assert(hana::Orderable<U>::value, "hana::greater(x, y) requires 'y' to be Orderable"); #endif return Greater::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); } //! @endcond template <typename T, typename U, bool condition> struct greater_impl<T, U, when<condition>> : default_ { template <typename X, typename Y> static constexpr decltype(auto) apply(X&& x, Y&& y) { return hana::less(static_cast<Y&&>(y), static_cast<X&&>(x)); } }; // Cross-type overload template <typename T, typename U> struct greater_impl<T, U, when< detail::has_nontrivial_common_embedding<Orderable, T, U>::value >> { using C = typename hana::common<T, U>::type; template <typename X, typename Y> static constexpr decltype(auto) apply(X&& x, Y&& y) { return hana::greater(hana::to<C>(static_cast<X&&>(x)), hana::to<C>(static_cast<Y&&>(y))); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_GREATER_HPP PK �\�[>>u�� � extend.hppnu �[��� /*! @file Defines `boost::hana::extend`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EXTEND_HPP #define BOOST_HANA_EXTEND_HPP #include <boost/hana/fwd/extend.hpp> #include <boost/hana/concept/comonad.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/duplicate.hpp> #include <boost/hana/transform.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename W_, typename F> constexpr decltype(auto) extend_t::operator()(W_&& w, F&& f) const { using W = typename hana::tag_of<W_>::type; using Extend = BOOST_HANA_DISPATCH_IF(extend_impl<W>, hana::Comonad<W>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Comonad<W>::value, "hana::extend(w, f) requires 'w' to be a Comonad"); #endif return Extend::apply(static_cast<W_&&>(w), static_cast<F&&>(f)); } //! @endcond template <typename W, bool condition> struct extend_impl<W, when<condition>> : default_ { template <typename X, typename F> static constexpr decltype(auto) apply(X&& x, F&& f) { return hana::transform(hana::duplicate(static_cast<X&&>(x)), static_cast<F&&>(f)); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_EXTEND_HPP PK �\�[� {" " all_of.hppnu �[��� /*! @file Defines `boost::hana::all_of`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_ALL_OF_HPP #define BOOST_HANA_ALL_OF_HPP #include <boost/hana/fwd/all_of.hpp> #include <boost/hana/any_of.hpp> #include <boost/hana/concept/searchable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/functional/compose.hpp> #include <boost/hana/not.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Pred> constexpr auto all_of_t::operator()(Xs&& xs, Pred&& pred) const { using S = typename hana::tag_of<Xs>::type; using AllOf = BOOST_HANA_DISPATCH_IF(all_of_impl<S>, hana::Searchable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Searchable<S>::value, "hana::all_of(xs, pred) requires 'xs' to be a Searchable"); #endif return AllOf::apply(static_cast<Xs&&>(xs), static_cast<Pred&&>(pred)); } //! @endcond template <typename S, bool condition> struct all_of_impl<S, when<condition>> : default_ { template <typename Xs, typename Pred> static constexpr auto apply(Xs&& xs, Pred&& pred) { return hana::not_(hana::any_of(static_cast<Xs&&>(xs), hana::compose(hana::not_, static_cast<Pred&&>(pred)))); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_ALL_OF_HPP PK �\�[#��� cartesian_product.hppnu �[��� /*! @file Defines `boost::hana::cartesian_product`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CARTESIAN_PRODUCT_HPP #define BOOST_HANA_CARTESIAN_PRODUCT_HPP #include <boost/hana/fwd/cartesian_product.hpp> #include <boost/hana/at.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/detail/array.hpp> #include <boost/hana/integral_constant.hpp> #include <boost/hana/length.hpp> #include <boost/hana/unpack.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs> constexpr auto cartesian_product_t::operator()(Xs&& xs) const { using S = typename hana::tag_of<Xs>::type; using CartesianProduct = BOOST_HANA_DISPATCH_IF( cartesian_product_impl<S>, hana::Sequence<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Sequence<S>::value, "hana::cartesian_product(xs) requires 'xs' to be a Sequence"); #endif return CartesianProduct::apply(static_cast<Xs&&>(xs)); } //! @endcond namespace detail { template <std::size_t ...Lengths> struct cartesian_product_indices { static constexpr std::size_t total_length() { std::size_t lengths[sizeof...(Lengths)] = {Lengths...}; std::size_t r = 1; for (std::size_t len: lengths) r *= len; return r; } static constexpr std::size_t length = total_length(); static constexpr auto indices_of(std::size_t i) { constexpr std::size_t lengths[sizeof...(Lengths)] = {Lengths...}; constexpr std::size_t n = sizeof...(Lengths); detail::array<std::size_t, n> result{}; for (std::size_t j = n; j--;) { result[j] = i % lengths[j]; i /= lengths[j]; } return result; } template <typename S, std::size_t n, std::size_t ...k, typename ...Xs> static constexpr auto product_element(std::index_sequence<k...>, Xs&& ...xs) { constexpr auto indices = indices_of(n); return hana::make<S>(hana::at_c<indices[k]>(xs)...); } template <typename S, std::size_t ...n, typename ...Xs> static constexpr auto create_product(std::index_sequence<n...>, Xs&& ...xs) { return hana::make<S>(product_element<S, n>( std::make_index_sequence<sizeof...(Xs)>{}, xs... )...); } }; } // Credits: implementation adapted from http://github.com/alexk7/hel. template <typename S, bool condition> struct cartesian_product_impl<S, when<condition>> : default_ { template <typename Xs> static constexpr auto apply(Xs&& xs) { return hana::unpack(static_cast<Xs&&>(xs), cartesian_product_impl{}); } template <typename ...Xs> constexpr auto operator()(Xs&& ...xs) const { using indices = detail::cartesian_product_indices< decltype(hana::length(xs))::value... >; return indices::template create_product<S>( std::make_index_sequence<indices::length>{}, static_cast<Xs&&>(xs)...); } constexpr auto operator()() const { return hana::make<S>(); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CARTESIAN_PRODUCT_HPP PK �\�[�]6oY Y while.hppnu �[��� /*! @file Defines `boost::hana::while_`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_WHILE_HPP #define BOOST_HANA_WHILE_HPP #include <boost/hana/fwd/while.hpp> #include <boost/hana/bool.hpp> #include <boost/hana/concept/constant.hpp> #include <boost/hana/concept/constant.hpp> #include <boost/hana/concept/logical.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/to.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/canonical_constant.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Pred, typename State, typename F> constexpr decltype(auto) while_t::operator()(Pred&& pred, State&& state, F&& f) const { using Cond = decltype(pred(state)); using Bool = typename hana::tag_of<Cond>::type; using While = BOOST_HANA_DISPATCH_IF(while_impl<Bool>, hana::Logical<Bool>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Logical<Bool>::value, "hana::while_(pred, state, f) requires 'pred(state)' to be a Logical"); #endif return While::apply(static_cast<Pred&&>(pred), static_cast<State&&>(state), static_cast<F&&>(f)); } //! @endcond template <typename L, bool condition> struct while_impl<L, hana::when<condition>> : hana::default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; template <typename L> struct while_impl<L, hana::when<std::is_arithmetic<L>::value>> { template <typename Pred, typename State, typename F> static auto apply(Pred&& pred, State&& state, F&& f) -> decltype( true ? f(static_cast<State&&>(state)) : static_cast<State&&>(state) ) { if (pred(state)) { decltype(auto) r = f(static_cast<State&&>(state)); return hana::while_(static_cast<Pred&&>(pred), static_cast<decltype(r)&&>(r), static_cast<F&&>(f)); } else { return static_cast<State&&>(state); } } }; template <typename C> struct while_impl<C, hana::when< hana::Constant<C>::value && hana::Logical<typename C::value_type>::value >> { template <typename Pred, typename State, typename F> static constexpr State while_helper(hana::false_, Pred&&, State&& state, F&&) { return static_cast<State&&>(state); } template <typename Pred, typename State, typename F> static constexpr decltype(auto) while_helper(hana::true_, Pred&& pred, State&& state, F&& f) { decltype(auto) r = f(static_cast<State&&>(state)); return hana::while_(static_cast<Pred&&>(pred), static_cast<decltype(r)&&>(r), static_cast<F&&>(f)); } template <typename Pred, typename State, typename F> static constexpr decltype(auto) apply(Pred&& pred, State&& state, F&& f) { // Since `pred(state)` returns a `Constant`, we do not actually // need to call it; we only need its decltype. However, we still // call it to run potential side effects. I'm not sure whether // that is desirable, since we pretty much take for granted that // functions are pure, but we'll do it like this for now. Also, I // think there is something rather deep hidden behind this, and // understanding what must be done here should give us a better // understanding of something non-trivial. auto cond_ = pred(state); constexpr auto cond = hana::value(cond_); constexpr bool truth_value = hana::if_(cond, true, false); return while_helper(hana::bool_c<truth_value>, static_cast<Pred&&>(pred), static_cast<State&&>(state), static_cast<F&&>(f)); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_WHILE_HPP PK �\�[{�/ functional/lockstep.hppnu �[��� /*! @file Defines `boost::hana::lockstep`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FUNCTIONAL_LOCKSTEP_HPP #define BOOST_HANA_FUNCTIONAL_LOCKSTEP_HPP #include <boost/hana/basic_tuple.hpp> #include <boost/hana/config.hpp> #include <boost/hana/detail/decay.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-functional //! Invoke a function with the result of invoking other functions on its //! arguments, in lockstep. //! //! Specifically, `lockstep(f)(g1, ..., gN)` is a function such that //! @code //! lockstep(f)(g1, ..., gN)(x1, ..., xN) == f(g1(x1), ..., gN(xN)) //! @endcode //! //! Since each `g` is invoked on its corresponding argument in lockstep, //! the number of arguments must match the number of `g`s. //! //! //! Example //! ------- //! @include example/functional/lockstep.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto lockstep = [](auto&& f, auto&& ...g) { return [perfect-capture](auto&& ...x) -> decltype(auto) { return forwarded(f)(forwarded(g)(forwarded(x))...); }; }; #else template <typename Indices, typename F, typename ...G> struct lockstep_t; template <typename F> struct pre_lockstep_t; struct make_pre_lockstep_t { struct secret { }; template <typename F> constexpr pre_lockstep_t<typename detail::decay<F>::type> operator()(F&& f) const { return {static_cast<F&&>(f)}; } }; template <std::size_t ...n, typename F, typename ...G> struct lockstep_t<std::index_sequence<n...>, F, G...> { template <typename ...T> constexpr lockstep_t(make_pre_lockstep_t::secret, T&& ...t) : storage_{static_cast<T&&>(t)...} { } basic_tuple<F, G...> storage_; template <typename ...X> constexpr decltype(auto) operator()(X&& ...x) const& { return hana::at_c<0>(storage_)( hana::at_c<n+1>(storage_)(static_cast<X&&>(x))... ); } template <typename ...X> constexpr decltype(auto) operator()(X&& ...x) & { return hana::at_c<0>(storage_)( hana::at_c<n+1>(storage_)(static_cast<X&&>(x))... ); } template <typename ...X> constexpr decltype(auto) operator()(X&& ...x) && { return static_cast<F&&>(hana::at_c<0>(storage_))( static_cast<G&&>(hana::at_c<n+1>(storage_))(static_cast<X&&>(x))... ); } }; template <typename F> struct pre_lockstep_t { F f; template <typename ...G> constexpr lockstep_t<std::make_index_sequence<sizeof...(G)>, F, typename detail::decay<G>::type...> operator()(G&& ...g) const& { return {make_pre_lockstep_t::secret{}, this->f, static_cast<G&&>(g)...}; } template <typename ...G> constexpr lockstep_t<std::make_index_sequence<sizeof...(G)>, F, typename detail::decay<G>::type...> operator()(G&& ...g) && { return {make_pre_lockstep_t::secret{}, static_cast<F&&>(this->f), static_cast<G&&>(g)...}; } }; constexpr make_pre_lockstep_t lockstep{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FUNCTIONAL_LOCKSTEP_HPP PK �\�[�v\�2 �2 functional/placeholder.hppnu �[��� /*! @file Defines `boost::hana::_`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FUNCTIONAL_PLACEHOLDER_HPP #define BOOST_HANA_FUNCTIONAL_PLACEHOLDER_HPP #include <boost/hana/basic_tuple.hpp> #include <boost/hana/config.hpp> #include <boost/hana/detail/create.hpp> #include <boost/hana/detail/decay.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-functional //! Create simple functions representing C++ operators inline. //! //! Specifically, `_` is an object used as a placeholder to build //! function objects representing calls to C++ operators. It works //! by overloading the operators between `_` and any object so that //! they return a function object which actually calls the corresponding //! operator on its argument(s). Hence, for any supported operator `@`: //! @code //! (_ @ _)(x, y) == x @ y //! @endcode //! //! Operators may also be partially applied to one argument inline: //! @code //! (x @ _)(y) == x @ y //! (_ @ y)(x) == x @ y //! @endcode //! //! When invoked with more arguments than required, functions created with //! `_` will discard the superfluous instead of triggering an error: //! @code //! (_ @ _)(x, y, z...) == x @ y //! @endcode //! //! This makes functions created with `_` easier to use in higher-order //! algorithms, which sometime provide more information than necessary //! to their callbacks. //! //! ### Supported operators //! - Arithmetic: binary `+`, binary `-`, `/`, `*`, `%`, unary `+`, unary `-` //! - Bitwise: `~`, `&`, `|`, `^`, `<<`, `>>` //! - Comparison: `==`, `!=`, `<`, `<=`, `>`, `>=` //! - %Logical: `||`, `&&`, `!` //! - Member access: `*` (dereference), `[]` (array subscript) //! - Other: `()` (function call) //! //! More complex functionality like the ability to compose placeholders //! into larger function objects inline are not supported. This is on //! purpose; you should either use C++14 generic lambdas or a library //! like [Boost.Phoenix][] if you need bigger guns. The goal here is //! to save you a couple of characters in simple situations. //! //! ### Example //! @include example/functional/placeholder.cpp //! //! [Boost.Phoenix]: http://www.boost.org/doc/libs/release/libs/phoenix/doc/html/index.html #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr unspecified _{}; #else namespace placeholder_detail { template <typename I> struct subscript { I i; template <typename Xs, typename ...Z> constexpr auto operator()(Xs&& xs, Z const& ...) const& -> decltype(static_cast<Xs&&>(xs)[i]) { return static_cast<Xs&&>(xs)[i]; } template <typename Xs, typename ...Z> constexpr auto operator()(Xs&& xs, Z const& ...) & -> decltype(static_cast<Xs&&>(xs)[i]) { return static_cast<Xs&&>(xs)[i]; } template <typename Xs, typename ...Z> constexpr auto operator()(Xs&& xs, Z const& ...) && -> decltype(static_cast<Xs&&>(xs)[std::declval<I>()]) { return static_cast<Xs&&>(xs)[std::move(i)]; } }; template <typename F, typename Xs, std::size_t ...i> constexpr decltype(auto) invoke_impl(F&& f, Xs&& xs, std::index_sequence<i...>) { return static_cast<F&&>(f)(hana::at_c<i>(static_cast<Xs&&>(xs).storage_)...); } template <typename ...X> struct invoke; struct placeholder { struct secret { }; template <typename X> constexpr decltype(auto) operator[](X&& x) const { return detail::create<subscript>{}(static_cast<X&&>(x)); } template <typename ...X> constexpr invoke<typename detail::decay<X>::type...> operator()(X&& ...x) const { return {secret{}, static_cast<X&&>(x)...}; } }; template <typename ...X> struct invoke { template <typename ...Y> constexpr invoke(placeholder::secret, Y&& ...y) : storage_{static_cast<Y&&>(y)...} { } basic_tuple<X...> storage_; template <typename F, typename ...Z> constexpr auto operator()(F&& f, Z const& ...) const& -> decltype( static_cast<F&&>(f)(std::declval<X const&>()...) ) { return invoke_impl(static_cast<F&&>(f), *this, std::make_index_sequence<sizeof...(X)>{}); } template <typename F, typename ...Z> constexpr auto operator()(F&& f, Z const& ...) & -> decltype( static_cast<F&&>(f)(std::declval<X&>()...) ) { return invoke_impl(static_cast<F&&>(f), *this, std::make_index_sequence<sizeof...(X)>{}); } template <typename F, typename ...Z> constexpr auto operator()(F&& f, Z const& ...) && -> decltype( static_cast<F&&>(f)(std::declval<X&&>()...) ) { return invoke_impl(static_cast<F&&>(f), static_cast<invoke&&>(*this), std::make_index_sequence<sizeof...(X)>{}); } }; #define BOOST_HANA_PLACEHOLDER_BINARY_OP(op, op_name) \ template <typename X> \ struct op_name ## _left { \ X x; \ \ template <typename Y, typename ...Z> \ constexpr auto operator()(Y&& y, Z const& ...) const& -> decltype( \ std::declval<X const&>() op static_cast<Y&&>(y)) \ { return x op static_cast<Y&&>(y); } \ \ template <typename Y, typename ...Z> \ constexpr auto operator()(Y&& y, Z const& ...) & -> decltype( \ std::declval<X&>() op static_cast<Y&&>(y)) \ { return x op static_cast<Y&&>(y); } \ \ template <typename Y, typename ...Z> \ constexpr auto operator()(Y&& y, Z const& ...) && -> decltype( \ std::declval<X>() op static_cast<Y&&>(y)) \ { return std::move(x) op static_cast<Y&&>(y); } \ }; \ \ template <typename Y> \ struct op_name ## _right { \ Y y; \ \ template <typename X, typename ...Z> \ constexpr auto operator()(X&& x, Z const& ...) const& -> decltype( \ static_cast<X&&>(x) op std::declval<Y const&>()) \ { return static_cast<X&&>(x) op y; } \ \ template <typename X, typename ...Z> \ constexpr auto operator()(X&& x, Z const& ...) & -> decltype( \ static_cast<X&&>(x) op std::declval<Y&>()) \ { return static_cast<X&&>(x) op y; } \ \ template <typename X, typename ...Z> \ constexpr auto operator()(X&& x, Z const& ...) && -> decltype( \ static_cast<X&&>(x) op std::declval<Y>()) \ { return static_cast<X&&>(x) op std::move(y); } \ }; \ \ struct op_name { \ template <typename X, typename Y, typename ...Z> \ constexpr auto operator()(X&& x, Y&& y, Z const& ...) const -> decltype(\ static_cast<X&&>(x) op static_cast<Y&&>(y)) \ { return static_cast<X&&>(x) op static_cast<Y&&>(y); } \ }; \ \ template <typename X> \ constexpr decltype(auto) operator op (X&& x, placeholder) \ { return detail::create<op_name ## _left>{}(static_cast<X&&>(x)); } \ \ template <typename Y> \ constexpr decltype(auto) operator op (placeholder, Y&& y) \ { return detail::create<op_name ## _right>{}(static_cast<Y&&>(y)); } \ \ inline constexpr decltype(auto) operator op (placeholder, placeholder) \ { return op_name{}; } \ /**/ #define BOOST_HANA_PLACEHOLDER_UNARY_OP(op, op_name) \ struct op_name { \ template <typename X, typename ...Z> \ constexpr auto operator()(X&& x, Z const& ...) const \ -> decltype(op static_cast<X&&>(x)) \ { return op static_cast<X&&>(x); } \ }; \ \ inline constexpr decltype(auto) operator op (placeholder) \ { return op_name{}; } \ /**/ // Arithmetic BOOST_HANA_PLACEHOLDER_UNARY_OP(+, unary_plus) BOOST_HANA_PLACEHOLDER_UNARY_OP(-, unary_minus) BOOST_HANA_PLACEHOLDER_BINARY_OP(+, plus) BOOST_HANA_PLACEHOLDER_BINARY_OP(-, minus) BOOST_HANA_PLACEHOLDER_BINARY_OP(*, times) BOOST_HANA_PLACEHOLDER_BINARY_OP(/, divide) BOOST_HANA_PLACEHOLDER_BINARY_OP(%, modulo) // Bitwise BOOST_HANA_PLACEHOLDER_UNARY_OP(~, bitwise_not) BOOST_HANA_PLACEHOLDER_BINARY_OP(&, bitwise_and) BOOST_HANA_PLACEHOLDER_BINARY_OP(|, bitwise_or) BOOST_HANA_PLACEHOLDER_BINARY_OP(^, bitwise_xor) BOOST_HANA_PLACEHOLDER_BINARY_OP(<<, left_shift) BOOST_HANA_PLACEHOLDER_BINARY_OP(>>, right_shift) // Comparison BOOST_HANA_PLACEHOLDER_BINARY_OP(==, equal) BOOST_HANA_PLACEHOLDER_BINARY_OP(!=, not_equal) BOOST_HANA_PLACEHOLDER_BINARY_OP(<, less) BOOST_HANA_PLACEHOLDER_BINARY_OP(<=, less_equal) BOOST_HANA_PLACEHOLDER_BINARY_OP(>, greater) BOOST_HANA_PLACEHOLDER_BINARY_OP(>=, greater_equal) // Logical BOOST_HANA_PLACEHOLDER_BINARY_OP(||, logical_or) BOOST_HANA_PLACEHOLDER_BINARY_OP(&&, logical_and) BOOST_HANA_PLACEHOLDER_UNARY_OP(!, logical_not) // Member access (array subscript is a member function) BOOST_HANA_PLACEHOLDER_UNARY_OP(*, dereference) // Other (function call is a member function) #undef BOOST_HANA_PREFIX_PLACEHOLDER_OP #undef BOOST_HANA_BINARY_PLACEHOLDER_OP } // end namespace placeholder_detail constexpr placeholder_detail::placeholder _{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FUNCTIONAL_PLACEHOLDER_HPP PK �\�[�sF:A A functional/compose.hppnu �[��� /*! @file Defines `boost::hana::compose`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FUNCTIONAL_COMPOSE_HPP #define BOOST_HANA_FUNCTIONAL_COMPOSE_HPP #include <boost/hana/config.hpp> #include <boost/hana/detail/create.hpp> #include <boost/hana/detail/variadic/foldl1.hpp> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-functional //! Return the composition of two functions or more. //! //! `compose` is defined inductively. When given more than two functions, //! `compose(f, g, h...)` is equivalent to `compose(f, compose(g, h...))`. //! When given two functions, `compose(f, g)` is a function such that //! @code //! compose(f, g)(x, y...) == f(g(x), y...) //! @endcode //! //! If you need composition of the form `f(g(x, y...))`, use `demux` instead. //! //! @note //! `compose` is an associative operation; `compose(f, compose(g, h))` //! is equivalent to `compose(compose(f, g), h)`. //! //! @internal //! ### Proof of associativity //! //! @code //! compose(f, compose(g, h))(x, xs...) == f(compose(g, h)(x), xs...) //! == f(g(h(x)), xs...) //! //! compose(compose(f, g), h)(x, xs...) == compose(f, g)(h(x), xs...) //! == f(g(h(x)), xs...) //! @endcode //! @endinternal //! //! ### Example //! @include example/functional/compose.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto compose = [](auto&& f1, auto&& f2, ..., auto&& fn) { return [perfect-capture](auto&& x, auto&& ...xs) -> decltype(auto) { return forwarded(f1)( forwarded(f2)( ... forwarded(fn)(forwarded(x)) ), forwarded(xs)... ); } }; #else template <typename F, typename G> struct _compose { F f; G g; template <typename X, typename ...Xs> constexpr decltype(auto) operator()(X&& x, Xs&& ...xs) const& { return f( g(static_cast<X&&>(x)), static_cast<Xs&&>(xs)... ); } template <typename X, typename ...Xs> constexpr decltype(auto) operator()(X&& x, Xs&& ...xs) & { return f( g(static_cast<X&&>(x)), static_cast<Xs&&>(xs)... ); } template <typename X, typename ...Xs> constexpr decltype(auto) operator()(X&& x, Xs&& ...xs) && { return std::move(f)( std::move(g)(static_cast<X&&>(x)), static_cast<Xs&&>(xs)... ); } }; struct _make_compose { template <typename F, typename G, typename ...H> constexpr decltype(auto) operator()(F&& f, G&& g, H&& ...h) const { return detail::variadic::foldl1(detail::create<_compose>{}, static_cast<F&&>(f), static_cast<G&&>(g), static_cast<H&&>(h)... ); } }; constexpr _make_compose compose{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FUNCTIONAL_COMPOSE_HPP PK �\�[Rʆى � functional/id.hppnu �[��� /*! @file Defines `boost::hana::id`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FUNCTIONAL_ID_HPP #define BOOST_HANA_FUNCTIONAL_ID_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-functional //! The identity function -- returns its argument unchanged. //! //! ### Example //! @include example/functional/id.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto id = [](auto&& x) -> decltype(auto) { return forwarded(x); }; #else struct id_t { template <typename T> constexpr T operator()(T&& t) const { return static_cast<T&&>(t); } }; constexpr id_t id{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FUNCTIONAL_ID_HPP PK �\�[�&:6� � functional/arg.hppnu �[��� /*! @file Defines `boost::hana::arg`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FUNCTIONAL_ARG_HPP #define BOOST_HANA_FUNCTIONAL_ARG_HPP #include <boost/hana/config.hpp> #include <cstddef> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-functional //! Return the `n`th passed argument. //! //! Specifically, `arg<n>(x1, ..., xn, ..., xm)` is equivalent to `xn`. //! Note that indexing starts at 1, so `arg<1>` returns the 1st argument, //! `arg<2>` the 2nd and so on. Using `arg<0>` is an error. Passing //! less than `n` arguments to `arg<n>` is also an error. //! //! //! @tparam n //! An unsigned integer representing the argument to return. `n` must be //! positive (meaning nonzero). //! //! @param x1, ..., xm //! A variadic pack of arguments from which the `n`th one is returned. //! //! //! @internal //! ### Discussion: could `n` be dynamic? //! We could have chosen `arg` to be used like `arg(n)(x...)` instead of //! `arg<n>(x...)`. Provided all the arguments were of the same type, it //! would then be possible for `n` to only be known at runtime. However, //! we would then lose the ability to assert the in-boundedness of `n` //! statically. //! //! ### Rationale for `n` being a non-type template parameter //! I claim that the only interesting use case is with a compile-time //! `n`, which means that the usage would become `arg(int_<n>)(x...)`, //! which is more cumbersome to write than `arg<n>(x...)`. This is open //! for discussion. //! @endinternal //! //! ### Example //! @include example/functional/arg.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <std::size_t n> constexpr auto arg = [](auto&& x1, ..., auto&& xm) -> decltype(auto) { return forwarded(xn); }; #else template <std::size_t n, typename = void> struct arg_t; template <> struct arg_t<1> { template <typename X1, typename ...Xn> constexpr X1 operator()(X1&& x1, Xn&& ...) const { return static_cast<X1&&>(x1); } }; template <> struct arg_t<2> { template <typename X1, typename X2, typename ...Xn> constexpr X2 operator()(X1&&, X2&& x2, Xn&& ...) const { return static_cast<X2&&>(x2); } }; template <> struct arg_t<3> { template <typename X1, typename X2, typename X3, typename ...Xn> constexpr X3 operator()(X1&&, X2&&, X3&& x3, Xn&& ...) const { return static_cast<X3&&>(x3); } }; template <> struct arg_t<4> { template <typename X1, typename X2, typename X3, typename X4, typename ...Xn> constexpr X4 operator()(X1&&, X2&&, X3&&, X4&& x4, Xn&& ...) const { return static_cast<X4&&>(x4); } }; template <> struct arg_t<5> { template <typename X1, typename X2, typename X3, typename X4, typename X5, typename ...Xn> constexpr X5 operator()(X1&&, X2&&, X3&&, X4&&, X5&& x5, Xn&& ...) const { return static_cast<X5&&>(x5); } }; template <std::size_t n, typename> struct arg_t { static_assert(n > 0, "invalid usage of boost::hana::arg<n> with n == 0"); template <typename X1, typename X2, typename X3, typename X4, typename X5, typename ...Xn> constexpr decltype(auto) operator()(X1&&, X2&&, X3&&, X4&&, X5&&, Xn&& ...xn) const { static_assert(sizeof...(xn) >= n - 5, "invalid usage of boost::hana::arg<n> with too few arguments"); // Since compilers will typically try to continue for a bit after // an error/static assertion, we must avoid sending the compiler // in a very long computation if n == 0. return arg_t<n == 0 ? 1 : n - 5>{}(static_cast<Xn&&>(xn)...); } }; template <std::size_t n> struct arg_t<n, std::enable_if_t<(n > 25)>> { template < typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12, typename X13, typename X14, typename X15, typename X16, typename X17, typename X18, typename X19, typename X20, typename X21, typename X22, typename X23, typename X24, typename X25, typename ...Xn> constexpr decltype(auto) operator()(X1&&, X2&&, X3&&, X4&&, X5&&, X6&&, X7&&, X8&&, X9&&, X10&&, X11&&, X12&&, X13&&, X14&&, X15&&, X16&&, X17&&, X18&&, X19&&, X20&&, X21&&, X22&&, X23&&, X24&&, X25&&, Xn&& ...xn) const { return arg_t<n - 25>{}(static_cast<Xn&&>(xn)...); } }; template <std::size_t n> constexpr arg_t<n> arg{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FUNCTIONAL_ARG_HPP PK �\�[I�} functional/flip.hppnu �[��� /*! @file Defines `boost::hana::flip`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FUNCTIONAL_FLIP_HPP #define BOOST_HANA_FUNCTIONAL_FLIP_HPP #include <boost/hana/config.hpp> #include <boost/hana/detail/create.hpp> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-functional //! Invoke a function with its two first arguments reversed. //! //! Specifically, `flip(f)` is a function such that //! @code //! flip(f)(x, y, z...) == f(y, x, z...) //! @endcode //! //! ### Example //! @include example/functional/flip.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto flip = [](auto&& f) { return [perfect-capture](auto&& x, auto&& y, auto&& ...z) -> decltype(auto) { return forwarded(f)(forwarded(y), forwarded(x), forwarded(z)...); }; }; #else template <typename F> struct flip_t { F f; template <typename X, typename Y, typename ...Z> constexpr decltype(auto) operator()(X&& x, Y&& y, Z&& ...z) const& { return f( static_cast<Y&&>(y), static_cast<X&&>(x), static_cast<Z&&>(z)... ); } template <typename X, typename Y, typename ...Z> constexpr decltype(auto) operator()(X&& x, Y&& y, Z&& ...z) & { return f( static_cast<Y&&>(y), static_cast<X&&>(x), static_cast<Z&&>(z)... ); } template <typename X, typename Y, typename ...Z> constexpr decltype(auto) operator()(X&& x, Y&& y, Z&& ...z) && { return std::move(f)( static_cast<Y&&>(y), static_cast<X&&>(x), static_cast<Z&&>(z)... ); } }; constexpr detail::create<flip_t> flip{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FUNCTIONAL_FLIP_HPP PK �\�[�%|| | functional/apply.hppnu �[��� /*! @file Defines `boost::hana::apply`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FUNCTIONAL_APPLY_HPP #define BOOST_HANA_FUNCTIONAL_APPLY_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-functional //! Invokes a Callable with the given arguments. //! //! This is equivalent to [std::invoke][1] that will be added in C++17. //! However, `apply` is a function object instead of a function, which //! makes it possible to pass it to higher-order algorithms. //! //! //! @param f //! A [Callable][2] to be invoked with the given arguments. //! //! @param x... //! The arguments to call `f` with. The number of `x...` must match the //! arity of `f`. //! //! //! Example //! ------- //! @include example/functional/apply.cpp //! //! [1]: http://en.cppreference.com/w/cpp/utility/functional/invoke //! [2]: http://en.cppreference.com/w/cpp/named_req/Callable #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto apply = [](auto&& f, auto&& ...x) -> decltype(auto) { return forwarded(f)(forwarded(x)...); }; #else struct apply_t { template <typename F, typename... Args> constexpr auto operator()(F&& f, Args&&... args) const -> decltype(static_cast<F&&>(f)(static_cast<Args&&>(args)...)) { return static_cast<F&&>(f)(static_cast<Args&&>(args)...); } template <typename Base, typename T, typename Derived> constexpr auto operator()(T Base::*pmd, Derived&& ref) const -> decltype(static_cast<Derived&&>(ref).*pmd) { return static_cast<Derived&&>(ref).*pmd; } template <typename PMD, typename Pointer> constexpr auto operator()(PMD pmd, Pointer&& ptr) const -> decltype((*static_cast<Pointer&&>(ptr)).*pmd) { return (*static_cast<Pointer&&>(ptr)).*pmd; } template <typename Base, typename T, typename Derived, typename... Args> constexpr auto operator()(T Base::*pmf, Derived&& ref, Args&&... args) const -> decltype((static_cast<Derived&&>(ref).*pmf)(static_cast<Args&&>(args)...)) { return (static_cast<Derived&&>(ref).*pmf)(static_cast<Args&&>(args)...); } template <typename PMF, typename Pointer, typename... Args> constexpr auto operator()(PMF pmf, Pointer&& ptr, Args&& ...args) const -> decltype(((*static_cast<Pointer&&>(ptr)).*pmf)(static_cast<Args&&>(args)...)) { return ((*static_cast<Pointer&&>(ptr)).*pmf)(static_cast<Args&&>(args)...); } }; constexpr apply_t apply{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FUNCTIONAL_APPLY_HPP PK �\�[Ӓ�qn n functional/iterate.hppnu �[��� /*! @file Defines `boost::hana::iterate`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FUNCTIONAL_ITERATE_HPP #define BOOST_HANA_FUNCTIONAL_ITERATE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/functional/partial.hpp> #include <cstddef> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-functional //! Applies another function `n` times to its argument. //! //! Given a function `f` and an argument `x`, `iterate<n>(f, x)` returns //! the result of applying `f` `n` times to its argument. In other words, //! @code //! iterate<n>(f, x) == f(f( ... f(x))) //! ^^^^^^^^^^ n times total //! @endcode //! //! If `n == 0`, `iterate<n>(f, x)` returns the `x` argument unchanged //! and `f` is never applied. It is important to note that the function //! passed to `iterate<n>` must be a unary function. Indeed, since `f` //! will be called with the result of the previous `f` application, it //! may only take a single argument. //! //! In addition to what's documented above, `iterate` can also be //! partially applied to the function argument out-of-the-box. In //! other words, `iterate<n>(f)` is a function object applying `f` //! `n` times to the argument it is called with, which means that //! @code //! iterate<n>(f)(x) == iterate<n>(f, x) //! @endcode //! //! This is provided for convenience, and it turns out to be especially //! useful in conjunction with higher-order algorithms. //! //! //! Signature //! --------- //! Given a function \f$ f : T \to T \f$ and `x` and argument of data //! type `T`, the signature is //! \f$ //! \mathtt{iterate_n} : (T \to T) \times T \to T //! \f$ //! //! @tparam n //! An unsigned integer representing the number of times that `f` //! should be applied to its argument. //! //! @param f //! A function to apply `n` times to its argument. //! //! @param x //! The initial value to call `f` with. //! //! //! Example //! ------- //! @include example/functional/iterate.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <std::size_t n> constexpr auto iterate = [](auto&& f) { return [perfect-capture](auto&& x) -> decltype(auto) { return f(f( ... f(forwarded(x)))); }; }; #else template <std::size_t n, typename = when<true>> struct iterate_t; template <> struct iterate_t<0> { template <typename F, typename X> constexpr X operator()(F&&, X&& x) const { return static_cast<X&&>(x); } }; template <> struct iterate_t<1> { template <typename F, typename X> constexpr decltype(auto) operator()(F&& f, X&& x) const { return f(static_cast<X&&>(x)); } }; template <> struct iterate_t<2> { template <typename F, typename X> constexpr decltype(auto) operator()(F&& f, X&& x) const { return f(f(static_cast<X&&>(x))); } }; template <> struct iterate_t<3> { template <typename F, typename X> constexpr decltype(auto) operator()(F&& f, X&& x) const { return f(f(f(static_cast<X&&>(x)))); } }; template <> struct iterate_t<4> { template <typename F, typename X> constexpr decltype(auto) operator()(F&& f, X&& x) const { return f(f(f(f(static_cast<X&&>(x))))); } }; template <> struct iterate_t<5> { template <typename F, typename X> constexpr decltype(auto) operator()(F&& f, X&& x) const { return f(f(f(f(f(static_cast<X&&>(x)))))); } }; template <std::size_t n> struct iterate_t<n, when<(n >= 6) && (n < 12)>> { template <typename F, typename X> constexpr decltype(auto) operator()(F&& f, X&& x) const { return iterate_t<n - 6>{}(f, f(f(f(f(f(f(static_cast<X&&>(x))))))) ); } }; template <std::size_t n> struct iterate_t<n, when<(n >= 12) && (n < 24)>> { template <typename F, typename X> constexpr decltype(auto) operator()(F&& f, X&& x) const { return iterate_t<n - 12>{}(f, f(f(f(f(f(f(f(f(f(f(f(f( static_cast<X&&>(x) )))))))))))) ); } }; template <std::size_t n> struct iterate_t<n, when<(n >= 24) && (n < 48)>> { template <typename F, typename X> constexpr decltype(auto) operator()(F&& f, X&& x) const { return iterate_t<n - 24>{}(f, f(f(f(f(f(f(f(f(f(f(f(f( f(f(f(f(f(f(f(f(f(f(f(f( static_cast<X&&>(x) )))))))))))) )))))))))))) ); } }; template <std::size_t n> struct iterate_t<n, when<(n >= 48)>> { template <typename F, typename X> constexpr decltype(auto) operator()(F&& f, X&& x) const { return iterate_t<n - 48>{}(f, f(f(f(f(f(f(f(f(f(f(f(f( f(f(f(f(f(f(f(f(f(f(f(f( f(f(f(f(f(f(f(f(f(f(f(f( f(f(f(f(f(f(f(f(f(f(f(f( static_cast<X&&>(x) )))))))))))) )))))))))))) )))))))))))) )))))))))))) ); } }; template <std::size_t n> struct make_iterate_t { template <typename F> constexpr decltype(auto) operator()(F&& f) const { return hana::partial(iterate_t<n>{}, static_cast<F&&>(f)); } template <typename F, typename X> constexpr decltype(auto) operator()(F&& f, X&& x) const { return iterate_t<n>{}(static_cast<F&&>(f), static_cast<X&&>(x)); } }; template <std::size_t n> constexpr make_iterate_t<n> iterate{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FUNCTIONAL_ITERATE_HPP PK �\�[@P$�� � functional/partial.hppnu �[��� /*! @file Defines `boost::hana::partial`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FUNCTIONAL_PARTIAL_HPP #define BOOST_HANA_FUNCTIONAL_PARTIAL_HPP #include <boost/hana/basic_tuple.hpp> #include <boost/hana/config.hpp> #include <boost/hana/detail/decay.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-functional //! Partially apply a function to some arguments. //! //! Given a function `f` and some arguments, `partial` returns a new //! function corresponding to the partially applied function `f`. This //! allows providing some arguments to a function and letting the rest //! of the arguments be provided later. Specifically, `partial(f, x...)` //! is a function such that //! @code //! partial(f, x...)(y...) == f(x..., y...) //! @endcode //! //! @note //! The arity of `f` must match the total number of arguments passed to //! it, i.e. `sizeof...(x) + sizeof...(y)`. //! //! //! Example //! ------- //! @include example/functional/partial.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto partial = [](auto&& f, auto&& ...x) { return [perfect-capture](auto&& ...y) -> decltype(auto) { return forwarded(f)(forwarded(x)..., forwarded(y)...); }; }; #else template <typename Indices, typename F, typename ...X> struct partial_t; struct make_partial_t { struct secret { }; template <typename F, typename ...X> constexpr partial_t< std::make_index_sequence<sizeof...(X)>, typename detail::decay<F>::type, typename detail::decay<X>::type... > operator()(F&& f, X&& ...x) const { return {secret{}, static_cast<F&&>(f), static_cast<X&&>(x)...}; } }; template <std::size_t ...n, typename F, typename ...X> struct partial_t<std::index_sequence<n...>, F, X...> { partial_t() = default; template <typename ...T> constexpr partial_t(make_partial_t::secret, T&& ...t) : storage_{static_cast<T&&>(t)...} { } basic_tuple<F, X...> storage_; template <typename ...Y> constexpr decltype(auto) operator()(Y&& ...y) const& { return hana::at_c<0>(storage_)( hana::at_c<n+1>(storage_)..., static_cast<Y&&>(y)... ); } template <typename ...Y> constexpr decltype(auto) operator()(Y&& ...y) & { return hana::at_c<0>(storage_)( hana::at_c<n+1>(storage_)..., static_cast<Y&&>(y)... ); } template <typename ...Y> constexpr decltype(auto) operator()(Y&& ...y) && { return static_cast<F&&>(hana::at_c<0>(storage_))( static_cast<X&&>(hana::at_c<n+1>(storage_))..., static_cast<Y&&>(y)... ); } }; constexpr make_partial_t partial{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FUNCTIONAL_PARTIAL_HPP PK �\�[U�p�� � functional/always.hppnu �[��� /*! @file Defines `boost::hana::always`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FUNCTIONAL_ALWAYS_HPP #define BOOST_HANA_FUNCTIONAL_ALWAYS_HPP #include <boost/hana/config.hpp> #include <boost/hana/detail/create.hpp> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-functional //! Return a constant function returning `x` regardless of the //! argument(s) it is invoked with. //! //! Specifically, `always(x)` is a function such that //! @code //! always(x)(y...) == x //! @endcode //! for any `y...`. A copy of `x` is made and it is owned by the //! `always(x)` function. When `always(x)` is called, it will return //! a reference to the `x` it owns. This reference is valid as long //! as `always(x)` is in scope. //! //! //! ### Example //! @include example/functional/always.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto always = [](auto&& x) { return [perfect-capture](auto const& ...y) -> decltype(auto) { return forwarded(x); }; }; #else template <typename T> struct _always { T val_; template <typename ...Args> constexpr T const& operator()(Args const& ...) const& { return val_; } template <typename ...Args> constexpr T& operator()(Args const& ...) & { return val_; } template <typename ...Args> constexpr T operator()(Args const& ...) && { return std::move(val_); } }; constexpr detail::create<_always> always{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FUNCTIONAL_ALWAYS_HPP PK �\�[a � � functional/on.hppnu �[��� /*! @file Defines `boost::hana::on`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FUNCTIONAL_ON_HPP #define BOOST_HANA_FUNCTIONAL_ON_HPP #include <boost/hana/config.hpp> #include <boost/hana/detail/create.hpp> #include <boost/hana/functional/infix.hpp> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-functional //! Invoke a function with the result of invoking another function on //! each argument. //! //! Specifically, `on(f, g)` is a function such that //! @code //! on(f, g)(x...) == f(g(x)...) //! @endcode //! //! For convenience, `on` also supports infix application as provided //! by `infix`. //! //! //! @note //! `on` is associative, i.e. `on(f, on(g, h))` is equivalent to //! `on(on(f, g), h)`. //! //! @internal //! ### Proof of associativity //! //! @code //! on(f, on(g, h))(xs...) == f(on(g, h)(xs)...) //! == f(g(h(xs))...) //! //! on(on(f, g), h)(xs...) == on(f, g)(h(xs)...) //! == f(g(h(xs))...) //! @endcode //! @endinternal //! //! //! ### Example //! @include example/functional/on.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto on = infix([](auto&& f, auto&& g) { return [perfect-capture](auto&& ...x) -> decltype(auto) { return forwarded(f)(g(forwarded(x))...); }; }); #else template <typename F, typename G> struct on_t { F f; G g; template <typename ...X> constexpr decltype(auto) operator()(X&& ...x) const& { return f(g(static_cast<X&&>(x))...); } template <typename ...X> constexpr decltype(auto) operator()(X&& ...x) & { return f(g(static_cast<X&&>(x))...); } template <typename ...X> constexpr decltype(auto) operator()(X&& ...x) && { return std::move(f)(g(static_cast<X&&>(x))...); } }; constexpr auto on = infix(detail::create<on_t>{}); #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FUNCTIONAL_ON_HPP PK �\�[��17y y functional/overload.hppnu �[��� /*! @file Defines `boost::hana::overload`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FUNCTIONAL_OVERLOAD_HPP #define BOOST_HANA_FUNCTIONAL_OVERLOAD_HPP #include <boost/hana/config.hpp> #include <boost/hana/detail/decay.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-functional //! Pick one of several functions to call based on overload resolution. //! //! Specifically, `overload(f1, f2, ..., fn)` is a function object such //! that //! @code //! overload(f1, f2, ..., fn)(x...) == fk(x...) //! @endcode //! //! where `fk` is the function of `f1, ..., fn` that would be called if //! overload resolution was performed amongst that set of functions only. //! If more than one function `fk` would be picked by overload resolution, //! then the call is ambiguous. //! //! ### Example //! @include example/functional/overload.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto overload = [](auto&& f1, auto&& f2, ..., auto&& fn) { return [perfect-capture](auto&& ...x) -> decltype(auto) { return forwarded(fk)(forwarded(x)...); }; }; #else template <typename F, typename ...G> struct overload_t : overload_t<F>::type , overload_t<G...>::type { using type = overload_t; using overload_t<F>::type::operator(); using overload_t<G...>::type::operator(); template <typename F_, typename ...G_> constexpr explicit overload_t(F_&& f, G_&& ...g) : overload_t<F>::type(static_cast<F_&&>(f)) , overload_t<G...>::type(static_cast<G_&&>(g)...) { } }; template <typename F> struct overload_t<F> { using type = F; }; template <typename R, typename ...Args> struct overload_t<R(*)(Args...)> { using type = overload_t; R (*fptr_)(Args...); explicit constexpr overload_t(R (*fp)(Args...)) : fptr_(fp) { } constexpr R operator()(Args ...args) const { return fptr_(static_cast<Args&&>(args)...); } }; struct make_overload_t { template <typename ...F, typename Overload = typename overload_t< typename detail::decay<F>::type... >::type > constexpr Overload operator()(F&& ...f) const { return Overload(static_cast<F&&>(f)...); } }; constexpr make_overload_t overload{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FUNCTIONAL_OVERLOAD_HPP PK �\�[�=�{ { functional/overload_linearly.hppnu �[��� /*! @file Defines `boost::hana::overload_linearly`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FUNCTIONAL_OVERLOAD_LINEARLY_HPP #define BOOST_HANA_FUNCTIONAL_OVERLOAD_LINEARLY_HPP #include <boost/hana/config.hpp> #include <boost/hana/detail/decay.hpp> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-functional //! Call the first function that produces a valid call expression. //! //! Given functions `f1, ..., fn`, `overload_linearly(f1, ..., fn)` is //! a new function that calls the first `fk` producing a valid call //! expression with the given arguments. Specifically, //! @code //! overload_linearly(f1, ..., fn)(args...) == fk(args...) //! @endcode //! //! where `fk` is the _first_ function such that `fk(args...)` is a valid //! expression. //! //! //! Example //! ------- //! @include example/functional/overload_linearly.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto overload_linearly = [](auto&& f1, auto&& f2, ..., auto&& fn) { return [perfect-capture](auto&& ...x) -> decltype(auto) { return forwarded(fk)(forwarded(x)...); }; }; #else template <typename F, typename G> struct overload_linearly_t { F f; G g; private: template <typename ...Args, typename = decltype(std::declval<F const&>()(std::declval<Args>()...))> constexpr F const& which(int) const& { return f; } template <typename ...Args, typename = decltype(std::declval<F&>()(std::declval<Args>()...))> constexpr F& which(int) & { return f; } template <typename ...Args, typename = decltype(std::declval<F&&>()(std::declval<Args>()...))> constexpr F which(int) && { return static_cast<F&&>(f); } template <typename ...Args> constexpr G const& which(long) const& { return g; } template <typename ...Args> constexpr G& which(long) & { return g; } template <typename ...Args> constexpr G which(long) && { return static_cast<G&&>(g); } public: template <typename ...Args> constexpr decltype(auto) operator()(Args&& ...args) const& { return which<Args...>(int{})(static_cast<Args&&>(args)...); } template <typename ...Args> constexpr decltype(auto) operator()(Args&& ...args) & { return which<Args...>(int{})(static_cast<Args&&>(args)...); } template <typename ...Args> constexpr decltype(auto) operator()(Args&& ...args) && { return which<Args...>(int{})(static_cast<Args&&>(args)...); } }; struct make_overload_linearly_t { template <typename F, typename G> constexpr overload_linearly_t< typename detail::decay<F>::type, typename detail::decay<G>::type > operator()(F&& f, G&& g) const { return {static_cast<F&&>(f), static_cast<G&&>(g)}; } template <typename F, typename G, typename ...H> constexpr decltype(auto) operator()(F&& f, G&& g, H&& ...h) const { return (*this)(static_cast<F&&>(f), (*this)(static_cast<G&&>(g), static_cast<H&&>(h)...)); } template <typename F> constexpr typename detail::decay<F>::type operator()(F&& f) const { return static_cast<F&&>(f); } }; constexpr make_overload_linearly_t overload_linearly{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FUNCTIONAL_OVERLOAD_LINEARLY_HPP PK �\�[+�[Z> > functional/infix.hppnu �[��� /*! @file Defines `boost::hana::infix`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FUNCTIONAL_INFIX_HPP #define BOOST_HANA_FUNCTIONAL_INFIX_HPP #include <boost/hana/config.hpp> #include <boost/hana/detail/decay.hpp> #include <boost/hana/functional/partial.hpp> #include <boost/hana/functional/reverse_partial.hpp> #include <type_traits> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-functional //! Return an equivalent function that can also be applied in infix //! notation. //! //! Specifically, `infix(f)` is an object such that: //! @code //! infix(f)(x1, ..., xn) == f(x1, ..., xn) //! x ^infix(f)^ y == f(x, y) //! @endcode //! //! Hence, the returned function can still be applied using the usual //! function call syntax, but it also gains the ability to be applied in //! infix notation. The infix syntax allows a great deal of expressiveness, //! especially when used in combination with some higher order algorithms. //! Since `operator^` is left-associative, `x ^infix(f)^ y` is actually //! parsed as `(x ^infix(f))^ y`. However, for flexibility, the order in //! which both arguments are applied in infix notation does not matter. //! Hence, it is always the case that //! @code //! (x ^ infix(f)) ^ y == x ^ (infix(f) ^ y) //! @endcode //! //! However, note that applying more than one argument in infix //! notation to the same side of the operator will result in a //! compile-time assertion: //! @code //! (infix(f) ^ x) ^ y; // compile-time assertion //! y ^ (x ^ infix(f)); // compile-time assertion //! @endcode //! //! Additionally, a function created with `infix` may be partially applied //! in infix notation. Specifically, //! @code //! (x ^ infix(f))(y1, ..., yn) == f(x, y1, ..., yn) //! (infix(f) ^ y)(x1, ..., xn) == f(x1, ..., xn, y) //! @endcode //! //! @internal //! ### Rationales //! 1. The `^` operator was chosen because it is left-associative and //! has a low enough priority so that most expressions will render //! the expected behavior. //! 2. The operator can't be customimzed because that would require more //! sophistication in the implementation; I want to keep it as simple //! as possible. There is also an advantage in having a uniform syntax //! for infix application. //! @endinternal //! //! @param f //! The function which gains the ability to be applied in infix notation. //! The function must be at least binary; a compile-time error will be //! triggered otherwise. //! //! ### Example //! @include example/functional/infix.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto infix = [](auto f) { return unspecified; }; #else namespace infix_detail { // This needs to be in the same namespace as `operator^` so it can be // found by ADL. template <bool left, bool right, typename F> struct infix_t { F f; template <typename ...X> constexpr decltype(auto) operator()(X&& ...x) const& { return f(static_cast<X&&>(x)...); } template <typename ...X> constexpr decltype(auto) operator()(X&& ...x) & { return f(static_cast<X&&>(x)...); } template <typename ...X> constexpr decltype(auto) operator()(X&& ...x) && { return std::move(f)(static_cast<X&&>(x)...); } }; template <bool left, bool right> struct make_infix { template <typename F> constexpr infix_t<left, right, typename detail::decay<F>::type> operator()(F&& f) const { return {static_cast<F&&>(f)}; } }; template <bool left, bool right> struct Infix; struct Object; template <typename T> struct dispatch { using type = Object; }; template <bool left, bool right, typename F> struct dispatch<infix_t<left, right, F>> { using type = Infix<left, right>; }; template <typename, typename> struct bind_infix; // infix(f) ^ y template <> struct bind_infix<Infix<false, false>, Object> { template <typename F, typename Y> static constexpr decltype(auto) apply(F&& f, Y&& y) { return make_infix<false, true>{}( hana::reverse_partial( static_cast<F&&>(f), static_cast<Y&&>(y) ) ); } }; // (x^infix(f)) ^ y template <> struct bind_infix<Infix<true, false>, Object> { template <typename F, typename Y> static constexpr decltype(auto) apply(F&& f, Y&& y) { return static_cast<F&&>(f)(static_cast<Y&&>(y)); } }; // x ^ infix(f) template <> struct bind_infix<Object, Infix<false, false>> { template <typename X, typename F> static constexpr decltype(auto) apply(X&& x, F&& f) { return make_infix<true, false>{}( hana::partial(static_cast<F&&>(f), static_cast<X&&>(x)) ); } }; // x ^ (infix(f)^y) template <> struct bind_infix<Object, Infix<false, true>> { template <typename X, typename F> static constexpr decltype(auto) apply(X&& x, F&& f) { return static_cast<F&&>(f)(static_cast<X&&>(x)); } }; template <typename T> using strip = typename std::remove_cv< typename std::remove_reference<T>::type >::type; template <typename X, typename Y> constexpr decltype(auto) operator^(X&& x, Y&& y) { return bind_infix< typename dispatch<strip<X>>::type, typename dispatch<strip<Y>>::type >::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); } } // end namespace infix_detail constexpr infix_detail::make_infix<false, false> infix{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FUNCTIONAL_INFIX_HPP PK �\�[�ƀ�� � functional/fix.hppnu �[��� /*! @file Defines `boost::hana::fix`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FUNCTIONAL_FIX_HPP #define BOOST_HANA_FUNCTIONAL_FIX_HPP #include <boost/hana/config.hpp> #include <boost/hana/detail/create.hpp> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-functional //! Return a function computing the fixed point of a function. //! //! `fix` is an implementation of the [Y-combinator][], also called the //! fixed-point combinator. It encodes the idea of recursion, and in fact //! any recursive function can be written in terms of it. //! //! Specifically, `fix(f)` is a function such that //! @code //! fix(f)(x...) == f(fix(f), x...) //! @endcode //! //! This definition allows `f` to use its first argument as a continuation //! to call itself recursively. Indeed, if `f` calls its first argument //! with `y...`, it is equivalent to calling `f(fix(f), y...)` per the //! above equation. //! //! Most of the time, it is more convenient and efficient to define //! recursive functions without using a fixed-point combinator. However, //! there are some cases where `fix` provides either more flexibility //! (e.g. the ability to change the callback inside `f`) or makes it //! possible to write functions that couldn't be defined recursively //! otherwise. //! //! @param f //! A function called as `f(self, x...)`, where `x...` are the arguments //! in the `fix(f)(x...)` expression and `self` is `fix(f)`. //! //! ### Example //! @include example/functional/fix.cpp //! //! [Y-combinator]: http://en.wikipedia.org/wiki/Fixed-point_combinator #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto fix = [](auto&& f) { return [perfect-capture](auto&& ...x) -> decltype(auto) { return forwarded(f)(fix(f), forwarded(x)...); }; }; #else template <typename F> struct fix_t; constexpr detail::create<fix_t> fix{}; template <typename F> struct fix_t { F f; template <typename ...X> constexpr decltype(auto) operator()(X&& ...x) const& { return f(fix(f), static_cast<X&&>(x)...); } template <typename ...X> constexpr decltype(auto) operator()(X&& ...x) & { return f(fix(f), static_cast<X&&>(x)...); } template <typename ...X> constexpr decltype(auto) operator()(X&& ...x) && { return std::move(f)(fix(f), static_cast<X&&>(x)...); } }; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FUNCTIONAL_FIX_HPP PK �\�[ �m=T T functional/curry.hppnu �[��� /*! @file Defines `boost::hana::curry`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FUNCTIONAL_CURRY_HPP #define BOOST_HANA_FUNCTIONAL_CURRY_HPP #include <boost/hana/config.hpp> #include <boost/hana/detail/decay.hpp> #include <boost/hana/functional/apply.hpp> #include <boost/hana/functional/partial.hpp> #include <cstddef> #include <type_traits> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-functional //! Curry a function up to the given number of arguments. //! //! [Currying][Wikipedia.currying] is a technique in which we consider a //! function taking multiple arguments (or, equivalently, a tuple of //! arguments), and turn it into a function which takes a single argument //! and returns a function to handle the remaining arguments. To help //! visualize, let's denote the type of a function `f` which takes //! arguments of types `X1, ..., Xn` and returns a `R` as //! @code //! (X1, ..., Xn) -> R //! @endcode //! //! Then, currying is the process of taking `f` and turning it into an //! equivalent function (call it `g`) of type //! @code //! X1 -> (X2 -> (... -> (Xn -> R))) //! @endcode //! //! This gives us the following equivalence, where `x1`, ..., `xn` are //! objects of type `X1`, ..., `Xn` respectively: //! @code //! f(x1, ..., xn) == g(x1)...(xn) //! @endcode //! //! Currying can be useful in several situations, especially when working //! with higher-order functions. //! //! This `curry` utility is an implementation of currying in C++. //! Specifically, `curry<n>(f)` is a function such that //! @code //! curry<n>(f)(x1)...(xn) == f(x1, ..., xn) //! @endcode //! //! Note that the `n` has to be specified explicitly because the existence //! of functions with variadic arguments in C++ make it impossible to know //! when currying should stop. //! //! Unlike usual currying, this implementation also allows a curried //! function to be called with several arguments at a time. Hence, the //! following always holds //! @code //! curry<n>(f)(x1, ..., xk) == curry<n - k>(f)(x1)...(xk) //! @endcode //! //! Of course, this requires `k` to be less than or equal to `n`; failure //! to satisfy this will trigger a static assertion. This syntax is //! supported because it makes curried functions usable where normal //! functions are expected. //! //! Another "extension" is that `curry<0>(f)` is supported: `curry<0>(f)` //! is a nullary function; whereas the classical definition for currying //! seems to leave this case undefined, as nullary functions don't make //! much sense in purely functional languages. //! //! //! Example //! ------- //! @include example/functional/curry.cpp //! //! //! [Wikipedia.currying]: http://en.wikipedia.org/wiki/Currying #ifdef BOOST_HANA_DOXYGEN_INVOKED template <std::size_t n> constexpr auto curry = [](auto&& f) { return [perfect-capture](auto&& x1) { return [perfect-capture](auto&& x2) { ... return [perfect-capture](auto&& xn) -> decltype(auto) { return forwarded(f)( forwarded(x1), forwarded(x2), ..., forwarded(xn) ); }; }; }; }; #else template <std::size_t n, typename F> struct curry_t; template <std::size_t n> struct make_curry_t { template <typename F> constexpr curry_t<n, typename detail::decay<F>::type> operator()(F&& f) const { return {static_cast<F&&>(f)}; } }; template <std::size_t n> constexpr make_curry_t<n> curry{}; namespace curry_detail { namespace { template <std::size_t n> constexpr make_curry_t<n> curry_or_call{}; template <> constexpr auto curry_or_call<0> = apply; }} template <std::size_t n, typename F> struct curry_t { F f; template <typename ...X> constexpr decltype(auto) operator()(X&& ...x) const& { static_assert(sizeof...(x) <= n, "too many arguments provided to boost::hana::curry"); return curry_detail::curry_or_call<n - sizeof...(x)>( partial(f, static_cast<X&&>(x)...) ); } template <typename ...X> constexpr decltype(auto) operator()(X&& ...x) & { static_assert(sizeof...(x) <= n, "too many arguments provided to boost::hana::curry"); return curry_detail::curry_or_call<n - sizeof...(x)>( partial(f, static_cast<X&&>(x)...) ); } template <typename ...X> constexpr decltype(auto) operator()(X&& ...x) && { static_assert(sizeof...(x) <= n, "too many arguments provided to boost::hana::curry"); return curry_detail::curry_or_call<n - sizeof...(x)>( partial(std::move(f), static_cast<X&&>(x)...) ); } }; template <typename F> struct curry_t<0, F> { F f; constexpr decltype(auto) operator()() const& { return f(); } constexpr decltype(auto) operator()() & { return f(); } constexpr decltype(auto) operator()() && { return std::move(f)(); } }; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FUNCTIONAL_CURRY_HPP PK �\�[�hGN% N% functional/demux.hppnu �[��� /*! @file Defines `boost::hana::demux`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FUNCTIONAL_DEMUX_HPP #define BOOST_HANA_FUNCTIONAL_DEMUX_HPP #include <boost/hana/basic_tuple.hpp> #include <boost/hana/config.hpp> #include <boost/hana/detail/decay.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-functional //! Invoke a function with the results of invoking other functions //! on its arguments. //! //! Specifically, `demux(f)(g...)` is a function such that //! @code //! demux(f)(g...)(x...) == f(g(x...)...) //! @endcode //! //! Each `g` is called with all the arguments, and then `f` is called //! with the result of each `g`. Hence, the arity of `f` must match //! the number of `g`s. //! //! This is called `demux` because of a vague similarity between this //! device and a demultiplexer in signal processing. `demux` takes what //! can be seen as a continuation (`f`), a bunch of functions to split a //! signal (`g...`) and zero or more arguments representing the signal //! (`x...`). Then, it calls the continuation with the result of //! splitting the signal with whatever functions where given. //! //! @note //! When used with two functions only, `demux` is associative. In other //! words (and noting `demux(f, g) = demux(f)(g)` to ease the notation), //! it is true that `demux(demux(f, g), h) == demux(f, demux(g, h))`. //! //! //! Signature //! --------- //! The signature of `demux` is //! \f[ //! \mathtt{demux} : //! (B_1 \times \dotsb \times B_n \to C) //! \to ((A_1 \times \dotsb \times A_n \to B_1) //! \times \dotsb //! \times (A_1 \times \dotsb \times A_n \to B_n)) //! \to (A_1 \times \dotsb \times A_n \to C) //! \f] //! //! This can be rewritten more tersely as //! \f[ //! \mathtt{demux} : //! \left(\prod_{i=1}^n B_i \to C \right) //! \to \prod_{j=1}^n \left(\prod_{i=1}^n A_i \to B_j \right) //! \to \left(\prod_{i=1}^n A_i \to C \right) //! \f] //! //! //! Link with normal composition //! ---------------------------- //! The signature of `compose` is //! \f[ //! \mathtt{compose} : (B \to C) \times (A \to B) \to (A \to C) //! \f] //! //! A valid observation is that this coincides exactly with the type //! of `demux` when used with a single unary function. Actually, both //! functions are equivalent: //! @code //! demux(f)(g)(x) == compose(f, g)(x) //! @endcode //! //! However, let's now consider the curried version of `compose`, //! `curry<2>(compose)`: //! \f[ //! \mathtt{curry_2(compose)} : (B \to C) \to ((A \to B) \to (A \to C)) //! \f] //! //! For the rest of this explanation, we'll just consider the curried //! version of `compose` and so we'll use `compose` instead of //! `curry<2>(compose)` to lighten the notation. With currying, we can //! now consider `compose` applied to itself: //! \f[ //! \mathtt{compose(compose, compose)} : //! (B \to C) \to (A_1 \to A_2 \to B) \to (A_1 \to A_2 \to C) //! \f] //! //! If we uncurry deeply the above expression, we obtain //! \f[ //! \mathtt{compose(compose, compose)} : //! (B \to C) \times (A_1 \times A_2 \to B) \to (A_1 \times A_2 \to C) //! \f] //! //! This signature is exactly the same as that of `demux` when given a //! single binary function, and indeed they are equivalent definitions. //! We can also generalize this further by considering //! `compose(compose(compose, compose), compose)`: //! \f[ //! \mathtt{compose(compose(compose, compose), compose)} : //! (B \to C) \to (A_1 \to A_2 \to A_3 \to B) //! \to (A_1 \to A_2 \to A_3 \to C) //! \f] //! //! which uncurries to //! \f[ //! \mathtt{compose(compose(compose, compose), compose)} : //! (B \to C) \times (A_1 \times A_2 \times A_3 \to B) //! \to (A_1 \times A_2 \times A_3 \to C) //! \f] //! //! This signature is exactly the same as that of `demux` when given a //! single ternary function. Hence, for a single n-ary function `g`, //! `demux(f)(g)` is equivalent to the n-times composition of `compose` //! with itself, applied to `g` and `f`: //! @code //! demux(f)(g) == fold_left([compose, ..., compose], id, compose)(g, f) //! // ^^^^^^^^^^^^^^^^^^^^^ n times //! @endcode //! //! More information on this insight can be seen [here][1]. Also, I'm //! not sure how this insight could be generalized to more than one //! function `g`, or if that is even possible. //! //! //! Proof of associativity in the binary case //! ----------------------------------------- //! As explained above, `demux` is associative when it is used with //! two functions only. Indeed, given functions `f`, `g` and `h` with //! suitable signatures, we have //! @code //! demux(f)(demux(g)(h))(x...) == f(demux(g)(h)(x...)) //! == f(g(h(x...))) //! @endcode //! //! On the other hand, we have //! @code //! demux(demux(f)(g))(h)(x...) == demux(f)(g)(h(x...)) //! == f(g(h(x...))) //! @endcode //! //! and hence `demux` is associative in the binary case. //! //! //! Example //! ------- //! @include example/functional/demux.cpp //! //! [1]: http://stackoverflow.com/q/5821089/627587 #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto demux = [](auto&& f) { return [perfect-capture](auto&& ...g) { return [perfect-capture](auto&& ...x) -> decltype(auto) { // x... can't be forwarded unless there is a single g // function, or that could cause double-moves. return forwarded(f)(forwarded(g)(x...)...); }; }; }; #else template <typename F> struct pre_demux_t; struct make_pre_demux_t { struct secret { }; template <typename F> constexpr pre_demux_t<typename detail::decay<F>::type> operator()(F&& f) const { return {static_cast<F&&>(f)}; } }; template <typename Indices, typename F, typename ...G> struct demux_t; template <typename F> struct pre_demux_t { F f; template <typename ...G> constexpr demux_t<std::make_index_sequence<sizeof...(G)>, F, typename detail::decay<G>::type...> operator()(G&& ...g) const& { return {make_pre_demux_t::secret{}, this->f, static_cast<G&&>(g)...}; } template <typename ...G> constexpr demux_t<std::make_index_sequence<sizeof...(G)>, F, typename detail::decay<G>::type...> operator()(G&& ...g) && { return {make_pre_demux_t::secret{}, static_cast<F&&>(this->f), static_cast<G&&>(g)...}; } }; template <std::size_t ...n, typename F, typename ...G> struct demux_t<std::index_sequence<n...>, F, G...> { template <typename ...T> constexpr demux_t(make_pre_demux_t::secret, T&& ...t) : storage_{static_cast<T&&>(t)...} { } basic_tuple<F, G...> storage_; template <typename ...X> constexpr decltype(auto) operator()(X&& ...x) const& { return hana::at_c<0>(storage_)( hana::at_c<n+1>(storage_)(x...)... ); } template <typename ...X> constexpr decltype(auto) operator()(X&& ...x) & { return hana::at_c<0>(storage_)( hana::at_c<n+1>(storage_)(x...)... ); } template <typename ...X> constexpr decltype(auto) operator()(X&& ...x) && { return static_cast<F&&>(hana::at_c<0>(storage_))( static_cast<G&&>(hana::at_c<n+1>(storage_))(x...)... ); } }; template <typename F, typename G> struct demux_t<std::index_sequence<0>, F, G> { template <typename ...T> constexpr demux_t(make_pre_demux_t::secret, T&& ...t) : storage_{static_cast<T&&>(t)...} { } basic_tuple<F, G> storage_; template <typename ...X> constexpr decltype(auto) operator()(X&& ...x) const& { return hana::at_c<0>(storage_)( hana::at_c<1>(storage_)(static_cast<X&&>(x)...) ); } template <typename ...X> constexpr decltype(auto) operator()(X&& ...x) & { return hana::at_c<0>(storage_)( hana::at_c<1>(storage_)(static_cast<X&&>(x)...) ); } template <typename ...X> constexpr decltype(auto) operator()(X&& ...x) && { return static_cast<F&&>(hana::at_c<0>(storage_))( static_cast<G&&>(hana::at_c<1>(storage_))(static_cast<X&&>(x)...) ); } }; constexpr make_pre_demux_t demux{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FUNCTIONAL_DEMUX_HPP PK �\�[��� � functional/capture.hppnu �[��� /*! @file Defines `boost::hana::capture`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FUNCTIONAL_CAPTURE_HPP #define BOOST_HANA_FUNCTIONAL_CAPTURE_HPP #include <boost/hana/basic_tuple.hpp> #include <boost/hana/config.hpp> #include <boost/hana/detail/decay.hpp> #include <boost/hana/functional/partial.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-functional //! Create a function capturing the given variables. //! //! Given 0 or more variables, `capture` creates a closure that can be //! used to partially apply a function. This is very similar to `partial`, //! except that `capture` allows the partially applied function to be //! specified later. Specifically, `capture(vars...)` is a function object //! taking a function `f` and returning `f` partially applied to `vars...`. //! In other words, //! @code //! capture(vars...)(f)(args...) == f(vars..., args...) //! @endcode //! //! @note //! The arity of `f` must match the total number of arguments passed to //! it, i.e. `sizeof...(vars) + sizeof...(args)`. //! //! //! Example //! ------- //! @include example/functional/capture.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto capture = [](auto&& ...variables) { return [perfect-capture](auto&& f) { return [perfect-capture](auto&& ...args) -> decltype(auto) { return forwarded(f)(forwarded(variables)..., forwarded(args)...); }; }; }; #else namespace detail { template <typename F, typename Closure, std::size_t ...i> constexpr auto apply_capture(F&& f, Closure&& closure, std::index_sequence<i...>) { return hana::partial(static_cast<F&&>(f), hana::at_c<i>(static_cast<Closure&&>(closure).storage_)... ); } } template <typename ...X> struct capture_t; struct make_capture_t { struct secret { }; template <typename ...X> constexpr capture_t<typename detail::decay<X>::type...> operator()(X&& ...x) const { return {secret{}, static_cast<X&&>(x)...}; } }; template <typename ...X> struct capture_t { template <typename ...Y> constexpr capture_t(make_capture_t::secret, Y&& ...y) : storage_{static_cast<Y&&>(y)...} { } basic_tuple<X...> storage_; template <typename F> constexpr auto operator()(F&& f) const& { return detail::apply_capture( static_cast<F&&>(f), *this, std::make_index_sequence<sizeof...(X)>{} ); } template <typename F> constexpr auto operator()(F&& f) & { return detail::apply_capture( static_cast<F&&>(f), *this, std::make_index_sequence<sizeof...(X)>{} ); } template <typename F> constexpr auto operator()(F&& f) && { return detail::apply_capture( static_cast<F&&>(f), static_cast<capture_t&&>(*this), std::make_index_sequence<sizeof...(X)>{} ); } }; constexpr make_capture_t capture{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FUNCTIONAL_CAPTURE_HPP PK �\�[s��� � functional/reverse_partial.hppnu �[��� /*! @file Defines `boost::hana::reverse_partial`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FUNCTIONAL_REVERSE_PARTIAL_HPP #define BOOST_HANA_FUNCTIONAL_REVERSE_PARTIAL_HPP #include <boost/hana/basic_tuple.hpp> #include <boost/hana/config.hpp> #include <boost/hana/detail/decay.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-functional //! Partially apply a function to some arguments. //! //! Given a function `f` and some arguments, `reverse_partial` returns a //! new function corresponding to `f` whose last arguments are partially //! applied. Specifically, `reverse_partial(f, x...)` is a function such //! that //! @code //! reverse_partial(f, x...)(y...) == f(y..., x...) //! @endcode //! //! @note //! The arity of `f` must match the total number of arguments passed to //! it, i.e. `sizeof...(x) + sizeof...(y)`. //! //! //! Example //! ------- //! @include example/functional/reverse_partial.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto reverse_partial = [](auto&& f, auto&& ...x) { return [perfect-capture](auto&& ...y) -> decltype(auto) { return forwarded(f)(forwarded(y)..., forwarded(x)...); }; }; #else template <typename Indices, typename F, typename ...X> struct reverse_partial_t; struct make_reverse_partial_t { struct secret { }; template <typename F, typename ...X> constexpr reverse_partial_t< std::make_index_sequence<sizeof...(X)>, typename detail::decay<F>::type, typename detail::decay<X>::type... > operator()(F&& f, X&& ...x) const { return {secret{}, static_cast<F&&>(f), static_cast<X&&>(x)...}; } }; template <std::size_t ...n, typename F, typename ...X> struct reverse_partial_t<std::index_sequence<n...>, F, X...> { reverse_partial_t() = default; template <typename ...T> constexpr reverse_partial_t(make_reverse_partial_t::secret, T&& ...t) : storage_{static_cast<T&&>(t)...} { } basic_tuple<F, X...> storage_; template <typename ...Y> constexpr decltype(auto) operator()(Y&& ...y) const& { return hana::at_c<0>(storage_)( static_cast<Y&&>(y)..., hana::at_c<n+1>(storage_)... ); } template <typename ...Y> constexpr decltype(auto) operator()(Y&& ...y) & { return hana::at_c<0>(storage_)( static_cast<Y&&>(y)..., hana::at_c<n+1>(storage_)... ); } template <typename ...Y> constexpr decltype(auto) operator()(Y&& ...y) && { return static_cast<F&&>(hana::at_c<0>(storage_))( static_cast<Y&&>(y)..., static_cast<X&&>(hana::at_c<n+1>(storage_))... ); } }; constexpr make_reverse_partial_t reverse_partial{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FUNCTIONAL_REVERSE_PARTIAL_HPP PK �\�[\C minimum.hppnu �[��� /*! @file Defines `boost::hana::minimum`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_MINIMUM_HPP #define BOOST_HANA_MINIMUM_HPP #include <boost/hana/fwd/minimum.hpp> #include <boost/hana/concept/foldable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/nested_by.hpp> // required by fwd decl #include <boost/hana/fold_left.hpp> #include <boost/hana/if.hpp> #include <boost/hana/less.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs> constexpr decltype(auto) minimum_t::operator()(Xs&& xs) const { using S = typename hana::tag_of<Xs>::type; using Minimum = BOOST_HANA_DISPATCH_IF(minimum_impl<S>, hana::Foldable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Foldable<S>::value, "hana::minimum(xs) requires 'xs' to be Foldable"); #endif return Minimum::apply(static_cast<Xs&&>(xs)); } template <typename Xs, typename Predicate> constexpr decltype(auto) minimum_t::operator()(Xs&& xs, Predicate&& pred) const { using S = typename hana::tag_of<Xs>::type; using Minimum = BOOST_HANA_DISPATCH_IF(minimum_pred_impl<S>, hana::Foldable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Foldable<S>::value, "hana::minimum(xs, predicate) requires 'xs' to be Foldable"); #endif return Minimum::apply(static_cast<Xs&&>(xs), static_cast<Predicate&&>(pred)); } //! @endcond ////////////////////////////////////////////////////////////////////////// // minimum (with a custom predicate) ////////////////////////////////////////////////////////////////////////// namespace detail { template <typename Pred> struct min_by { Pred pred; template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) const { auto result = (*pred)(x, y); return hana::if_(result, static_cast<X&&>(x), static_cast<Y&&>(y)); } }; } template <typename T, bool condition> struct minimum_pred_impl<T, when<condition>> : default_ { template <typename Xs, typename Pred> static constexpr decltype(auto) apply(Xs&& xs, Pred const& pred) { // We use a pointer instead of a reference to avoid a Clang ICE. return hana::fold_left(static_cast<Xs&&>(xs), detail::min_by<decltype(&pred)>{&pred} ); } }; ////////////////////////////////////////////////////////////////////////// // minimum (without a custom predicate) ////////////////////////////////////////////////////////////////////////// template <typename T, bool condition> struct minimum_impl<T, when<condition>> : default_ { template <typename Xs> static constexpr decltype(auto) apply(Xs&& xs) { return hana::minimum(static_cast<Xs&&>(xs), hana::less); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_MINIMUM_HPP PK �\�[�õ<� � chain.hppnu �[��� /*! @file Defines `boost::hana::chain`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CHAIN_HPP #define BOOST_HANA_CHAIN_HPP #include <boost/hana/fwd/chain.hpp> #include <boost/hana/concept/monad.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/flatten.hpp> #include <boost/hana/transform.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename F> constexpr decltype(auto) chain_t::operator()(Xs&& xs, F&& f) const { using M = typename hana::tag_of<Xs>::type; using Chain = BOOST_HANA_DISPATCH_IF(chain_impl<M>, hana::Monad<M>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Monad<M>::value, "hana::chain(xs, f) requires 'xs' to be a Monad"); #endif return Chain::apply(static_cast<Xs&&>(xs), static_cast<F&&>(f)); } //! @endcond template <typename M, bool condition> struct chain_impl<M, when<condition>> : default_ { template <typename Xs, typename F> static constexpr auto apply(Xs&& xs, F&& f) { return hana::flatten(hana::transform(static_cast<Xs&&>(xs), static_cast<F&&>(f))); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CHAIN_HPP PK �\�[k�| � � remove.hppnu �[��� /*! @file Defines `boost::hana::remove`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_REMOVE_HPP #define BOOST_HANA_REMOVE_HPP #include <boost/hana/fwd/remove.hpp> #include <boost/hana/concept/monad_plus.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/equal.hpp> #include <boost/hana/filter.hpp> #include <boost/hana/functional/compose.hpp> #include <boost/hana/not.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Value> constexpr auto remove_t::operator()(Xs&& xs, Value&& value) const { using M = typename hana::tag_of<Xs>::type; using Remove = BOOST_HANA_DISPATCH_IF(remove_impl<M>, hana::MonadPlus<M>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::MonadPlus<M>::value, "hana::remove(xs, value) requires 'xs' to be a MonadPlus"); #endif return Remove::apply(static_cast<Xs&&>(xs), static_cast<Value&&>(value)); } //! @endcond template <typename M, bool condition> struct remove_impl<M, when<condition>> : default_ { template <typename Xs, typename Value> static constexpr auto apply(Xs&& xs, Value&& value) { return hana::filter(static_cast<Xs&&>(xs), hana::compose(hana::not_, hana::equal.to(static_cast<Value&&>(value)))); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_REMOVE_HPP PK �\�[( 7g g partition.hppnu �[��� /*! @file Defines `boost::hana::partition`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_PARTITION_HPP #define BOOST_HANA_PARTITION_HPP #include <boost/hana/fwd/partition.hpp> #include <boost/hana/at.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/detail/algorithm.hpp> #include <boost/hana/detail/array.hpp> #include <boost/hana/detail/decay.hpp> #include <boost/hana/detail/nested_by.hpp> // required by fwd decl #include <boost/hana/pair.hpp> #include <boost/hana/unpack.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Pred> constexpr auto partition_t::operator()(Xs&& xs, Pred&& pred) const { using S = typename hana::tag_of<Xs>::type; using Partition = BOOST_HANA_DISPATCH_IF(partition_impl<S>, hana::Sequence<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Sequence<S>::value, "hana::partition(xs, pred) requires 'xs' to be a Sequence"); #endif return Partition::apply(static_cast<Xs&&>(xs), static_cast<Pred&&>(pred)); } //! @endcond namespace detail { template <bool ...B> struct partition_indices { static constexpr detail::array<bool, sizeof...(B)> results{{B...}}; static constexpr std::size_t left_size = detail::count(results.begin(), results.end(), true); static constexpr std::size_t right_size = sizeof...(B) - left_size; static constexpr auto compute_left() { detail::array<std::size_t, left_size> indices{}; std::size_t* left = &indices[0]; for (std::size_t i = 0; i < sizeof...(B); ++i) if (results[i]) *left++ = i; return indices; } static constexpr auto compute_right() { detail::array<std::size_t, right_size> indices{}; std::size_t* right = &indices[0]; for (std::size_t i = 0; i < sizeof...(B); ++i) if (!results[i]) *right++ = i; return indices; } static constexpr auto left_indices = compute_left(); static constexpr auto right_indices = compute_right(); template <typename S, typename Xs, std::size_t ...l, std::size_t ...r> static constexpr auto apply(Xs&& xs, std::index_sequence<l...>, std::index_sequence<r...>) { return hana::make<hana::pair_tag>( hana::make<S>(hana::at_c<left_indices[l]>(static_cast<Xs&&>(xs))...), hana::make<S>(hana::at_c<right_indices[r]>(static_cast<Xs&&>(xs))...) ); } }; template <typename Pred> struct deduce_partition_indices { template <typename ...Xs> auto operator()(Xs&& ...xs) const -> detail::partition_indices< static_cast<bool>(detail::decay< decltype(std::declval<Pred>()(static_cast<Xs&&>(xs))) >::type::value)... > { return {}; } }; } template <typename S, bool condition> struct partition_impl<S, when<condition>> : default_ { template <typename Xs, typename Pred> static constexpr auto apply(Xs&& xs, Pred&&) { using Indices = decltype(hana::unpack( static_cast<Xs&&>(xs), detail::deduce_partition_indices<Pred&&>{} )); return Indices::template apply<S>( static_cast<Xs&&>(xs), std::make_index_sequence<Indices::left_size>{}, std::make_index_sequence<Indices::right_size>{} ); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_PARTITION_HPP PK �\�[�� concept.hppnu �[��� /*! @file Master header for the `boost/hana/concept/` subdirectory. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CONCEPT_HPP #define BOOST_HANA_CONCEPT_HPP #include <boost/hana/concept/applicative.hpp> #include <boost/hana/concept/comonad.hpp> #include <boost/hana/concept/comparable.hpp> #include <boost/hana/concept/constant.hpp> #include <boost/hana/concept/euclidean_ring.hpp> #include <boost/hana/concept/foldable.hpp> #include <boost/hana/concept/functor.hpp> #include <boost/hana/concept/group.hpp> #include <boost/hana/concept/hashable.hpp> #include <boost/hana/concept/integral_constant.hpp> #include <boost/hana/concept/iterable.hpp> #include <boost/hana/concept/logical.hpp> #include <boost/hana/concept/metafunction.hpp> #include <boost/hana/concept/monad.hpp> #include <boost/hana/concept/monad_plus.hpp> #include <boost/hana/concept/monoid.hpp> #include <boost/hana/concept/orderable.hpp> #include <boost/hana/concept/product.hpp> #include <boost/hana/concept/ring.hpp> #include <boost/hana/concept/searchable.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/concept/struct.hpp> #endif // !BOOST_HANA_CONCEPT_HPP PK �\�[z�v+0 +0 string.hppnu �[��� /*! @file Defines `boost::hana::string`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_STRING_HPP #define BOOST_HANA_STRING_HPP #include <boost/hana/fwd/string.hpp> #include <boost/hana/bool.hpp> #include <boost/hana/concept/constant.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/detail/algorithm.hpp> #include <boost/hana/detail/operators/adl.hpp> #include <boost/hana/detail/operators/comparable.hpp> #include <boost/hana/detail/operators/iterable.hpp> #include <boost/hana/detail/operators/orderable.hpp> #include <boost/hana/fwd/at.hpp> #include <boost/hana/fwd/contains.hpp> #include <boost/hana/fwd/core/tag_of.hpp> #include <boost/hana/fwd/core/to.hpp> #include <boost/hana/fwd/drop_front.hpp> #include <boost/hana/fwd/equal.hpp> #include <boost/hana/fwd/find.hpp> #include <boost/hana/fwd/front.hpp> #include <boost/hana/fwd/hash.hpp> #include <boost/hana/fwd/is_empty.hpp> #include <boost/hana/fwd/length.hpp> #include <boost/hana/fwd/less.hpp> #include <boost/hana/fwd/plus.hpp> #include <boost/hana/fwd/unpack.hpp> #include <boost/hana/fwd/zero.hpp> #include <boost/hana/if.hpp> #include <boost/hana/integral_constant.hpp> #include <boost/hana/optional.hpp> #include <boost/hana/type.hpp> #include <utility> #include <cstddef> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN ////////////////////////////////////////////////////////////////////////// // string<> ////////////////////////////////////////////////////////////////////////// //! @cond namespace detail { template <char ...s> constexpr char const string_storage[sizeof...(s) + 1] = {s..., '\0'}; } template <char ...s> struct string : detail::operators::adl<string<s...>> , detail::iterable_operators<string<s...>> { static constexpr char const* c_str() { return &detail::string_storage<s...>[0]; } }; //! @endcond template <char ...s> struct tag_of<string<s...>> { using type = string_tag; }; ////////////////////////////////////////////////////////////////////////// // make<string_tag> ////////////////////////////////////////////////////////////////////////// template <> struct make_impl<string_tag> { template <typename ...Chars> static constexpr auto apply(Chars const& ...) { return hana::string<hana::value<Chars>()...>{}; } }; ////////////////////////////////////////////////////////////////////////// // BOOST_HANA_STRING ////////////////////////////////////////////////////////////////////////// namespace string_detail { template <typename S, std::size_t ...N> constexpr string<S::get()[N]...> prepare_impl(S, std::index_sequence<N...>) { return {}; } template <typename S> constexpr decltype(auto) prepare(S s) { return prepare_impl(s, std::make_index_sequence<sizeof(S::get()) - 1>{}); } } #define BOOST_HANA_STRING(s) \ (::boost::hana::string_detail::prepare([]{ \ struct tmp { \ static constexpr decltype(auto) get() { return s; } \ }; \ return tmp{}; \ }())) \ /**/ #ifdef BOOST_HANA_CONFIG_ENABLE_STRING_UDL ////////////////////////////////////////////////////////////////////////// // _s user-defined literal ////////////////////////////////////////////////////////////////////////// namespace literals { template <typename CharT, CharT ...s> constexpr auto operator"" _s() { static_assert(std::is_same<CharT, char>::value, "hana::string: Only narrow string literals are supported with " "the _s string literal right now. See https://github.com/boostorg/hana/issues/80 " "if you need support for fancier types of compile-time strings."); return hana::string_c<s...>; } } #endif ////////////////////////////////////////////////////////////////////////// // Operators ////////////////////////////////////////////////////////////////////////// namespace detail { template <> struct comparable_operators<string_tag> { static constexpr bool value = true; }; template <> struct orderable_operators<string_tag> { static constexpr bool value = true; }; } ////////////////////////////////////////////////////////////////////////// // to<char const*> ////////////////////////////////////////////////////////////////////////// template <> struct to_impl<char const*, string_tag> { template <char ...c> static constexpr char const* apply(string<c...> const&) { return string<c...>::c_str(); } }; ////////////////////////////////////////////////////////////////////////// // to<string_tag> ////////////////////////////////////////////////////////////////////////// namespace detail { constexpr std::size_t cx_strlen(char const* s) { std::size_t n = 0u; while (*s != '\0') ++s, ++n; return n; } template <typename S, std::size_t ...I> constexpr hana::string<hana::value<S>()[I]...> expand(std::index_sequence<I...>) { return {}; } } template <typename IC> struct to_impl<hana::string_tag, IC, hana::when< hana::Constant<IC>::value && std::is_convertible<typename IC::value_type, char const*>::value >> { template <typename S> static constexpr auto apply(S const&) { constexpr char const* s = hana::value<S>(); constexpr std::size_t len = detail::cx_strlen(s); return detail::expand<S>(std::make_index_sequence<len>{}); } }; ////////////////////////////////////////////////////////////////////////// // Comparable ////////////////////////////////////////////////////////////////////////// template <> struct equal_impl<string_tag, string_tag> { template <typename S> static constexpr auto apply(S const&, S const&) { return hana::true_c; } template <typename S1, typename S2> static constexpr auto apply(S1 const&, S2 const&) { return hana::false_c; } }; ////////////////////////////////////////////////////////////////////////// // Orderable ////////////////////////////////////////////////////////////////////////// template <> struct less_impl<string_tag, string_tag> { template <char ...s1, char ...s2> static constexpr auto apply(string<s1...> const&, string<s2...> const&) { // We put a '\0' at the end only to avoid empty arrays. constexpr char const c_str1[] = {s1..., '\0'}; constexpr char const c_str2[] = {s2..., '\0'}; return hana::bool_c<detail::lexicographical_compare( c_str1, c_str1 + sizeof...(s1), c_str2, c_str2 + sizeof...(s2) )>; } }; ////////////////////////////////////////////////////////////////////////// // Monoid ////////////////////////////////////////////////////////////////////////// template <> struct plus_impl<string_tag, string_tag> { template <char ...s1, char ...s2> static constexpr auto apply(string<s1...> const&, string<s2...> const&) { return string<s1..., s2...>{}; } }; template <> struct zero_impl<string_tag> { static constexpr auto apply() { return string<>{}; } }; template <char ...s1, char ...s2> constexpr auto operator+(string<s1...> const&, string<s2...> const&) { return hana::string<s1..., s2...>{}; } ////////////////////////////////////////////////////////////////////////// // Foldable ////////////////////////////////////////////////////////////////////////// template <> struct unpack_impl<string_tag> { template <char ...s, typename F> static constexpr decltype(auto) apply(string<s...> const&, F&& f) { return static_cast<F&&>(f)(char_<s>{}...); } }; template <> struct length_impl<string_tag> { template <char ...s> static constexpr auto apply(string<s...> const&) { return hana::size_c<sizeof...(s)>; } }; ////////////////////////////////////////////////////////////////////////// // Iterable ////////////////////////////////////////////////////////////////////////// template <> struct front_impl<string_tag> { template <char x, char ...xs> static constexpr auto apply(string<x, xs...> const&) { return hana::char_c<x>; } }; template <> struct drop_front_impl<string_tag> { template <std::size_t N, char ...xs, std::size_t ...i> static constexpr auto helper(string<xs...> const&, std::index_sequence<i...>) { constexpr char s[] = {xs...}; return hana::string_c<s[i + N]...>; } template <char ...xs, typename N> static constexpr auto apply(string<xs...> const& s, N const&) { return helper<N::value>(s, std::make_index_sequence< (N::value < sizeof...(xs)) ? sizeof...(xs) - N::value : 0 >{}); } template <typename N> static constexpr auto apply(string<> const& s, N const&) { return s; } }; template <> struct is_empty_impl<string_tag> { template <char ...s> static constexpr auto apply(string<s...> const&) { return hana::bool_c<sizeof...(s) == 0>; } }; template <> struct at_impl<string_tag> { template <char ...s, typename N> static constexpr auto apply(string<s...> const&, N const&) { // We put a '\0' at the end to avoid an empty array. constexpr char characters[] = {s..., '\0'}; constexpr auto n = N::value; return hana::char_c<characters[n]>; } }; ////////////////////////////////////////////////////////////////////////// // Searchable ////////////////////////////////////////////////////////////////////////// template <> struct contains_impl<string_tag> { template <char ...s, typename C> static constexpr auto helper(string<s...> const&, C const&, hana::true_) { constexpr char const characters[] = {s..., '\0'}; constexpr char c = hana::value<C>(); return hana::bool_c< detail::find(characters, characters + sizeof...(s), c) != characters + sizeof...(s) >; } template <typename S, typename C> static constexpr auto helper(S const&, C const&, hana::false_) { return hana::false_c; } template <typename S, typename C> static constexpr auto apply(S const& s, C const& c) { return helper(s, c, hana::bool_c<hana::Constant<C>::value>); } }; template <> struct find_impl<string_tag> { template <char ...s, typename Char> static constexpr auto apply(string<s...> const& str, Char const& c) { return hana::if_(contains_impl<string_tag>::apply(str, c), hana::just(c), hana::nothing ); } }; ////////////////////////////////////////////////////////////////////////// // Hashable ////////////////////////////////////////////////////////////////////////// template <> struct hash_impl<string_tag> { template <typename String> static constexpr auto apply(String const&) { return hana::type_c<String>; } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_STRING_HPP PK �\�[x�� � find.hppnu �[��� /*! @file Defines `boost::hana::find`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FIND_HPP #define BOOST_HANA_FIND_HPP #include <boost/hana/fwd/find.hpp> #include <boost/hana/concept/searchable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/equal.hpp> #include <boost/hana/find_if.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Key> constexpr auto find_t::operator()(Xs&& xs, Key const& key) const { using S = typename hana::tag_of<Xs>::type; using Find = BOOST_HANA_DISPATCH_IF(find_impl<S>, hana::Searchable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Searchable<S>::value, "hana::find(xs, key) requires 'xs' to be Searchable"); #endif return Find::apply(static_cast<Xs&&>(xs), key); } //! @endcond namespace detail { template <typename T> struct equal_to { T const& t; template <typename U> constexpr auto operator()(U const& u) const { return hana::equal(t, u); } }; } template <typename S, bool condition> struct find_impl<S, when<condition>> : default_ { template <typename Xs, typename Key> static constexpr auto apply(Xs&& xs, Key const& key) { return hana::find_if(static_cast<Xs&&>(xs), detail::equal_to<Key>{key}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FIND_HPP PK �\�[�,� � max.hppnu �[��� /*! @file Defines `boost::hana::max`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_MAX_HPP #define BOOST_HANA_MAX_HPP #include <boost/hana/fwd/max.hpp> #include <boost/hana/concept/orderable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/if.hpp> #include <boost/hana/less.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename X, typename Y> constexpr decltype(auto) max_t::operator()(X&& x, Y&& y) const { using T = typename hana::tag_of<X>::type; using U = typename hana::tag_of<Y>::type; using Max = BOOST_HANA_DISPATCH_IF(decltype(max_impl<T, U>{}), hana::Orderable<T>::value && hana::Orderable<U>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Orderable<T>::value, "hana::max(x, y) requires 'x' to be Orderable"); static_assert(hana::Orderable<U>::value, "hana::max(x, y) requires 'y' to be Orderable"); #endif return Max::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); } //! @endcond template <typename T, typename U, bool condition> struct max_impl<T, U, when<condition>> : default_ { template <typename X, typename Y> static constexpr decltype(auto) apply(X&& x, Y&& y) { decltype(auto) cond = hana::less(x, y); return hana::if_(static_cast<decltype(cond)&&>(cond), static_cast<Y&&>(y), static_cast<X&&>(x) ); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_MAX_HPP PK �\�[WL� value.hppnu �[��� /*! @file Defines `boost::hana::value`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_VALUE_HPP #define BOOST_HANA_VALUE_HPP #include <boost/hana/fwd/value.hpp> #include <boost/hana/concept/constant.hpp> #include <boost/hana/concept/integral_constant.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN template <typename C, bool condition> struct value_impl<C, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...args) = delete; }; template <typename T> constexpr decltype(auto) value() { using RawT = typename std::remove_cv< typename std::remove_reference<T>::type >::type; using C = typename hana::tag_of<RawT>::type; using Value = BOOST_HANA_DISPATCH_IF( value_impl<C>, hana::Constant<C>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Constant<C>::value, "hana::value<T>() requires 'T' to be a Constant"); #endif return Value::template apply<RawT>(); } template <typename I> struct value_impl<I, when<hana::IntegralConstant<I>::value>> { template <typename C> static constexpr auto apply() { return C::value; } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_VALUE_HPP PK �\�[q֪� � mult.hppnu �[��� /*! @file Defines `boost::hana::mult`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_MULT_HPP #define BOOST_HANA_MULT_HPP #include <boost/hana/fwd/mult.hpp> #include <boost/hana/concept/constant.hpp> #include <boost/hana/concept/ring.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/to.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/canonical_constant.hpp> #include <boost/hana/detail/has_common_embedding.hpp> #include <boost/hana/value.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename X, typename Y> constexpr decltype(auto) mult_t::operator()(X&& x, Y&& y) const { using T = typename hana::tag_of<X>::type; using U = typename hana::tag_of<Y>::type; using Mult = BOOST_HANA_DISPATCH_IF(decltype(mult_impl<T, U>{}), hana::Ring<T>::value && hana::Ring<U>::value && !is_default<mult_impl<T, U>>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Ring<T>::value, "hana::mult(x, y) requires 'x' to be in a Ring"); static_assert(hana::Ring<U>::value, "hana::mult(x, y) requires 'y' to be in a Ring"); static_assert(!is_default<mult_impl<T, U>>::value, "hana::mult(x, y) requires 'x' and 'y' to be embeddable " "in a common Ring"); #endif return Mult::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); } //! @endcond template <typename T, typename U, bool condition> struct mult_impl<T, U, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; // Cross-type overload template <typename T, typename U> struct mult_impl<T, U, when< detail::has_nontrivial_common_embedding<Ring, T, U>::value >> { using C = typename common<T, U>::type; template <typename X, typename Y> static constexpr decltype(auto) apply(X&& x, Y&& y) { return hana::mult(hana::to<C>(static_cast<X&&>(x)), hana::to<C>(static_cast<Y&&>(y))); } }; ////////////////////////////////////////////////////////////////////////// // Model for non-boolean arithmetic data types ////////////////////////////////////////////////////////////////////////// template <typename T> struct mult_impl<T, T, when<std::is_arithmetic<T>::value && !std::is_same<bool, T>::value>> { template <typename X, typename Y> static constexpr decltype(auto) apply(X&& x, Y&& y) { return static_cast<X&&>(x) * static_cast<Y&&>(y); } }; ////////////////////////////////////////////////////////////////////////// // Model for Constants over a Ring ////////////////////////////////////////////////////////////////////////// namespace detail { template <typename C, typename X, typename Y> struct constant_from_mult { static constexpr auto value = hana::mult(hana::value<X>(), hana::value<Y>()); using hana_tag = detail::CanonicalConstant<typename C::value_type>; }; } template <typename C> struct mult_impl<C, C, when< hana::Constant<C>::value && Ring<typename C::value_type>::value >> { template <typename X, typename Y> static constexpr decltype(auto) apply(X const&, Y const&) { return hana::to<C>(detail::constant_from_mult<C, X, Y>{}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_MULT_HPP PK �\�[�z��T T insert.hppnu �[��� /*! @file Defines `boost::hana::insert`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_INSERT_HPP #define BOOST_HANA_INSERT_HPP #include <boost/hana/fwd/insert.hpp> #include <boost/hana/append.hpp> #include <boost/hana/concat.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/drop_front.hpp> #include <boost/hana/take_front.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Set, typename ...Args> constexpr decltype(auto) insert_t::operator()(Set&& set, Args&& ...args) const { return insert_impl<typename hana::tag_of<Set>::type>::apply( static_cast<Set&&>(set), static_cast<Args&&>(args)... ); } //! @endcond template <typename T, bool condition> struct insert_impl<T, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; template <typename S> struct insert_impl<S, when<Sequence<S>::value>> { template <typename Xs, typename N, typename Element> static constexpr auto apply(Xs&& xs, N const& n, Element&& e) { return hana::concat(hana::append(hana::take_front(xs, n), static_cast<Element&&>(e)), hana::drop_front(xs, n)); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_INSERT_HPP PK �\�[M.�4 monadic_fold_right.hppnu �[��� /*! @file Defines `boost::hana::monadic_fold_right`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_MONADIC_FOLD_RIGHT_HPP #define BOOST_HANA_MONADIC_FOLD_RIGHT_HPP #include <boost/hana/fwd/monadic_fold_right.hpp> #include <boost/hana/chain.hpp> #include <boost/hana/concept/foldable.hpp> #include <boost/hana/concept/monad.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/decay.hpp> #include <boost/hana/fold_left.hpp> #include <boost/hana/functional/curry.hpp> #include <boost/hana/functional/partial.hpp> #include <boost/hana/lift.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename M> template <typename Xs, typename State, typename F> constexpr decltype(auto) monadic_fold_right_t<M>::operator()(Xs&& xs, State&& state, F&& f) const { using S = typename hana::tag_of<Xs>::type; using MonadicFoldRight = BOOST_HANA_DISPATCH_IF(monadic_fold_right_impl<S>, hana::Foldable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Monad<M>::value, "hana::monadic_fold_right<M> requires 'M' to be a Monad"); static_assert(hana::Foldable<S>::value, "hana::monadic_fold_right<M>(xs, state, f) requires 'xs' to be Foldable"); #endif return MonadicFoldRight::template apply<M>(static_cast<Xs&&>(xs), static_cast<State&&>(state), static_cast<F&&>(f)); } //! @endcond //! @cond template <typename M> template <typename Xs, typename F> constexpr decltype(auto) monadic_fold_right_t<M>::operator()(Xs&& xs, F&& f) const { using S = typename hana::tag_of<Xs>::type; using MonadicFoldRight = BOOST_HANA_DISPATCH_IF(monadic_fold_right_impl<S>, hana::Foldable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Monad<M>::value, "hana::monadic_fold_right<M> requires 'M' to be a Monad"); static_assert(hana::Foldable<S>::value, "hana::monadic_fold_right<M>(xs, f) requires 'xs' to be Foldable"); #endif return MonadicFoldRight::template apply<M>(static_cast<Xs&&>(xs), static_cast<F&&>(f)); } //! @endcond namespace detail { struct foldrM_helper { template <typename F, typename K, typename X, typename Z> constexpr decltype(auto) operator()(F&& f, K&& k, X&& x, Z&& z) const { return hana::chain( static_cast<F&&>(f)( static_cast<X&&>(x), static_cast<Z&&>(z) ), static_cast<K&&>(k) ); } }; template <typename End, typename M, typename F> struct monadic_foldr1_helper { F f; template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) const { return f(static_cast<X&&>(x), static_cast<Y&&>(y)); } template <typename X> constexpr decltype(auto) operator()(X&& x, End) const { return hana::lift<M>(static_cast<X&&>(x)); } }; } template <typename T, bool condition> struct monadic_fold_right_impl<T, when<condition>> : default_ { // with state template <typename M, typename Xs, typename S, typename F> static constexpr decltype(auto) apply(Xs&& xs, S&& s, F&& f) { return hana::fold_left( static_cast<Xs&&>(xs), hana::lift<M>, hana::curry<3>(hana::partial( detail::foldrM_helper{}, static_cast<F&&>(f) )) )(static_cast<S&&>(s)); } // without state template <typename M, typename Xs, typename F> static constexpr decltype(auto) apply(Xs&& xs, F&& f) { struct end { }; using G = detail::monadic_foldr1_helper<end, M, typename detail::decay<F>::type>; decltype(auto) result = hana::monadic_fold_right<M>( static_cast<Xs&&>(xs), end{}, G{static_cast<F&&>(f)} ); static_assert(!std::is_same< std::remove_reference_t<decltype(result)>, decltype(hana::lift<M>(end{})) >{}, "hana::monadic_fold_right<M>(xs, f) requires 'xs' to be non-empty"); return result; } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_MONADIC_FOLD_RIGHT_HPP PK �\�[�t� replace.hppnu �[��� /*! @file Defines `boost::hana::replace`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_REPLACE_HPP #define BOOST_HANA_REPLACE_HPP #include <boost/hana/fwd/replace.hpp> #include <boost/hana/concept/functor.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/equal.hpp> #include <boost/hana/replace_if.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename OldVal, typename NewVal> constexpr auto replace_t::operator()(Xs&& xs, OldVal&& oldval, NewVal&& newval) const { using S = typename hana::tag_of<Xs>::type; using Replace = BOOST_HANA_DISPATCH_IF(replace_impl<S>, hana::Functor<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Functor<S>::value, "hana::replace(xs, oldval, newval) requires 'xs' to be a Functor"); #endif return Replace::apply(static_cast<Xs&&>(xs), static_cast<OldVal&&>(oldval), static_cast<NewVal&&>(newval)); } //! @endcond template <typename Fun, bool condition> struct replace_impl<Fun, when<condition>> : default_ { template <typename Xs, typename OldVal, typename NewVal> static constexpr decltype(auto) apply(Xs&& xs, OldVal&& oldval, NewVal&& newval) { return hana::replace_if( static_cast<Xs&&>(xs), hana::equal.to(static_cast<OldVal&&>(oldval)), static_cast<NewVal&&>(newval) ); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_REPLACE_HPP PK �\�[v���y y filter.hppnu �[��� /*! @file Defines `boost::hana::filter`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FILTER_HPP #define BOOST_HANA_FILTER_HPP #include <boost/hana/fwd/filter.hpp> #include <boost/hana/at.hpp> #include <boost/hana/bool.hpp> #include <boost/hana/chain.hpp> #include <boost/hana/concept/monad_plus.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/detail/algorithm.hpp> #include <boost/hana/detail/array.hpp> #include <boost/hana/detail/decay.hpp> #include <boost/hana/empty.hpp> #include <boost/hana/lift.hpp> #include <boost/hana/unpack.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Pred> constexpr auto filter_t::operator()(Xs&& xs, Pred&& pred) const { using M = typename hana::tag_of<Xs>::type; using Filter = BOOST_HANA_DISPATCH_IF(filter_impl<M>, hana::MonadPlus<M>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::MonadPlus<M>::value, "hana::filter(xs, pred) requires 'xs' to be a MonadPlus"); #endif return Filter::apply(static_cast<Xs&&>(xs), static_cast<Pred&&>(pred)); } //! @endcond namespace detail { template <typename Pred, typename M> struct lift_or_empty { template <typename X> static constexpr auto helper(X&& x, hana::true_) { return hana::lift<M>(static_cast<X&&>(x)); } template <typename X> static constexpr auto helper(X&&, hana::false_) { return hana::empty<M>(); } template <typename X> constexpr auto operator()(X&& x) const { constexpr bool cond = decltype(std::declval<Pred>()(x))::value; return helper(static_cast<X&&>(x), hana::bool_c<cond>); } }; } template <typename M, bool condition> struct filter_impl<M, when<condition>> : default_ { template <typename Xs, typename Pred> static constexpr decltype(auto) apply(Xs&& xs, Pred const&) { return hana::chain(static_cast<Xs&&>(xs), detail::lift_or_empty<Pred, M>{} ); } }; namespace detail { template <bool ...b> struct filter_indices { static constexpr auto compute_indices() { constexpr bool bs[] = {b..., false}; // avoid empty array constexpr std::size_t N = detail::count(bs, bs + sizeof(bs), true); detail::array<std::size_t, N> indices{}; std::size_t* keep = &indices[0]; for (std::size_t i = 0; i < sizeof...(b); ++i) if (bs[i]) *keep++ = i; return indices; } static constexpr auto cached_indices = compute_indices(); }; template <typename Pred> struct make_filter_indices { Pred const& pred; template <typename ...X> auto operator()(X&& ...x) const -> filter_indices< static_cast<bool>(detail::decay< decltype(pred(static_cast<X&&>(x))) >::type::value)... > { return {}; } }; } template <typename S> struct filter_impl<S, when<Sequence<S>::value>> { template <typename Indices, typename Xs, std::size_t ...i> static constexpr auto filter_helper(Xs&& xs, std::index_sequence<i...>) { return hana::make<S>( hana::at_c<Indices::cached_indices[i]>(static_cast<Xs&&>(xs))... ); } template <typename Xs, typename Pred> static constexpr auto apply(Xs&& xs, Pred const& pred) { using Indices = decltype( hana::unpack(static_cast<Xs&&>(xs), detail::make_filter_indices<Pred>{pred}) ); return filter_impl::filter_helper<Indices>( static_cast<Xs&&>(xs), std::make_index_sequence<Indices::cached_indices.size()>{} ); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FILTER_HPP PK �\�[, =Ⱥ � define_struct.hppnu �[��� /*! @file Defines the `BOOST_HANA_DEFINE_STRUCT` macro. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DEFINE_STRUCT_HPP #define BOOST_HANA_DEFINE_STRUCT_HPP #include <boost/hana/fwd/define_struct.hpp> #include <boost/hana/detail/struct_macros.hpp> #endif // !BOOST_HANA_DEFINE_STRUCT_HPP PK �\�[>q��A A negate.hppnu �[��� /*! @file Defines `boost::hana::negate`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_NEGATE_HPP #define BOOST_HANA_NEGATE_HPP #include <boost/hana/fwd/negate.hpp> #include <boost/hana/concept/group.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/fwd/minus.hpp> #include <boost/hana/zero.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename X> constexpr decltype(auto) negate_t::operator()(X&& x) const { using G = typename hana::tag_of<X>::type; using Negate = BOOST_HANA_DISPATCH_IF(negate_impl<G>, hana::Group<G>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Group<G>::value, "hana::negate(x) requires 'x' to be in a Group"); #endif return Negate::apply(static_cast<X&&>(x)); } //! @endcond template <typename T, bool condition> struct negate_impl<T, when<condition>> : default_ { template <typename X> static constexpr decltype(auto) apply(X&& x) { return hana::minus(hana::zero<T>(), static_cast<X&&>(x)); } }; ////////////////////////////////////////////////////////////////////////// // Model for arithmetic data types ////////////////////////////////////////////////////////////////////////// template <typename T> struct negate_impl<T, when<std::is_arithmetic<T>::value && !std::is_same<bool, T>::value>> { template <typename X> static constexpr decltype(auto) apply(X&& x) { return -static_cast<X&&>(x); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_NEGATE_HPP PK �\�[kzZ[z z fold.hppnu �[��� /*! @file Defines `boost::hana::fold`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FOLD_HPP #define BOOST_HANA_FOLD_HPP #include <boost/hana/fwd/fold.hpp> #include <boost/hana/fold_left.hpp> #endif // !BOOST_HANA_FOLD_HPP PK �\�[���QO O slice.hppnu �[��� /*! @file Defines `boost::hana::slice` and `boost::hana::slice_c`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_SLICE_HPP #define BOOST_HANA_SLICE_HPP #include <boost/hana/fwd/slice.hpp> #include <boost/hana/at.hpp> #include <boost/hana/concept/foldable.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/range.hpp> #include <boost/hana/unpack.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Indices> constexpr auto slice_t::operator()(Xs&& xs, Indices&& indices) const { using S = typename hana::tag_of<Xs>::type; using Slice = BOOST_HANA_DISPATCH_IF(slice_impl<S>, hana::Sequence<S>::value && hana::Foldable<Indices>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Sequence<S>::value, "hana::slice(xs, indices) requires 'xs' to be a Sequence"); static_assert(hana::Foldable<Indices>::value, "hana::slice(xs, indices) requires 'indices' to be Foldable"); #endif return Slice::apply(static_cast<Xs&&>(xs), static_cast<Indices&&>(indices)); } //! @endcond namespace detail { template <typename Xs> struct take_arbitrary { Xs& xs; using S = typename hana::tag_of<Xs>::type; template <typename ...N> constexpr auto operator()(N const& ...) const { return hana::make<S>(hana::at_c<N::value>(xs)...); } }; } template <typename S, bool condition> struct slice_impl<S, when<condition>> : default_ { template <std::size_t from, typename Xs, std::size_t ...i> static constexpr auto from_offset(Xs&& xs, std::index_sequence<i...>) { return hana::make<S>(hana::at_c<from + i>(static_cast<Xs&&>(xs))...); } template <typename Xs, typename T, T from, T to> static constexpr auto apply(Xs&& xs, hana::range<T, from, to> const&) { return slice_impl::from_offset<from>( static_cast<Xs&&>(xs), std::make_index_sequence<to - from>{} ); } //! @todo //! Since we have the right to specify the same index more than once, //! we can't move from the elements of the source sequence even if it //! is a temporary object: we could end up double-moving. Perhaps it //! would be possible to determine the indices from which we can move //! without incurring a too large compile-time penalty? template <typename Xs, typename Indices> static constexpr auto apply(Xs const& xs, Indices const& indices) { return hana::unpack(indices, detail::take_arbitrary<Xs const>{xs}); } }; template <std::size_t from, std::size_t to> struct slice_c_t { template <typename Xs> constexpr auto operator()(Xs&& xs) const { return hana::slice(static_cast<Xs&&>(xs), hana::range_c<std::size_t, from, to>); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_SLICE_HPP PK �\�[U� �/ / monadic_compose.hppnu �[��� /*! @file Defines `boost::hana::monadic_compose`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_MONADIC_COMPOSE_HPP #define BOOST_HANA_MONADIC_COMPOSE_HPP #include <boost/hana/fwd/monadic_compose.hpp> #include <boost/hana/chain.hpp> #include <boost/hana/concept/monad.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/functional/partial.hpp> BOOST_HANA_NAMESPACE_BEGIN namespace detail { struct monadic_compose_helper { template <typename F, typename G, typename X> constexpr decltype(auto) operator()(F&& f, G&& g, X&& x) const { using M = typename hana::tag_of<decltype(g(x))>::type; #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Monad<M>::value, "hana::monadic_compose(f, g) requires 'g' to return a monadic value"); #endif return hana::chain(static_cast<G&&>(g)(static_cast<X&&>(x)), static_cast<F&&>(f)); } }; } //! @cond template <typename F, typename G> constexpr auto monadic_compose_t::operator()(F&& f, G&& g) const { return hana::partial(detail::monadic_compose_helper{}, static_cast<F&&>(f), static_cast<G&&>(g) ); } //! @endcond BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_MONADIC_COMPOSE_HPP PK �\�[ 75r� � mod.hppnu �[��� /*! @file Defines `boost::hana::mod`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_MOD_HPP #define BOOST_HANA_MOD_HPP #include <boost/hana/fwd/mod.hpp> #include <boost/hana/concept/constant.hpp> #include <boost/hana/concept/euclidean_ring.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/to.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/canonical_constant.hpp> #include <boost/hana/detail/has_common_embedding.hpp> #include <boost/hana/value.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename X, typename Y> constexpr decltype(auto) mod_t::operator()(X&& x, Y&& y) const { using T = typename hana::tag_of<X>::type; using U = typename hana::tag_of<Y>::type; using Mod = BOOST_HANA_DISPATCH_IF(decltype(mod_impl<T, U>{}), hana::EuclideanRing<T>::value && hana::EuclideanRing<U>::value && !is_default<mod_impl<T, U>>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::EuclideanRing<T>::value, "hana::mod(x, y) requires 'x' to be an EuclideanRing"); static_assert(hana::EuclideanRing<U>::value, "hana::mod(x, y) requires 'y' to be an EuclideanRing"); static_assert(!is_default<mod_impl<T, U>>::value, "hana::mod(x, y) requires 'x' and 'y' to be embeddable " "in a common EuclideanRing"); #endif return Mod::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); } //! @endcond template <typename T, typename U, bool condition> struct mod_impl<T, U, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; // Cross-type overload template <typename T, typename U> struct mod_impl<T, U, when< detail::has_nontrivial_common_embedding<EuclideanRing, T, U>::value >> { using C = typename common<T, U>::type; template <typename X, typename Y> static constexpr decltype(auto) apply(X&& x, Y&& y) { return hana::mod(hana::to<C>(static_cast<X&&>(x)), hana::to<C>(static_cast<Y&&>(y))); } }; ////////////////////////////////////////////////////////////////////////// // Model for integral data types ////////////////////////////////////////////////////////////////////////// template <typename T> struct mod_impl<T, T, when<std::is_integral<T>::value && !std::is_same<T, bool>::value>> { template <typename X, typename Y> static constexpr decltype(auto) apply(X&& x, Y&& y) { return static_cast<X&&>(x) % static_cast<Y&&>(y); } }; ////////////////////////////////////////////////////////////////////////// // Model for Constants over an EuclideanRing ////////////////////////////////////////////////////////////////////////// namespace detail { template <typename C, typename X, typename Y> struct constant_from_mod { static constexpr auto value = hana::mod(hana::value<X>(), hana::value<Y>()); using hana_tag = detail::CanonicalConstant<typename C::value_type>; }; } template <typename C> struct mod_impl<C, C, when< hana::Constant<C>::value && EuclideanRing<typename C::value_type>::value >> { template <typename X, typename Y> static constexpr decltype(auto) apply(X const&, Y const&) { return hana::to<C>(detail::constant_from_mod<C, X, Y>{}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_MOD_HPP PK �\�[ X+C* * if.hppnu �[��� /*! @file Defines `boost::hana::if_`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_IF_HPP #define BOOST_HANA_IF_HPP #include <boost/hana/fwd/if.hpp> #include <boost/hana/concept/logical.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/eval_if.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Cond, typename Then, typename Else> constexpr decltype(auto) if_t::operator()(Cond&& cond, Then&& then_, Else&& else_) const { using Bool = typename hana::tag_of<Cond>::type; using If = BOOST_HANA_DISPATCH_IF(if_impl<Bool>, hana::Logical<Bool>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Logical<Bool>::value, "hana::if_(cond, then, else) requires 'cond' to be a Logical"); #endif return If::apply(static_cast<Cond&&>(cond), static_cast<Then&&>(then_), static_cast<Else&&>(else_)); } //! @endcond namespace detail { template <typename T> struct hold { T value; constexpr T&& operator()() && { return static_cast<T&&>(value); } }; } template <typename L, bool condition> struct if_impl<L, when<condition>> : default_ { template <typename C, typename T, typename E> static constexpr auto apply(C&& c, T&& t, E&& e) { return hana::eval_if(static_cast<C&&>(c), detail::hold<T&&>{static_cast<T&&>(t)}, detail::hold<E&&>{static_cast<E&&>(e)} ); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_IF_HPP PK �\�[,'YD D zip_shortest_with.hppnu �[��� /*! @file Defines `boost::hana::zip_shortest_with`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_ZIP_SHORTEST_WITH_HPP #define BOOST_HANA_ZIP_SHORTEST_WITH_HPP #include <boost/hana/fwd/zip_shortest_with.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/config.hpp> #include <boost/hana/detail/algorithm.hpp> #include <boost/hana/detail/fast_and.hpp> #include <boost/hana/integral_constant.hpp> #include <boost/hana/length.hpp> #include <boost/hana/take_front.hpp> #include <boost/hana/zip_with.hpp> #include <cstddef> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename F, typename Xs, typename ...Ys> constexpr auto zip_shortest_with_t::operator()(F&& f, Xs&& xs, Ys&& ...ys) const { #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(detail::fast_and< hana::Sequence<Xs>::value, hana::Sequence<Ys>::value... >::value, "hana::zip_shortest_with(f, xs, ys...) requires 'xs' and 'ys...' to be Sequences"); #endif return zip_shortest_with_impl<typename hana::tag_of<Xs>::type>::apply( static_cast<F&&>(f), static_cast<Xs&&>(xs), static_cast<Ys&&>(ys)... ); } //! @endcond template <typename S, bool condition> struct zip_shortest_with_impl<S, when<condition>> : default_ { template <typename F, typename ...Xs> static constexpr decltype(auto) apply(F&& f, Xs&& ...xs) { constexpr std::size_t lengths[] = { decltype(hana::length(xs))::value... }; constexpr std::size_t min_len = *detail::min_element(lengths, lengths + sizeof...(xs)); return hana::zip_with(static_cast<F&&>(f), hana::take_front(static_cast<Xs&&>(xs), hana::size_c<min_len>)... ); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_ZIP_SHORTEST_WITH_HPP PK �\�[d�w w size.hppnu �[��� /*! @file Defines `boost::hana::size`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_SIZE_HPP #define BOOST_HANA_SIZE_HPP #include <boost/hana/fwd/size.hpp> #include <boost/hana/length.hpp> #endif // !BOOST_HANA_SIZE_HPP PK �\�[�~�~� � remove_at.hppnu �[��� /*! @file Defines `boost::hana::remove_at` and `boost::hana::remove_at_c`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_REMOVE_AT_HPP #define BOOST_HANA_REMOVE_AT_HPP #include <boost/hana/fwd/remove_at.hpp> #include <boost/hana/at.hpp> #include <boost/hana/concept/integral_constant.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/integral_constant.hpp> #include <boost/hana/length.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename N> constexpr auto remove_at_t::operator()(Xs&& xs, N const& n) const { using S = typename hana::tag_of<Xs>::type; using RemoveAt = BOOST_HANA_DISPATCH_IF(remove_at_impl<S>, hana::Sequence<S>::value && hana::IntegralConstant<N>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Sequence<S>::value, "hana::remove_at(xs, n) requires 'xs' to be a Sequence"); static_assert(hana::IntegralConstant<N>::value, "hana::remove_at(xs, n) requires 'n' to be an IntegralConstant"); #endif static_assert(N::value >= 0, "hana::remove_at(xs, n) requires 'n' to be non-negative"); return RemoveAt::apply(static_cast<Xs&&>(xs), n); } //! @endcond template <typename S, bool condition> struct remove_at_impl<S, when<condition>> : default_ { template <typename Xs, std::size_t ...before, std::size_t ...after> static constexpr auto remove_at_helper(Xs&& xs, std::index_sequence<before...>, std::index_sequence<after...>) { return hana::make<S>( hana::at_c<before>(static_cast<Xs&&>(xs))..., hana::at_c<after + sizeof...(before) + 1>(static_cast<Xs&&>(xs))... ); } template <typename Xs, typename N> static constexpr auto apply(Xs&& xs, N const&) { constexpr std::size_t n = N::value; constexpr std::size_t len = decltype(hana::length(xs))::value; static_assert(n < len, "hana::remove_at(xs, n) requires 'n' to be in the bounds of the sequence"); return remove_at_helper(static_cast<Xs&&>(xs), std::make_index_sequence<n>{}, std::make_index_sequence<len - n - 1>{}); } }; template <std::size_t n> struct remove_at_c_t { template <typename Xs> constexpr decltype(auto) operator()(Xs&& xs) const { return hana::remove_at(static_cast<Xs&&>(xs), hana::size_c<n>); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_REMOVE_AT_HPP PK �\�[����� � ordering.hppnu �[��� /*! @file Defines `boost::hana::ordering`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_ORDERING_HPP #define BOOST_HANA_ORDERING_HPP #include <boost/hana/fwd/ordering.hpp> #include <boost/hana/config.hpp> #include <boost/hana/detail/decay.hpp> #include <boost/hana/less.hpp> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <typename F> struct less_by { F f; template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) const& { return hana::less(f(static_cast<X&&>(x)), f(static_cast<Y&&>(y))); } template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) & { return hana::less(f(static_cast<X&&>(x)), f(static_cast<Y&&>(y))); } }; } //! @cond template <typename F> constexpr auto ordering_t::operator()(F&& f) const { return detail::less_by<typename detail::decay<F>::type>{static_cast<F&&>(f)}; } //! @endcond BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_ORDERING_HPP PK �\�[ F&H} } sum.hppnu �[��� /*! @file Defines `boost::hana::sum`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_SUM_HPP #define BOOST_HANA_SUM_HPP #include <boost/hana/fwd/sum.hpp> #include <boost/hana/concept/foldable.hpp> #include <boost/hana/concept/monoid.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/fold_left.hpp> #include <boost/hana/integral_constant.hpp> // required by fwd decl #include <boost/hana/plus.hpp> #include <boost/hana/zero.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename M> template <typename Xs> constexpr decltype(auto) sum_t<M>::operator()(Xs&& xs) const { using S = typename hana::tag_of<Xs>::type; using Sum = BOOST_HANA_DISPATCH_IF(sum_impl<S>, hana::Foldable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Monoid<M>::value, "hana::sum<M> requires 'M' to be a Monoid"); static_assert(hana::Foldable<S>::value, "hana::sum<M>(xs) requires 'xs' to be Foldable"); #endif return Sum::template apply<M>(static_cast<Xs&&>(xs)); } //! @endcond template <typename T, bool condition> struct sum_impl<T, when<condition>> : default_ { template <typename M, typename Xs> static constexpr decltype(auto) apply(Xs&& xs) { return hana::fold_left(static_cast<Xs&&>(xs), hana::zero<M>(), hana::plus); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_SUM_HPP PK �\�[��;� � first.hppnu �[��� /*! @file Defines `boost::hana::first`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FIRST_HPP #define BOOST_HANA_FIRST_HPP #include <boost/hana/fwd/first.hpp> #include <boost/hana/concept/product.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Pair> constexpr decltype(auto) first_t::operator()(Pair&& pair) const { using P = typename hana::tag_of<Pair>::type; using First = BOOST_HANA_DISPATCH_IF(first_impl<P>, hana::Product<P>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Product<P>::value, "hana::first(pair) requires 'pair' to be a Product"); #endif return First::apply(static_cast<Pair&&>(pair)); } //! @endcond template <typename P, bool condition> struct first_impl<P, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FIRST_HPP PK �\�[iU�?� � is_disjoint.hppnu �[��� /*! @file Defines `boost::hana::is_disjoint`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_IS_DISJOINT_HPP #define BOOST_HANA_IS_DISJOINT_HPP #include <boost/hana/fwd/is_disjoint.hpp> #include <boost/hana/concept/searchable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/contains.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/none_of.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Ys> constexpr auto is_disjoint_t::operator()(Xs&& xs, Ys&& ys) const { using S1 = typename hana::tag_of<Xs>::type; using S2 = typename hana::tag_of<Ys>::type; using IsDisjoint = BOOST_HANA_DISPATCH_IF( decltype(is_disjoint_impl<S1, S2>{}), hana::Searchable<S1>::value && hana::Searchable<S2>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Searchable<S1>::value, "hana::is_disjoint(xs, ys) requires 'xs' to be Searchable"); static_assert(hana::Searchable<S2>::value, "hana::is_disjoint(xs, ys) requires 'ys' to be Searchable"); #endif return IsDisjoint::apply(static_cast<Xs&&>(xs), static_cast<Ys&&>(ys)); } //! @endcond namespace detail { template <typename Ys> struct in_by_reference { Ys const& ys; template <typename X> constexpr auto operator()(X const& x) const { return hana::contains(ys, x); } }; } template <typename S1, typename S2, bool condition> struct is_disjoint_impl<S1, S2, when<condition>> : default_ { template <typename Xs, typename Ys> static constexpr auto apply(Xs const& xs, Ys const& ys) { return hana::none_of(xs, detail::in_by_reference<Ys>{ys}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_IS_DISJOINT_HPP PK �\�[�(+�l l remove_if.hppnu �[��� /*! @file Defines `boost::hana::remove_if`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_REMOVE_IF_HPP #define BOOST_HANA_REMOVE_IF_HPP #include <boost/hana/fwd/remove_if.hpp> #include <boost/hana/concept/monad_plus.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/filter.hpp> #include <boost/hana/functional/compose.hpp> #include <boost/hana/not.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Pred> constexpr auto remove_if_t::operator()(Xs&& xs, Pred&& pred) const { using M = typename hana::tag_of<Xs>::type; using RemoveIf = BOOST_HANA_DISPATCH_IF(remove_if_impl<M>, hana::MonadPlus<M>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::MonadPlus<M>::value, "hana::remove_if(xs, predicate) requires 'xs' to be a MonadPlus"); #endif return RemoveIf::apply(static_cast<Xs&&>(xs), static_cast<Pred&&>(pred)); } //! @endcond template <typename M, bool condition> struct remove_if_impl<M, when<condition>> : default_ { template <typename Xs, typename Pred> static constexpr auto apply(Xs&& xs, Pred&& pred) { return hana::filter(static_cast<Xs&&>(xs), hana::compose(hana::not_, static_cast<Pred&&>(pred))); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_REMOVE_IF_HPP PK �\�[����K K fold_right.hppnu �[��� /*! @file Defines `boost::hana::fold_right`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FOLD_RIGHT_HPP #define BOOST_HANA_FOLD_RIGHT_HPP #include <boost/hana/fwd/fold_right.hpp> #include <boost/hana/concept/foldable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/variadic/foldr1.hpp> #include <boost/hana/functional/partial.hpp> #include <boost/hana/fwd/unpack.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename State, typename F> constexpr decltype(auto) fold_right_t::operator()(Xs&& xs, State&& state, F&& f) const { using S = typename hana::tag_of<Xs>::type; using FoldRight = BOOST_HANA_DISPATCH_IF(fold_right_impl<S>, hana::Foldable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Foldable<S>::value, "hana::fold_right(xs, state, f) requires 'xs' to be Foldable"); #endif return FoldRight::apply(static_cast<Xs&&>(xs), static_cast<State&&>(state), static_cast<F&&>(f)); } template <typename Xs, typename F> constexpr decltype(auto) fold_right_t::operator()(Xs&& xs, F&& f) const { using S = typename hana::tag_of<Xs>::type; using FoldRight = BOOST_HANA_DISPATCH_IF(fold_right_impl<S>, hana::Foldable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Foldable<S>::value, "hana::fold_right(xs, f) requires 'xs' to be Foldable"); #endif return FoldRight::apply(static_cast<Xs&&>(xs), static_cast<F&&>(f)); } //! @endcond namespace detail { template <typename F, typename State> struct variadic_foldr { F& f; State& state; template <typename ...T> constexpr decltype(auto) operator()(T&& ...t) const { return detail::variadic::foldr( static_cast<F&&>(f), static_cast<State&&>(state), static_cast<T&&>(t)... ); } }; } template <typename T, bool condition> struct fold_right_impl<T, when<condition>> : default_ { // with state template <typename Xs, typename S, typename F> static constexpr decltype(auto) apply(Xs&& xs, S&& s, F&& f) { return hana::unpack(static_cast<Xs&&>(xs), detail::variadic_foldr<F, S>{f, s} ); } // without state template <typename Xs, typename F> static constexpr decltype(auto) apply(Xs&& xs, F&& f) { return hana::unpack(static_cast<Xs&&>(xs), hana::partial( detail::variadic::foldr1, static_cast<F&&>(f) ) ); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FOLD_RIGHT_HPP PK �\�[��V�� � version.hppnu �[��� /*! @file Defines macros for tracking the version of the library. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_VERSION_HPP #define BOOST_HANA_VERSION_HPP //! @internal //! Transforms a (version, revision, patchlevel) triple into a number of the //! form 0xVVRRPPPP to allow comparing versions in a normalized way. //! //! See http://sourceforge.net/p/predef/wiki/VersionNormalization. #define BOOST_HANA_CONFIG_VERSION(version, revision, patch) \ (((version) << 24) + ((revision) << 16) + (patch)) //! @ingroup group-config //! Macro expanding to the major version of the library, i.e. the `x` in `x.y.z`. #define BOOST_HANA_MAJOR_VERSION 1 //! @ingroup group-config //! Macro expanding to the minor version of the library, i.e. the `y` in `x.y.z`. #define BOOST_HANA_MINOR_VERSION 7 //! @ingroup group-config //! Macro expanding to the patch level of the library, i.e. the `z` in `x.y.z`. #define BOOST_HANA_PATCH_VERSION 0 //! @ingroup group-config //! Macro expanding to the full version of the library, in hexadecimal //! representation. //! //! Specifically, `BOOST_HANA_VERSION` expands to an hexadecimal number of the //! form 0xVVRRPPPP, where `VV` is the major version of the library, `RR` is //! the minor version and `PPPP` is the patch level. This allows the version //! of the library to be compared: //! @snippet example/version.cpp main //! //! //! @note //! The major, minor and patch versions of the library are also available //! individually with the `BOOST_HANA_{MAJOR,MINOR,PATCH}_VERSION` macros. #define BOOST_HANA_VERSION \ BOOST_HANA_CONFIG_VERSION(BOOST_HANA_MAJOR_VERSION, \ BOOST_HANA_MINOR_VERSION, \ BOOST_HANA_PATCH_VERSION) \ /**/ #endif // !BOOST_HANA_VERSION_HPP PK �\�[Z�?�� � accessors.hppnu �[��� /*! @file Defines `boost::hana::accessors`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_ACCESSORS_HPP #define BOOST_HANA_ACCESSORS_HPP #include <boost/hana/fwd/accessors.hpp> #include <boost/hana/concept/struct.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> BOOST_HANA_NAMESPACE_BEGIN template <typename S> struct accessors_t { #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Struct<S>::value, "hana::accessors<S> requires 'S' to be a Struct"); #endif constexpr decltype(auto) operator()() const { using Accessors = BOOST_HANA_DISPATCH_IF(accessors_impl<S>, hana::Struct<S>::value ); return Accessors::apply(); } }; template <typename S, bool condition> struct accessors_impl<S, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; namespace struct_detail { template <typename ...> struct is_valid { static constexpr bool value = true; }; } template <typename S> struct accessors_impl<S, when< struct_detail::is_valid<typename S::hana_accessors_impl>::value >> : S::hana_accessors_impl { }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_ACCESSORS_HPP PK �\�[Kk�w� � drop_back.hppnu �[��� /*! @file Defines `boost::hana::drop_back`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DROP_BACK_HPP #define BOOST_HANA_DROP_BACK_HPP #include <boost/hana/fwd/drop_back.hpp> #include <boost/hana/at.hpp> #include <boost/hana/concept/integral_constant.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/integral_constant.hpp> #include <boost/hana/length.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename N> constexpr auto drop_back_t::operator()(Xs&& xs, N const& n) const { using S = typename hana::tag_of<Xs>::type; using DropBack = BOOST_HANA_DISPATCH_IF(drop_back_impl<S>, hana::Sequence<S>::value && hana::IntegralConstant<N>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Sequence<S>::value, "hana::drop_back(xs, n) requires 'xs' to be a Sequence"); static_assert(hana::IntegralConstant<N>::value, "hana::drop_back(xs, n) requires 'n' to be an IntegralConstant"); #endif static_assert(N::value >= 0, "hana::drop_back(xs, n) requires 'n' to be non-negative"); return DropBack::apply(static_cast<Xs&&>(xs), n); } template <typename Xs> constexpr auto drop_back_t::operator()(Xs&& xs) const { return (*this)(static_cast<Xs&&>(xs), hana::size_c<1>); } //! @endcond template <typename S, bool condition> struct drop_back_impl<S, when<condition>> : default_ { template <typename Xs, std::size_t ...n> static constexpr auto drop_back_helper(Xs&& xs, std::index_sequence<n...>) { return hana::make<S>(hana::at_c<n>(static_cast<Xs&&>(xs))...); } template <typename Xs, typename N> static constexpr auto apply(Xs&& xs, N const&) { constexpr std::size_t n = N::value; constexpr std::size_t len = decltype(hana::length(xs))::value; return drop_back_helper(static_cast<Xs&&>(xs), std::make_index_sequence<(n > len ? 0 : len - n)>{}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DROP_BACK_HPP PK �\�[� ܝ7 7 unpack.hppnu �[��� /*! @file Defines `boost::hana::unpack`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_UNPACK_HPP #define BOOST_HANA_UNPACK_HPP #include <boost/hana/fwd/unpack.hpp> #include <boost/hana/accessors.hpp> #include <boost/hana/at.hpp> #include <boost/hana/concept/foldable.hpp> #include <boost/hana/concept/iterable.hpp> #include <boost/hana/concept/struct.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/first.hpp> #include <boost/hana/functional/partial.hpp> #include <boost/hana/fwd/fold_left.hpp> #include <boost/hana/length.hpp> #include <boost/hana/pair.hpp> #include <boost/hana/second.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename F> constexpr decltype(auto) unpack_t::operator()(Xs&& xs, F&& f) const { using S = typename hana::tag_of<Xs>::type; using Unpack = BOOST_HANA_DISPATCH_IF(unpack_impl<S>, hana::Foldable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Foldable<S>::value, "hana::unpack(xs, f) requires 'xs' to be Foldable"); #endif return Unpack::apply(static_cast<Xs&&>(xs), static_cast<F&&>(f)); } //! @endcond template <typename T, bool condition> struct unpack_impl<T, when<condition>> : default_ { template <typename Xs, typename F> static constexpr decltype(auto) apply(Xs&& xs, F&& f) { return hana::fold_left(static_cast<Xs&&>(xs), static_cast<F&&>(f), hana::partial)(); } }; template <typename It> struct unpack_impl<It, when< hana::Iterable<It>::value && !is_default<length_impl<It>>::value >> { template <typename Xs, typename F, std::size_t ...i> static constexpr decltype(auto) unpack_helper(Xs&& xs, F&& f, std::index_sequence<i...>) { return static_cast<F&&>(f)(hana::at_c<i>(static_cast<Xs&&>(xs))...); } template <typename Xs, typename F> static constexpr decltype(auto) apply(Xs&& xs, F&& f) { constexpr std::size_t N = decltype(hana::length(xs))::value; return unpack_helper(static_cast<Xs&&>(xs), static_cast<F&&>(f), std::make_index_sequence<N>{}); } }; template <typename T, std::size_t N> struct unpack_impl<T[N]> { template <typename Xs, typename F, std::size_t ...i> static constexpr decltype(auto) unpack_helper(Xs&& xs, F&& f, std::index_sequence<i...>) { return static_cast<F&&>(f)(static_cast<Xs&&>(xs)[i]...); } template <typename Xs, typename F> static constexpr decltype(auto) apply(Xs&& xs, F&& f) { return unpack_impl::unpack_helper(static_cast<Xs&&>(xs), static_cast<F&&>(f), std::make_index_sequence<N>{}); } }; ////////////////////////////////////////////////////////////////////////// // Model for Products ////////////////////////////////////////////////////////////////////////// template <typename T> struct unpack_impl<T, when<hana::Product<T>::value>> { template <typename P, typename F> static constexpr decltype(auto) apply(P&& p, F&& f) { return static_cast<F&&>(f)( hana::first(static_cast<P&&>(p)), hana::second(static_cast<P&&>(p)) ); } }; ////////////////////////////////////////////////////////////////////////// // Model for Structs ////////////////////////////////////////////////////////////////////////// namespace struct_detail { // This is equivalent to `demux`, except that `demux` can't forward // the `udt` because it does not know the `g`s are accessors. Hence, // this can result in faster code. struct almost_demux { template <typename F, typename Udt, typename ...Members> constexpr decltype(auto) operator()(F&& f, Udt&& udt, Members&& ...g) const { return static_cast<F&&>(f)(hana::make_pair( hana::first(static_cast<Members&&>(g)), hana::second(static_cast<Members&&>(g)) (static_cast<Udt&&>(udt)) )...); } }; } template <typename S> struct unpack_impl<S, when<hana::Struct<S>::value>> { template <typename Udt, typename F> static constexpr decltype(auto) apply(Udt&& udt, F&& f) { return hana::unpack(hana::accessors<S>(), hana::partial(struct_detail::almost_demux{}, static_cast<F&&>(f), static_cast<Udt&&>(udt))); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_UNPACK_HPP PK �\�[����{ { insert_range.hppnu �[��� /*! @file Defines `boost::hana::insert_range`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_INSERT_RANGE_HPP #define BOOST_HANA_INSERT_RANGE_HPP #include <boost/hana/fwd/insert_range.hpp> #include <boost/hana/concat.hpp> #include <boost/hana/concept/foldable.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/to.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/drop_front.hpp> #include <boost/hana/take_front.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename N, typename Elements> constexpr auto insert_range_t::operator()(Xs&& xs, N&& n, Elements&& elements) const { using S = typename hana::tag_of<Xs>::type; using InsertRange = BOOST_HANA_DISPATCH_IF(insert_range_impl<S>, hana::Sequence<Xs>::value && hana::Foldable<Elements>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Sequence<Xs>::value, "hana::insert_range(xs, n, elements) requires 'xs' to be a Sequence"); static_assert(hana::Foldable<Elements>::value, "hana::insert_range(xs, n, elements) requires 'elements' to be a Foldable"); #endif return InsertRange::apply(static_cast<Xs&&>(xs), static_cast<N&&>(n), static_cast<Elements&&>(elements)); } //! @endcond template <typename S, bool condition> struct insert_range_impl<S, when<condition>> { template <typename Xs, typename N, typename Elements> static constexpr auto apply(Xs&& xs, N const& n, Elements&& e) { return hana::concat( hana::concat( hana::take_front(xs, n), hana::to<S>(static_cast<Elements&&>(e)) ), hana::drop_front(xs, n) ); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_INSERT_RANGE_HPP PK �\�[5��� � unfold_right.hppnu �[��� /*! @file Defines `boost::hana::unfold_right`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_UNFOLD_RIGHT_HPP #define BOOST_HANA_UNFOLD_RIGHT_HPP #include <boost/hana/fwd/unfold_right.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/empty.hpp> #include <boost/hana/first.hpp> #include <boost/hana/functional/partial.hpp> #include <boost/hana/optional.hpp> #include <boost/hana/prepend.hpp> #include <boost/hana/second.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename S> struct unfold_right_t { #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Sequence<S>::value, "hana::unfold_right<S> requires 'S' to be a Sequence"); #endif template <typename State, typename F> constexpr auto operator()(State&& state, F&& f) const { return unfold_right_impl<S>::apply( static_cast<State&&>(state), static_cast<F&&>(f) ); } }; //! @endcond template <typename S, bool condition> struct unfold_right_impl<S, when<condition>> : default_ { struct unfold_right_helper { template <typename F, typename P> constexpr auto operator()(F&& f, P&& p) const { return hana::prepend( unfold_right_impl::apply( hana::second(static_cast<P&&>(p)), static_cast<F&&>(f) ), hana::first(static_cast<P&&>(p)) ); } }; template <typename Init, typename F> static constexpr auto apply(Init&& init, F&& f) { decltype(auto) elt = f(static_cast<Init&&>(init)); return hana::maybe(hana::empty<S>(), hana::partial(unfold_right_helper{}, static_cast<F&&>(f)), static_cast<decltype(elt)&&>(elt) ); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_UNFOLD_RIGHT_HPP PK �\�[O��� � lexicographical_compare.hppnu �[��� /*! @file Defines `boost::hana::lexicographical_compare`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_LEXICOGRAPHICAL_COMPARE_HPP #define BOOST_HANA_LEXICOGRAPHICAL_COMPARE_HPP #include <boost/hana/fwd/lexicographical_compare.hpp> #include <boost/hana/bool.hpp> #include <boost/hana/concept/iterable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/drop_front.hpp> #include <boost/hana/front.hpp> #include <boost/hana/if.hpp> #include <boost/hana/is_empty.hpp> #include <boost/hana/less.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Ys> constexpr auto lexicographical_compare_t::operator()(Xs const& xs, Ys const& ys) const { return hana::lexicographical_compare(xs, ys, hana::less); } template <typename Xs, typename Ys, typename Pred> constexpr auto lexicographical_compare_t::operator()(Xs const& xs, Ys const& ys, Pred const& pred) const { using It1 = typename hana::tag_of<Xs>::type; using It2 = typename hana::tag_of<Ys>::type; using LexicographicalCompare = BOOST_HANA_DISPATCH_IF( lexicographical_compare_impl<It1>, hana::Iterable<It1>::value && hana::Iterable<It2>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Iterable<It1>::value, "hana::lexicographical_compare(xs, ys, pred) requires 'xs' to be Iterable"); static_assert(hana::Iterable<It2>::value, "hana::lexicographical_compare(xs, ys, pred) requires 'ys' to be Iterable"); #endif return LexicographicalCompare::apply(xs, ys, pred); } //! @endcond template <typename It, bool condition> struct lexicographical_compare_impl<It, when<condition>> : default_ { template <typename Xs, typename Ys, typename Pred> static constexpr auto helper2(Xs const&, Ys const&, Pred const&, hana::true_) { return hana::false_c; } template <typename Xs, typename Ys, typename Pred> static constexpr auto helper2(Xs const& xs, Ys const& ys, Pred const& pred, hana::false_) { return apply(hana::drop_front(xs), hana::drop_front(ys), pred); } template <typename Xs, typename Ys, typename Pred> static constexpr auto helper2(Xs const& xs, Ys const& ys, Pred const& pred, bool is_greater) { return is_greater ? false : apply(hana::drop_front(xs), hana::drop_front(ys), pred); } template <typename Xs, typename Ys, typename Pred> static constexpr auto helper1(Xs const&, Ys const&, Pred const&, hana::true_) { return hana::true_c; } template <typename Xs, typename Ys, typename Pred> static constexpr auto helper1(Xs const& xs, Ys const& ys, Pred const& pred, hana::false_) { return helper2(xs, ys, pred, hana::if_(pred(hana::front(ys), hana::front(xs)), hana::true_c, hana::false_c)); } template <typename Xs, typename Ys, typename Pred> static constexpr auto helper1(Xs const& xs, Ys const& ys, Pred const& pred, bool is_less) { return is_less ? true : helper2(xs, ys, pred, hana::if_(pred(hana::front(ys), hana::front(xs)), hana::true_c, hana::false_c)); } template <typename Xs, typename Ys, typename Pred> static constexpr auto helper(Xs const&, Ys const& ys, Pred const&, hana::true_) { return hana::not_(hana::is_empty(ys)); } template <typename Xs, typename Ys, typename Pred> static constexpr auto helper(Xs const& xs, Ys const& ys, Pred const& pred, hana::false_) { return helper1(xs, ys, pred, hana::if_(pred(hana::front(xs), hana::front(ys)), hana::true_c, hana::false_c)); } template <typename Xs, typename Ys, typename Pred> static constexpr auto apply(Xs const& xs, Ys const& ys, Pred const& pred) { return helper(xs, ys, pred, hana::bool_c< decltype(hana::is_empty(xs))::value || decltype(hana::is_empty(ys))::value >); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_LEXICOGRAPHICAL_COMPARE_HPP PK �\�[�4 �� � power.hppnu �[��� /*! @file Defines `boost::hana::power`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_POWER_HPP #define BOOST_HANA_POWER_HPP #include <boost/hana/fwd/power.hpp> #include <boost/hana/concept/integral_constant.hpp> #include <boost/hana/concept/ring.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/functional/iterate.hpp> #include <boost/hana/functional/partial.hpp> #include <boost/hana/mult.hpp> #include <boost/hana/one.hpp> #include <cstddef> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename X, typename N> constexpr decltype(auto) power_t::operator()(X&& x, N const& n) const { using R = typename hana::tag_of<X>::type; using Power = BOOST_HANA_DISPATCH_IF(power_impl<R>, hana::Ring<R>::value && hana::IntegralConstant<N>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Ring<R>::value, "hana::power(x, n) requires 'x' to be in a Ring"); static_assert(hana::IntegralConstant<N>::value, "hana::power(x, n) requires 'n' to be an IntegralConstant"); #endif static_assert(N::value >= 0, "hana::power(x, n) requires 'n' to be non-negative"); return Power::apply(static_cast<X&&>(x), n); } //! @endcond template <typename R, bool condition> struct power_impl<R, when<condition>> : default_ { template <typename X, typename N> static constexpr decltype(auto) apply(X&& x, N const&) { constexpr std::size_t n = N::value; return hana::iterate<n>( hana::partial(hana::mult, static_cast<X&&>(x)), hana::one<R>() ); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_POWER_HPP PK �\�[Ĝ�S" " detail/dispatch_if.hppnu �[��� /*! @file Defines `BOOST_HANA_DISPATCH_IF`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_DISPATCH_IF_HPP #define BOOST_HANA_DETAIL_DISPATCH_IF_HPP #include <boost/hana/config.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN struct deleted_implementation { template <typename ...T> static constexpr auto apply(T&& ...) = delete; }; //! @ingroup group-details //! Dispatch to the given implementation method only when a condition is //! satisfied. //! //! If the condition is satisfied, this macro is equivalent to the type //! `IMPL`. Otherwise, it is equivalent to a type with a deleted static //! function named `apply`. When a tag-dispatching error happens, the //! condition should be false and the deleted static function `apply` //! will prevent the compiler from generating too much garbage. //! //! @note //! When `BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS` is defined, the //! condition is always ignored and this macro expands to the //! implementation only. //! //! @remark //! This must be implemented as a macro, because we don't want the //! condition to be evaluated at all when //! `BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS` is defined. #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS #define BOOST_HANA_DISPATCH_IF(IMPL, ...) \ ::std::conditional_t< \ (__VA_ARGS__), \ IMPL, \ ::boost::hana::deleted_implementation \ > \ /**/ #else #define BOOST_HANA_DISPATCH_IF(IMPL, ...) IMPL #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_DISPATCH_IF_HPP PK �\�[LWld! ! detail/has_duplicates.hppnu �[��� /*! @file Defines `boost::hana::detail::has_duplicates`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_HAS_DUPLICATES_HPP #define BOOST_HANA_DETAIL_HAS_DUPLICATES_HPP #include <boost/hana/config.hpp> #include <boost/hana/detail/fast_and.hpp> #include <boost/hana/equal.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <typename T, typename ...U> constexpr std::size_t pack_count() { std::size_t c = 0; std::size_t expand[] = {0, // avoid empty array (decltype(hana::equal(std::declval<T>(), std::declval<U>()))::value ? ++c : c)... }; (void)expand; return c; } //! @ingroup group-details //! Returns whether any of the `T`s are duplicate w.r.t. `hana::equal`. //! //! In particular, this does not check whether all of the `T`s are unique //! as _types_, but rather whether they are unique when compared as //! `hana::equal(std::declval<T>(), std::declval<U>())`. This assumes //! the comparison to return an `IntegralConstant` that can be explicitly //! converted to `bool`. //! //! @note //! Since this utility is mostly used in assertions to check that there //! are no duplicates in a sequence, we expect it to return `false` most //! of the time (otherwise we will assert). Hence, this implementation is //! biased towards the fact that we __will__ have to compare every pair of //! elements in most cases, and it does not try to be lazy. //! //! @todo //! This implementation is O(n^2). We could do it in O(n), but that would //! require a more elaborate setup including storage with O(1) lookup //! (which could be based on a compile-time hash). If we implement such //! storage for associative sequences, we could use it to optimize this. template <typename ...T> struct has_duplicates { static constexpr bool value = sizeof...(T) > 0 && !detail::fast_and<(detail::pack_count<T, T...>() == 1)...>::value ; }; } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_HAS_DUPLICATES_HPP PK �\�[���U detail/nested_to.hppnu �[��� /*! @file Defines `boost::hana::detail::nested_to`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_NESTED_TO_HPP #define BOOST_HANA_DETAIL_NESTED_TO_HPP #include <boost/hana/detail/nested_to_fwd.hpp> #include <boost/hana/config.hpp> #include <boost/hana/functional/partial.hpp> BOOST_HANA_NAMESPACE_BEGIN namespace detail { //! @cond template <typename Algorithm> template <typename X> constexpr decltype(auto) nested_to_t<Algorithm>::operator()(X&& x) const { return hana::partial(Algorithm{}, static_cast<X&&>(x)); } //! @endcond } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_NESTED_TO_HPP PK �\�[B�]�d d detail/any_of.hppnu �[��� /*! @file Defines `boost::hana::detail::any_of`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_ANY_OF_HPP #define BOOST_HANA_DETAIL_ANY_OF_HPP #include <boost/hana/config.hpp> #include <type_traits> #include <utility> BOOST_HANA_NAMESPACE_BEGIN namespace detail { std::false_type expand(...); template <template <typename ...> class Predicate, typename ...T> decltype(expand( typename std::enable_if<!Predicate<T>::value, void*>::type{}... )) any_of_impl(int); template <template <typename ...> class Predicate, typename ...T> std::true_type any_of_impl(...); //! @ingroup group-details //! Returns whether the `Predicate` is satisfied by any of the `T...`. //! //! This metafunction will short-circuit the evaluation at the first //! type satisfying the predicate, if such a type exists. //! //! //! @note //! The implementation technique used here was originally shown to //! me by Eric Fiselier. All credits where due. template <template <typename ...> class Predicate, typename ...T> struct any_of : decltype(any_of_impl<Predicate, T...>(int{})) { }; } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_ANY_OF_HPP PK �\�[gQ�� � detail/nested_by.hppnu �[��� /*! @file Defines `boost::hana::detail::nested_by`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_NESTED_BY_HPP #define BOOST_HANA_DETAIL_NESTED_BY_HPP #include <boost/hana/config.hpp> #include <boost/hana/detail/nested_by_fwd.hpp> #include <boost/hana/functional/flip.hpp> #include <boost/hana/functional/partial.hpp> BOOST_HANA_NAMESPACE_BEGIN namespace detail { //! @cond template <typename Algorithm> template <typename Predicate, typename Object> constexpr decltype(auto) nested_by_t<Algorithm>:: operator()(Predicate&& predicate, Object&& object) const { return Algorithm{}(static_cast<Object&&>(object), static_cast<Predicate&&>(predicate)); } template <typename Algorithm> template <typename Predicate> constexpr decltype(auto) nested_by_t<Algorithm>::operator()(Predicate&& predicate) const { return hana::partial(hana::flip(Algorithm{}), static_cast<Predicate&&>(predicate)); } //! @endcond } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_NESTED_BY_HPP PK �\�[ۃq�� � detail/concepts.hppnu �[��� /*! @file Defines concepts from the Standard library. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_CONCEPTS_HPP #define BOOST_HANA_DETAIL_CONCEPTS_HPP #include <boost/hana/config.hpp> #include <boost/hana/detail/std_common_type.hpp> #include <boost/hana/detail/void_t.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN namespace detail { //! @cond ////////////////////////////////////////////////////////////////////////// // EqualityComparable ////////////////////////////////////////////////////////////////////////// template <typename T, typename U = T, typename = void> struct EqualityComparable : std::false_type { }; template <typename T> struct EqualityComparable<T, T, detail::void_t< decltype(static_cast<T&&>(*(T*)0) == static_cast<T&&>(*(T*)0) ? 0:0), decltype(static_cast<T&&>(*(T*)0) != static_cast<T&&>(*(T*)0) ? 0:0) >> : std::true_type { }; template <typename T, typename U> struct EqualityComparable<T, U, typename std::enable_if< !std::is_same<T, U>::value, detail::void_t< decltype(static_cast<T&&>(*(T*)0) == static_cast<U&&>(*(U*)0) ? 0:0), decltype(static_cast<U&&>(*(U*)0) == static_cast<T&&>(*(T*)0) ? 0:0), decltype(static_cast<T&&>(*(T*)0) != static_cast<U&&>(*(U*)0) ? 0:0), decltype(static_cast<U&&>(*(U*)0) != static_cast<T&&>(*(T*)0) ? 0:0), typename detail::std_common_type<T, U>::type >>::type> : std::integral_constant<bool, EqualityComparable<T>::value && EqualityComparable<U>::value && EqualityComparable<typename detail::std_common_type<T, U>::type>::value > { }; ////////////////////////////////////////////////////////////////////////// // LessThanComparable ////////////////////////////////////////////////////////////////////////// template <typename T, typename U = T, typename = void> struct LessThanComparable : std::false_type { }; template <typename T> struct LessThanComparable<T, T, detail::void_t< decltype(static_cast<T&&>(*(T*)0) < static_cast<T&&>(*(T*)0) ? 0:0) >> : std::true_type { }; template <typename T, typename U> struct LessThanComparable<T, U, std::enable_if_t< !std::is_same<T, U>::value, detail::void_t< decltype(static_cast<T&&>(*(T*)0) < static_cast<U&&>(*(U*)0) ? 0:0), decltype(static_cast<U&&>(*(U*)0) < static_cast<T&&>(*(T*)0) ? 0:0), typename detail::std_common_type<T, U>::type > >> : std::integral_constant<bool, LessThanComparable<T>::value && LessThanComparable<U>::value && LessThanComparable<typename detail::std_common_type<T, U>::type>::value > { }; //! @endcond } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_CONCEPTS_HPP PK �\�[�GyD' D' detail/integral_constant.hppnu �[��� /*! @file Defines the barebones `boost::hana::integral_constant` template, but no operations on it. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_INTEGRAL_CONSTANT_HPP #define BOOST_HANA_DETAIL_INTEGRAL_CONSTANT_HPP #include <boost/hana/config.hpp> #include <boost/hana/detail/operators/adl.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN //! Tag representing `hana::integral_constant`. //! @relates hana::integral_constant template <typename T> struct integral_constant_tag { using value_type = T; }; namespace ic_detail { template <typename T, T v> struct with_index_t { template <typename F> constexpr void operator()(F&& f) const; }; template <typename T, T v> struct times_t { static constexpr with_index_t<T, v> with_index{}; template <typename F> constexpr void operator()(F&& f) const; }; } //! @ingroup group-datatypes //! Compile-time value of an integral type. //! //! An `integral_constant` is an object that represents a compile-time //! integral value. As the name suggests, `hana::integral_constant` is //! basically equivalent to `std::integral_constant`, except that //! `hana::integral_constant` also provide other goodies to make them //! easier to use, like arithmetic operators and similar features. In //! particular, `hana::integral_constant` is guaranteed to inherit from //! the corresponding `std::integral_constant`, and hence have the same //! members and capabilities. The sections below explain the extensions //! to `std::integral_constant` provided by `hana::integral_constant`. //! //! //! Arithmetic operators //! -------------------- //! `hana::integral_constant` provides arithmetic operators that return //! `hana::integral_constant`s to ease writing compile-time arithmetic: //! @snippet example/integral_constant.cpp operators //! //! It is pretty important to realize that these operators return other //! `integral_constant`s, not normal values of an integral type. //! Actually, all those operators work pretty much in the same way. //! Simply put, for an operator `@`, //! @code //! integral_constant<T, x>{} @ integral_constant<T, y>{} == integral_constant<T, x @ y>{} //! @endcode //! //! The fact that the operators return `Constant`s is very important //! because it allows all the information that's known at compile-time //! to be conserved as long as it's only used with other values known at //! compile-time. It is also interesting to observe that whenever an //! `integral_constant` is combined with a normal runtime value, the //! result will be a runtime value (because of the implicit conversion). //! In general, this gives us the following table //! //! left operand | right operand | result //! :-----------------: | :-----------------: | :-----------------: //! `integral_constant` | `integral_constant` | `integral_constant` //! `integral_constant` | runtime | runtime //! runtime | `integral_constant` | runtime //! runtime | runtime | runtime //! //! The full range of provided operators is //! - Arithmetic: binary `+`, binary `-`, `/`, `*`, `%`, unary `+`, unary `-` //! - Bitwise: `~`, `&`, `|`, `^`, `<<`, `>>` //! - Comparison: `==`, `!=`, `<`, `<=`, `>`, `>=` //! - %Logical: `||`, `&&`, `!` //! //! //! Construction with user-defined literals //! --------------------------------------- //! `integral_constant`s of type `long long` can be created with the //! `_c` user-defined literal, which is contained in the `literals` //! namespace: //! @snippet example/integral_constant.cpp literals //! //! //! Modeled concepts //! ---------------- //! 1. `Constant` and `IntegralConstant`\n //! An `integral_constant` is a model of the `IntegralConstant` concept in //! the most obvious way possible. Specifically, //! @code //! integral_constant<T, v>::value == v // of type T //! @endcode //! The model of `Constant` follows naturally from the model of `IntegralConstant`, i.e. //! @code //! value<integral_constant<T, v>>() == v // of type T //! @endcode //! //! 2. `Comparable`, `Orderable`, `Logical`, `Monoid`, `Group`, `Ring`, and `EuclideanRing`, `Hashable`\n //! Those models are exactly those provided for `Constant`s, which are //! documented in their respective concepts. #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename T, T v> struct integral_constant { //! Call a function n times. //! //! `times` allows a nullary function to be invoked `n` times: //! @code //! int_<3>::times(f) //! @endcode //! should be expanded by any decent compiler to //! @code //! f(); f(); f(); //! @endcode //! //! This can be useful in several contexts, e.g. for loop unrolling: //! @snippet example/integral_constant.cpp times_loop_unrolling //! //! Note that `times` is really a static function object, not just a //! static function. This allows `int_<n>::%times` to be passed to //! higher-order algorithms: //! @snippet example/integral_constant.cpp times_higher_order //! //! Also, since static members can be accessed using both the `.` and //! the `::` syntax, one can take advantage of this (loophole?) to //! call `times` on objects just as well as on types: //! @snippet example/integral_constant.cpp from_object //! //! @note //! `times` is equivalent to the `hana::repeat` function, which works //! on an arbitrary `IntegralConstant`. //! //! Sometimes, it is also useful to know the index we're at inside the //! function. This can be achieved by using `times.with_index`: //! @snippet example/integral_constant.cpp times_with_index_runtime //! //! Remember that `times` is a _function object_, and hence it can //! have subobjects. `with_index` is just a function object nested //! inside `times`, which allows for this nice little interface. Also //! note that the indices passed to the function are `integral_constant`s; //! they are known at compile-time. Hence, we can do compile-time stuff //! with them, like indexing inside a tuple: //! @snippet example/integral_constant.cpp times_with_index_compile_time //! //! @note //! `times.with_index(f)` guarantees that the calls to `f` will be //! done in order of ascending index. In other words, `f` will be //! called as `f(0)`, `f(1)`, `f(2)`, etc., but with `integral_constant`s //! instead of normal integers. Side effects can also be done in the //! function passed to `times` and `times.with_index`. template <typename F> static constexpr void times(F&& f) { f(); f(); ... f(); // n times total } //! Equivalent to `hana::plus` template <typename X, typename Y> friend constexpr auto operator+(X&& x, Y&& y); //! Equivalent to `hana::minus` template <typename X, typename Y> friend constexpr auto operator-(X&& x, Y&& y); //! Equivalent to `hana::negate` template <typename X> friend constexpr auto operator-(X&& x); //! Equivalent to `hana::mult` template <typename X, typename Y> friend constexpr auto operator*(X&& x, Y&& y); //! Equivalent to `hana::div` template <typename X, typename Y> friend constexpr auto operator/(X&& x, Y&& y); //! Equivalent to `hana::mod` template <typename X, typename Y> friend constexpr auto operator%(X&& x, Y&& y); //! Equivalent to `hana::equal` template <typename X, typename Y> friend constexpr auto operator==(X&& x, Y&& y); //! Equivalent to `hana::not_equal` template <typename X, typename Y> friend constexpr auto operator!=(X&& x, Y&& y); //! Equivalent to `hana::or_` template <typename X, typename Y> friend constexpr auto operator||(X&& x, Y&& y); //! Equivalent to `hana::and_` template <typename X, typename Y> friend constexpr auto operator&&(X&& x, Y&& y); //! Equivalent to `hana::not_` template <typename X> friend constexpr auto operator!(X&& x); //! Equivalent to `hana::less` template <typename X, typename Y> friend constexpr auto operator<(X&& x, Y&& y); //! Equivalent to `hana::greater` template <typename X, typename Y> friend constexpr auto operator>(X&& x, Y&& y); //! Equivalent to `hana::less_equal` template <typename X, typename Y> friend constexpr auto operator<=(X&& x, Y&& y); //! Equivalent to `hana::greater_equal` template <typename X, typename Y> friend constexpr auto operator>=(X&& x, Y&& y); }; #else template <typename T, T v> #ifdef BOOST_HANA_WORKAROUND_MSVC_EMPTYBASE struct __declspec(empty_bases) integral_constant #else struct integral_constant #endif : std::integral_constant<T, v> , detail::operators::adl<integral_constant<T, v>> { using type = integral_constant; // override std::integral_constant::type static constexpr ic_detail::times_t<T, v> times{}; using hana_tag = integral_constant_tag<T>; }; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_INTEGRAL_CONSTANT_HPP PK �\�[5�X X detail/nested_than_fwd.hppnu �[��� /*! @file Forward declares `boost::hana::detail::nested_than`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_NESTED_THAN_FWD_HPP #define BOOST_HANA_DETAIL_NESTED_THAN_FWD_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <typename Algorithm> struct nested_than_t { template <typename X> constexpr decltype(auto) operator()(X&& x) const; }; //! @ingroup group-details //! Provides a `.than` static constexpr function object. //! //! When creating a binary function object of type `Algo` whose signature //! is `A x B -> Return`, `nested_than<Algo>` can be used as a base class //! of `Algo`. Doing so will provide a static constexpr member called //! `than`, which has the following signature: //! @code //! B -> A -> Return //! @endcode //! //! Note that the function object `Algo` must be default-constructible, //! since it will be called as `Algo{}(arguments...)`. //! //! @note //! This function object is especially useful because it takes care of //! avoiding ODR violations caused by the nested static constexpr member. template <typename Algorithm> struct nested_than { static constexpr nested_than_t<Algorithm> than{}; }; template <typename Algorithm> constexpr nested_than_t<Algorithm> nested_than<Algorithm>::than; } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_NESTED_THAN_FWD_HPP PK �\�[�n!9q/ q/ detail/struct_macros.hppnu �[��� /*! @file Defines the `BOOST_HANA_DEFINE_STRUCT`, `BOOST_HANA_ADAPT_STRUCT`, and `BOOST_HANA_ADAPT_ADT` macros. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ ////////////////////////////////////////////////////////////////////////////// // THIS FILE IS GENERATED FROM THE <boost/hana/detail/struct_macros.erb.hpp> // ERB TEMPLATE. DO NOT EDIT THIS FILE DIRECTLY. // // THE ERB TEMPLATE CONTAINS INFORMATION ABOUT HOW TO REGENERATE THIS FILE. ////////////////////////////////////////////////////////////////////////////// #ifndef BOOST_HANA_DETAIL_STRUCT_MACROS_HPP #define BOOST_HANA_DETAIL_STRUCT_MACROS_HPP #include <boost/hana/config.hpp> #include <boost/hana/detail/preprocessor.hpp> #include <boost/hana/pair.hpp> #include <boost/hana/string.hpp> #include <boost/hana/tuple.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN namespace struct_detail { template <typename Memptr, Memptr ptr> struct member_ptr { template <typename T> constexpr decltype(auto) operator()(T&& t) const { return static_cast<T&&>(t).*ptr; } }; constexpr std::size_t strlen(char const* s) { std::size_t n = 0; while (*s++ != '\0') ++n; return n; } template <std::size_t n, typename Names, std::size_t ...i> constexpr auto prepare_member_name_impl(std::index_sequence<i...>) { return hana::string_c<hana::at_c<n>(Names::get())[i]...>; } template <std::size_t n, typename Names> constexpr auto prepare_member_name() { constexpr std::size_t len = strlen(hana::at_c<n>(Names::get())); return prepare_member_name_impl<n, Names>(std::make_index_sequence<len>{}); } } BOOST_HANA_NAMESPACE_END ////////////////////////////////////////////////////////////////////////////// // BOOST_HANA_PP_NARG ////////////////////////////////////////////////////////////////////////////// //! @ingroup group-details //! Macro expanding to the number of arguments it is passed. //! //! Specifically, `BOOST_HANA_PP_NARG(x1, ..., xn)` expands to `n`. It is //! an error to call this macro with 0 arguments. #ifdef BOOST_HANA_WORKAROUND_MSVC_PREPROCESSOR_616033 #define BOOST_HANA_PP_NARG(...) \ BOOST_HANA_PP_CONCAT(BOOST_HANA_PP_NARG_IMPL(__VA_ARGS__, 40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,),) #else #define BOOST_HANA_PP_NARG(...) \ BOOST_HANA_PP_NARG_IMPL(__VA_ARGS__, 40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,) #endif #define BOOST_HANA_PP_NARG_IMPL(e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40, N, ...) N ////////////////////////////////////////////////////////////////////////////// // BOOST_HANA_PP_BACK ////////////////////////////////////////////////////////////////////////////// //! @ingroup group-details //! Expands to its last argument. #define BOOST_HANA_PP_BACK(...) \ BOOST_HANA_PP_BACK_IMPL(BOOST_HANA_PP_NARG(__VA_ARGS__), __VA_ARGS__) #ifdef BOOST_HANA_WORKAROUND_MSVC_PREPROCESSOR_616033 #define BOOST_HANA_PP_BACK_IMPL(N, ...) BOOST_HANA_PP_BACK_IMPL_I(N, __VA_ARGS__) #define BOOST_HANA_PP_BACK_IMPL_I(N, ...) \ BOOST_HANA_PP_CONCAT(BOOST_HANA_PP_CONCAT(BOOST_HANA_PP_BACK_IMPL_, N)(__VA_ARGS__),) #else #define BOOST_HANA_PP_BACK_IMPL(N, ...) \ BOOST_HANA_PP_CONCAT(BOOST_HANA_PP_BACK_IMPL_, N)(__VA_ARGS__) #endif #define BOOST_HANA_PP_BACK_IMPL_1(e1) e1 #define BOOST_HANA_PP_BACK_IMPL_2(e1, e2) e2 #define BOOST_HANA_PP_BACK_IMPL_3(e1, e2, e3) e3 #define BOOST_HANA_PP_BACK_IMPL_4(e1, e2, e3, e4) e4 #define BOOST_HANA_PP_BACK_IMPL_5(e1, e2, e3, e4, e5) e5 #define BOOST_HANA_PP_BACK_IMPL_6(e1, e2, e3, e4, e5, e6) e6 #define BOOST_HANA_PP_BACK_IMPL_7(e1, e2, e3, e4, e5, e6, e7) e7 #define BOOST_HANA_PP_BACK_IMPL_8(e1, e2, e3, e4, e5, e6, e7, e8) e8 #define BOOST_HANA_PP_BACK_IMPL_9(e1, e2, e3, e4, e5, e6, e7, e8, e9) e9 #define BOOST_HANA_PP_BACK_IMPL_10(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10) e10 #define BOOST_HANA_PP_BACK_IMPL_11(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11) e11 #define BOOST_HANA_PP_BACK_IMPL_12(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12) e12 #define BOOST_HANA_PP_BACK_IMPL_13(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13) e13 #define BOOST_HANA_PP_BACK_IMPL_14(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14) e14 #define BOOST_HANA_PP_BACK_IMPL_15(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15) e15 #define BOOST_HANA_PP_BACK_IMPL_16(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16) e16 #define BOOST_HANA_PP_BACK_IMPL_17(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17) e17 #define BOOST_HANA_PP_BACK_IMPL_18(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18) e18 #define BOOST_HANA_PP_BACK_IMPL_19(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19) e19 #define BOOST_HANA_PP_BACK_IMPL_20(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20) e20 #define BOOST_HANA_PP_BACK_IMPL_21(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21) e21 #define BOOST_HANA_PP_BACK_IMPL_22(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22) e22 #define BOOST_HANA_PP_BACK_IMPL_23(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23) e23 #define BOOST_HANA_PP_BACK_IMPL_24(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24) e24 #define BOOST_HANA_PP_BACK_IMPL_25(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25) e25 #define BOOST_HANA_PP_BACK_IMPL_26(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26) e26 #define BOOST_HANA_PP_BACK_IMPL_27(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27) e27 #define BOOST_HANA_PP_BACK_IMPL_28(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28) e28 #define BOOST_HANA_PP_BACK_IMPL_29(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29) e29 #define BOOST_HANA_PP_BACK_IMPL_30(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30) e30 #define BOOST_HANA_PP_BACK_IMPL_31(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31) e31 #define BOOST_HANA_PP_BACK_IMPL_32(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32) e32 #define BOOST_HANA_PP_BACK_IMPL_33(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33) e33 #define BOOST_HANA_PP_BACK_IMPL_34(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34) e34 #define BOOST_HANA_PP_BACK_IMPL_35(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35) e35 #define BOOST_HANA_PP_BACK_IMPL_36(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36) e36 #define BOOST_HANA_PP_BACK_IMPL_37(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37) e37 #define BOOST_HANA_PP_BACK_IMPL_38(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38) e38 #define BOOST_HANA_PP_BACK_IMPL_39(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39) e39 #define BOOST_HANA_PP_BACK_IMPL_40(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40) e40 ////////////////////////////////////////////////////////////////////////////// // BOOST_HANA_PP_DROP_BACK ////////////////////////////////////////////////////////////////////////////// //! @ingroup group-details //! Expands to all of its arguments, except for the last one. #define BOOST_HANA_PP_DROP_BACK(...) \ BOOST_HANA_PP_DROP_BACK_IMPL(BOOST_HANA_PP_NARG(__VA_ARGS__), __VA_ARGS__) #ifdef BOOST_HANA_WORKAROUND_MSVC_PREPROCESSOR_616033 #define BOOST_HANA_PP_DROP_BACK_IMPL(N, ...) BOOST_HANA_PP_DROP_BACK_IMPL_I(N, __VA_ARGS__) #define BOOST_HANA_PP_DROP_BACK_IMPL_I(N, ...) \ BOOST_HANA_PP_CONCAT(BOOST_HANA_PP_CONCAT(BOOST_HANA_PP_DROP_BACK_IMPL_, N)(__VA_ARGS__),) #else #define BOOST_HANA_PP_DROP_BACK_IMPL(N, ...) \ BOOST_HANA_PP_CONCAT(BOOST_HANA_PP_DROP_BACK_IMPL_, N)(__VA_ARGS__) #endif #define BOOST_HANA_PP_DROP_BACK_IMPL_1(e1) #define BOOST_HANA_PP_DROP_BACK_IMPL_2(e1, e2)e1 #define BOOST_HANA_PP_DROP_BACK_IMPL_3(e1, e2, e3)e1, e2 #define BOOST_HANA_PP_DROP_BACK_IMPL_4(e1, e2, e3, e4)e1, e2, e3 #define BOOST_HANA_PP_DROP_BACK_IMPL_5(e1, e2, e3, e4, e5)e1, e2, e3, e4 #define BOOST_HANA_PP_DROP_BACK_IMPL_6(e1, e2, e3, e4, e5, e6)e1, e2, e3, e4, e5 #define BOOST_HANA_PP_DROP_BACK_IMPL_7(e1, e2, e3, e4, e5, e6, e7)e1, e2, e3, e4, e5, e6 #define BOOST_HANA_PP_DROP_BACK_IMPL_8(e1, e2, e3, e4, e5, e6, e7, e8)e1, e2, e3, e4, e5, e6, e7 #define BOOST_HANA_PP_DROP_BACK_IMPL_9(e1, e2, e3, e4, e5, e6, e7, e8, e9)e1, e2, e3, e4, e5, e6, e7, e8 #define BOOST_HANA_PP_DROP_BACK_IMPL_10(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10)e1, e2, e3, e4, e5, e6, e7, e8, e9 #define BOOST_HANA_PP_DROP_BACK_IMPL_11(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10 #define BOOST_HANA_PP_DROP_BACK_IMPL_12(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11 #define BOOST_HANA_PP_DROP_BACK_IMPL_13(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12 #define BOOST_HANA_PP_DROP_BACK_IMPL_14(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13 #define BOOST_HANA_PP_DROP_BACK_IMPL_15(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14 #define BOOST_HANA_PP_DROP_BACK_IMPL_16(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15 #define BOOST_HANA_PP_DROP_BACK_IMPL_17(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16 #define BOOST_HANA_PP_DROP_BACK_IMPL_18(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17 #define BOOST_HANA_PP_DROP_BACK_IMPL_19(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18 #define BOOST_HANA_PP_DROP_BACK_IMPL_20(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19 #define BOOST_HANA_PP_DROP_BACK_IMPL_21(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20 #define BOOST_HANA_PP_DROP_BACK_IMPL_22(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21 #define BOOST_HANA_PP_DROP_BACK_IMPL_23(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22 #define BOOST_HANA_PP_DROP_BACK_IMPL_24(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23 #define BOOST_HANA_PP_DROP_BACK_IMPL_25(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24 #define BOOST_HANA_PP_DROP_BACK_IMPL_26(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25 #define BOOST_HANA_PP_DROP_BACK_IMPL_27(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26 #define BOOST_HANA_PP_DROP_BACK_IMPL_28(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27 #define BOOST_HANA_PP_DROP_BACK_IMPL_29(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28 #define BOOST_HANA_PP_DROP_BACK_IMPL_30(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29 #define BOOST_HANA_PP_DROP_BACK_IMPL_31(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30 #define BOOST_HANA_PP_DROP_BACK_IMPL_32(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31 #define BOOST_HANA_PP_DROP_BACK_IMPL_33(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32 #define BOOST_HANA_PP_DROP_BACK_IMPL_34(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33 #define BOOST_HANA_PP_DROP_BACK_IMPL_35(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34 #define BOOST_HANA_PP_DROP_BACK_IMPL_36(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35 #define BOOST_HANA_PP_DROP_BACK_IMPL_37(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36 #define BOOST_HANA_PP_DROP_BACK_IMPL_38(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37 #define BOOST_HANA_PP_DROP_BACK_IMPL_39(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38 #define BOOST_HANA_PP_DROP_BACK_IMPL_40(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39 ////////////////////////////////////////////////////////////////////////////// // BOOST_HANA_ADAPT_STRUCT ////////////////////////////////////////////////////////////////////////////// template <typename ...> struct BOOST_HANA_ADAPT_STRUCT_must_be_called_in_the_global_namespace; #define BOOST_HANA_ADAPT_STRUCT(...) \ template <> \ struct BOOST_HANA_ADAPT_STRUCT_must_be_called_in_the_global_namespace<>; \ BOOST_HANA_ADAPT_STRUCT_IMPL(BOOST_HANA_PP_NARG(__VA_ARGS__), __VA_ARGS__)\ static_assert(true, "force the usage of a trailing semicolon") \ /**/ #ifdef BOOST_HANA_WORKAROUND_MSVC_PREPROCESSOR_616033 #define BOOST_HANA_ADAPT_STRUCT_IMPL(N, ...) BOOST_HANA_ADAPT_STRUCT_IMPL_I(N, __VA_ARGS__) #define BOOST_HANA_ADAPT_STRUCT_IMPL_I(N, ...) \ BOOST_HANA_PP_CONCAT(BOOST_HANA_PP_CONCAT(BOOST_HANA_ADAPT_STRUCT_IMPL_, N)(__VA_ARGS__),) #else #define BOOST_HANA_ADAPT_STRUCT_IMPL(N, ...) \ BOOST_HANA_PP_CONCAT(BOOST_HANA_ADAPT_STRUCT_IMPL_, N)(__VA_ARGS__) #endif #define BOOST_HANA_ADAPT_STRUCT_IMPL_1(TYPE ) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ \ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_2(TYPE , m1) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_3(TYPE , m1, m2) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_4(TYPE , m1, m2, m3) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_5(TYPE , m1, m2, m3, m4) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_6(TYPE , m1, m2, m3, m4, m5) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_7(TYPE , m1, m2, m3, m4, m5, m6) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_8(TYPE , m1, m2, m3, m4, m5, m6, m7) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_9(TYPE , m1, m2, m3, m4, m5, m6, m7, m8) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_10(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_11(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_12(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_13(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_14(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_15(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_16(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_17(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_18(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_19(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_20(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_21(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_22(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_23(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_24(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_25(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_26(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_27(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_28(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_29(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27), BOOST_HANA_PP_STRINGIZE(m28) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m28), &TYPE::m28>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_30(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27), BOOST_HANA_PP_STRINGIZE(m28), BOOST_HANA_PP_STRINGIZE(m29) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m28), &TYPE::m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m29), &TYPE::m29>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_31(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27), BOOST_HANA_PP_STRINGIZE(m28), BOOST_HANA_PP_STRINGIZE(m29), BOOST_HANA_PP_STRINGIZE(m30) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m28), &TYPE::m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m29), &TYPE::m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m30), &TYPE::m30>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_32(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27), BOOST_HANA_PP_STRINGIZE(m28), BOOST_HANA_PP_STRINGIZE(m29), BOOST_HANA_PP_STRINGIZE(m30), BOOST_HANA_PP_STRINGIZE(m31) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m28), &TYPE::m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m29), &TYPE::m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m30), &TYPE::m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m31), &TYPE::m31>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_33(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27), BOOST_HANA_PP_STRINGIZE(m28), BOOST_HANA_PP_STRINGIZE(m29), BOOST_HANA_PP_STRINGIZE(m30), BOOST_HANA_PP_STRINGIZE(m31), BOOST_HANA_PP_STRINGIZE(m32) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m28), &TYPE::m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m29), &TYPE::m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m30), &TYPE::m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m31), &TYPE::m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m32), &TYPE::m32>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_34(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27), BOOST_HANA_PP_STRINGIZE(m28), BOOST_HANA_PP_STRINGIZE(m29), BOOST_HANA_PP_STRINGIZE(m30), BOOST_HANA_PP_STRINGIZE(m31), BOOST_HANA_PP_STRINGIZE(m32), BOOST_HANA_PP_STRINGIZE(m33) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m28), &TYPE::m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m29), &TYPE::m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m30), &TYPE::m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m31), &TYPE::m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m32), &TYPE::m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m33), &TYPE::m33>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_35(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27), BOOST_HANA_PP_STRINGIZE(m28), BOOST_HANA_PP_STRINGIZE(m29), BOOST_HANA_PP_STRINGIZE(m30), BOOST_HANA_PP_STRINGIZE(m31), BOOST_HANA_PP_STRINGIZE(m32), BOOST_HANA_PP_STRINGIZE(m33), BOOST_HANA_PP_STRINGIZE(m34) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m28), &TYPE::m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m29), &TYPE::m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m30), &TYPE::m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m31), &TYPE::m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m32), &TYPE::m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m33), &TYPE::m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m34), &TYPE::m34>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_36(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27), BOOST_HANA_PP_STRINGIZE(m28), BOOST_HANA_PP_STRINGIZE(m29), BOOST_HANA_PP_STRINGIZE(m30), BOOST_HANA_PP_STRINGIZE(m31), BOOST_HANA_PP_STRINGIZE(m32), BOOST_HANA_PP_STRINGIZE(m33), BOOST_HANA_PP_STRINGIZE(m34), BOOST_HANA_PP_STRINGIZE(m35) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m28), &TYPE::m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m29), &TYPE::m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m30), &TYPE::m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m31), &TYPE::m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m32), &TYPE::m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m33), &TYPE::m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m34), &TYPE::m34>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m35), &TYPE::m35>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_37(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27), BOOST_HANA_PP_STRINGIZE(m28), BOOST_HANA_PP_STRINGIZE(m29), BOOST_HANA_PP_STRINGIZE(m30), BOOST_HANA_PP_STRINGIZE(m31), BOOST_HANA_PP_STRINGIZE(m32), BOOST_HANA_PP_STRINGIZE(m33), BOOST_HANA_PP_STRINGIZE(m34), BOOST_HANA_PP_STRINGIZE(m35), BOOST_HANA_PP_STRINGIZE(m36) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m28), &TYPE::m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m29), &TYPE::m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m30), &TYPE::m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m31), &TYPE::m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m32), &TYPE::m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m33), &TYPE::m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m34), &TYPE::m34>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m35), &TYPE::m35>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m36), &TYPE::m36>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_38(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36, m37) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27), BOOST_HANA_PP_STRINGIZE(m28), BOOST_HANA_PP_STRINGIZE(m29), BOOST_HANA_PP_STRINGIZE(m30), BOOST_HANA_PP_STRINGIZE(m31), BOOST_HANA_PP_STRINGIZE(m32), BOOST_HANA_PP_STRINGIZE(m33), BOOST_HANA_PP_STRINGIZE(m34), BOOST_HANA_PP_STRINGIZE(m35), BOOST_HANA_PP_STRINGIZE(m36), BOOST_HANA_PP_STRINGIZE(m37) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m28), &TYPE::m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m29), &TYPE::m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m30), &TYPE::m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m31), &TYPE::m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m32), &TYPE::m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m33), &TYPE::m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m34), &TYPE::m34>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m35), &TYPE::m35>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m36), &TYPE::m36>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<36, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m37), &TYPE::m37>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_39(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36, m37, m38) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27), BOOST_HANA_PP_STRINGIZE(m28), BOOST_HANA_PP_STRINGIZE(m29), BOOST_HANA_PP_STRINGIZE(m30), BOOST_HANA_PP_STRINGIZE(m31), BOOST_HANA_PP_STRINGIZE(m32), BOOST_HANA_PP_STRINGIZE(m33), BOOST_HANA_PP_STRINGIZE(m34), BOOST_HANA_PP_STRINGIZE(m35), BOOST_HANA_PP_STRINGIZE(m36), BOOST_HANA_PP_STRINGIZE(m37), BOOST_HANA_PP_STRINGIZE(m38) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m28), &TYPE::m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m29), &TYPE::m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m30), &TYPE::m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m31), &TYPE::m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m32), &TYPE::m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m33), &TYPE::m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m34), &TYPE::m34>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m35), &TYPE::m35>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m36), &TYPE::m36>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<36, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m37), &TYPE::m37>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<37, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m38), &TYPE::m38>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_40(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36, m37, m38, m39) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27), BOOST_HANA_PP_STRINGIZE(m28), BOOST_HANA_PP_STRINGIZE(m29), BOOST_HANA_PP_STRINGIZE(m30), BOOST_HANA_PP_STRINGIZE(m31), BOOST_HANA_PP_STRINGIZE(m32), BOOST_HANA_PP_STRINGIZE(m33), BOOST_HANA_PP_STRINGIZE(m34), BOOST_HANA_PP_STRINGIZE(m35), BOOST_HANA_PP_STRINGIZE(m36), BOOST_HANA_PP_STRINGIZE(m37), BOOST_HANA_PP_STRINGIZE(m38), BOOST_HANA_PP_STRINGIZE(m39) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m28), &TYPE::m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m29), &TYPE::m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m30), &TYPE::m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m31), &TYPE::m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m32), &TYPE::m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m33), &TYPE::m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m34), &TYPE::m34>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m35), &TYPE::m35>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m36), &TYPE::m36>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<36, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m37), &TYPE::m37>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<37, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m38), &TYPE::m38>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<38, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m39), &TYPE::m39>{})\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_STRUCT_IMPL_41(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36, m37, m38, m39, m40) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27), BOOST_HANA_PP_STRINGIZE(m28), BOOST_HANA_PP_STRINGIZE(m29), BOOST_HANA_PP_STRINGIZE(m30), BOOST_HANA_PP_STRINGIZE(m31), BOOST_HANA_PP_STRINGIZE(m32), BOOST_HANA_PP_STRINGIZE(m33), BOOST_HANA_PP_STRINGIZE(m34), BOOST_HANA_PP_STRINGIZE(m35), BOOST_HANA_PP_STRINGIZE(m36), BOOST_HANA_PP_STRINGIZE(m37), BOOST_HANA_PP_STRINGIZE(m38), BOOST_HANA_PP_STRINGIZE(m39), BOOST_HANA_PP_STRINGIZE(m40) \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m28), &TYPE::m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m29), &TYPE::m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m30), &TYPE::m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m31), &TYPE::m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m32), &TYPE::m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m33), &TYPE::m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m34), &TYPE::m34>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m35), &TYPE::m35>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m36), &TYPE::m36>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<36, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m37), &TYPE::m37>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<37, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m38), &TYPE::m38>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<38, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m39), &TYPE::m39>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<39, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m40), &TYPE::m40>{})\ ); \ } \ }; \ }} \ /**/ ////////////////////////////////////////////////////////////////////////////// // BOOST_HANA_ADAPT_ADT ////////////////////////////////////////////////////////////////////////////// template <typename ...> struct BOOST_HANA_ADAPT_ADT_must_be_called_in_the_global_namespace; #define BOOST_HANA_ADAPT_ADT(...) \ template <> \ struct BOOST_HANA_ADAPT_ADT_must_be_called_in_the_global_namespace<>; \ BOOST_HANA_ADAPT_ADT_IMPL(BOOST_HANA_PP_NARG(__VA_ARGS__), __VA_ARGS__) \ static_assert(true, "force the usage of a trailing semicolon") \ /**/ #ifdef BOOST_HANA_WORKAROUND_MSVC_PREPROCESSOR_616033 #define BOOST_HANA_ADAPT_ADT_IMPL(N, ...) BOOST_HANA_ADAPT_ADT_IMPL_I(N, __VA_ARGS__) #define BOOST_HANA_ADAPT_ADT_IMPL_I(N, ...) \ BOOST_HANA_PP_CONCAT(BOOST_HANA_PP_CONCAT(BOOST_HANA_ADAPT_ADT_IMPL_, N)(__VA_ARGS__),) #else #define BOOST_HANA_ADAPT_ADT_IMPL(N, ...) \ BOOST_HANA_PP_CONCAT(BOOST_HANA_ADAPT_ADT_IMPL_, N)(__VA_ARGS__) #endif #define BOOST_HANA_ADAPT_ADT_IMPL_1(TYPE ) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ \ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_2(TYPE , m1) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_3(TYPE , m1, m2) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_4(TYPE , m1, m2, m3) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_5(TYPE , m1, m2, m3, m4) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_6(TYPE , m1, m2, m3, m4, m5) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_7(TYPE , m1, m2, m3, m4, m5, m6) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_8(TYPE , m1, m2, m3, m4, m5, m6, m7) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_9(TYPE , m1, m2, m3, m4, m5, m6, m7, m8) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_10(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_11(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_12(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_13(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_14(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_15(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_16(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_17(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_18(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_19(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_20(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_21(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_22(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_23(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_24(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_25(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_26(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_27(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_28(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_29(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m28)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), BOOST_HANA_PP_DROP_FRONT m28)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_30(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m29)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), BOOST_HANA_PP_DROP_FRONT m28), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), BOOST_HANA_PP_DROP_FRONT m29)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_31(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m30)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), BOOST_HANA_PP_DROP_FRONT m28), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), BOOST_HANA_PP_DROP_FRONT m29), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), BOOST_HANA_PP_DROP_FRONT m30)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_32(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m31)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), BOOST_HANA_PP_DROP_FRONT m28), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), BOOST_HANA_PP_DROP_FRONT m29), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), BOOST_HANA_PP_DROP_FRONT m30), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), BOOST_HANA_PP_DROP_FRONT m31)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_33(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m32)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), BOOST_HANA_PP_DROP_FRONT m28), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), BOOST_HANA_PP_DROP_FRONT m29), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), BOOST_HANA_PP_DROP_FRONT m30), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), BOOST_HANA_PP_DROP_FRONT m31), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), BOOST_HANA_PP_DROP_FRONT m32)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_34(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m33)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), BOOST_HANA_PP_DROP_FRONT m28), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), BOOST_HANA_PP_DROP_FRONT m29), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), BOOST_HANA_PP_DROP_FRONT m30), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), BOOST_HANA_PP_DROP_FRONT m31), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), BOOST_HANA_PP_DROP_FRONT m32), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), BOOST_HANA_PP_DROP_FRONT m33)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_35(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m34)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), BOOST_HANA_PP_DROP_FRONT m28), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), BOOST_HANA_PP_DROP_FRONT m29), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), BOOST_HANA_PP_DROP_FRONT m30), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), BOOST_HANA_PP_DROP_FRONT m31), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), BOOST_HANA_PP_DROP_FRONT m32), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), BOOST_HANA_PP_DROP_FRONT m33), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), BOOST_HANA_PP_DROP_FRONT m34)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_36(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m34), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m35)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), BOOST_HANA_PP_DROP_FRONT m28), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), BOOST_HANA_PP_DROP_FRONT m29), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), BOOST_HANA_PP_DROP_FRONT m30), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), BOOST_HANA_PP_DROP_FRONT m31), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), BOOST_HANA_PP_DROP_FRONT m32), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), BOOST_HANA_PP_DROP_FRONT m33), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), BOOST_HANA_PP_DROP_FRONT m34), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), BOOST_HANA_PP_DROP_FRONT m35)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_37(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m34), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m35), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m36)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), BOOST_HANA_PP_DROP_FRONT m28), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), BOOST_HANA_PP_DROP_FRONT m29), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), BOOST_HANA_PP_DROP_FRONT m30), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), BOOST_HANA_PP_DROP_FRONT m31), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), BOOST_HANA_PP_DROP_FRONT m32), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), BOOST_HANA_PP_DROP_FRONT m33), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), BOOST_HANA_PP_DROP_FRONT m34), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), BOOST_HANA_PP_DROP_FRONT m35), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), BOOST_HANA_PP_DROP_FRONT m36)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_38(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36, m37) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m34), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m35), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m36), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m37)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), BOOST_HANA_PP_DROP_FRONT m28), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), BOOST_HANA_PP_DROP_FRONT m29), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), BOOST_HANA_PP_DROP_FRONT m30), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), BOOST_HANA_PP_DROP_FRONT m31), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), BOOST_HANA_PP_DROP_FRONT m32), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), BOOST_HANA_PP_DROP_FRONT m33), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), BOOST_HANA_PP_DROP_FRONT m34), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), BOOST_HANA_PP_DROP_FRONT m35), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), BOOST_HANA_PP_DROP_FRONT m36), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<36, member_names>(), BOOST_HANA_PP_DROP_FRONT m37)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_39(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36, m37, m38) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m34), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m35), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m36), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m37), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m38)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), BOOST_HANA_PP_DROP_FRONT m28), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), BOOST_HANA_PP_DROP_FRONT m29), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), BOOST_HANA_PP_DROP_FRONT m30), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), BOOST_HANA_PP_DROP_FRONT m31), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), BOOST_HANA_PP_DROP_FRONT m32), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), BOOST_HANA_PP_DROP_FRONT m33), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), BOOST_HANA_PP_DROP_FRONT m34), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), BOOST_HANA_PP_DROP_FRONT m35), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), BOOST_HANA_PP_DROP_FRONT m36), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<36, member_names>(), BOOST_HANA_PP_DROP_FRONT m37), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<37, member_names>(), BOOST_HANA_PP_DROP_FRONT m38)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_40(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36, m37, m38, m39) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m34), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m35), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m36), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m37), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m38), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m39)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), BOOST_HANA_PP_DROP_FRONT m28), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), BOOST_HANA_PP_DROP_FRONT m29), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), BOOST_HANA_PP_DROP_FRONT m30), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), BOOST_HANA_PP_DROP_FRONT m31), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), BOOST_HANA_PP_DROP_FRONT m32), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), BOOST_HANA_PP_DROP_FRONT m33), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), BOOST_HANA_PP_DROP_FRONT m34), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), BOOST_HANA_PP_DROP_FRONT m35), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), BOOST_HANA_PP_DROP_FRONT m36), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<36, member_names>(), BOOST_HANA_PP_DROP_FRONT m37), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<37, member_names>(), BOOST_HANA_PP_DROP_FRONT m38), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<38, member_names>(), BOOST_HANA_PP_DROP_FRONT m39)\ ); \ } \ }; \ }} \ /**/ #define BOOST_HANA_ADAPT_ADT_IMPL_41(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36, m37, m38, m39, m40) \ namespace boost { namespace hana { \ template <> \ struct accessors_impl<TYPE> { \ template <typename ...> \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m34), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m35), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m36), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m37), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m38), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m39), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m40)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), BOOST_HANA_PP_DROP_FRONT m28), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), BOOST_HANA_PP_DROP_FRONT m29), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), BOOST_HANA_PP_DROP_FRONT m30), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), BOOST_HANA_PP_DROP_FRONT m31), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), BOOST_HANA_PP_DROP_FRONT m32), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), BOOST_HANA_PP_DROP_FRONT m33), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), BOOST_HANA_PP_DROP_FRONT m34), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), BOOST_HANA_PP_DROP_FRONT m35), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), BOOST_HANA_PP_DROP_FRONT m36), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<36, member_names>(), BOOST_HANA_PP_DROP_FRONT m37), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<37, member_names>(), BOOST_HANA_PP_DROP_FRONT m38), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<38, member_names>(), BOOST_HANA_PP_DROP_FRONT m39), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<39, member_names>(), BOOST_HANA_PP_DROP_FRONT m40)\ ); \ } \ }; \ }} \ /**/ ////////////////////////////////////////////////////////////////////////////// // BOOST_HANA_DEFINE_STRUCT ////////////////////////////////////////////////////////////////////////////// #define BOOST_HANA_DEFINE_STRUCT(...) \ BOOST_HANA_DEFINE_STRUCT_IMPL(BOOST_HANA_PP_NARG(__VA_ARGS__), __VA_ARGS__) #ifdef BOOST_HANA_WORKAROUND_MSVC_PREPROCESSOR_616033 #define BOOST_HANA_DEFINE_STRUCT_IMPL(N, ...) BOOST_HANA_DEFINE_STRUCT_IMPL_I(N, __VA_ARGS__) #define BOOST_HANA_DEFINE_STRUCT_IMPL_I(N, ...) \ BOOST_HANA_PP_CONCAT(BOOST_HANA_PP_CONCAT(BOOST_HANA_DEFINE_STRUCT_IMPL_, N)(__VA_ARGS__),) #else #define BOOST_HANA_DEFINE_STRUCT_IMPL(N, ...) \ BOOST_HANA_PP_CONCAT(BOOST_HANA_DEFINE_STRUCT_IMPL_, N)(__VA_ARGS__) #endif #define BOOST_HANA_DEFINE_STRUCT_IMPL_1(TYPE ) \ \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ \ ); \ } \ }; \ return ::boost::hana::make_tuple( \ \ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_2(TYPE , m1) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_3(TYPE , m1, m2) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_4(TYPE , m1, m2, m3) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_5(TYPE , m1, m2, m3, m4) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_6(TYPE , m1, m2, m3, m4, m5) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_7(TYPE , m1, m2, m3, m4, m5, m6) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_8(TYPE , m1, m2, m3, m4, m5, m6, m7) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_9(TYPE , m1, m2, m3, m4, m5, m6, m7, m8) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_10(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_11(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_12(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_13(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_14(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_15(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_16(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_17(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_18(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_19(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_20(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_21(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_22(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_23(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_24(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_25(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_26(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_27(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_28(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_29(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; BOOST_HANA_PP_DROP_BACK m28 BOOST_HANA_PP_BACK m28; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m28)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m28), &TYPE::BOOST_HANA_PP_BACK m28>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_30(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; BOOST_HANA_PP_DROP_BACK m28 BOOST_HANA_PP_BACK m28; BOOST_HANA_PP_DROP_BACK m29 BOOST_HANA_PP_BACK m29; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m29)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m28), &TYPE::BOOST_HANA_PP_BACK m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m29), &TYPE::BOOST_HANA_PP_BACK m29>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_31(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; BOOST_HANA_PP_DROP_BACK m28 BOOST_HANA_PP_BACK m28; BOOST_HANA_PP_DROP_BACK m29 BOOST_HANA_PP_BACK m29; BOOST_HANA_PP_DROP_BACK m30 BOOST_HANA_PP_BACK m30; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m30)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m28), &TYPE::BOOST_HANA_PP_BACK m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m29), &TYPE::BOOST_HANA_PP_BACK m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m30), &TYPE::BOOST_HANA_PP_BACK m30>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_32(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; BOOST_HANA_PP_DROP_BACK m28 BOOST_HANA_PP_BACK m28; BOOST_HANA_PP_DROP_BACK m29 BOOST_HANA_PP_BACK m29; BOOST_HANA_PP_DROP_BACK m30 BOOST_HANA_PP_BACK m30; BOOST_HANA_PP_DROP_BACK m31 BOOST_HANA_PP_BACK m31; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m31)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m28), &TYPE::BOOST_HANA_PP_BACK m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m29), &TYPE::BOOST_HANA_PP_BACK m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m30), &TYPE::BOOST_HANA_PP_BACK m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m31), &TYPE::BOOST_HANA_PP_BACK m31>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_33(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; BOOST_HANA_PP_DROP_BACK m28 BOOST_HANA_PP_BACK m28; BOOST_HANA_PP_DROP_BACK m29 BOOST_HANA_PP_BACK m29; BOOST_HANA_PP_DROP_BACK m30 BOOST_HANA_PP_BACK m30; BOOST_HANA_PP_DROP_BACK m31 BOOST_HANA_PP_BACK m31; BOOST_HANA_PP_DROP_BACK m32 BOOST_HANA_PP_BACK m32; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m32)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m28), &TYPE::BOOST_HANA_PP_BACK m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m29), &TYPE::BOOST_HANA_PP_BACK m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m30), &TYPE::BOOST_HANA_PP_BACK m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m31), &TYPE::BOOST_HANA_PP_BACK m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m32), &TYPE::BOOST_HANA_PP_BACK m32>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_34(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; BOOST_HANA_PP_DROP_BACK m28 BOOST_HANA_PP_BACK m28; BOOST_HANA_PP_DROP_BACK m29 BOOST_HANA_PP_BACK m29; BOOST_HANA_PP_DROP_BACK m30 BOOST_HANA_PP_BACK m30; BOOST_HANA_PP_DROP_BACK m31 BOOST_HANA_PP_BACK m31; BOOST_HANA_PP_DROP_BACK m32 BOOST_HANA_PP_BACK m32; BOOST_HANA_PP_DROP_BACK m33 BOOST_HANA_PP_BACK m33; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m33)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m28), &TYPE::BOOST_HANA_PP_BACK m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m29), &TYPE::BOOST_HANA_PP_BACK m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m30), &TYPE::BOOST_HANA_PP_BACK m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m31), &TYPE::BOOST_HANA_PP_BACK m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m32), &TYPE::BOOST_HANA_PP_BACK m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m33), &TYPE::BOOST_HANA_PP_BACK m33>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_35(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; BOOST_HANA_PP_DROP_BACK m28 BOOST_HANA_PP_BACK m28; BOOST_HANA_PP_DROP_BACK m29 BOOST_HANA_PP_BACK m29; BOOST_HANA_PP_DROP_BACK m30 BOOST_HANA_PP_BACK m30; BOOST_HANA_PP_DROP_BACK m31 BOOST_HANA_PP_BACK m31; BOOST_HANA_PP_DROP_BACK m32 BOOST_HANA_PP_BACK m32; BOOST_HANA_PP_DROP_BACK m33 BOOST_HANA_PP_BACK m33; BOOST_HANA_PP_DROP_BACK m34 BOOST_HANA_PP_BACK m34; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m34)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m28), &TYPE::BOOST_HANA_PP_BACK m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m29), &TYPE::BOOST_HANA_PP_BACK m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m30), &TYPE::BOOST_HANA_PP_BACK m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m31), &TYPE::BOOST_HANA_PP_BACK m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m32), &TYPE::BOOST_HANA_PP_BACK m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m33), &TYPE::BOOST_HANA_PP_BACK m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m34), &TYPE::BOOST_HANA_PP_BACK m34>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_36(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; BOOST_HANA_PP_DROP_BACK m28 BOOST_HANA_PP_BACK m28; BOOST_HANA_PP_DROP_BACK m29 BOOST_HANA_PP_BACK m29; BOOST_HANA_PP_DROP_BACK m30 BOOST_HANA_PP_BACK m30; BOOST_HANA_PP_DROP_BACK m31 BOOST_HANA_PP_BACK m31; BOOST_HANA_PP_DROP_BACK m32 BOOST_HANA_PP_BACK m32; BOOST_HANA_PP_DROP_BACK m33 BOOST_HANA_PP_BACK m33; BOOST_HANA_PP_DROP_BACK m34 BOOST_HANA_PP_BACK m34; BOOST_HANA_PP_DROP_BACK m35 BOOST_HANA_PP_BACK m35; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m34), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m35)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m28), &TYPE::BOOST_HANA_PP_BACK m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m29), &TYPE::BOOST_HANA_PP_BACK m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m30), &TYPE::BOOST_HANA_PP_BACK m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m31), &TYPE::BOOST_HANA_PP_BACK m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m32), &TYPE::BOOST_HANA_PP_BACK m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m33), &TYPE::BOOST_HANA_PP_BACK m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m34), &TYPE::BOOST_HANA_PP_BACK m34>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m35), &TYPE::BOOST_HANA_PP_BACK m35>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_37(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; BOOST_HANA_PP_DROP_BACK m28 BOOST_HANA_PP_BACK m28; BOOST_HANA_PP_DROP_BACK m29 BOOST_HANA_PP_BACK m29; BOOST_HANA_PP_DROP_BACK m30 BOOST_HANA_PP_BACK m30; BOOST_HANA_PP_DROP_BACK m31 BOOST_HANA_PP_BACK m31; BOOST_HANA_PP_DROP_BACK m32 BOOST_HANA_PP_BACK m32; BOOST_HANA_PP_DROP_BACK m33 BOOST_HANA_PP_BACK m33; BOOST_HANA_PP_DROP_BACK m34 BOOST_HANA_PP_BACK m34; BOOST_HANA_PP_DROP_BACK m35 BOOST_HANA_PP_BACK m35; BOOST_HANA_PP_DROP_BACK m36 BOOST_HANA_PP_BACK m36; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m34), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m35), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m36)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m28), &TYPE::BOOST_HANA_PP_BACK m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m29), &TYPE::BOOST_HANA_PP_BACK m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m30), &TYPE::BOOST_HANA_PP_BACK m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m31), &TYPE::BOOST_HANA_PP_BACK m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m32), &TYPE::BOOST_HANA_PP_BACK m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m33), &TYPE::BOOST_HANA_PP_BACK m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m34), &TYPE::BOOST_HANA_PP_BACK m34>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m35), &TYPE::BOOST_HANA_PP_BACK m35>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m36), &TYPE::BOOST_HANA_PP_BACK m36>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_38(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36, m37) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; BOOST_HANA_PP_DROP_BACK m28 BOOST_HANA_PP_BACK m28; BOOST_HANA_PP_DROP_BACK m29 BOOST_HANA_PP_BACK m29; BOOST_HANA_PP_DROP_BACK m30 BOOST_HANA_PP_BACK m30; BOOST_HANA_PP_DROP_BACK m31 BOOST_HANA_PP_BACK m31; BOOST_HANA_PP_DROP_BACK m32 BOOST_HANA_PP_BACK m32; BOOST_HANA_PP_DROP_BACK m33 BOOST_HANA_PP_BACK m33; BOOST_HANA_PP_DROP_BACK m34 BOOST_HANA_PP_BACK m34; BOOST_HANA_PP_DROP_BACK m35 BOOST_HANA_PP_BACK m35; BOOST_HANA_PP_DROP_BACK m36 BOOST_HANA_PP_BACK m36; BOOST_HANA_PP_DROP_BACK m37 BOOST_HANA_PP_BACK m37; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m34), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m35), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m36), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m37)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m28), &TYPE::BOOST_HANA_PP_BACK m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m29), &TYPE::BOOST_HANA_PP_BACK m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m30), &TYPE::BOOST_HANA_PP_BACK m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m31), &TYPE::BOOST_HANA_PP_BACK m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m32), &TYPE::BOOST_HANA_PP_BACK m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m33), &TYPE::BOOST_HANA_PP_BACK m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m34), &TYPE::BOOST_HANA_PP_BACK m34>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m35), &TYPE::BOOST_HANA_PP_BACK m35>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m36), &TYPE::BOOST_HANA_PP_BACK m36>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<36, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m37), &TYPE::BOOST_HANA_PP_BACK m37>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_39(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36, m37, m38) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; BOOST_HANA_PP_DROP_BACK m28 BOOST_HANA_PP_BACK m28; BOOST_HANA_PP_DROP_BACK m29 BOOST_HANA_PP_BACK m29; BOOST_HANA_PP_DROP_BACK m30 BOOST_HANA_PP_BACK m30; BOOST_HANA_PP_DROP_BACK m31 BOOST_HANA_PP_BACK m31; BOOST_HANA_PP_DROP_BACK m32 BOOST_HANA_PP_BACK m32; BOOST_HANA_PP_DROP_BACK m33 BOOST_HANA_PP_BACK m33; BOOST_HANA_PP_DROP_BACK m34 BOOST_HANA_PP_BACK m34; BOOST_HANA_PP_DROP_BACK m35 BOOST_HANA_PP_BACK m35; BOOST_HANA_PP_DROP_BACK m36 BOOST_HANA_PP_BACK m36; BOOST_HANA_PP_DROP_BACK m37 BOOST_HANA_PP_BACK m37; BOOST_HANA_PP_DROP_BACK m38 BOOST_HANA_PP_BACK m38; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m34), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m35), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m36), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m37), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m38)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m28), &TYPE::BOOST_HANA_PP_BACK m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m29), &TYPE::BOOST_HANA_PP_BACK m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m30), &TYPE::BOOST_HANA_PP_BACK m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m31), &TYPE::BOOST_HANA_PP_BACK m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m32), &TYPE::BOOST_HANA_PP_BACK m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m33), &TYPE::BOOST_HANA_PP_BACK m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m34), &TYPE::BOOST_HANA_PP_BACK m34>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m35), &TYPE::BOOST_HANA_PP_BACK m35>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m36), &TYPE::BOOST_HANA_PP_BACK m36>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<36, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m37), &TYPE::BOOST_HANA_PP_BACK m37>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<37, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m38), &TYPE::BOOST_HANA_PP_BACK m38>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_40(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36, m37, m38, m39) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; BOOST_HANA_PP_DROP_BACK m28 BOOST_HANA_PP_BACK m28; BOOST_HANA_PP_DROP_BACK m29 BOOST_HANA_PP_BACK m29; BOOST_HANA_PP_DROP_BACK m30 BOOST_HANA_PP_BACK m30; BOOST_HANA_PP_DROP_BACK m31 BOOST_HANA_PP_BACK m31; BOOST_HANA_PP_DROP_BACK m32 BOOST_HANA_PP_BACK m32; BOOST_HANA_PP_DROP_BACK m33 BOOST_HANA_PP_BACK m33; BOOST_HANA_PP_DROP_BACK m34 BOOST_HANA_PP_BACK m34; BOOST_HANA_PP_DROP_BACK m35 BOOST_HANA_PP_BACK m35; BOOST_HANA_PP_DROP_BACK m36 BOOST_HANA_PP_BACK m36; BOOST_HANA_PP_DROP_BACK m37 BOOST_HANA_PP_BACK m37; BOOST_HANA_PP_DROP_BACK m38 BOOST_HANA_PP_BACK m38; BOOST_HANA_PP_DROP_BACK m39 BOOST_HANA_PP_BACK m39; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m34), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m35), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m36), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m37), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m38), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m39)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m28), &TYPE::BOOST_HANA_PP_BACK m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m29), &TYPE::BOOST_HANA_PP_BACK m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m30), &TYPE::BOOST_HANA_PP_BACK m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m31), &TYPE::BOOST_HANA_PP_BACK m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m32), &TYPE::BOOST_HANA_PP_BACK m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m33), &TYPE::BOOST_HANA_PP_BACK m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m34), &TYPE::BOOST_HANA_PP_BACK m34>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m35), &TYPE::BOOST_HANA_PP_BACK m35>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m36), &TYPE::BOOST_HANA_PP_BACK m36>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<36, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m37), &TYPE::BOOST_HANA_PP_BACK m37>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<37, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m38), &TYPE::BOOST_HANA_PP_BACK m38>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<38, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m39), &TYPE::BOOST_HANA_PP_BACK m39>{})\ ); \ } \ } \ /**/ #define BOOST_HANA_DEFINE_STRUCT_IMPL_41(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36, m37, m38, m39, m40) \ BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; BOOST_HANA_PP_DROP_BACK m28 BOOST_HANA_PP_BACK m28; BOOST_HANA_PP_DROP_BACK m29 BOOST_HANA_PP_BACK m29; BOOST_HANA_PP_DROP_BACK m30 BOOST_HANA_PP_BACK m30; BOOST_HANA_PP_DROP_BACK m31 BOOST_HANA_PP_BACK m31; BOOST_HANA_PP_DROP_BACK m32 BOOST_HANA_PP_BACK m32; BOOST_HANA_PP_DROP_BACK m33 BOOST_HANA_PP_BACK m33; BOOST_HANA_PP_DROP_BACK m34 BOOST_HANA_PP_BACK m34; BOOST_HANA_PP_DROP_BACK m35 BOOST_HANA_PP_BACK m35; BOOST_HANA_PP_DROP_BACK m36 BOOST_HANA_PP_BACK m36; BOOST_HANA_PP_DROP_BACK m37 BOOST_HANA_PP_BACK m37; BOOST_HANA_PP_DROP_BACK m38 BOOST_HANA_PP_BACK m38; BOOST_HANA_PP_DROP_BACK m39 BOOST_HANA_PP_BACK m39; BOOST_HANA_PP_DROP_BACK m40 BOOST_HANA_PP_BACK m40; \ \ struct hana_accessors_impl { \ static constexpr auto apply() { \ struct member_names { \ static constexpr auto get() { \ return ::boost::hana::make_tuple( \ BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m34), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m35), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m36), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m37), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m38), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m39), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m40)\ ); \ } \ }; \ return ::boost::hana::make_tuple( \ ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m28), &TYPE::BOOST_HANA_PP_BACK m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m29), &TYPE::BOOST_HANA_PP_BACK m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m30), &TYPE::BOOST_HANA_PP_BACK m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m31), &TYPE::BOOST_HANA_PP_BACK m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m32), &TYPE::BOOST_HANA_PP_BACK m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m33), &TYPE::BOOST_HANA_PP_BACK m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m34), &TYPE::BOOST_HANA_PP_BACK m34>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m35), &TYPE::BOOST_HANA_PP_BACK m35>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m36), &TYPE::BOOST_HANA_PP_BACK m36>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<36, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m37), &TYPE::BOOST_HANA_PP_BACK m37>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<37, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m38), &TYPE::BOOST_HANA_PP_BACK m38>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<38, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m39), &TYPE::BOOST_HANA_PP_BACK m39>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<39, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m40), &TYPE::BOOST_HANA_PP_BACK m40>{})\ ); \ } \ } \ /**/ #endif // !BOOST_HANA_DETAIL_STRUCT_MACROS_HPP PK �\�[�XJ J detail/index_if.hppnu �[��� /*! @file Defines `boost::hana::detail::index_if`. @copyright Louis Dionne 2013-2017 @copyright Jason Rice 2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_INDEX_IF_HPP #define BOOST_HANA_DETAIL_INDEX_IF_HPP #include <boost/hana/config.hpp> #include <boost/hana/detail/decay.hpp> #include <boost/hana/integral_constant.hpp> #include <boost/hana/optional.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <std::size_t i, std::size_t N, bool Done> struct index_if_helper; template <std::size_t i, std::size_t N> struct index_if_helper<i, N, false> { template <typename Pred, typename X1, typename ...Xs> using f = typename index_if_helper<i + 1, N, static_cast<bool>(detail::decay<decltype( std::declval<Pred>()(std::declval<X1>()))>::type::value) >::template f<Pred, Xs...>; }; template <std::size_t N> struct index_if_helper<N, N, false> { template <typename ...> using f = hana::optional<>; }; template <std::size_t i, std::size_t N> struct index_if_helper<i, N, true> { template <typename ...> using f = hana::optional<hana::size_t<i - 1>>; }; template <typename Pred, typename ...Xs> struct index_if { using type = typename index_if_helper<0, sizeof...(Xs), false> ::template f<Pred, Xs...>; }; } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_INDEX_IF_HPP PK �\�[z�� � detail/preprocessor.hppnu �[��� /*! @file Defines generally useful preprocessor macros. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_PREPROCESSOR_HPP #define BOOST_HANA_DETAIL_PREPROCESSOR_HPP //! @ingroup group-details //! Expands to the concatenation of its two arguments. #define BOOST_HANA_PP_CONCAT(x, y) BOOST_HANA_PP_CONCAT_PRIMITIVE(x, y) #define BOOST_HANA_PP_CONCAT_PRIMITIVE(x, y) x ## y //! @ingroup group-details //! Expands to the stringized version of its argument. #define BOOST_HANA_PP_STRINGIZE(...) BOOST_HANA_PP_STRINGIZE_PRIMITIVE(__VA_ARGS__) #define BOOST_HANA_PP_STRINGIZE_PRIMITIVE(...) #__VA_ARGS__ //! @ingroup group-details //! Expands to its first argument. #ifdef BOOST_HANA_WORKAROUND_MSVC_PREPROCESSOR_616033 #define BOOST_HANA_PP_FRONT(...) BOOST_HANA_PP_FRONT_IMPL_I(__VA_ARGS__) #define BOOST_HANA_PP_FRONT_IMPL_I(...) BOOST_HANA_PP_CONCAT(BOOST_HANA_PP_FRONT_IMPL(__VA_ARGS__, ),) #else #define BOOST_HANA_PP_FRONT(...) BOOST_HANA_PP_FRONT_IMPL(__VA_ARGS__, ) #endif #define BOOST_HANA_PP_FRONT_IMPL(e0, ...) e0 //! @ingroup group-details //! Expands to all of its arguments, except for the first one. //! //! This macro may not be called with less than 2 arguments. #define BOOST_HANA_PP_DROP_FRONT(e0, ...) __VA_ARGS__ #endif // !BOOST_HANA_DETAIL_PREPROCESSOR_HPP PK �\�[�X�A� � detail/canonical_constant.hppnu �[��� /*! @file Defines `boost::hana::detail::CanonicalConstant`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_CANONICAL_CONSTANT_HPP #define BOOST_HANA_DETAIL_CANONICAL_CONSTANT_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN namespace detail { //! @ingroup group-details //! Tag representing a canonical `Constant`. //! //! This is an implementation detail used to provide many models for //! stuff like `Monoid`, `Group`, etc. To create a `CanonicalConstant`, //! simply create an object with a nested `hana_tag` equal to the proper //! specialization of `CanonicalConstant<T>`, and then also provide a //! `constexpr` static member `::%value` holding the value of the constant. template <typename T> struct CanonicalConstant { using value_type = T; }; } BOOST_HANA_NAMESPACE_END #include <boost/hana/concept/constant.hpp> #include <boost/hana/concept/integral_constant.hpp> #include <boost/hana/core/to.hpp> #include <boost/hana/core/when.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN ////////////////////////////////////////////////////////////////////////// // Constant ////////////////////////////////////////////////////////////////////////// template <typename T> struct value_impl<detail::CanonicalConstant<T>> { template <typename X> static constexpr decltype(auto) apply() { return X::value; } }; namespace detail { template <typename T, typename X> struct canonical_constant { static constexpr auto value = hana::to<T>(hana::value<X>()); using hana_tag = detail::CanonicalConstant<T>; }; } template <typename T, typename C> struct to_impl<detail::CanonicalConstant<T>, C, when< hana::Constant<C>::value && is_convertible<typename C::value_type, T>::value >> : embedding<is_embedded<typename C::value_type, T>::value> { template <typename X> static constexpr detail::canonical_constant<T, X> apply(X const&) { return {}; } }; ////////////////////////////////////////////////////////////////////////// // IntegralConstant (when value_type is integral) ////////////////////////////////////////////////////////////////////////// template <typename T> struct IntegralConstant<detail::CanonicalConstant<T>> { static constexpr bool value = std::is_integral<T>::value; }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_CANONICAL_CONSTANT_HPP PK �\�[� �. . detail/array.hppnu �[��� /*! @file Defines `boost::hana::detail::array`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_ARRAY_HPP #define BOOST_HANA_DETAIL_ARRAY_HPP #include <boost/hana/config.hpp> #include <boost/hana/detail/algorithm.hpp> #include <boost/hana/functional/placeholder.hpp> #include <cstddef> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <typename N> constexpr N factorial(N n) { N result = 1; while (n != 0) result *= n--; return result; } //! @ingroup group-details //! A minimal `std::array` with better `constexpr` support. //! //! We also provide some algorithms from the `constexpr/algorithm.hpp` //! header as member functions to make them easier to use in constexpr //! contexts, since a `constexpr` `array` can't be mutated in place. template <typename T, std::size_t Size> struct array { T elems_[Size > 0 ? Size : 1]; constexpr T& operator[](std::size_t n) { return elems_[n]; } constexpr T const& operator[](std::size_t n) const { return elems_[n]; } constexpr std::size_t size() const noexcept { return Size; } constexpr T* begin() noexcept { return elems_; } constexpr T const* begin() const noexcept { return elems_; } constexpr T* end() noexcept { return elems_ + Size; } constexpr T const* end() const noexcept { return elems_ + Size; } // Algorithms from constexpr/algorithm.hpp constexpr array reverse() const { array result = *this; detail::reverse(result.begin(), result.end()); return result; } template <typename BinaryPred> constexpr auto permutations(BinaryPred pred) const { array<array<T, Size>, detail::factorial(Size)> result{}; auto out = result.begin(); array copy = *this; do *out++ = copy; while (detail::next_permutation(copy.begin(), copy.end(), pred)); return result; } constexpr auto permutations() const { return this->permutations(hana::_ < hana::_); } template <typename BinaryPred> constexpr auto sort(BinaryPred pred) const { array result = *this; detail::sort(result.begin(), result.end(), pred); return result; } constexpr auto sort() const { return this->sort(hana::_ < hana::_); } template <typename U> constexpr auto iota(U value) const { array result = *this; detail::iota(result.begin(), result.end(), value); return result; } }; template <typename T, std::size_t M, typename U, std::size_t N> constexpr bool operator==(array<T, M> a, array<U, N> b) { return M == N && detail::equal(a.begin(), a.end(), b.begin(), b.end()); } template <typename T, std::size_t M, typename U, std::size_t N> constexpr bool operator<(array<T, M> a, array<U, N> b) { return M < N || detail::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end()); } } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_ARRAY_HPP PK �\�[LUV detail/operators/adl.hppnu �[��� /*! @file Defines `boost::hana::detail::operators::adl`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_OPERATORS_ADL_HPP #define BOOST_HANA_DETAIL_OPERATORS_ADL_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace operators { //! @ingroup group-details //! Enables [ADL](http://en.cppreference.com/w/cpp/language/adl) in the //! `hana::detail::operators` namespace. //! //! This is used by containers in Hana as a quick way to automatically //! define the operators associated to some concepts, in conjunction //! with the `detail::xxx_operators` family of metafunctions. //! //! Note that `adl` can be passed template arguments to make it unique //! amongst a set of derived classes. This allows a set of derived classes //! not to possess a common base class, which would disable the EBO when //! many of these derived classes are stored in a Hana container. If EBO //! is not a concern, `adl<>` can simply be used. template <typename ...> struct adl { }; }} BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_OPERATORS_ADL_HPP PK �\�[˂�� detail/operators/logical.hppnu �[��� /*! @file Defines logical operators. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_OPERATORS_LOGICAL_HPP #define BOOST_HANA_DETAIL_OPERATORS_LOGICAL_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/fwd/and.hpp> #include <boost/hana/fwd/not.hpp> #include <boost/hana/fwd/or.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <typename Tag> struct logical_operators { static constexpr bool value = false; }; namespace operators { template <typename X, typename Y, typename = typename std::enable_if< detail::logical_operators<typename hana::tag_of<X>::type>::value || detail::logical_operators<typename hana::tag_of<Y>::type>::value >::type> constexpr auto operator||(X&& x, Y&& y) { return hana::or_(static_cast<X&&>(x), static_cast<Y&&>(y)); } template <typename X, typename Y, typename = typename std::enable_if< detail::logical_operators<typename hana::tag_of<X>::type>::value || detail::logical_operators<typename hana::tag_of<Y>::type>::value >::type> constexpr auto operator&&(X&& x, Y&& y) { return hana::and_(static_cast<X&&>(x), static_cast<Y&&>(y)); } template <typename X, typename = typename std::enable_if< detail::logical_operators<typename hana::tag_of<X>::type>::value >::type> constexpr auto operator!(X&& x) { return hana::not_(static_cast<X&&>(x)); } } // end namespace operators } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_OPERATORS_LOGICAL_HPP PK �\�[��o�� � detail/operators/searchable.hppnu �[��� /*! @file Defines operators for Searchables. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_OPERATORS_SEARCHABLE_HPP #define BOOST_HANA_DETAIL_OPERATORS_SEARCHABLE_HPP #include <boost/hana/config.hpp> #include <boost/hana/fwd/at_key.hpp> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <typename Derived> struct searchable_operators { template <typename Key> constexpr decltype(auto) operator[](Key&& key) & { return hana::at_key(static_cast<Derived&>(*this), static_cast<Key&&>(key)); } template <typename Key> constexpr decltype(auto) operator[](Key&& key) && { return hana::at_key(static_cast<Derived&&>(*this), static_cast<Key&&>(key)); } template <typename Key> constexpr decltype(auto) operator[](Key&& key) const& { return hana::at_key(static_cast<Derived const&>(*this), static_cast<Key&&>(key)); } }; } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_OPERATORS_SEARCHABLE_HPP PK �\�[�� detail/operators/monad.hppnu �[��� /*! @file Defines operators for Monads. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_OPERATORS_MONAD_HPP #define BOOST_HANA_DETAIL_OPERATORS_MONAD_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/fwd/chain.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <typename Tag> struct monad_operators { static constexpr bool value = false; }; namespace operators { template <typename Xs, typename F, typename = typename std::enable_if< detail::monad_operators<typename hana::tag_of<Xs>::type>::value >::type> constexpr auto operator|(Xs&& xs, F&& f) { return hana::chain(static_cast<Xs&&>(xs), static_cast<F&&>(f)); } } // end namespace operators } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_OPERATORS_MONAD_HPP PK �\�[���!� � detail/operators/iterable.hppnu �[��� /*! @file Defines operators for Iterables. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_OPERATORS_ITERABLE_HPP #define BOOST_HANA_DETAIL_OPERATORS_ITERABLE_HPP #include <boost/hana/config.hpp> #include <boost/hana/fwd/at.hpp> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <typename Derived> struct iterable_operators { template <typename N> constexpr decltype(auto) operator[](N&& n) & { return hana::at(static_cast<Derived&>(*this), static_cast<N&&>(n)); } template <typename N> constexpr decltype(auto) operator[](N&& n) const& { return hana::at(static_cast<Derived const&>(*this), static_cast<N&&>(n)); } template <typename N> constexpr decltype(auto) operator[](N&& n) && { return hana::at(static_cast<Derived&&>(*this), static_cast<N&&>(n)); } }; } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_OPERATORS_ITERABLE_HPP PK �\�[V�ha< < detail/operators/comparable.hppnu �[��� /*! @file Defines operators for Comparables. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_OPERATORS_COMPARABLE_HPP #define BOOST_HANA_DETAIL_OPERATORS_COMPARABLE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/fwd/equal.hpp> #include <boost/hana/fwd/not_equal.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <typename Tag> struct comparable_operators { static constexpr bool value = false; }; namespace operators { template <typename X, typename Y, typename = typename std::enable_if< !detail::has_idempotent_tag<X>::value && !detail::has_idempotent_tag<Y>::value && (detail::comparable_operators< typename hana::tag_of<X>::type>::value || detail::comparable_operators< typename hana::tag_of<Y>::type>::value) >::type> constexpr auto operator==(X&& x, Y&& y) { return hana::equal(static_cast<X&&>(x), static_cast<Y&&>(y)); } template <typename X, typename Y, typename = typename std::enable_if< !detail::has_idempotent_tag<X>::value && !detail::has_idempotent_tag<Y>::value && (detail::comparable_operators< typename hana::tag_of<X>::type>::value || detail::comparable_operators< typename hana::tag_of<Y>::type>::value) >::type> constexpr auto operator!=(X&& x, Y&& y) { return hana::not_equal(static_cast<X&&>(x), static_cast<Y&&>(y)); } } // end namespace operators } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_OPERATORS_COMPARABLE_HPP PK �\�[�# e e detail/operators/orderable.hppnu �[��� /*! @file Defines operators for Orderables. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_OPERATORS_ORDERABLE_HPP #define BOOST_HANA_DETAIL_OPERATORS_ORDERABLE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/fwd/greater.hpp> #include <boost/hana/fwd/greater_equal.hpp> #include <boost/hana/fwd/less.hpp> #include <boost/hana/fwd/less_equal.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <typename Tag> struct orderable_operators { static constexpr bool value = false; }; namespace operators { template <typename X, typename Y, typename = typename std::enable_if< detail::orderable_operators<typename hana::tag_of<X>::type>::value || detail::orderable_operators<typename hana::tag_of<Y>::type>::value >::type> constexpr auto operator<(X&& x, Y&& y) { return hana::less(static_cast<X&&>(x), static_cast<Y&&>(y)); } template <typename X, typename Y, typename = typename std::enable_if< detail::orderable_operators<typename hana::tag_of<X>::type>::value || detail::orderable_operators<typename hana::tag_of<Y>::type>::value >::type> constexpr auto operator>(X&& x, Y&& y) { return hana::greater(static_cast<X&&>(x), static_cast<Y&&>(y)); } template <typename X, typename Y, typename = typename std::enable_if< detail::orderable_operators<typename hana::tag_of<X>::type>::value || detail::orderable_operators<typename hana::tag_of<Y>::type>::value >::type> constexpr auto operator<=(X&& x, Y&& y) { return hana::less_equal(static_cast<X&&>(x), static_cast<Y&&>(y)); } template <typename X, typename Y, typename = typename std::enable_if< detail::orderable_operators<typename hana::tag_of<X>::type>::value || detail::orderable_operators<typename hana::tag_of<Y>::type>::value >::type> constexpr auto operator>=(X&& x, Y&& y) { return hana::greater_equal(static_cast<X&&>(x), static_cast<Y&&>(y)); } } // end namespace operators } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_OPERATORS_ORDERABLE_HPP PK �\�[-��� detail/operators/arithmetic.hppnu �[��� /*! @file Defines arithmetic operators. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_OPERATORS_ARITHMETIC_HPP #define BOOST_HANA_DETAIL_OPERATORS_ARITHMETIC_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/fwd/div.hpp> #include <boost/hana/fwd/minus.hpp> #include <boost/hana/fwd/mod.hpp> #include <boost/hana/fwd/mult.hpp> #include <boost/hana/fwd/negate.hpp> #include <boost/hana/fwd/plus.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <typename Tag> struct arithmetic_operators { static constexpr bool value = false; }; namespace operators { template <typename X, typename Y, typename = typename std::enable_if< detail::arithmetic_operators<typename hana::tag_of<X>::type>::value || detail::arithmetic_operators<typename hana::tag_of<Y>::type>::value >::type> constexpr auto operator+(X&& x, Y&& y) { return hana::plus(static_cast<X&&>(x), static_cast<Y&&>(y)); } template <typename X, typename Y, typename = typename std::enable_if< detail::arithmetic_operators<typename hana::tag_of<X>::type>::value || detail::arithmetic_operators<typename hana::tag_of<Y>::type>::value >::type> constexpr auto operator-(X&& x, Y&& y) { return hana::minus(static_cast<X&&>(x), static_cast<Y&&>(y)); } template <typename X, typename = typename std::enable_if< detail::arithmetic_operators<typename hana::tag_of<X>::type>::value >::type> constexpr auto operator-(X&& x) { return hana::negate(static_cast<X&&>(x)); } template <typename X, typename Y, typename = typename std::enable_if< detail::arithmetic_operators<typename hana::tag_of<X>::type>::value || detail::arithmetic_operators<typename hana::tag_of<Y>::type>::value >::type> constexpr auto operator*(X&& x, Y&& y) { return hana::mult(static_cast<X&&>(x), static_cast<Y&&>(y)); } template <typename X, typename Y, typename = typename std::enable_if< detail::arithmetic_operators<typename hana::tag_of<X>::type>::value || detail::arithmetic_operators<typename hana::tag_of<Y>::type>::value >::type> constexpr auto operator/(X&& x, Y&& y) { return hana::div(static_cast<X&&>(x), static_cast<Y&&>(y)); } template <typename X, typename Y, typename = typename std::enable_if< detail::arithmetic_operators<typename hana::tag_of<X>::type>::value || detail::arithmetic_operators<typename hana::tag_of<Y>::type>::value >::type> constexpr auto operator%(X&& x, Y&& y) { return hana::mod(static_cast<X&&>(x), static_cast<Y&&>(y)); } } // end namespace operators } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_OPERATORS_ARITHMETIC_HPP PK �\�[�V�N] ] detail/wrong.hppnu �[��� /*! @file Defines `boost::hana::detail::wrong`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_WRONG_HPP #define BOOST_HANA_DETAIL_WRONG_HPP #include <boost/hana/config.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN namespace detail { //! @ingroup group-detail //! Equivalent to a type-dependent `std::false_type`. //! //! This is useful for making a static assertion that would otherwise //! always fire up dependent on some template parameters. //! //! //! Example //! ------- //! @include example/detail/wrong.cpp template <typename ...> struct wrong : std::false_type { }; } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_WRONG_HPP PK �\�[���8� � & detail/variadic/reverse_apply/flat.hppnu �[��� /*! @file Defines `boost::hana::detail::variadic::reverse_apply_flat`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_VARIADIC_REVERSE_APPLY_FLAT_HPP #define BOOST_HANA_DETAIL_VARIADIC_REVERSE_APPLY_FLAT_HPP #include <boost/hana/config.hpp> #include <boost/hana/detail/variadic/at.hpp> #include <utility> BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic { template <int ...i, typename F, typename ...X> constexpr decltype(auto) reverse_apply_flat_helper(std::integer_sequence<int, i...>, F&& f, X&& ...x) { return static_cast<F&&>(f)( detail::variadic::at<sizeof...(x) - i - 1>( static_cast<X&&>(x)... )... ); } template <typename F, typename ...X> constexpr decltype(auto) reverse_apply_flat(F&& f, X&& ...x) { return reverse_apply_flat_helper( std::make_integer_sequence<int, sizeof...(x)>{}, static_cast<F&&>(f), static_cast<X&&>(x)... ); } }} BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_VARIADIC_REVERSE_APPLY_FLAT_HPP PK �\�[�n�=� � * detail/variadic/reverse_apply/unrolled.hppnu �[��� /*! @file Defines `boost::hana::detail::variadic::reverse_apply_unrolled`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_VARIADIC_REVERSE_APPLY_UNROLLED_HPP #define BOOST_HANA_DETAIL_VARIADIC_REVERSE_APPLY_UNROLLED_HPP #include <boost/hana/config.hpp> #include <boost/hana/functional/reverse_partial.hpp> BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic { struct reverse_apply_unrolled_impl { template <typename F> constexpr decltype(auto) operator()(F&& f) const { return static_cast<F&&>(f)(); } template <typename F, typename X1> constexpr decltype(auto) operator()(F&& f, X1&& x1) const { return static_cast<F&&>(f)( static_cast<X1&&>(x1) ); } template <typename F, typename X1, typename X2> constexpr decltype(auto) operator()(F&& f, X1&& x1, X2&& x2) const { return static_cast<F&&>(f)( static_cast<X2&&>(x2), static_cast<X1&&>(x1) ); } template <typename F, typename X1, typename X2, typename X3> constexpr decltype(auto) operator()(F&& f, X1&& x1, X2&& x2, X3&& x3) const { return static_cast<F&&>(f)( static_cast<X3&&>(x3), static_cast<X2&&>(x2), static_cast<X1&&>(x1) ); } template <typename F, typename X1, typename X2, typename X3, typename X4> constexpr decltype(auto) operator()(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4) const { return static_cast<F&&>(f)( static_cast<X4&&>(x4), static_cast<X3&&>(x3), static_cast<X2&&>(x2), static_cast<X1&&>(x1) ); } template <typename F, typename X1, typename X2, typename X3, typename X4, typename X5> constexpr decltype(auto) operator()(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5) const { return static_cast<F&&>(f)( static_cast<X5&&>(x5), static_cast<X4&&>(x4), static_cast<X3&&>(x3), static_cast<X2&&>(x2), static_cast<X1&&>(x1) ); } template <typename F, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename ...Xn> constexpr decltype(auto) operator()(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6, Xn&& ...xn) const { return (*this)(hana::reverse_partial( static_cast<F&&>(f) , static_cast<X6&&>(x6) , static_cast<X5&&>(x5) , static_cast<X4&&>(x4) , static_cast<X3&&>(x3) , static_cast<X2&&>(x2) , static_cast<X1&&>(x1) ), static_cast<Xn&&>(xn)...); } }; constexpr reverse_apply_unrolled_impl reverse_apply_unrolled{}; }} BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_VARIADIC_REVERSE_APPLY_UNROLLED_HPP PK �\�[�� detail/variadic/split_at.hppnu �[��� /*! @file Defines `boost::hana::detail::variadic::split_at`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_VARIADIC_SPLIT_AT_HPP #define BOOST_HANA_DETAIL_VARIADIC_SPLIT_AT_HPP #include <boost/hana/config.hpp> #include <boost/hana/functional/partial.hpp> #include <boost/hana/functional/reverse_partial.hpp> #include <cstddef> BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic { template <std::size_t n> struct split_at_t { template <typename F, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename ...Xs> constexpr decltype(auto) operator()(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6, X7&& x7, X8&& x8, Xs&& ...xs) const { return split_at_t<n - 8>{}( hana::partial(static_cast<F&&>(f), static_cast<X1&&>(x1), static_cast<X2&&>(x2), static_cast<X3&&>(x3), static_cast<X4&&>(x4), static_cast<X5&&>(x5), static_cast<X6&&>(x6), static_cast<X7&&>(x7), static_cast<X8&&>(x8) ), static_cast<Xs&&>(xs)... ); } }; template <> struct split_at_t<0> { template <typename F, typename ...Xs> constexpr decltype(auto) operator()(F&& f, Xs&& ...xs) const { return static_cast<F&&>(f)()(static_cast<Xs&&>(xs)...); } }; template <> struct split_at_t<1> { template <typename F, typename X1, typename ...Xs> constexpr decltype(auto) operator()(F&& f, X1&& x1, Xs&& ...xs) const { return static_cast<F&&>(f)( static_cast<X1&&>(x1) )(static_cast<Xs&&>(xs)...); } }; template <> struct split_at_t<2> { template <typename F, typename X1, typename X2, typename ...Xs> constexpr decltype(auto) operator()(F&& f, X1&& x1, X2&& x2, Xs&& ...xs) const { return static_cast<F&&>(f)( static_cast<X1&&>(x1), static_cast<X2&&>(x2) )(static_cast<Xs&&>(xs)...); } }; template <> struct split_at_t<3> { template <typename F, typename X1, typename X2, typename X3, typename ...Xs> constexpr decltype(auto) operator()(F&& f, X1&& x1, X2&& x2, X3&& x3, Xs&& ...xs) const { return static_cast<F&&>(f)( static_cast<X1&&>(x1), static_cast<X2&&>(x2), static_cast<X3&&>(x3) )(static_cast<Xs&&>(xs)...); } }; template <> struct split_at_t<4> { template <typename F, typename X1, typename X2, typename X3, typename X4, typename ...Xs> constexpr decltype(auto) operator()(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4, Xs&& ...xs) const { return static_cast<F&&>(f)( static_cast<X1&&>(x1), static_cast<X2&&>(x2), static_cast<X3&&>(x3), static_cast<X4&&>(x4) )(static_cast<Xs&&>(xs)...); } }; template <> struct split_at_t<5> { template <typename F, typename X1, typename X2, typename X3, typename X4, typename X5, typename ...Xs> constexpr decltype(auto) operator()(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, Xs&& ...xs) const { return static_cast<F&&>(f)( static_cast<X1&&>(x1), static_cast<X2&&>(x2), static_cast<X3&&>(x3), static_cast<X4&&>(x4), static_cast<X5&&>(x5) )(static_cast<Xs&&>(xs)...); } }; template <> struct split_at_t<6> { template <typename F, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename ...Xs> constexpr decltype(auto) operator()(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6, Xs&& ...xs) const { return static_cast<F&&>(f)( static_cast<X1&&>(x1), static_cast<X2&&>(x2), static_cast<X3&&>(x3), static_cast<X4&&>(x4), static_cast<X5&&>(x5), static_cast<X6&&>(x6) )(static_cast<Xs&&>(xs)...); } }; template <> struct split_at_t<7> { template <typename F, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename ...Xs> constexpr decltype(auto) operator()(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6, X7&& x7, Xs&& ...xs) const { return static_cast<F&&>(f)( static_cast<X1&&>(x1), static_cast<X2&&>(x2), static_cast<X3&&>(x3), static_cast<X4&&>(x4), static_cast<X5&&>(x5), static_cast<X6&&>(x6), static_cast<X7&&>(x7) )(static_cast<Xs&&>(xs)...); } }; template <std::size_t n> struct _makesplit_at_t { template <typename ...Xs> constexpr decltype(auto) operator()(Xs&& ...xs) const { return hana::reverse_partial(split_at_t<n>{}, static_cast<Xs&&>(xs)...); } }; template <std::size_t n> constexpr _makesplit_at_t<n> split_at{}; }} BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_VARIADIC_SPLIT_AT_HPP PK �\�[�K�y y ! detail/variadic/reverse_apply.hppnu �[��� /*! @file Defines `boost::hana::detail::variadic::reverse_apply`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_VARIADIC_REVERSE_APPLY_HPP #define BOOST_HANA_DETAIL_VARIADIC_REVERSE_APPLY_HPP #include <boost/hana/config.hpp> #include <boost/hana/detail/variadic/reverse_apply/unrolled.hpp> BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic { BOOST_HANA_CONSTEXPR_LAMBDA auto reverse_apply = [](auto&& f, auto&& ...x) -> decltype(auto) { return detail::variadic::reverse_apply_unrolled( static_cast<decltype(f)>(f), static_cast<decltype(x)>(x)... ); }; }} BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_VARIADIC_REVERSE_APPLY_HPP PK �\�[�0W9�, �, detail/variadic/foldr1.hppnu �[��� /*! @file Defines `boost::hana::detail::variadic::foldr1`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_VARIADIC_FOLDR1_HPP #define BOOST_HANA_DETAIL_VARIADIC_FOLDR1_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic { //! @cond template <unsigned int n, typename = when<true>> struct foldr1_impl; template <> struct foldr1_impl<1> { template <typename F, typename X1> static constexpr X1 apply(F&&, X1&& x1) { return static_cast<X1&&>(x1); } }; template <> struct foldr1_impl<2> { template <typename F, typename X1, typename X2> static constexpr decltype(auto) apply(F&& f, X1&& x1, X2&& x2) { return static_cast<F&&>(f)(static_cast<X1&&>(x1), static_cast<X2&&>(x2)); } }; template <> struct foldr1_impl<3> { template <typename F, typename X1, typename X2, typename X3> static constexpr decltype(auto) apply(F&& f, X1&& x1, X2&& x2, X3&& x3) { return f(static_cast<X1&&>(x1), f(static_cast<X2&&>(x2), static_cast<X3&&>(x3))); } }; template <> struct foldr1_impl<4> { template <typename F, typename X1, typename X2, typename X3, typename X4> static constexpr decltype(auto) apply(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4) { return f(static_cast<X1&&>(x1), f(static_cast<X2&&>(x2), f(static_cast<X3&&>(x3), static_cast<X4&&>(x4)))); } }; template <> struct foldr1_impl<5> { template <typename F, typename X1, typename X2, typename X3, typename X4, typename X5> static constexpr decltype(auto) apply(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5) { return f(static_cast<X1&&>(x1), f(static_cast<X2&&>(x2), f(static_cast<X3&&>(x3), f(static_cast<X4&&>(x4), static_cast<X5&&>(x5))))); } }; template <> struct foldr1_impl<6> { template <typename F, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6> static constexpr decltype(auto) apply(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6) { return f(static_cast<X1&&>(x1), f(static_cast<X2&&>(x2), f(static_cast<X3&&>(x3), f(static_cast<X4&&>(x4), f(static_cast<X5&&>(x5), static_cast<X6&&>(x6)))))); } }; template <unsigned int n> struct foldr1_impl<n, when<(n >= 7) && (n < 14)>> { template <typename F, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename ...Xn> static constexpr decltype(auto) apply(F&& f , X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6, X7&& x7 , Xn&& ...xn) { return f(static_cast<X1&&>(x1), f(static_cast<X2&&>(x2), f(static_cast<X3&&>(x3), f(static_cast<X4&&>(x4), f(static_cast<X5&&>(x5), f(static_cast<X6&&>(x6), foldr1_impl<sizeof...(xn) + 1>::apply(f, static_cast<X7&&>(x7), static_cast<Xn&&>(xn)...))))))); } }; template <unsigned int n> struct foldr1_impl<n, when<(n >= 14) && (n < 28)>> { template < typename F , typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7 , typename X8, typename X9, typename X10, typename X11, typename X12, typename X13, typename X14 , typename ...Xn > static constexpr decltype(auto) apply(F&& f , X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6, X7&& x7 , X8&& x8, X9&& x9, X10&& x10, X11&& x11, X12&& x12, X13&& x13, X14&& x14 , Xn&& ...xn) { return f(static_cast<X1&&>(x1), f(static_cast<X2&&>(x2), f(static_cast<X3&&>(x3), f(static_cast<X4&&>(x4), f(static_cast<X5&&>(x5), f(static_cast<X6&&>(x6), f(static_cast<X7&&>(x7), f(static_cast<X8&&>(x8), f(static_cast<X9&&>(x9), f(static_cast<X10&&>(x10), f(static_cast<X11&&>(x11), f(static_cast<X12&&>(x12), f(static_cast<X13&&>(x13), foldr1_impl<sizeof...(xn) + 1>::apply(f, static_cast<X14&&>(x14), static_cast<Xn&&>(xn)...)))))))))))))); } }; template <unsigned int n> struct foldr1_impl<n, when<(n >= 28) && (n < 56)>> { template < typename F , typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7 , typename X8, typename X9, typename X10, typename X11, typename X12, typename X13, typename X14 , typename X15, typename X16, typename X17, typename X18, typename X19, typename X20, typename X21 , typename X22, typename X23, typename X24, typename X25, typename X26, typename X27, typename X28 , typename ...Xn > static constexpr decltype(auto) apply(F&& f , X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6, X7&& x7 , X8&& x8, X9&& x9, X10&& x10, X11&& x11, X12&& x12, X13&& x13, X14&& x14 , X15&& x15, X16&& x16, X17&& x17, X18&& x18, X19&& x19, X20&& x20, X21&& x21 , X22&& x22, X23&& x23, X24&& x24, X25&& x25, X26&& x26, X27&& x27, X28&& x28 , Xn&& ...xn) { return f(static_cast<X1&&>(x1), f(static_cast<X2&&>(x2), f(static_cast<X3&&>(x3), f(static_cast<X4&&>(x4), f(static_cast<X5&&>(x5), f(static_cast<X6&&>(x6), f(static_cast<X7&&>(x7), f(static_cast<X8&&>(x8), f(static_cast<X9&&>(x9), f(static_cast<X10&&>(x10), f(static_cast<X11&&>(x11), f(static_cast<X12&&>(x12), f(static_cast<X13&&>(x13), f(static_cast<X14&&>(x14), f(static_cast<X15&&>(x15), f(static_cast<X16&&>(x16), f(static_cast<X17&&>(x17), f(static_cast<X18&&>(x18), f(static_cast<X19&&>(x19), f(static_cast<X20&&>(x20), f(static_cast<X21&&>(x21), f(static_cast<X22&&>(x22), f(static_cast<X23&&>(x23), f(static_cast<X24&&>(x24), f(static_cast<X25&&>(x25), f(static_cast<X26&&>(x26), f(static_cast<X27&&>(x27), foldr1_impl<sizeof...(xn) + 1>::apply(f, static_cast<X28&&>(x28), static_cast<Xn&&>(xn)...)))))))))))))))))))))))))))); } }; template <unsigned int n> struct foldr1_impl<n, when<(n >= 56)>> { template < typename F , typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7 , typename X8, typename X9, typename X10, typename X11, typename X12, typename X13, typename X14 , typename X15, typename X16, typename X17, typename X18, typename X19, typename X20, typename X21 , typename X22, typename X23, typename X24, typename X25, typename X26, typename X27, typename X28 , typename X29, typename X30, typename X31, typename X32, typename X33, typename X34, typename X35 , typename X36, typename X37, typename X38, typename X39, typename X40, typename X41, typename X42 , typename X43, typename X44, typename X45, typename X46, typename X47, typename X48, typename X49 , typename X50, typename X51, typename X52, typename X53, typename X54, typename X55, typename X56 , typename ...Xn > static constexpr decltype(auto) apply(F&& f , X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6, X7&& x7 , X8&& x8, X9&& x9, X10&& x10, X11&& x11, X12&& x12, X13&& x13, X14&& x14 , X15&& x15, X16&& x16, X17&& x17, X18&& x18, X19&& x19, X20&& x20, X21&& x21 , X22&& x22, X23&& x23, X24&& x24, X25&& x25, X26&& x26, X27&& x27, X28&& x28 , X29&& x29, X30&& x30, X31&& x31, X32&& x32, X33&& x33, X34&& x34, X35&& x35 , X36&& x36, X37&& x37, X38&& x38, X39&& x39, X40&& x40, X41&& x41, X42&& x42 , X43&& x43, X44&& x44, X45&& x45, X46&& x46, X47&& x47, X48&& x48, X49&& x49 , X50&& x50, X51&& x51, X52&& x52, X53&& x53, X54&& x54, X55&& x55, X56&& x56 , Xn&& ...xn) { return f(static_cast<X1&&>(x1), f(static_cast<X2&&>(x2), f(static_cast<X3&&>(x3), f(static_cast<X4&&>(x4), f(static_cast<X5&&>(x5), f(static_cast<X6&&>(x6), f(static_cast<X7&&>(x7), f(static_cast<X8&&>(x8), f(static_cast<X9&&>(x9), f(static_cast<X10&&>(x10), f(static_cast<X11&&>(x11), f(static_cast<X12&&>(x12), f(static_cast<X13&&>(x13), f(static_cast<X14&&>(x14), f(static_cast<X15&&>(x15), f(static_cast<X16&&>(x16), f(static_cast<X17&&>(x17), f(static_cast<X18&&>(x18), f(static_cast<X19&&>(x19), f(static_cast<X20&&>(x20), f(static_cast<X21&&>(x21), f(static_cast<X22&&>(x22), f(static_cast<X23&&>(x23), f(static_cast<X24&&>(x24), f(static_cast<X25&&>(x25), f(static_cast<X26&&>(x26), f(static_cast<X27&&>(x27), f(static_cast<X28&&>(x28), f(static_cast<X29&&>(x29), f(static_cast<X30&&>(x30), f(static_cast<X31&&>(x31), f(static_cast<X32&&>(x32), f(static_cast<X33&&>(x33), f(static_cast<X34&&>(x34), f(static_cast<X35&&>(x35), f(static_cast<X36&&>(x36), f(static_cast<X37&&>(x37), f(static_cast<X38&&>(x38), f(static_cast<X39&&>(x39), f(static_cast<X40&&>(x40), f(static_cast<X41&&>(x41), f(static_cast<X42&&>(x42), f(static_cast<X43&&>(x43), f(static_cast<X44&&>(x44), f(static_cast<X45&&>(x45), f(static_cast<X46&&>(x46), f(static_cast<X47&&>(x47), f(static_cast<X48&&>(x48), f(static_cast<X49&&>(x49), f(static_cast<X50&&>(x50), f(static_cast<X51&&>(x51), f(static_cast<X52&&>(x52), f(static_cast<X53&&>(x53), f(static_cast<X54&&>(x54), f(static_cast<X55&&>(x55), foldr1_impl<sizeof...(xn) + 1>::apply(f, static_cast<X56&&>(x56), static_cast<Xn&&>(xn)...)))))))))))))))))))))))))))))))))))))))))))))))))))))))); } }; //! @endcond struct foldr1_t { template <typename F, typename X1, typename ...Xn> constexpr decltype(auto) operator()(F&& f, X1&& x1, Xn&& ...xn) const { return foldr1_impl<sizeof...(xn) + 1>::apply( static_cast<F&&>(f), static_cast<X1&&>(x1), static_cast<Xn&&>(xn)... ); } }; constexpr foldr1_t foldr1{}; struct foldr_t { template <typename F, typename State, typename ...Xn> constexpr decltype(auto) operator()(F&& f, State&& state, Xn&& ...xn) const { return foldr1_impl<sizeof...(xn) + 1>::apply( static_cast<F&&>(f), static_cast<Xn&&>(xn)..., static_cast<State&&>(state) ); } }; constexpr foldr_t foldr{}; }} BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_VARIADIC_FOLDR1_HPP PK �\�[ (4l3 3 detail/variadic/at.hppnu �[��� /*! @file Defines `boost::hana::detail::variadic::at`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_VARIADIC_AT_HPP #define BOOST_HANA_DETAIL_VARIADIC_AT_HPP #include <boost/hana/config.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic { template <std::size_t n, typename = std::make_index_sequence<n>> struct at_type; template <std::size_t n, std::size_t ...ignore> struct at_type<n, std::index_sequence<ignore...>> { private: template <typename Nth> static constexpr auto go(decltype(ignore, (void*)0)..., Nth nth, ...) { return nth; } public: template <typename ...Xs> constexpr auto operator()(Xs ...xs) const { return *go(&xs...); } }; template <std::size_t n> constexpr at_type<n> at{}; }} BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_VARIADIC_AT_HPP PK �\�[n��|. . detail/variadic/drop_into.hppnu �[��� /*! @file Defines `boost::hana::detail::variadic::drop_into`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_VARIADIC_DROP_INTO_HPP #define BOOST_HANA_DETAIL_VARIADIC_DROP_INTO_HPP #include <boost/hana/config.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic { template <std::size_t n, typename F, typename = std::make_index_sequence<n>> struct dropper; template <std::size_t n, typename F, std::size_t ...ignore> struct dropper<n, F, std::index_sequence<ignore...>> { F f; template <typename ...Rest> constexpr auto go(decltype(ignore, (void*)0)..., Rest ...rest) const { return f(*rest...); } template <typename ...Xs> constexpr auto operator()(Xs ...xs) const { return go(&xs...); } }; template <std::size_t n> struct make_dropper { template <typename F> constexpr auto operator()(F f) const { return dropper<n, decltype(f)>{f}; } }; template <std::size_t n> constexpr make_dropper<n> drop_into{}; }} BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_VARIADIC_DROP_INTO_HPP PK �\�[G�5�� � detail/variadic/take.hppnu �[��� /*! @file Defines `boost::hana::detail::variadic::take`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_VARIADIC_TAKE_HPP #define BOOST_HANA_DETAIL_VARIADIC_TAKE_HPP #include <boost/hana/config.hpp> #include <boost/hana/detail/variadic/split_at.hpp> #include <boost/hana/functional/always.hpp> #include <boost/hana/functional/reverse_partial.hpp> #include <cstddef> BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic { struct take_impl2 { template <typename F, typename ...Xs> constexpr decltype(auto) operator()(F&& f, Xs&& ...xs) const { return static_cast<F&&>(f)(static_cast<Xs&&>(xs)...); } }; struct take_impl1 { template <typename ...Xs> constexpr auto operator()(Xs&& ...xs) const { return hana::always( reverse_partial(take_impl2{}, static_cast<Xs&&>(xs)...) ); } }; template <std::size_t n> struct take_t { template <typename ...Xs> constexpr decltype(auto) operator()(Xs&& ...xs) const { return variadic::split_at<n>(static_cast<Xs&&>(xs)...)(take_impl1{}); } }; template <std::size_t n> constexpr take_t<n> take{}; }} BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_VARIADIC_TAKE_HPP PK �\�[ܖ�A�, �, detail/variadic/foldl1.hppnu �[��� /*! @file Defines `boost::hana::detail::variadic::foldl1`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_VARIADIC_FOLDL1_HPP #define BOOST_HANA_DETAIL_VARIADIC_FOLDL1_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic { //! @cond template <unsigned int n, typename = when<true>> struct foldl1_impl; template <> struct foldl1_impl<1> { template <typename F, typename X1> static constexpr X1 apply(F&&, X1&& x1) { return static_cast<X1&&>(x1); } }; template <> struct foldl1_impl<2> { template <typename F, typename X1, typename X2> static constexpr decltype(auto) apply(F&& f, X1&& x1, X2&& x2) { return static_cast<F&&>(f)(static_cast<X1&&>(x1), static_cast<X2&&>(x2)); } }; template <> struct foldl1_impl<3> { template <typename F, typename X1, typename X2, typename X3> static constexpr decltype(auto) apply(F&& f, X1&& x1, X2&& x2, X3&& x3) { return f(f(static_cast<X1&&>(x1), static_cast<X2&&>(x2)), static_cast<X3&&>(x3)); } }; template <> struct foldl1_impl<4> { template <typename F, typename X1, typename X2, typename X3, typename X4> static constexpr decltype(auto) apply(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4) { return f(f(f(static_cast<X1&&>(x1), static_cast<X2&&>(x2)), static_cast<X3&&>(x3)), static_cast<X4&&>(x4)); } }; template <> struct foldl1_impl<5> { template <typename F, typename X1, typename X2, typename X3, typename X4, typename X5> static constexpr decltype(auto) apply(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5) { return f(f(f(f(static_cast<X1&&>(x1), static_cast<X2&&>(x2)), static_cast<X3&&>(x3)), static_cast<X4&&>(x4)), static_cast<X5&&>(x5)); } }; template <> struct foldl1_impl<6> { template <typename F, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6> static constexpr decltype(auto) apply(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6) { return f(f(f(f(f(static_cast<X1&&>(x1), static_cast<X2&&>(x2)), static_cast<X3&&>(x3)), static_cast<X4&&>(x4)), static_cast<X5&&>(x5)), static_cast<X6&&>(x6)); } }; template <unsigned int n> struct foldl1_impl<n, when<(n >= 7) && (n < 14)>> { template <typename F, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename ...Xn> static constexpr decltype(auto) apply(F&& f , X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6, X7&& x7 , Xn&& ...xn) { return foldl1_impl<sizeof...(xn) + 1>::apply( f, f(f(f(f(f(f(static_cast<X1&&>(x1), static_cast<X2&&>(x2)), static_cast<X3&&>(x3)), static_cast<X4&&>(x4)), static_cast<X5&&>(x5)), static_cast<X6&&>(x6)), static_cast<X7&&>(x7)), static_cast<Xn&&>(xn)... ); } }; template <unsigned int n> struct foldl1_impl<n, when<(n >= 14) && (n < 28)>> { template < typename F , typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7 , typename X8, typename X9, typename X10, typename X11, typename X12, typename X13, typename X14 , typename ...Xn > static constexpr decltype(auto) apply(F&& f , X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6, X7&& x7 , X8&& x8, X9&& x9, X10&& x10, X11&& x11, X12&& x12, X13&& x13, X14&& x14 , Xn&& ...xn) { return foldl1_impl<sizeof...(xn) + 1>::apply( f, f(f(f(f(f(f(f(f(f(f(f(f(f( static_cast<X1&&>(x1), static_cast<X2&&>(x2)), static_cast<X3&&>(x3)), static_cast<X4&&>(x4)), static_cast<X5&&>(x5)), static_cast<X6&&>(x6)), static_cast<X7&&>(x7)), static_cast<X8&&>(x8)), static_cast<X9&&>(x9)), static_cast<X10&&>(x10)), static_cast<X11&&>(x11)), static_cast<X12&&>(x12)), static_cast<X13&&>(x13)), static_cast<X14&&>(x14)) , static_cast<Xn&&>(xn)...); } }; template <unsigned int n> struct foldl1_impl<n, when<(n >= 28) && (n < 56)>> { template < typename F , typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7 , typename X8, typename X9, typename X10, typename X11, typename X12, typename X13, typename X14 , typename X15, typename X16, typename X17, typename X18, typename X19, typename X20, typename X21 , typename X22, typename X23, typename X24, typename X25, typename X26, typename X27, typename X28 , typename ...Xn > static constexpr decltype(auto) apply(F&& f , X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6, X7&& x7 , X8&& x8, X9&& x9, X10&& x10, X11&& x11, X12&& x12, X13&& x13, X14&& x14 , X15&& x15, X16&& x16, X17&& x17, X18&& x18, X19&& x19, X20&& x20, X21&& x21 , X22&& x22, X23&& x23, X24&& x24, X25&& x25, X26&& x26, X27&& x27, X28&& x28 , Xn&& ...xn) { return foldl1_impl<sizeof...(xn) + 1>::apply( f, f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f( static_cast<X1&&>(x1), static_cast<X2&&>(x2)), static_cast<X3&&>(x3)), static_cast<X4&&>(x4)), static_cast<X5&&>(x5)), static_cast<X6&&>(x6)), static_cast<X7&&>(x7)), static_cast<X8&&>(x8)), static_cast<X9&&>(x9)), static_cast<X10&&>(x10)), static_cast<X11&&>(x11)), static_cast<X12&&>(x12)), static_cast<X13&&>(x13)), static_cast<X14&&>(x14)), static_cast<X15&&>(x15)), static_cast<X16&&>(x16)), static_cast<X17&&>(x17)), static_cast<X18&&>(x18)), static_cast<X19&&>(x19)), static_cast<X20&&>(x20)), static_cast<X21&&>(x21)), static_cast<X22&&>(x22)), static_cast<X23&&>(x23)), static_cast<X24&&>(x24)), static_cast<X25&&>(x25)), static_cast<X26&&>(x26)), static_cast<X27&&>(x27)), static_cast<X28&&>(x28)) , static_cast<Xn&&>(xn)...); } }; template <unsigned int n> struct foldl1_impl<n, when<(n >= 56)>> { template < typename F , typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7 , typename X8, typename X9, typename X10, typename X11, typename X12, typename X13, typename X14 , typename X15, typename X16, typename X17, typename X18, typename X19, typename X20, typename X21 , typename X22, typename X23, typename X24, typename X25, typename X26, typename X27, typename X28 , typename X29, typename X30, typename X31, typename X32, typename X33, typename X34, typename X35 , typename X36, typename X37, typename X38, typename X39, typename X40, typename X41, typename X42 , typename X43, typename X44, typename X45, typename X46, typename X47, typename X48, typename X49 , typename X50, typename X51, typename X52, typename X53, typename X54, typename X55, typename X56 , typename ...Xn > static constexpr decltype(auto) apply(F&& f , X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6, X7&& x7 , X8&& x8, X9&& x9, X10&& x10, X11&& x11, X12&& x12, X13&& x13, X14&& x14 , X15&& x15, X16&& x16, X17&& x17, X18&& x18, X19&& x19, X20&& x20, X21&& x21 , X22&& x22, X23&& x23, X24&& x24, X25&& x25, X26&& x26, X27&& x27, X28&& x28 , X29&& x29, X30&& x30, X31&& x31, X32&& x32, X33&& x33, X34&& x34, X35&& x35 , X36&& x36, X37&& x37, X38&& x38, X39&& x39, X40&& x40, X41&& x41, X42&& x42 , X43&& x43, X44&& x44, X45&& x45, X46&& x46, X47&& x47, X48&& x48, X49&& x49 , X50&& x50, X51&& x51, X52&& x52, X53&& x53, X54&& x54, X55&& x55, X56&& x56 , Xn&& ...xn) { return foldl1_impl<sizeof...(xn) + 1>::apply( f, f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f( static_cast<X1&&>(x1), static_cast<X2&&>(x2)), static_cast<X3&&>(x3)), static_cast<X4&&>(x4)), static_cast<X5&&>(x5)), static_cast<X6&&>(x6)), static_cast<X7&&>(x7)), static_cast<X8&&>(x8)), static_cast<X9&&>(x9)), static_cast<X10&&>(x10)), static_cast<X11&&>(x11)), static_cast<X12&&>(x12)), static_cast<X13&&>(x13)), static_cast<X14&&>(x14)), static_cast<X15&&>(x15)), static_cast<X16&&>(x16)), static_cast<X17&&>(x17)), static_cast<X18&&>(x18)), static_cast<X19&&>(x19)), static_cast<X20&&>(x20)), static_cast<X21&&>(x21)), static_cast<X22&&>(x22)), static_cast<X23&&>(x23)), static_cast<X24&&>(x24)), static_cast<X25&&>(x25)), static_cast<X26&&>(x26)), static_cast<X27&&>(x27)), static_cast<X28&&>(x28)), static_cast<X29&&>(x29)), static_cast<X30&&>(x30)), static_cast<X31&&>(x31)), static_cast<X32&&>(x32)), static_cast<X33&&>(x33)), static_cast<X34&&>(x34)), static_cast<X35&&>(x35)), static_cast<X36&&>(x36)), static_cast<X37&&>(x37)), static_cast<X38&&>(x38)), static_cast<X39&&>(x39)), static_cast<X40&&>(x40)), static_cast<X41&&>(x41)), static_cast<X42&&>(x42)), static_cast<X43&&>(x43)), static_cast<X44&&>(x44)), static_cast<X45&&>(x45)), static_cast<X46&&>(x46)), static_cast<X47&&>(x47)), static_cast<X48&&>(x48)), static_cast<X49&&>(x49)), static_cast<X50&&>(x50)), static_cast<X51&&>(x51)), static_cast<X52&&>(x52)), static_cast<X53&&>(x53)), static_cast<X54&&>(x54)), static_cast<X55&&>(x55)), static_cast<X56&&>(x56)) , static_cast<Xn&&>(xn)...); } }; //! @endcond struct foldl1_t { template <typename F, typename X1, typename ...Xn> constexpr decltype(auto) operator()(F&& f, X1&& x1, Xn&& ...xn) const { return foldl1_impl<sizeof...(xn) + 1>::apply( static_cast<F&&>(f), static_cast<X1&&>(x1), static_cast<Xn&&>(xn)... ); } }; constexpr foldl1_t foldl1{}; constexpr auto foldl = foldl1; }} BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_VARIADIC_FOLDL1_HPP PK �\�[7( = = detail/std_common_type.hppnu �[��� /*! @file Defines a SFINAE-friendly version of `std::common_type`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_STD_COMMON_TYPE_HPP #define BOOST_HANA_DETAIL_STD_COMMON_TYPE_HPP #include <boost/hana/config.hpp> #include <boost/hana/detail/decay.hpp> #include <utility> BOOST_HANA_NAMESPACE_BEGIN namespace detail { //! @ingroup group-details //! Equivalent to `std::common_type`, except it is SFINAE-friendly and //! does not support custom specializations. template <typename T, typename U, typename = void> struct std_common_type { }; template <typename T, typename U> struct std_common_type<T, U, decltype((void)( true ? std::declval<T>() : std::declval<U>() ))> { using type = typename detail::decay< decltype(true ? std::declval<T>() : std::declval<U>()) >::type; }; } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_STD_COMMON_TYPE_HPP PK �\�[ۋ�*� � detail/decay.hppnu �[��� /*! @file Defines a replacement for `std::decay`, which is sometimes too slow at compile-time. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_DECAY_HPP #define BOOST_HANA_DETAIL_DECAY_HPP #include <boost/hana/config.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN namespace detail { //! @ingroup group-details //! Equivalent to `std::decay`, except faster. //! //! `std::decay` in libc++ is implemented in a suboptimal way. Since //! this is used literally everywhere by the `make<...>` functions, it //! is very important to keep this as efficient as possible. //! //! @note //! `std::decay` is still being used in some places in the library. //! Indeed, this is a peephole optimization and it would not be wise //! to clutter the code with our own implementation of `std::decay`, //! except when this actually makes a difference in compile-times. template <typename T, typename U = typename std::remove_reference<T>::type> struct decay { using type = typename std::remove_cv<U>::type; }; template <typename T, typename U> struct decay<T, U[]> { using type = U*; }; template <typename T, typename U, std::size_t N> struct decay<T, U[N]> { using type = U*; }; template <typename T, typename R, typename ...A> struct decay<T, R(A...)> { using type = R(*)(A...); }; template <typename T, typename R, typename ...A> struct decay<T, R(A..., ...)> { using type = R(*)(A..., ...); }; } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_DECAY_HPP PK �\�[/Bʇ� � " detail/first_unsatisfied_index.hppnu �[��� /*! @file Defines `boost::hana::detail::first_unsatisfied_index`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_FIRST_UNSATISFIED_INDEX_HPP #define BOOST_HANA_DETAIL_FIRST_UNSATISFIED_INDEX_HPP #include <boost/hana/config.hpp> #include <boost/hana/integral_constant.hpp> #include <boost/hana/value.hpp> #include <utility> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <bool, typename Pred, typename ...Xs> struct find_tail_size; template <typename Pred, typename X, typename ...Xs> struct find_tail_size<true, Pred, X, Xs...> { static constexpr int value = find_tail_size< static_cast<bool>(hana::value<decltype(std::declval<Pred>()(std::declval<X>()))>()), Pred, Xs... >::value; }; template <typename Pred> struct find_tail_size<true, Pred> { static constexpr int value = -1; }; template <typename Pred, typename ...Xs> struct find_tail_size<false, Pred, Xs...> { static constexpr int value = sizeof...(Xs); }; //! @ingroup group-details //! Returns the index of the first element which does not satisfy `Pred`, //! or `sizeof...(Xs)` if no such element exists. template <typename Pred> struct first_unsatisfied_index { template <typename ...Xs> constexpr auto operator()(Xs&& ...) const { return hana::size_c< sizeof...(Xs) - 1 - find_tail_size<true, Pred, Xs&&...>::value >; } }; } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_FIRST_UNSATISFIED_INDEX_HPP PK �\�[B�: : detail/type_at.hppnu �[��� /*! @file Defines `boost::hana::detail::type_at`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_TYPE_AT_HPP #define BOOST_HANA_DETAIL_TYPE_AT_HPP #include <boost/hana/config.hpp> #include <cstddef> #include <utility> // If possible, use an intrinsic provided by Clang #if defined(__has_builtin) # if __has_builtin(__type_pack_element) # define BOOST_HANA_USE_TYPE_PACK_ELEMENT_INTRINSIC # endif #endif BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace td { template <std::size_t I, typename T> struct elt { using type = T; }; template <typename Indices, typename ...T> struct indexer; template <std::size_t ...I, typename ...T> struct indexer<std::index_sequence<I...>, T...> : elt<I, T>... { }; template <std::size_t I, typename T> elt<I, T> get_elt(elt<I, T> const&); } //! @ingroup group-details //! Classic MPL-style metafunction returning the nth element of a type //! parameter pack. template <std::size_t n, typename ...T> struct type_at { #if defined(BOOST_HANA_USE_TYPE_PACK_ELEMENT_INTRINSIC) using type = __type_pack_element<n, T...>; #else using Indexer = td::indexer<std::make_index_sequence<sizeof...(T)>, T...>; using type = typename decltype(td::get_elt<n>(Indexer{}))::type; #endif }; } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_TYPE_AT_HPP PK �\�[q�]U U detail/algorithm.hppnu �[��� /*! @file Defines several `constexpr` algorithms. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_ALGORITHM_HPP #define BOOST_HANA_DETAIL_ALGORITHM_HPP #include <boost/hana/functional/placeholder.hpp> #include <boost/hana/config.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN namespace detail { // Do not call this swap, otherwise it can get picked up by ADL and conflict // with std::swap (see https://github.com/boostorg/hana/issues/297). template <typename T> constexpr void constexpr_swap(T& x, T& y) { auto tmp = x; x = y; y = std::move(tmp); } template <typename BidirIter> constexpr void reverse(BidirIter first, BidirIter last) { while (first != last) { if (first == --last) break; detail::constexpr_swap(*first, *last); ++first; } } template <typename BidirIter, typename BinaryPred> constexpr bool next_permutation(BidirIter first, BidirIter last, BinaryPred pred) { BidirIter i = last; if (first == last || first == --i) return false; while (true) { BidirIter ip1 = i; if (pred(*--i, *ip1)) { BidirIter j = last; while (!pred(*i, *--j)) ; detail::constexpr_swap(*i, *j); detail::reverse(ip1, last); return true; } if (i == first) { detail::reverse(first, last); return false; } } } template <typename BidirIter> constexpr bool next_permutation(BidirIter first, BidirIter last) { return detail::next_permutation(first, last, hana::_ < hana::_); } template <typename InputIter1, typename InputIter2, typename BinaryPred> constexpr bool lexicographical_compare(InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2, BinaryPred pred) { for (; first2 != last2; ++first1, ++first2) { if (first1 == last1 || pred(*first1, *first2)) return true; else if (pred(*first2, *first1)) return false; } return false; } template <typename InputIter1, typename InputIter2> constexpr bool lexicographical_compare(InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2) { return detail::lexicographical_compare(first1, last1, first2, last2, hana::_ < hana::_); } template <typename InputIter1, typename InputIter2, typename BinaryPred> constexpr bool equal(InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2, BinaryPred pred) { for (; first1 != last1 && first2 != last2; ++first1, ++first2) if (!pred(*first1, *first2)) return false; return first1 == last1 && first2 == last2; } template <typename InputIter1, typename InputIter2> constexpr bool equal(InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2) { return detail::equal(first1, last1, first2, last2, hana::_ == hana::_); } template <typename BidirIter, typename BinaryPred> constexpr void sort(BidirIter first, BidirIter last, BinaryPred pred) { if (first == last) return; BidirIter i = first; for (++i; i != last; ++i) { BidirIter j = i; auto t = *j; for (BidirIter k = i; k != first && pred(t, *--k); --j) *j = *k; *j = t; } } template <typename BidirIter> constexpr void sort(BidirIter first, BidirIter last) { detail::sort(first, last, hana::_ < hana::_); } template <typename InputIter, typename T> constexpr InputIter find(InputIter first, InputIter last, T const& value) { for (; first != last; ++first) if (*first == value) return first; return last; } template <typename InputIter, typename UnaryPred> constexpr InputIter find_if(InputIter first, InputIter last, UnaryPred pred) { for (; first != last; ++first) if (pred(*first)) return first; return last; } template <typename ForwardIter, typename T> constexpr void iota(ForwardIter first, ForwardIter last, T value) { while (first != last) { *first++ = value; ++value; } } template <typename InputIt, typename T> constexpr std::size_t count(InputIt first, InputIt last, T const& value) { std::size_t n = 0; for (; first != last; ++first) if (*first == value) ++n; return n; } template <typename InputIt, typename T, typename F> constexpr T accumulate(InputIt first, InputIt last, T init, F f) { for (; first != last; ++first) init = f(init, *first); return init; } template <typename InputIt, typename T> constexpr T accumulate(InputIt first, InputIt last, T init) { return detail::accumulate(first, last, init, hana::_ + hana::_); } template <typename ForwardIt> constexpr ForwardIt min_element(ForwardIt first, ForwardIt last) { if (first == last) return last; ForwardIt smallest = first; ++first; for (; first != last; ++first) if (*first < *smallest) smallest = first; return smallest; } } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_ALGORITHM_HPP PK �\�[��p p detail/unpack_flatten.hppnu �[��� /*! @file Defines `boost::hana::detail::unpack_flatten`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_UNPACK_FLATTEN_HPP #define BOOST_HANA_DETAIL_UNPACK_FLATTEN_HPP #include <boost/hana/at.hpp> #include <boost/hana/config.hpp> #include <boost/hana/detail/algorithm.hpp> #include <boost/hana/detail/array.hpp> #include <boost/hana/length.hpp> #include <boost/hana/unpack.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <std::size_t ...Lengths> struct flatten_indices { // avoid empty arrays by appending 0 to `lengths` static constexpr std::size_t lengths[sizeof...(Lengths) + 1] = {Lengths..., 0}; static constexpr auto flat_length = detail::accumulate(lengths, lengths + sizeof...(Lengths), 0); template <bool Inner> static constexpr auto compute() { detail::array<std::size_t, flat_length> indices{}; for (std::size_t index = 0, i = 0; i < sizeof...(Lengths); ++i) for (std::size_t j = 0; j < lengths[i]; ++j, ++index) indices[index] = (Inner ? i : j); return indices; } static constexpr auto inner = compute<true>(); static constexpr auto outer = compute<false>(); template <typename Xs, typename F, std::size_t ...i> static constexpr decltype(auto) apply(Xs&& xs, F&& f, std::index_sequence<i...>) { return static_cast<F&&>(f)( hana::at_c<outer[i]>(hana::at_c<inner[i]>( static_cast<Xs&&>(xs) ))... ); } }; struct make_flatten_indices { template <typename ...Xs> auto operator()(Xs const& ...xs) const -> detail::flatten_indices< decltype(hana::length(xs))::value... >; }; template <typename Xs, typename F> constexpr decltype(auto) unpack_flatten(Xs&& xs, F&& f) { using Indices = decltype(hana::unpack(xs, make_flatten_indices{})); return Indices::apply(static_cast<Xs&&>(xs), static_cast<F&&>(f), std::make_index_sequence<Indices::flat_length>{}); } } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_UNPACK_FLATTEN_HPP PK �\�[�6ͤ[ [ detail/nested_to_fwd.hppnu �[��� /*! @file Forward declares `boost::hana::detail::nested_to`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_NESTED_TO_FWD_HPP #define BOOST_HANA_DETAIL_NESTED_TO_FWD_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <typename Algorithm> struct nested_to_t { template <typename X> constexpr decltype(auto) operator()(X&& x) const; }; //! @ingroup group-details //! Provides a `.to` static constexpr function object. //! //! When creating a binary function object of type `Algo` whose signature //! is `Object x Object -> Return`, `nested_to<Algo>` can be used as a base //! class of `Algo`. Doing so will provide a static constexpr member called //! `to`, which has the following signature: //! @code //! Object -> Object -> Return //! @endcode //! //! Note that the function object `Algo` must be default-constructible, //! since the algorithm will be called as `Algo{}(arguments...)`. //! //! @note //! This function object is especially useful because it takes care of //! avoiding ODR violations caused by the nested static constexpr member. template <typename Algorithm> struct nested_to { static constexpr nested_to_t<Algorithm> to{}; }; template <typename Algorithm> constexpr nested_to_t<Algorithm> nested_to<Algorithm>::to; } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_NESTED_TO_FWD_HPP PK �\�[�ֽ�V V detail/nested_than.hppnu �[��� /*! @file Defines `boost::hana::detail::nested_than`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_NESTED_THAN_HPP #define BOOST_HANA_DETAIL_NESTED_THAN_HPP #include <boost/hana/detail/nested_than_fwd.hpp> #include <boost/hana/config.hpp> #include <boost/hana/functional/flip.hpp> #include <boost/hana/functional/partial.hpp> BOOST_HANA_NAMESPACE_BEGIN namespace detail { //! @cond template <typename Algorithm> template <typename X> constexpr decltype(auto) nested_than_t<Algorithm>::operator()(X&& x) const { return hana::partial(hana::flip(Algorithm{}), static_cast<X&&>(x)); } //! @endcond } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_NESTED_THAN_HPP PK �\�[e�`mo o detail/hash_table.hppnu �[��� /*! @file Defines `boost::hana::detail::hash_table`. @copyright Louis Dionne 2016 @copyright Jason Rice 2016 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_HASH_TABLE_HPP #define BOOST_HANA_DETAIL_HASH_TABLE_HPP #include <boost/hana/equal.hpp> #include <boost/hana/ext/std/integer_sequence.hpp> #include <boost/hana/ext/std/integral_constant.hpp> #include <boost/hana/find_if.hpp> #include <boost/hana/fold_left.hpp> #include <boost/hana/hash.hpp> #include <boost/hana/optional.hpp> #include <boost/hana/range.hpp> #include <boost/hana/type.hpp> #include <boost/hana/value.hpp> #include <cstddef> #include <type_traits> #include <utility> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <typename Hash, std::size_t ...i> struct bucket { }; template <typename ...Buckets> struct hash_table : Buckets... { }; // find_indices: // Returns an `index_sequence` containing possible indices for the given // `Key` in the `Map`. template <typename Hash, std::size_t ...i> std::index_sequence<i...> find_indices_impl(bucket<Hash, i...> const&); template <typename Hash> std::index_sequence<> find_indices_impl(...); template <typename Map, typename Key> struct find_indices { using Hash = typename decltype(hana::hash(std::declval<Key>()))::type; using type = decltype(detail::find_indices_impl<Hash>(std::declval<Map>())); }; // end find_indices // find_index: // Returns the actual index of a `Key` in the `Map`. The type of the key // associated to any given index must be retrievable with the `KeyAtIndex` // alias. template <template <std::size_t> class KeyAtIndex, typename Key> struct find_pred { template <typename Index> auto operator()(Index const&) const -> decltype( hana::equal(std::declval<KeyAtIndex<Index::value>>(), std::declval<Key>()) ); }; template <typename Indices, typename Key, template <std::size_t> class KeyAtIndex> struct find_index_impl { using type = decltype(hana::find_if(Indices{}, find_pred<KeyAtIndex, Key>{})); }; // This is a peephole optimization for buckets that have a single entry. // It provides a nice speedup in the at_key.number_of_lookups benchmark. // It is perhaps possible to make this part of `find_if` itself, but we // should make sure that we retain that speedup. template <std::size_t i, typename Key, template <std::size_t> class KeyAtIndex> struct find_index_impl<std::index_sequence<i>, Key, KeyAtIndex> { using Equal = decltype( hana::equal(std::declval<KeyAtIndex<i>>(), std::declval<Key>()) ); using type = typename std::conditional<Equal::value, hana::optional<std::integral_constant<std::size_t, i>>, hana::optional<> >::type; }; template <typename Map, typename Key, template <std::size_t> class KeyAtIndex> struct find_index { using Indices = typename find_indices<Map, Key>::type; using type = typename find_index_impl<Indices, Key, KeyAtIndex>::type; }; // end find_index // bucket_insert: // Inserts the given `Index` into the bucket of the `Map` in which `Key` falls. template <typename Bucket, typename Hash, std::size_t Index> struct update_bucket { using type = Bucket; }; template <std::size_t ...i, typename Hash, std::size_t Index> struct update_bucket<bucket<Hash, i...>, Hash, Index> { using type = bucket<Hash, i..., Index>; }; template <typename Map, typename Key, std::size_t Index, bool = (find_indices<Map, Key>::type::size() > 0) > struct bucket_insert; template <typename ...Buckets, typename Key, std::size_t Index> struct bucket_insert<hash_table<Buckets...>, Key, Index, true> { // There is a bucket for that Hash; append the new index to it. using Hash = typename decltype(hana::hash(std::declval<Key>()))::type; using type = hash_table<typename update_bucket<Buckets, Hash, Index>::type...>; }; template <typename ...Buckets, typename Key, std::size_t Index> struct bucket_insert<hash_table<Buckets...>, Key, Index, false> { // There is no bucket for that Hash; insert a new bucket. using Hash = typename decltype(hana::hash(std::declval<Key>()))::type; using type = hash_table<Buckets..., bucket<Hash, Index>>; }; // end bucket_insert // make_hash_table: // Creates a `hash_table` type able of holding the given number of // elements. The type of the key associated to any given index must // be retrievable using the `KeyAtIndex` alias. All the keys must // be distinct and have different hashes too. template <template <std::size_t> class KeyAtIndex, std::size_t N, typename Indices = std::make_index_sequence<N>> struct make_hash_table; template <template <std::size_t> class KeyAtIndex, std::size_t N, std::size_t ...i> struct make_hash_table<KeyAtIndex, N, std::index_sequence<i...>> { using type = hash_table< bucket<typename decltype(hana::hash(std::declval<KeyAtIndex<i>>()))::type, i>... >; }; } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_HASH_TABLE_HPP PK �\�[*���? ? detail/type_foldr1.hppnu �[��� /*! @file Defines `boost::hana::detail::type_foldr1`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_TYPE_FOLDR1_HPP #define BOOST_HANA_DETAIL_TYPE_FOLDR1_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <unsigned n> struct type_foldr1_t; template <> struct type_foldr1_t<0> { template < template <typename ...> class f, typename state > using result = state; }; template <> struct type_foldr1_t<1> { template < template <typename ...> class f, typename x1, typename state > using result = typename f<x1, state>::type; }; template <> struct type_foldr1_t<2> { template < template <typename ...> class f, typename x1, typename x2, typename state > using result = typename f<x1, typename f<x2, state>::type>::type; }; template <> struct type_foldr1_t<3> { template < template <typename ...> class f, typename x1, typename x2, typename x3, typename state > using result = typename f< x1, typename f< x2, typename f< x3, state >::type >::type >::type; }; template <> struct type_foldr1_t<4> { template < template <typename ...> class f, typename x1, typename x2, typename x3, typename x4, typename state > using result = typename f< x1, typename f< x2, typename f< x3, typename f< x4, state >::type >::type >::type >::type; }; template <> struct type_foldr1_t<5> { template < template <typename ...> class f, typename x1, typename x2, typename x3, typename x4, typename x5, typename state > using result = typename f< x1, typename f< x2, typename f< x3, typename f< x4, typename f< x5, state >::type >::type >::type >::type >::type; }; template <> struct type_foldr1_t<6> { template < template <typename ...> class f, typename x1, typename x2, typename x3, typename x4, typename x5, typename x6, typename ...xs > using result = typename f< x1, typename f< x2, typename f< x3, typename f< x4, typename f< x5, typename type_foldr1_t<(sizeof...(xs) > 6 ? 6 : sizeof...(xs))>:: template result<f, x6, xs...> >::type >::type >::type >::type >::type; }; template <template <typename ...> class f, typename x1, typename ...xn> struct type_foldr1 { using type = typename type_foldr1_t<(sizeof...(xn) > 6 ? 6 : sizeof...(xn))> ::template result<f, x1, xn...>; }; } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_TYPE_FOLDR1_HPP PK �\�[N��L L detail/type_foldl1.hppnu �[��� /*! @file Defines `boost::hana::detail::type_foldl1`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_TYPE_FOLDL1_HPP #define BOOST_HANA_DETAIL_TYPE_FOLDL1_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <unsigned n> struct type_foldl1_t; template <> struct type_foldl1_t<0> { template < template <typename ...> class f, typename state > using result = state; }; template <> struct type_foldl1_t<1> { template < template <typename ...> class f, typename state, typename x1 > using result = typename f<state, x1>::type; }; template <> struct type_foldl1_t<2> { template < template <typename ...> class f, typename state, typename x1, typename x2 > using result = typename f<typename f<state, x1>::type, x2>::type; }; template <> struct type_foldl1_t<3> { template < template <typename ...> class f, typename state, typename x1, typename x2, typename x3 > using result = typename f< typename f< typename f<state, x1>::type, x2 >::type, x3 >::type; }; template <> struct type_foldl1_t<4> { template < template <typename ...> class f, typename state, typename x1, typename x2, typename x3, typename x4 > using result = typename f< typename f< typename f< typename f<state, x1>::type, x2 >::type, x3 >::type, x4 >::type; }; template <> struct type_foldl1_t<5> { template < template <typename ...> class f, typename state, typename x1, typename x2, typename x3, typename x4, typename x5 > using result = typename f< typename f< typename f< typename f< typename f<state, x1>::type, x2 >::type, x3 >::type, x4 >::type, x5 >::type; }; template <> struct type_foldl1_t<6> { template < template <typename ...> class f, typename state, typename x1, typename x2, typename x3, typename x4, typename x5, typename x6, typename ...xs > using result = typename type_foldl1_t<(sizeof...(xs) > 6 ? 6 : sizeof...(xs))>:: template result< f, typename f< typename f< typename f< typename f< typename f< typename f<state, x1>::type, x2 >::type, x3 >::type, x4 >::type, x5 >::type, x6 >::type, xs... >; }; template <template <typename ...> class f, typename x1, typename ...xn> struct type_foldl1 { using type = typename type_foldl1_t<(sizeof...(xn) > 6 ? 6 : sizeof...(xn))> ::template result<f, x1, xn...>; }; } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_TYPE_FOLDL1_HPP PK �\�[@!��� � detail/create.hppnu �[��� /*! @file Defines `boost::hana::detail::create`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_CREATE_HPP #define BOOST_HANA_DETAIL_CREATE_HPP #include <boost/hana/config.hpp> #include <boost/hana/detail/decay.hpp> BOOST_HANA_NAMESPACE_BEGIN namespace detail { //! @ingroup group-details //! Implementation of the generic `std::make_xxx` pattern for arbitrary //! `xxx`s. template <template <typename ...> class T> struct create { template <typename ...X> constexpr T<typename detail::decay<X>::type...> operator()(X&& ...x) const { return T<typename detail::decay<X>::type...>{ static_cast<X&&>(x)... }; } }; } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_CREATE_HPP PK �\�[���(� � detail/has_common_embedding.hppnu �[��� /*! @file Defines `boost::hana::detail::has_[nontrivial_]common_embedding`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_HAS_COMMON_EMBEDDING_HPP #define BOOST_HANA_DETAIL_HAS_COMMON_EMBEDDING_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/common.hpp> #include <boost/hana/core/to.hpp> #include <boost/hana/detail/void_t.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <template <typename...> class Concept, typename T, typename U, typename = void> struct has_common_embedding_impl : std::false_type { }; template <template <typename...> class Concept, typename T, typename U> struct has_common_embedding_impl<Concept, T, U, detail::void_t< typename common<T, U>::type >> { using Common = typename common<T, U>::type; using type = std::integral_constant<bool, Concept<T>::value && Concept<U>::value && Concept<Common>::value && is_embedded<T, Common>::value && is_embedded<U, Common>::value >; }; //! @ingroup group-details //! Returns whether `T` and `U` both have an embedding into a //! common type. //! //! If `T` and `U` do not have a common-type, this metafunction returns //! false. template <template <typename...> class Concept, typename T, typename U> using has_common_embedding = typename has_common_embedding_impl<Concept, T, U>::type; template <template <typename...> class Concept, typename T, typename U> struct has_nontrivial_common_embedding_impl : has_common_embedding_impl<Concept, T, U> { }; template <template <typename...> class Concept, typename T> struct has_nontrivial_common_embedding_impl<Concept, T, T> : std::false_type { }; //! @ingroup group-details //! Returns whether `T` and `U` are distinct and both have an embedding //! into a common type. //! //! If `T` and `U` do not have a common-type, this metafunction returns //! false. template <template <typename...> class Concept, typename T, typename U> using has_nontrivial_common_embedding = typename has_nontrivial_common_embedding_impl<Concept, T, U>::type; } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_HAS_COMMON_EMBEDDING_HPP PK �\�[�`" " detail/ebo.hppnu �[��� /*! @file Defines `boost::hana::detail::ebo`. @copyright Louis Dionne 2013-2016 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_EBO_HPP #define BOOST_HANA_DETAIL_EBO_HPP #include <boost/hana/config.hpp> #include <boost/hana/detail/intrinsics.hpp> namespace _hana { ////////////////////////////////////////////////////////////////////////// // ebo<K, V> // // Building block to implement the Empty Base Optimization (EBO). We // use a short name and define it in a short namespace to reduce // symbol lengths, since this type is used as a building block for // other widely used types such as `hana::pair`. // // When available, we use compiler intrinsics to reduce the number // of instantiations. // // `ebo` provides a limited set of constructors to reduce instantiations. // Also, the constructors are open-ended and they do not check for the // validity of their arguments, again to reduce compile-time costs. // Users of `ebo` should make sure that they only try to construct an // `ebo` from a compatible value. // // EBOs can be indexed using an arbitrary type. The recommended usage is // to define an integrap constant wrapper for the specific container using // EBO, and then index using that wrapper: // // template <int> struct idx; // wrapper for tuple // template <typename ...T> // struct tuple : ebo<idx<0>, T0>, ebo<idx<1>, T1>, ... { }; // // The reason for defining one wrapper per container is to avoid any issues // that can arise when using `ebo_get`, which casts to the base class. If // `tuple` and `pair` are inheritting from `ebo`s with the same indexing // scheme, trying to use `ebo_get` on a tuple of pairs will trigger an // ambiguous base class conversion, since both tuple and pair inherit // from `ebo`s with the same keys. ////////////////////////////////////////////////////////////////////////// template <typename K, typename V, bool = BOOST_HANA_TT_IS_EMPTY(V) && !BOOST_HANA_TT_IS_FINAL(V) > struct ebo; // Specialize storage for empty types template <typename K, typename V> struct ebo<K, V, true> : V { constexpr ebo() { } template <typename T> explicit constexpr ebo(T&& t) : V(static_cast<T&&>(t)) { } }; // Specialize storage for non-empty types template <typename K, typename V> struct ebo<K, V, false> { constexpr ebo() : data_() { } template <typename T> explicit constexpr ebo(T&& t) : data_(static_cast<T&&>(t)) { } V data_; }; ////////////////////////////////////////////////////////////////////////// // ebo_get ////////////////////////////////////////////////////////////////////////// template <typename K, typename V> constexpr V const& ebo_get(ebo<K, V, true> const& x) { return x; } template <typename K, typename V> constexpr V& ebo_get(ebo<K, V, true>& x) { return x; } template <typename K, typename V> constexpr V&& ebo_get(ebo<K, V, true>&& x) { return static_cast<V&&>(x); } template <typename K, typename V> constexpr V const& ebo_get(ebo<K, V, false> const& x) { return x.data_; } template <typename K, typename V> constexpr V& ebo_get(ebo<K, V, false>& x) { return x.data_; } template <typename K, typename V> constexpr V&& ebo_get(ebo<K, V, false>&& x) { return static_cast<V&&>(x.data_); } } // end namespace _hana BOOST_HANA_NAMESPACE_BEGIN namespace detail { using ::_hana::ebo; using ::_hana::ebo_get; } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_EBO_HPP PK �\�[;��b� � detail/intrinsics.hppnu �[��� /*! @file Defines macros for commonly used type traits. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_INTRINSICS_HPP #define BOOST_HANA_DETAIL_INTRINSICS_HPP #include <boost/hana/config.hpp> // We use intrinsics if they are available because it speeds up the // compile-times. #if defined(BOOST_HANA_CONFIG_CLANG) # if __has_extension(is_empty) # define BOOST_HANA_TT_IS_EMPTY(T) __is_empty(T) # endif # if __has_extension(is_final) # define BOOST_HANA_TT_IS_FINAL(T) __is_final(T) # endif // TODO: Right now, this intrinsic is never used directly because of // https://llvm.org/bugs/show_bug.cgi?id=24173 # if __has_extension(is_constructible) && false # define BOOST_HANA_TT_IS_CONSTRUCTIBLE(...) __is_constructible(__VA_ARGS__) # endif # if __has_extension(is_assignable) # define BOOST_HANA_TT_IS_ASSIGNABLE(T, U) __is_assignable(T, U) # endif # if __has_extension(is_convertible) # define BOOST_HANA_TT_IS_CONVERTIBLE(T, U) __is_convertible(T, U) # endif #endif #if !defined(BOOST_HANA_TT_IS_EMPTY) # include <type_traits> # define BOOST_HANA_TT_IS_EMPTY(T) ::std::is_empty<T>::value #endif #if !defined(BOOST_HANA_TT_IS_FINAL) # include <type_traits> # define BOOST_HANA_TT_IS_FINAL(T) ::std::is_final<T>::value #endif #if !defined(BOOST_HANA_TT_IS_CONSTRUCTIBLE) # include <type_traits> # define BOOST_HANA_TT_IS_CONSTRUCTIBLE(...) ::std::is_constructible<__VA_ARGS__>::value #endif #if !defined(BOOST_HANA_TT_IS_ASSIGNABLE) # include <type_traits> # define BOOST_HANA_TT_IS_ASSIGNABLE(T, U) ::std::is_assignable<T, U>::value #endif #if !defined(BOOST_HANA_TT_IS_CONVERTIBLE) # include <type_traits> # define BOOST_HANA_TT_IS_CONVERTIBLE(T, U) ::std::is_convertible<T, U>::value #endif #endif // !BOOST_HANA_DETAIL_INTRINSICS_HPP PK �\�[� �� detail/void_t.hppnu �[��� /*! @file Defines an equivalent to the proposed `std::void_t`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_VOID_T_HPP #define BOOST_HANA_DETAIL_VOID_T_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <typename ...> using void_t = void; } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_VOID_T_HPP PK �\�[_l-#� � detail/nested_by_fwd.hppnu �[��� /*! @file Forward declares `boost::hana::detail::nested_by`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_NESTED_BY_FWD_HPP #define BOOST_HANA_DETAIL_NESTED_BY_FWD_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <typename Algorithm> struct nested_by_t { template <typename Predicate, typename Object> constexpr decltype(auto) operator()(Predicate&& predicate, Object&& object) const; template <typename Predicate> constexpr decltype(auto) operator()(Predicate&& predicate) const; }; //! @ingroup group-details //! Provides a `.by` static constexpr function object. //! //! When creating a binary function object of type `Algorithm` whose //! signature is `Object x Predicate -> Return`, `nested_by<Algorithm>` //! can be used as a base class to `Algorithm`. Doing so will provide a //! static constexpr member called `by`, which has the two following //! signatures: //! @code //! Predicate x Object -> Return //! Predicate -> (Object -> Return) //! @endcode //! //! In other words, `nested_by` is a `curry`ed and `flip`ped version of //! `Algorithm`. Note that the function object `Algorithm` must be //! default-constructible, since the algorithm will be called as //! `Algorithm{}(arguments...)`. //! //! @note //! This function object is especially useful because it takes care of //! avoiding ODR violations caused by the nested static constexpr member. template <typename Algorithm> struct nested_by { static constexpr nested_by_t<Algorithm> by{}; }; template <typename Algorithm> constexpr nested_by_t<Algorithm> nested_by<Algorithm>::by; } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_NESTED_BY_FWD_HPP PK �\�[���X X detail/fast_and.hppnu �[��� /*! @file Defines `boost::hana::detail::fast_and`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DETAIL_FAST_AND_HPP #define BOOST_HANA_DETAIL_FAST_AND_HPP #include <boost/hana/config.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <bool ...b> struct fast_and : std::is_same<fast_and<b...>, fast_and<(b, true)...>> { }; } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DETAIL_FAST_AND_HPP PK �\�[0�є� � minus.hppnu �[��� /*! @file Defines `boost::hana::minus`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_MINUS_HPP #define BOOST_HANA_MINUS_HPP #include <boost/hana/fwd/minus.hpp> #include <boost/hana/concept/constant.hpp> #include <boost/hana/concept/group.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/common.hpp> #include <boost/hana/core/to.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/canonical_constant.hpp> #include <boost/hana/detail/has_common_embedding.hpp> #include <boost/hana/fwd/negate.hpp> #include <boost/hana/plus.hpp> #include <boost/hana/value.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename X, typename Y> constexpr decltype(auto) minus_t::operator()(X&& x, Y&& y) const { using T = typename hana::tag_of<X>::type; using U = typename hana::tag_of<Y>::type; using Minus = BOOST_HANA_DISPATCH_IF(decltype(minus_impl<T, U>{}), hana::Group<T>::value && hana::Group<U>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Group<T>::value, "hana::minus(x, y) requires 'x' to be in a Group"); static_assert(hana::Group<U>::value, "hana::minus(x, y) requires 'y' to be in a Group"); #endif return Minus::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); } //! @endcond template <typename T, typename U, bool condition> struct minus_impl<T, U, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; template <typename T, bool condition> struct minus_impl<T, T, when<condition>> : default_ { template <typename X, typename Y> static constexpr decltype(auto) apply(X&& x, Y&& y) { return hana::plus(static_cast<X&&>(x), hana::negate(static_cast<Y&&>(y))); } }; // Cross-type overload template <typename T, typename U> struct minus_impl<T, U, when< detail::has_nontrivial_common_embedding<Group, T, U>::value >> { using C = typename common<T, U>::type; template <typename X, typename Y> static constexpr decltype(auto) apply(X&& x, Y&& y) { return hana::minus(hana::to<C>(static_cast<X&&>(x)), hana::to<C>(static_cast<Y&&>(y))); } }; ////////////////////////////////////////////////////////////////////////// // Model for arithmetic data types ////////////////////////////////////////////////////////////////////////// template <typename T> struct minus_impl<T, T, when<std::is_arithmetic<T>::value && !std::is_same<bool, T>::value>> { template <typename X, typename Y> static constexpr decltype(auto) apply(X&& x, Y&& y) { return static_cast<X&&>(x) - static_cast<Y&&>(y); } }; ////////////////////////////////////////////////////////////////////////// // Model for Constants over a Group ////////////////////////////////////////////////////////////////////////// namespace detail { template <typename C, typename X, typename Y> struct constant_from_minus { static constexpr auto value = hana::minus(hana::value<X>(), hana::value<Y>()); using hana_tag = detail::CanonicalConstant<typename C::value_type>; }; } template <typename C> struct minus_impl<C, C, when< hana::Constant<C>::value && Group<typename C::value_type>::value >> { template <typename X, typename Y> static constexpr decltype(auto) apply(X const&, Y const&) { return hana::to<C>(detail::constant_from_minus<C, X, Y>{}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_MINUS_HPP PK �\�[u��N. N. set.hppnu �[��� /*! @file Defines `boost::hana::set`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_SET_HPP #define BOOST_HANA_SET_HPP #include <boost/hana/fwd/set.hpp> #include <boost/hana/at.hpp> #include <boost/hana/bool.hpp> #include <boost/hana/concept/comparable.hpp> #include <boost/hana/concept/constant.hpp> #include <boost/hana/concept/hashable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/contains.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/core/to.hpp> #include <boost/hana/detail/decay.hpp> #include <boost/hana/detail/fast_and.hpp> #include <boost/hana/detail/has_duplicates.hpp> #include <boost/hana/detail/operators/adl.hpp> #include <boost/hana/detail/operators/comparable.hpp> #include <boost/hana/detail/operators/searchable.hpp> #include <boost/hana/equal.hpp> #include <boost/hana/erase_key.hpp> #include <boost/hana/find_if.hpp> #include <boost/hana/fold_left.hpp> #include <boost/hana/fwd/any_of.hpp> #include <boost/hana/fwd/core/to.hpp> #include <boost/hana/fwd/difference.hpp> #include <boost/hana/fwd/intersection.hpp> #include <boost/hana/fwd/union.hpp> #include <boost/hana/insert.hpp> #include <boost/hana/is_subset.hpp> #include <boost/hana/length.hpp> #include <boost/hana/or.hpp> #include <boost/hana/remove.hpp> #include <boost/hana/tuple.hpp> #include <boost/hana/unpack.hpp> #include <boost/hana/value.hpp> #include <cstddef> #include <type_traits> #include <utility> BOOST_HANA_NAMESPACE_BEGIN ////////////////////////////////////////////////////////////////////////// // set ////////////////////////////////////////////////////////////////////////// //! @cond template <typename ...Xs> struct set final : detail::operators::adl<set<Xs...>> , detail::searchable_operators<set<Xs...>> { tuple<Xs...> storage; using hana_tag = set_tag; static constexpr std::size_t size = sizeof...(Xs); explicit constexpr set(tuple<Xs...> const& xs) : storage(xs) { } explicit constexpr set(tuple<Xs...>&& xs) : storage(static_cast<tuple<Xs...>&&>(xs)) { } constexpr set() = default; constexpr set(set const& other) = default; constexpr set(set&& other) = default; }; //! @endcond ////////////////////////////////////////////////////////////////////////// // Operators ////////////////////////////////////////////////////////////////////////// namespace detail { template <> struct comparable_operators<set_tag> { static constexpr bool value = true; }; } ////////////////////////////////////////////////////////////////////////// // make<set_tag> ////////////////////////////////////////////////////////////////////////// template <> struct make_impl<set_tag> { template <typename ...Xs> static constexpr auto apply(Xs&& ...xs) { #if defined(BOOST_HANA_CONFIG_ENABLE_DEBUG_MODE) static_assert(detail::fast_and<hana::Comparable<Xs>::value...>::value, "hana::make_set(xs...) requires all the 'xs' to be Comparable"); static_assert(detail::fast_and<hana::Hashable<Xs>::value...>::value, "hana::make_set(xs...) requires all the 'xs' to be Hashable"); static_assert(detail::fast_and< Constant<decltype(hana::equal(xs, xs))>::value... >::value, "hana::make_set(xs...) requires all the 'xs' to be " "Comparable at compile-time"); static_assert(!detail::has_duplicates<Xs&&...>::value, "hana::make_set(xs...) requires all the 'xs' to be unique"); #endif return set<typename detail::decay<Xs>::type...>{ hana::make_tuple(static_cast<Xs&&>(xs)...) }; } }; ////////////////////////////////////////////////////////////////////////// // Comparable ////////////////////////////////////////////////////////////////////////// template <> struct equal_impl<set_tag, set_tag> { template <typename S1, typename S2> static constexpr auto equal_helper(S1 const& s1, S2 const& s2, hana::true_) { return hana::is_subset(s1, s2); } template <typename S1, typename S2> static constexpr auto equal_helper(S1 const&, S2 const&, hana::false_) { return hana::false_c; } template <typename S1, typename S2> static constexpr decltype(auto) apply(S1&& s1, S2&& s2) { return equal_impl::equal_helper(s1, s2, hana::bool_c< decltype(hana::length(s1.storage))::value == decltype(hana::length(s2.storage))::value >); } }; ////////////////////////////////////////////////////////////////////////// // Foldable ////////////////////////////////////////////////////////////////////////// template <> struct unpack_impl<set_tag> { template <typename Set, typename F> static constexpr decltype(auto) apply(Set&& set, F&& f) { return hana::unpack(static_cast<Set&&>(set).storage, static_cast<F&&>(f)); } }; ////////////////////////////////////////////////////////////////////////// // Searchable ////////////////////////////////////////////////////////////////////////// template <> struct find_if_impl<set_tag> { template <typename Xs, typename Pred> static constexpr auto apply(Xs&& xs, Pred&& pred) { return hana::find_if(static_cast<Xs&&>(xs).storage, static_cast<Pred&&>(pred)); } }; template <> struct any_of_impl<set_tag> { template <typename Pred> struct any_of_helper { Pred const& pred; template <typename ...X> constexpr auto operator()(X const& ...x) const { return hana::or_(pred(x)...); } constexpr auto operator()() const { return hana::false_c; } }; template <typename Xs, typename Pred> static constexpr auto apply(Xs const& xs, Pred const& pred) { return hana::unpack(xs.storage, any_of_helper<Pred>{pred}); } }; template <> struct is_subset_impl<set_tag, set_tag> { template <typename Ys> struct all_contained { Ys const& ys; template <typename ...X> constexpr auto operator()(X const& ...x) const { return hana::bool_c<detail::fast_and< hana::value<decltype(hana::contains(ys, x))>()... >::value>; } }; template <typename Xs, typename Ys> static constexpr auto apply(Xs const& xs, Ys const& ys) { return hana::unpack(xs, all_contained<Ys>{ys}); } }; ////////////////////////////////////////////////////////////////////////// // Conversions ////////////////////////////////////////////////////////////////////////// template <typename F> struct to_impl<set_tag, F, when<hana::Foldable<F>::value>> { template <typename Xs> static constexpr decltype(auto) apply(Xs&& xs) { return hana::fold_left(static_cast<Xs&&>(xs), hana::make_set(), hana::insert); } }; ////////////////////////////////////////////////////////////////////////// // insert ////////////////////////////////////////////////////////////////////////// template <> struct insert_impl<set_tag> { template <typename Xs, typename X, typename Indices> static constexpr auto insert_helper(Xs&& xs, X&&, hana::true_, Indices) { return static_cast<Xs&&>(xs); } template <typename Xs, typename X, std::size_t ...n> static constexpr auto insert_helper(Xs&& xs, X&& x, hana::false_, std::index_sequence<n...>) { return hana::make_set( hana::at_c<n>(static_cast<Xs&&>(xs).storage)..., static_cast<X&&>(x) ); } template <typename Xs, typename X> static constexpr auto apply(Xs&& xs, X&& x) { constexpr bool c = hana::value<decltype(hana::contains(xs, x))>(); constexpr std::size_t size = std::remove_reference<Xs>::type::size; return insert_helper(static_cast<Xs&&>(xs), static_cast<X&&>(x), hana::bool_c<c>, std::make_index_sequence<size>{}); } }; ////////////////////////////////////////////////////////////////////////// // erase_key ////////////////////////////////////////////////////////////////////////// template <> struct erase_key_impl<set_tag> { template <typename Xs, typename X> static constexpr decltype(auto) apply(Xs&& xs, X&& x) { return hana::unpack( hana::remove(static_cast<Xs&&>(xs).storage, static_cast<X&&>(x)), hana::make_set ); } }; ////////////////////////////////////////////////////////////////////////// // intersection ////////////////////////////////////////////////////////////////////////// namespace detail { template <typename Ys> struct set_insert_if_contains { Ys const& ys; template <typename Result, typename Key> static constexpr auto helper(Result&& result, Key&& key, hana::true_) { return hana::insert(static_cast<Result&&>(result), static_cast<Key&&>(key)); } template <typename Result, typename Key> static constexpr auto helper(Result&& result, Key&&, hana::false_) { return static_cast<Result&&>(result); } template <typename Result, typename Key> constexpr auto operator()(Result&& result, Key&& key) const { constexpr bool keep = hana::value<decltype(hana::contains(ys, key))>(); return set_insert_if_contains::helper(static_cast<Result&&>(result), static_cast<Key&&>(key), hana::bool_c<keep>); } }; } template <> struct intersection_impl<set_tag> { template <typename Xs, typename Ys> static constexpr auto apply(Xs&& xs, Ys const& ys) { return hana::fold_left(static_cast<Xs&&>(xs), hana::make_set(), detail::set_insert_if_contains<Ys>{ys}); } }; ////////////////////////////////////////////////////////////////////////// // union_ ////////////////////////////////////////////////////////////////////////// template <> struct union_impl<set_tag> { template <typename Xs, typename Ys> static constexpr auto apply(Xs&& xs, Ys&& ys) { return hana::fold_left(static_cast<Xs&&>(xs), static_cast<Ys&&>(ys), hana::insert); } }; ////////////////////////////////////////////////////////////////////////// // difference ////////////////////////////////////////////////////////////////////////// template <> struct difference_impl<set_tag> { template <typename Xs, typename Ys> static constexpr auto apply(Xs&& xs, Ys&& ys) { return hana::fold_left(static_cast<Ys&&>(ys), static_cast<Xs&&>(xs), hana::erase_key); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_SET_HPP PK �\�[��%AX AX map.hppnu �[��� /*! @file Defines `boost::hana::map`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_MAP_HPP #define BOOST_HANA_MAP_HPP #include <boost/hana/fwd/map.hpp> #include <boost/hana/all_of.hpp> #include <boost/hana/basic_tuple.hpp> #include <boost/hana/bool.hpp> #include <boost/hana/concept/comparable.hpp> #include <boost/hana/concept/constant.hpp> #include <boost/hana/concept/product.hpp> #include <boost/hana/config.hpp> #include <boost/hana/contains.hpp> #include <boost/hana/core/is_a.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/core/to.hpp> #include <boost/hana/detail/decay.hpp> #include <boost/hana/detail/fast_and.hpp> #include <boost/hana/detail/has_duplicates.hpp> #include <boost/hana/detail/hash_table.hpp> #include <boost/hana/detail/intrinsics.hpp> #include <boost/hana/detail/operators/adl.hpp> #include <boost/hana/detail/operators/comparable.hpp> #include <boost/hana/detail/operators/searchable.hpp> #include <boost/hana/equal.hpp> #include <boost/hana/find.hpp> #include <boost/hana/first.hpp> #include <boost/hana/fold_left.hpp> #include <boost/hana/functional/demux.hpp> #include <boost/hana/functional/on.hpp> #include <boost/hana/functional/partial.hpp> #include <boost/hana/fwd/any_of.hpp> #include <boost/hana/fwd/at_key.hpp> #include <boost/hana/fwd/difference.hpp> #include <boost/hana/fwd/erase_key.hpp> #include <boost/hana/fwd/intersection.hpp> #include <boost/hana/fwd/is_subset.hpp> #include <boost/hana/fwd/keys.hpp> #include <boost/hana/fwd/union.hpp> #include <boost/hana/insert.hpp> #include <boost/hana/integral_constant.hpp> #include <boost/hana/keys.hpp> #include <boost/hana/length.hpp> #include <boost/hana/optional.hpp> #include <boost/hana/remove_if.hpp> #include <boost/hana/second.hpp> #include <boost/hana/unpack.hpp> #include <boost/hana/value.hpp> #include <cstddef> #include <type_traits> #include <utility> BOOST_HANA_NAMESPACE_BEGIN ////////////////////////////////////////////////////////////////////////// // operators ////////////////////////////////////////////////////////////////////////// namespace detail { template <> struct comparable_operators<map_tag> { static constexpr bool value = true; }; } ////////////////////////////////////////////////////////////////////////// // map ////////////////////////////////////////////////////////////////////////// //! @cond namespace detail { template <typename ...> struct storage_is_default_constructible; template <typename ...T> struct storage_is_default_constructible<hana::basic_tuple<T...>> { static constexpr bool value = detail::fast_and< BOOST_HANA_TT_IS_CONSTRUCTIBLE(T)... >::value; }; template <typename ...> struct storage_is_copy_constructible; template <typename ...T> struct storage_is_copy_constructible<hana::basic_tuple<T...>> { static constexpr bool value = detail::fast_and< BOOST_HANA_TT_IS_CONSTRUCTIBLE(T, T const&)... >::value; }; template <typename ...> struct storage_is_move_constructible; template <typename ...T> struct storage_is_move_constructible<hana::basic_tuple<T...>> { static constexpr bool value = detail::fast_and< BOOST_HANA_TT_IS_CONSTRUCTIBLE(T, T&&)... >::value; }; template <typename ...> struct storage_is_copy_assignable; template <typename ...T> struct storage_is_copy_assignable<hana::basic_tuple<T...>> { static constexpr bool value = detail::fast_and< BOOST_HANA_TT_IS_ASSIGNABLE(T, T const&)... >::value; }; template <typename ...> struct storage_is_move_assignable; template <typename ...T> struct storage_is_move_assignable<hana::basic_tuple<T...>> { static constexpr bool value = detail::fast_and< BOOST_HANA_TT_IS_ASSIGNABLE(T, T&&)... >::value; }; template <typename HashTable, typename Storage> struct map_impl final : detail::searchable_operators<map_impl<HashTable, Storage>> , detail::operators::adl<map_impl<HashTable, Storage>> { using hash_table_type = HashTable; using storage_type = Storage; Storage storage; using hana_tag = map_tag; template <typename ...P, typename = typename std::enable_if< std::is_same< Storage, hana::basic_tuple<typename detail::decay<P>::type...> >::value >::type> explicit constexpr map_impl(P&& ...pairs) : storage{static_cast<P&&>(pairs)...} { } explicit constexpr map_impl(Storage&& xs) : storage(static_cast<Storage&&>(xs)) { } template <typename ...Dummy, typename = typename std::enable_if< detail::storage_is_default_constructible<Storage, Dummy...>::value >::type> constexpr map_impl() : storage() { } template <typename ...Dummy, typename = typename std::enable_if< detail::storage_is_copy_constructible<Storage, Dummy...>::value >::type> constexpr map_impl(map_impl const& other) : storage(other.storage) { } template <typename ...Dummy, typename = typename std::enable_if< detail::storage_is_move_constructible<Storage, Dummy...>::value >::type> constexpr map_impl(map_impl&& other) : storage(static_cast<Storage&&>(other.storage)) { } template <typename ...Dummy, typename = typename std::enable_if< detail::storage_is_move_assignable<Storage, Dummy...>::value >::type> constexpr map_impl& operator=(map_impl&& other) { storage = static_cast<Storage&&>(other.storage); return *this; } template <typename ...Dummy, typename = typename std::enable_if< detail::storage_is_copy_assignable<Storage, Dummy...>::value >::type> constexpr map_impl& operator=(map_impl const& other) { storage = other.storage; return *this; } // Prevent the compiler from defining the default copy and move // constructors, which interfere with the SFINAE above. ~map_impl() = default; }; //! @endcond template <typename Storage> struct KeyAtIndex { template <std::size_t i> using apply = decltype(hana::first(hana::at_c<i>(std::declval<Storage>()))); }; template <typename ...Pairs> struct make_map_type { using Storage = hana::basic_tuple<Pairs...>; using HashTable = typename detail::make_hash_table< detail::KeyAtIndex<Storage>::template apply, sizeof...(Pairs) >::type; using type = detail::map_impl<HashTable, Storage>; }; } ////////////////////////////////////////////////////////////////////////// // make<map_tag> ////////////////////////////////////////////////////////////////////////// template <> struct make_impl<map_tag> { template <typename ...Pairs> static constexpr auto apply(Pairs&& ...pairs) { #if defined(BOOST_HANA_CONFIG_ENABLE_DEBUG_MODE) static_assert(detail::fast_and<hana::Product<Pairs>::value...>::value, "hana::make_map(pairs...) requires all the 'pairs' to be Products"); static_assert(detail::fast_and< hana::Comparable<decltype(hana::first(pairs))>::value... >::value, "hana::make_map(pairs...) requires all the keys to be Comparable"); static_assert(detail::fast_and< hana::Constant< decltype(hana::equal(hana::first(pairs), hana::first(pairs))) >::value... >::value, "hana::make_map(pairs...) requires all the keys to be " "Comparable at compile-time"); //! @todo //! This can be implemented more efficiently by doing the check //! inside each bucket instead. static_assert(!detail::has_duplicates<decltype(hana::first(pairs))...>::value, "hana::make_map({keys, values}...) requires all the keys to be unique"); static_assert(!detail::has_duplicates<decltype(hana::hash(hana::first(pairs)))...>::value, "hana::make_map({keys, values}...) requires all the keys to have different hashes"); #endif using Map = typename detail::make_map_type<typename detail::decay<Pairs>::type...>::type; return Map{hana::make_basic_tuple(static_cast<Pairs&&>(pairs)...)}; } }; ////////////////////////////////////////////////////////////////////////// // keys ////////////////////////////////////////////////////////////////////////// template <> struct keys_impl<map_tag> { template <typename Map> static constexpr decltype(auto) apply(Map&& map) { return hana::transform(static_cast<Map&&>(map).storage, hana::first); } }; ////////////////////////////////////////////////////////////////////////// // values ////////////////////////////////////////////////////////////////////////// //! @cond template <typename Map> constexpr decltype(auto) values_t::operator()(Map&& map) const { return hana::transform(static_cast<Map&&>(map).storage, hana::second); } //! @endcond ////////////////////////////////////////////////////////////////////////// // insert ////////////////////////////////////////////////////////////////////////// template <> struct insert_impl<map_tag> { template <typename Map, typename Pair> static constexpr auto helper(Map&& map, Pair&& pair, ...) { using RawMap = typename std::remove_reference<Map>::type; using HashTable = typename RawMap::hash_table_type; using NewHashTable = typename detail::bucket_insert< HashTable, decltype(hana::first(pair)), decltype(hana::length(map.storage))::value >::type; using NewStorage = decltype( hana::append(static_cast<Map&&>(map).storage, static_cast<Pair&&>(pair)) ); return detail::map_impl<NewHashTable, NewStorage>( hana::append(static_cast<Map&&>(map).storage, static_cast<Pair&&>(pair)) ); } template <typename Map, typename Pair, std::size_t i> static constexpr auto helper(Map&& map, Pair&&, hana::optional<std::integral_constant<std::size_t, i>>) { return static_cast<Map&&>(map); } //! @todo //! Here, we insert only if the key is not already in the map. //! This should be handled by `bucket_insert`, and that would also //! be more efficient. template <typename Map, typename Pair> static constexpr auto apply(Map&& map, Pair&& pair) { using RawMap = typename std::remove_reference<Map>::type; using Storage = typename RawMap::storage_type; using HashTable = typename RawMap::hash_table_type; using Key = decltype(hana::first(pair)); using MaybeIndex = typename detail::find_index< HashTable, Key, detail::KeyAtIndex<Storage>::template apply >::type; return helper(static_cast<Map&&>(map), static_cast<Pair&&>(pair), MaybeIndex{}); } }; ////////////////////////////////////////////////////////////////////////// // erase_key ////////////////////////////////////////////////////////////////////////// template <> struct erase_key_impl<map_tag> { //! @todo //! We could implement some kind of `bucket_erase` metafunction //! that would be much more efficient than this. template <typename Map, typename Key> static constexpr auto erase_key_helper(Map&& map, Key const&, hana::false_) { return static_cast<Map&&>(map); } template <typename Map, typename Key> static constexpr auto erase_key_helper(Map&& map, Key const& key, hana::true_) { return hana::unpack( hana::remove_if(static_cast<Map&&>(map).storage, hana::on(hana::equal.to(key), hana::first)), hana::make_map ); } template <typename Map, typename Key> static constexpr auto apply_impl(Map&& map, Key const& key, hana::false_) { return erase_key_helper(static_cast<Map&&>(map), key, hana::contains(map, key)); } template <typename Map, typename Key> static constexpr auto apply_impl(Map&& map, Key const&, hana::true_) { return static_cast<Map&&>(map); } template <typename Map, typename Key> static constexpr auto apply(Map&& map, Key const& key) { constexpr bool is_empty = decltype(hana::length(map))::value == 0; return apply_impl(static_cast<Map&&>(map), key, hana::bool_<is_empty>{}); } }; ////////////////////////////////////////////////////////////////////////// // Comparable ////////////////////////////////////////////////////////////////////////// template <> struct equal_impl<map_tag, map_tag> { template <typename M1, typename M2> static constexpr auto equal_helper(M1 const&, M2 const&, hana::false_) { return hana::false_c; } template <typename M1, typename M2> static constexpr auto equal_helper(M1 const& m1, M2 const& m2, hana::true_) { return hana::all_of(hana::keys(m1), hana::demux(equal)( hana::partial(hana::find, m1), hana::partial(hana::find, m2) )); } template <typename M1, typename M2> static constexpr auto apply(M1 const& m1, M2 const& m2) { return equal_impl::equal_helper(m1, m2, hana::bool_c< decltype(hana::length(m1.storage))::value == decltype(hana::length(m2.storage))::value >); } }; ////////////////////////////////////////////////////////////////////////// // Searchable ////////////////////////////////////////////////////////////////////////// template <> struct find_impl<map_tag> { template <typename Map> static constexpr auto find_helper(Map&&, ...) { return hana::nothing; } template <typename Map, std::size_t i> static constexpr auto find_helper(Map&& map, hana::optional<std::integral_constant<std::size_t, i>>) { return hana::just(hana::second(hana::at_c<i>(static_cast<Map&&>(map).storage))); } template <typename Map, typename Key> static constexpr auto apply(Map&& map, Key const&) { using RawMap = typename std::remove_reference<Map>::type; using Storage = typename RawMap::storage_type; using HashTable = typename RawMap::hash_table_type; using MaybeIndex = typename detail::find_index< HashTable, Key, detail::KeyAtIndex<Storage>::template apply >::type; return find_helper(static_cast<Map&&>(map), MaybeIndex{}); } }; template <> struct find_if_impl<map_tag> { template <typename M, typename Pred> static constexpr auto apply(M&& map, Pred&& pred) { return hana::transform( hana::find_if(static_cast<M&&>(map).storage, hana::compose(static_cast<Pred&&>(pred), hana::first)), hana::second ); } }; template <> struct contains_impl<map_tag> { template <typename Map, typename Key> static constexpr auto apply(Map const&, Key const&) { using RawMap = typename std::remove_reference<Map>::type; using HashTable = typename RawMap::hash_table_type; using Storage = typename RawMap::storage_type; using MaybeIndex = typename detail::find_index< HashTable, Key, detail::KeyAtIndex<Storage>::template apply >::type; return hana::bool_<!decltype(hana::is_nothing(MaybeIndex{}))::value>{}; } }; template <> struct any_of_impl<map_tag> { template <typename M, typename Pred> static constexpr auto apply(M const& map, Pred const& pred) { return hana::any_of(hana::keys(map), pred); } }; template <> struct is_subset_impl<map_tag, map_tag> { template <typename Ys> struct all_contained { Ys const& ys; template <typename ...X> constexpr auto operator()(X const& ...x) const { return hana::bool_c<detail::fast_and< hana::value<decltype(hana::contains(ys, x))>()... >::value>; } }; template <typename Xs, typename Ys> static constexpr auto apply(Xs const& xs, Ys const& ys) { auto ys_keys = hana::keys(ys); return hana::unpack(hana::keys(xs), all_contained<decltype(ys_keys)>{ys_keys}); } }; template <> struct at_key_impl<map_tag> { template <typename Map, typename Key> static constexpr decltype(auto) apply(Map&& map, Key const&) { using RawMap = typename std::remove_reference<Map>::type; using HashTable = typename RawMap::hash_table_type; using Storage = typename RawMap::storage_type; using MaybeIndex = typename detail::find_index< HashTable, Key, detail::KeyAtIndex<Storage>::template apply >::type; static_assert(!decltype(hana::is_nothing(MaybeIndex{}))::value, "hana::at_key(map, key) requires the 'key' to be present in the 'map'"); constexpr std::size_t index = decltype(*MaybeIndex{}){}(); return hana::second(hana::at_c<index>(static_cast<Map&&>(map).storage)); } }; ////////////////////////////////////////////////////////////////////////// // union_ ////////////////////////////////////////////////////////////////////////// template <> struct union_impl<map_tag> { template <typename Xs, typename Ys> static constexpr auto apply(Xs&& xs, Ys&& ys) { return hana::fold_left(static_cast<Xs&&>(xs), static_cast<Ys&&>(ys), hana::insert); } }; ////////////////////////////////////////////////////////////////////////// // intersection_ ////////////////////////////////////////////////////////////////////////// namespace detail { template <typename Ys> struct map_insert_if_contains { Ys const& ys; // Second template param will be pair // Get its key and check if it exists, if it does, insert key, value pair. template <typename Result, typename Pair> static constexpr auto helper(Result&& result, Pair&& pair, hana::true_) { return hana::insert(static_cast<Result&&>(result), static_cast<Pair&&>(pair)); } template <typename Result, typename Pair> static constexpr auto helper(Result&& result, Pair&&, hana::false_) { return static_cast<Result&&>(result); } template <typename Result, typename Pair> constexpr auto operator()(Result&& result, Pair&& pair) const { constexpr bool keep = hana::value<decltype(hana::contains(ys, hana::first(pair)))>(); return map_insert_if_contains::helper(static_cast<Result&&>(result), static_cast<Pair&&>(pair), hana::bool_c<keep>); } }; } template <> struct intersection_impl<map_tag> { template <typename Xs, typename Ys> static constexpr auto apply(Xs&& xs, Ys const& ys) { return hana::fold_left(static_cast<Xs&&>(xs), hana::make_map(), detail::map_insert_if_contains<Ys>{ys}); } }; ////////////////////////////////////////////////////////////////////////// // difference ////////////////////////////////////////////////////////////////////////// template <> struct difference_impl<map_tag> { template <typename Xs, typename Ys> static constexpr auto apply(Xs&& xs, Ys&& ys) { return hana::fold_left( hana::keys(static_cast<Ys&&>(ys)), static_cast<Xs&&>(xs), hana::erase_key); } }; ////////////////////////////////////////////////////////////////////////// // Foldable ////////////////////////////////////////////////////////////////////////// template <> struct unpack_impl<map_tag> { template <typename M, typename F> static constexpr decltype(auto) apply(M&& map, F&& f) { return hana::unpack(static_cast<M&&>(map).storage, static_cast<F&&>(f)); } }; ////////////////////////////////////////////////////////////////////////// // Construction from a Foldable ////////////////////////////////////////////////////////////////////////// template <typename F> struct to_impl<map_tag, F, when<hana::Foldable<F>::value>> { template <typename Xs> static constexpr decltype(auto) apply(Xs&& xs) { return hana::fold_left( static_cast<Xs&&>(xs), hana::make_map(), hana::insert ); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_MAP_HPP PK �\�[[ϣl� � div.hppnu �[��� /*! @file Defines `boost::hana::div`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DIV_HPP #define BOOST_HANA_DIV_HPP #include <boost/hana/fwd/div.hpp> #include <boost/hana/concept/constant.hpp> #include <boost/hana/concept/euclidean_ring.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/to.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/canonical_constant.hpp> #include <boost/hana/detail/has_common_embedding.hpp> #include <boost/hana/value.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename X, typename Y> constexpr decltype(auto) div_t::operator()(X&& x, Y&& y) const { using T = typename hana::tag_of<X>::type; using U = typename hana::tag_of<Y>::type; using Div = BOOST_HANA_DISPATCH_IF(decltype(div_impl<T, U>{}), hana::EuclideanRing<T>::value && hana::EuclideanRing<U>::value && !is_default<div_impl<T, U>>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::EuclideanRing<T>::value, "hana::div(x, y) requires 'x' to be an EuclideanRing"); static_assert(hana::EuclideanRing<U>::value, "hana::div(x, y) requires 'y' to be an EuclideanRing"); static_assert(!is_default<div_impl<T, U>>::value, "hana::div(x, y) requires 'x' and 'y' to be embeddable " "in a common EuclideanRing"); #endif return Div::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); } //! @endcond template <typename T, typename U, bool condition> struct div_impl<T, U, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; // Cross-type overload template <typename T, typename U> struct div_impl<T, U, when< detail::has_nontrivial_common_embedding<EuclideanRing, T, U>::value >> { using C = typename common<T, U>::type; template <typename X, typename Y> static constexpr decltype(auto) apply(X&& x, Y&& y) { return hana::div(hana::to<C>(static_cast<X&&>(x)), hana::to<C>(static_cast<Y&&>(y))); } }; ////////////////////////////////////////////////////////////////////////// // Model for integral data types ////////////////////////////////////////////////////////////////////////// template <typename T> struct div_impl<T, T, when<std::is_integral<T>::value && !std::is_same<T, bool>::value>> { template <typename X, typename Y> static constexpr decltype(auto) apply(X&& x, Y&& y) { return static_cast<X&&>(x) / static_cast<Y&&>(y); } }; ////////////////////////////////////////////////////////////////////////// // Model for Constants over an EuclideanRing ////////////////////////////////////////////////////////////////////////// namespace detail { template <typename C, typename X, typename Y> struct constant_from_div { static constexpr auto value = hana::div(hana::value<X>(), hana::value<Y>()); using hana_tag = detail::CanonicalConstant<typename C::value_type>; }; } template <typename C> struct div_impl<C, C, when< hana::Constant<C>::value && EuclideanRing<typename C::value_type>::value >> { template <typename X, typename Y> static constexpr decltype(auto) apply(X const&, Y const&) { return hana::to<C>(detail::constant_from_div<C, X, Y>{}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DIV_HPP PK �\�[2�� � hash.hppnu �[��� /*! @file Defines `boost::hana::hash`. @copyright Jason Rice 2016 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_HASH_HPP #define BOOST_HANA_HASH_HPP #include <boost/hana/fwd/hash.hpp> #include <boost/hana/concept/hashable.hpp> #include <boost/hana/concept/integral_constant.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/fwd/integral_constant.hpp> #include <boost/hana/type.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename X> constexpr auto hash_t::operator()(X const& x) const { using Tag = typename hana::tag_of<X>::type; using Hash = BOOST_HANA_DISPATCH_IF(hash_impl<Tag>, hana::Hashable<Tag>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Hashable<Tag>::value, "hana::hash(x) requires 'x' to be Hashable"); #endif return Hash::apply(x); } //! @endcond template <typename Tag, bool condition> struct hash_impl<Tag, when<condition>> : default_ { template <typename X> static constexpr auto apply(X const&) = delete; }; namespace detail { template <typename T, typename = void> struct hash_integral_helper; template <typename Member, typename T> struct hash_integral_helper<Member T::*> { template <typename X> static constexpr auto apply(X const&) { return hana::type_c<hana::integral_constant<Member T::*, X::value>>; } }; template <typename T> struct hash_integral_helper<T, typename std::enable_if<std::is_signed<T>::value>::type > { template <typename X> static constexpr auto apply(X const&) { constexpr signed long long x = X::value; return hana::type_c<hana::integral_constant<signed long long, x>>; } }; template <typename T> struct hash_integral_helper<T, typename std::enable_if<std::is_unsigned<T>::value>::type > { template <typename X> static constexpr auto apply(X const&) { constexpr unsigned long long x = X::value; return hana::type_c<hana::integral_constant<unsigned long long, x>>; } }; template <> struct hash_integral_helper<bool> { template <typename X> static constexpr auto apply(X const&) { return hana::type_c<hana::integral_constant<bool, X::value>>; } }; template <> struct hash_integral_helper<char> { template <typename X> static constexpr auto apply(X const&) { using T = std::conditional<std::is_signed<char>::value, signed long long, unsigned long long >::type; constexpr T x = X::value; return hana::type_c<hana::integral_constant<T, x>>; } }; } template <typename Tag> struct hash_impl<Tag, when<hana::IntegralConstant<Tag>::value>> { template <typename X> static constexpr auto apply(X const& x) { using T = typename std::remove_cv<decltype(X::value)>::type; return detail::hash_integral_helper<T>::apply(x); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_HASH_HPP PK �\�[���� � take_front.hppnu �[��� /*! @file Defines `boost::hana::take_front` and `boost::hana::take_front_c`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_TAKE_FRONT_HPP #define BOOST_HANA_TAKE_FRONT_HPP #include <boost/hana/fwd/take_front.hpp> #include <boost/hana/at.hpp> #include <boost/hana/concept/integral_constant.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/integral_constant.hpp> #include <boost/hana/length.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename N> constexpr auto take_front_t::operator()(Xs&& xs, N const& n) const { using S = typename hana::tag_of<Xs>::type; using TakeFront = BOOST_HANA_DISPATCH_IF(take_front_impl<S>, hana::Sequence<S>::value && hana::IntegralConstant<N>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Sequence<S>::value, "hana::take_front(xs, n) requires 'xs' to be a Sequence"); static_assert(hana::IntegralConstant<N>::value, "hana::take_front(xs, n) requires 'n' to be an IntegralConstant"); #endif return TakeFront::apply(static_cast<Xs&&>(xs), n); } //! @endcond template <typename S, bool condition> struct take_front_impl<S, when<condition>> : default_ { template <typename Xs, std::size_t ...n> static constexpr auto take_front_helper(Xs&& xs, std::index_sequence<n...>) { return hana::make<S>(hana::at_c<n>(static_cast<Xs&&>(xs))...); } template <typename Xs, typename N> static constexpr auto apply(Xs&& xs, N const&) { constexpr std::size_t n = N::value; constexpr std::size_t size = decltype(hana::length(xs))::value; return take_front_helper(static_cast<Xs&&>(xs), std::make_index_sequence<(n < size ? n : size)>{}); } }; template <std::size_t n> struct take_front_c_t { template <typename Xs> constexpr auto operator()(Xs&& xs) const { return hana::take_front(static_cast<Xs&&>(xs), hana::size_c<n>); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_TAKE_FRONT_HPP PK �\�[{��H/ / suffix.hppnu �[��� /*! @file Defines `boost::hana::suffix`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_SUFFIX_HPP #define BOOST_HANA_SUFFIX_HPP #include <boost/hana/fwd/suffix.hpp> #include <boost/hana/chain.hpp> #include <boost/hana/concept/monad_plus.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/functional/partial.hpp> #include <boost/hana/lift.hpp> #include <boost/hana/prepend.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Sfx> constexpr auto suffix_t::operator()(Xs&& xs, Sfx&& sfx) const { using M = typename hana::tag_of<Xs>::type; using Suffix = BOOST_HANA_DISPATCH_IF(suffix_impl<M>, hana::MonadPlus<M>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::MonadPlus<M>::value, "hana::suffix(xs, sfx) requires 'xs' to be a MonadPlus"); #endif return Suffix::apply(static_cast<Xs&&>(xs), static_cast<Sfx&&>(sfx)); } //! @endcond template <typename M, bool condition> struct suffix_impl<M, when<condition>> : default_ { template <typename Xs, typename Z> static constexpr auto apply(Xs&& xs, Z&& z) { return hana::chain(static_cast<Xs&&>(xs), hana::partial(hana::prepend, hana::lift<M>(static_cast<Z&&>(z)))); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_SUFFIX_HPP PK �\�[&; ( eval.hppnu �[��� /*! @file Defines `boost::hana::eval`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EVAL_HPP #define BOOST_HANA_EVAL_HPP #include <boost/hana/fwd/eval.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/wrong.hpp> #include <boost/hana/functional/id.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Expr> constexpr decltype(auto) eval_t::operator()(Expr&& expr) const { return eval_impl<typename hana::tag_of<Expr>::type>::apply( static_cast<Expr&&>(expr) ); } //! @endcond template <typename T, bool condition> struct eval_impl<T, when<condition>> : default_ { template <typename Expr> static constexpr auto eval_helper(Expr&& expr, int) -> decltype(static_cast<Expr&&>(expr)()) { return static_cast<Expr&&>(expr)(); } template <typename Expr> static constexpr auto eval_helper(Expr&& expr, long) -> decltype(static_cast<Expr&&>(expr)(hana::id)) { return static_cast<Expr&&>(expr)(hana::id); } template <typename Expr> static constexpr auto eval_helper(Expr&&, ...) { static_assert(detail::wrong<Expr>{}, "hana::eval(expr) requires the expression to be a hana::lazy, " "a nullary Callable or a unary Callable that may be " "called with hana::id"); } template <typename Expr> static constexpr decltype(auto) apply(Expr&& expr) { return eval_helper(static_cast<Expr&&>(expr), int{}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_EVAL_HPP PK �\�[N� xE E span.hppnu �[��� /*! @file Defines `boost::hana::span`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_SPAN_HPP #define BOOST_HANA_SPAN_HPP #include <boost/hana/fwd/span.hpp> #include <boost/hana/at.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/detail/nested_by.hpp> // required by fwd decl #include <boost/hana/detail/first_unsatisfied_index.hpp> #include <boost/hana/length.hpp> #include <boost/hana/pair.hpp> #include <boost/hana/unpack.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Pred> constexpr auto span_t::operator()(Xs&& xs, Pred&& pred) const { using S = typename hana::tag_of<Xs>::type; using Span = BOOST_HANA_DISPATCH_IF(span_impl<S>, hana::Sequence<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Sequence<S>::value, "hana::span(xs, pred) requires 'xs' to be a Sequence"); #endif return Span::apply(static_cast<Xs&&>(xs), static_cast<Pred&&>(pred)); } //! @endcond template <typename S, bool condition> struct span_impl<S, when<condition>> : default_ { template <typename Xs, std::size_t ...before, std::size_t ...after> static constexpr auto span_helper(Xs&& xs, std::index_sequence<before...>, std::index_sequence<after...>) { return hana::make_pair( hana::make<S>(hana::at_c<before>(static_cast<Xs&&>(xs))...), hana::make<S>(hana::at_c<sizeof...(before) + after>(static_cast<Xs&&>(xs))...) ); } template <typename Xs, typename Pred> static constexpr auto apply(Xs&& xs, Pred&&) { using FirstUnsatisfied = decltype( hana::unpack(static_cast<Xs&&>(xs), detail::first_unsatisfied_index<Pred&&>{}) ); constexpr std::size_t breakpoint = FirstUnsatisfied::value; constexpr std::size_t N = decltype(hana::length(xs))::value; return span_helper(static_cast<Xs&&>(xs), std::make_index_sequence<breakpoint>{}, std::make_index_sequence<N - breakpoint>{}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_SPAN_HPP PK �\�[�fd�= = prefix.hppnu �[��� /*! @file Defines `boost::hana::prefix`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_PREFIX_HPP #define BOOST_HANA_PREFIX_HPP #include <boost/hana/fwd/prefix.hpp> #include <boost/hana/append.hpp> #include <boost/hana/chain.hpp> #include <boost/hana/concept/monad_plus.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/functional/partial.hpp> #include <boost/hana/lift.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Pref> constexpr auto prefix_t::operator()(Xs&& xs, Pref&& pref) const { using M = typename hana::tag_of<Xs>::type; using Prefix = BOOST_HANA_DISPATCH_IF(prefix_impl<M>, hana::MonadPlus<M>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::MonadPlus<M>::value, "hana::prefix(xs, pref) requires 'xs' to be a MonadPlus"); #endif return Prefix::apply(static_cast<Xs&&>(xs), static_cast<Pref&&>(pref)); } //! @endcond template <typename M, bool condition> struct prefix_impl<M, when<condition>> : default_ { template <typename Xs, typename Z> static constexpr decltype(auto) apply(Xs&& xs, Z&& z) { return hana::chain(static_cast<Xs&&>(xs), hana::partial(hana::append, hana::lift<M>(static_cast<Z&&>(z)))); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_PREFIX_HPP PK �\�[�:#� drop_front.hppnu �[��� /*! @file Defines `boost::hana::drop_front`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DROP_FRONT_HPP #define BOOST_HANA_DROP_FRONT_HPP #include <boost/hana/fwd/drop_front.hpp> #include <boost/hana/concept/integral_constant.hpp> #include <boost/hana/concept/iterable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/integral_constant.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename N> constexpr auto drop_front_t::operator()(Xs&& xs, N const& n) const { using It = typename hana::tag_of<Xs>::type; using DropFront = BOOST_HANA_DISPATCH_IF(drop_front_impl<It>, hana::Iterable<It>::value && hana::IntegralConstant<N>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Iterable<It>::value, "hana::drop_front(xs, n) requires 'xs' to be an Iterable"); static_assert(hana::IntegralConstant<N>::value, "hana::drop_front(xs, n) requires 'n' to be an IntegralConstant"); #endif return DropFront::apply(static_cast<Xs&&>(xs), n); } template <typename Xs> constexpr auto drop_front_t::operator()(Xs&& xs) const { return (*this)(static_cast<Xs&&>(xs), hana::size_t<1>{}); } //! @endcond template <typename It, bool condition> struct drop_front_impl<It, when<condition>> : default_ { template <typename Xs, typename N> static constexpr auto apply(Xs&&, N const&) = delete; }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DROP_FRONT_HPP PK �\�[�$~� reverse.hppnu �[��� /*! @file Defines `boost::hana::reverse`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_REVERSE_HPP #define BOOST_HANA_REVERSE_HPP #include <boost/hana/fwd/reverse.hpp> #include <boost/hana/at.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/length.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs> constexpr auto reverse_t::operator()(Xs&& xs) const { using S = typename hana::tag_of<Xs>::type; using Reverse = BOOST_HANA_DISPATCH_IF(reverse_impl<S>, hana::Sequence<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Sequence<S>::value, "hana::reverse(xs) requires 'xs' to be a Sequence"); #endif return Reverse::apply(static_cast<Xs&&>(xs)); } //! @endcond template <typename S, bool condition> struct reverse_impl<S, when<condition>> : default_ { template <typename Xs, std::size_t ...i> static constexpr auto reverse_helper(Xs&& xs, std::index_sequence<i...>) { return hana::make<S>( hana::at_c<sizeof...(i) - i - 1>(static_cast<Xs&&>(xs))... ); } template <typename Xs> static constexpr auto apply(Xs&& xs) { constexpr std::size_t N = decltype(hana::length(xs))::value; return reverse_helper(static_cast<Xs&&>(xs), std::make_index_sequence<N>{}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_REVERSE_HPP PK �\�[����$ �$ basic_tuple.hppnu �[��� /*! @file Defines `boost::hana::basic_tuple`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_BASIC_TUPLE_HPP #define BOOST_HANA_BASIC_TUPLE_HPP #include <boost/hana/fwd/basic_tuple.hpp> #include <boost/hana/config.hpp> #include <boost/hana/detail/decay.hpp> #include <boost/hana/detail/ebo.hpp> #include <boost/hana/fwd/at.hpp> #include <boost/hana/fwd/bool.hpp> #include <boost/hana/fwd/concept/sequence.hpp> #include <boost/hana/fwd/core/make.hpp> #include <boost/hana/fwd/core/tag_of.hpp> #include <boost/hana/fwd/drop_front.hpp> #include <boost/hana/fwd/integral_constant.hpp> #include <boost/hana/fwd/is_empty.hpp> #include <boost/hana/fwd/length.hpp> #include <boost/hana/fwd/transform.hpp> #include <boost/hana/fwd/unpack.hpp> #include <cstddef> #include <type_traits> #include <utility> BOOST_HANA_NAMESPACE_BEGIN namespace detail { ////////////////////////////////////////////////////////////////////// // basic_tuple_impl<n, Xn> ////////////////////////////////////////////////////////////////////// template <std::size_t> struct bti; // basic_tuple_index struct from_other { }; template <typename Indices, typename ...Xn> #ifdef BOOST_HANA_WORKAROUND_MSVC_EMPTYBASE struct __declspec(empty_bases) basic_tuple_impl; #else struct basic_tuple_impl; #endif template <std::size_t ...n, typename ...Xn> #ifdef BOOST_HANA_WORKAROUND_MSVC_EMPTYBASE struct __declspec(empty_bases) basic_tuple_impl<std::index_sequence<n...>, Xn...> #else struct basic_tuple_impl<std::index_sequence<n...>, Xn...> #endif : detail::ebo<bti<n>, Xn>... { static constexpr std::size_t size_ = sizeof...(Xn); constexpr basic_tuple_impl() = default; template <typename Other> explicit constexpr basic_tuple_impl(detail::from_other, Other&& other) : detail::ebo<bti<n>, Xn>(detail::ebo_get<bti<n>>(static_cast<Other&&>(other)))... { } template <typename ...Yn> explicit constexpr basic_tuple_impl(Yn&& ...yn) : detail::ebo<bti<n>, Xn>(static_cast<Yn&&>(yn))... { } }; } ////////////////////////////////////////////////////////////////////////// // basic_tuple ////////////////////////////////////////////////////////////////////////// //! @cond template <typename ...Xn> struct basic_tuple final : detail::basic_tuple_impl<std::make_index_sequence<sizeof...(Xn)>, Xn...> { using Base = detail::basic_tuple_impl<std::make_index_sequence<sizeof...(Xn)>, Xn...>; constexpr basic_tuple() = default; // copy constructor template <typename Other, typename = typename std::enable_if< std::is_same<typename detail::decay<Other>::type, basic_tuple>::value >::type> constexpr basic_tuple(Other&& other) : Base(detail::from_other{}, static_cast<Other&&>(other)) { } template <typename ...Yn> explicit constexpr basic_tuple(Yn&& ...yn) : Base(static_cast<Yn&&>(yn)...) { } }; //! @endcond template <typename ...Xn> struct tag_of<basic_tuple<Xn...>> { using type = basic_tuple_tag; }; ////////////////////////////////////////////////////////////////////////// // Foldable ////////////////////////////////////////////////////////////////////////// template <> struct unpack_impl<basic_tuple_tag> { template <std::size_t ...i, typename ...Xn, typename F> static constexpr decltype(auto) apply(detail::basic_tuple_impl<std::index_sequence<i...>, Xn...> const& xs, F&& f) { return static_cast<F&&>(f)( detail::ebo_get<detail::bti<i>>( static_cast<detail::ebo<detail::bti<i>, Xn> const&>(xs) )... ); } template <std::size_t ...i, typename ...Xn, typename F> static constexpr decltype(auto) apply(detail::basic_tuple_impl<std::index_sequence<i...>, Xn...>& xs, F&& f) { return static_cast<F&&>(f)( detail::ebo_get<detail::bti<i>>( static_cast<detail::ebo<detail::bti<i>, Xn>&>(xs) )... ); } template <std::size_t ...i, typename ...Xn, typename F> static constexpr decltype(auto) apply(detail::basic_tuple_impl<std::index_sequence<i...>, Xn...>&& xs, F&& f) { return static_cast<F&&>(f)( detail::ebo_get<detail::bti<i>>( static_cast<detail::ebo<detail::bti<i>, Xn>&&>(xs) )... ); } }; ////////////////////////////////////////////////////////////////////////// // Functor ////////////////////////////////////////////////////////////////////////// template <> struct transform_impl<basic_tuple_tag> { template <std::size_t ...i, typename ...Xn, typename F> static constexpr auto apply(detail::basic_tuple_impl<std::index_sequence<i...>, Xn...> const& xs, F const& f) { return hana::make_basic_tuple( f(detail::ebo_get<detail::bti<i>>( static_cast<detail::ebo<detail::bti<i>, Xn> const&>(xs) ))... ); } template <std::size_t ...i, typename ...Xn, typename F> static constexpr auto apply(detail::basic_tuple_impl<std::index_sequence<i...>, Xn...>& xs, F const& f) { return hana::make_basic_tuple( f(detail::ebo_get<detail::bti<i>>( static_cast<detail::ebo<detail::bti<i>, Xn>&>(xs) ))... ); } template <std::size_t ...i, typename ...Xn, typename F> static constexpr auto apply(detail::basic_tuple_impl<std::index_sequence<i...>, Xn...>&& xs, F const& f) { return hana::make_basic_tuple( f(detail::ebo_get<detail::bti<i>>( static_cast<detail::ebo<detail::bti<i>, Xn>&&>(xs) ))... ); } }; ////////////////////////////////////////////////////////////////////////// // Iterable ////////////////////////////////////////////////////////////////////////// template <> struct at_impl<basic_tuple_tag> { template <typename Xs, typename N> static constexpr decltype(auto) apply(Xs&& xs, N const&) { constexpr std::size_t index = N::value; return detail::ebo_get<detail::bti<index>>(static_cast<Xs&&>(xs)); } }; template <> struct drop_front_impl<basic_tuple_tag> { template <std::size_t N, typename Xs, std::size_t ...i> static constexpr auto drop_front_helper(Xs&& xs, std::index_sequence<i...>) { return hana::make_basic_tuple( detail::ebo_get<detail::bti<i+N>>(static_cast<Xs&&>(xs))... ); } template <typename Xs, typename N> static constexpr auto apply(Xs&& xs, N const&) { constexpr std::size_t len = detail::decay<Xs>::type::size_; return drop_front_helper<N::value>(static_cast<Xs&&>(xs), std::make_index_sequence< (N::value < len) ? len - N::value : 0 >{}); } }; template <> struct is_empty_impl<basic_tuple_tag> { template <typename ...Xs> static constexpr hana::bool_<sizeof...(Xs) == 0> apply(basic_tuple<Xs...> const&) { return {}; } }; // compile-time optimizations (to reduce the # of function instantiations) template <std::size_t n, typename ...Xs> constexpr decltype(auto) at_c(basic_tuple<Xs...> const& xs) { return detail::ebo_get<detail::bti<n>>(xs); } template <std::size_t n, typename ...Xs> constexpr decltype(auto) at_c(basic_tuple<Xs...>& xs) { return detail::ebo_get<detail::bti<n>>(xs); } template <std::size_t n, typename ...Xs> constexpr decltype(auto) at_c(basic_tuple<Xs...>&& xs) { return detail::ebo_get<detail::bti<n>>(static_cast<basic_tuple<Xs...>&&>(xs)); } ////////////////////////////////////////////////////////////////////////// // Sequence ////////////////////////////////////////////////////////////////////////// template <> struct Sequence<basic_tuple_tag> { static constexpr bool value = true; }; template <> struct make_impl<basic_tuple_tag> { template <typename ...Xn> static constexpr basic_tuple<typename detail::decay<Xn>::type...> apply(Xn&& ...xn) { return basic_tuple<typename detail::decay<Xn>::type...>{ static_cast<Xn&&>(xn)... }; } }; ////////////////////////////////////////////////////////////////////////// // length ////////////////////////////////////////////////////////////////////////// template <> struct length_impl<basic_tuple_tag> { template <typename ...Xn> static constexpr auto apply(basic_tuple<Xn...> const&) { return hana::size_t<sizeof...(Xn)>{}; } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_BASIC_TUPLE_HPP PK �\�[���� erase_key.hppnu �[��� /*! @file Defines `boost::hana::erase_key`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_ERASE_KEY_HPP #define BOOST_HANA_ERASE_KEY_HPP #include <boost/hana/fwd/erase_key.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Set, typename ...Args> constexpr decltype(auto) erase_key_t::operator()(Set&& set, Args&& ...args) const { return erase_key_impl<typename hana::tag_of<Set>::type>::apply( static_cast<Set&&>(set), static_cast<Args&&>(args)... ); } //! @endcond template <typename T, bool condition> struct erase_key_impl<T, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_ERASE_KEY_HPP PK �\�[��!� � members.hppnu �[��� /*! @file Defines `boost::hana::members`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_MEMBERS_HPP #define BOOST_HANA_MEMBERS_HPP #include <boost/hana/fwd/members.hpp> #include <boost/hana/accessors.hpp> #include <boost/hana/concept/struct.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/second.hpp> #include <boost/hana/transform.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Object> constexpr auto members_t::operator()(Object&& object) const { using S = typename hana::tag_of<Object>::type; using Members = BOOST_HANA_DISPATCH_IF(members_impl<S>, hana::Struct<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Struct<S>::value, "hana::members(object) requires 'object' to be a Struct"); #endif return Members::apply(static_cast<Object&&>(object)); } //! @endcond namespace struct_detail { template <typename Holder, typename Forward> struct members_helper { Holder object; template <typename Accessor> constexpr decltype(auto) operator()(Accessor&& accessor) const { return hana::second(static_cast<Accessor&&>(accessor))( static_cast<Forward>(object) ); } }; } template <typename S, bool condition> struct members_impl<S, when<condition>> : default_ { template <typename Object> static constexpr auto apply(Object&& object) { return hana::transform(hana::accessors<S>(), struct_detail::members_helper<Object&, Object&&>{object} ); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_MEMBERS_HPP PK �\�[/�T� � zip.hppnu �[��� /*! @file Defines `boost::hana::zip`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_ZIP_HPP #define BOOST_HANA_ZIP_HPP #include <boost/hana/fwd/zip.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/fast_and.hpp> #include <boost/hana/tuple.hpp> #include <boost/hana/zip_with.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename ...Ys> constexpr auto zip_t::operator()(Xs&& xs, Ys&& ...ys) const { #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(detail::fast_and< hana::Sequence<Xs>::value, hana::Sequence<Ys>::value... >::value, "hana::zip(xs, ys...) requires 'xs' and 'ys...' to be Sequences"); #endif return zip_impl<typename hana::tag_of<Xs>::type>::apply( static_cast<Xs&&>(xs), static_cast<Ys&&>(ys)... ); } //! @endcond template <typename S, bool condition> struct zip_impl<S, when<condition>> : default_ { template <typename ...Xs> static constexpr decltype(auto) apply(Xs&& ...xs) { return hana::zip_with(hana::make_tuple, static_cast<Xs&&>(xs)...); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_ZIP_HPP PK �\�[^��8 8 fold_left.hppnu �[��� /*! @file Defines `boost::hana::fold_left`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FOLD_LEFT_HPP #define BOOST_HANA_FOLD_LEFT_HPP #include <boost/hana/fwd/fold_left.hpp> #include <boost/hana/concept/foldable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/variadic/foldl1.hpp> #include <boost/hana/functional/partial.hpp> #include <boost/hana/unpack.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename State, typename F> constexpr decltype(auto) fold_left_t::operator()(Xs&& xs, State&& state, F&& f) const { using S = typename hana::tag_of<Xs>::type; using FoldLeft = BOOST_HANA_DISPATCH_IF(fold_left_impl<S>, hana::Foldable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Foldable<S>::value, "hana::fold_left(xs, state, f) requires 'xs' to be Foldable"); #endif return FoldLeft::apply(static_cast<Xs&&>(xs), static_cast<State&&>(state), static_cast<F&&>(f)); } template <typename Xs, typename F> constexpr decltype(auto) fold_left_t::operator()(Xs&& xs, F&& f) const { using S = typename hana::tag_of<Xs>::type; using FoldLeft = BOOST_HANA_DISPATCH_IF(fold_left_impl<S>, hana::Foldable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Foldable<S>::value, "hana::fold_left(xs, f) requires 'xs' to be Foldable"); #endif return FoldLeft::apply(static_cast<Xs&&>(xs), static_cast<F&&>(f)); } //! @endcond namespace detail { template <typename F, typename State> struct variadic_foldl1 { F& f; State& state; template <typename ...T> constexpr decltype(auto) operator()(T&& ...t) const { return detail::variadic::foldl1( static_cast<F&&>(f), static_cast<State&&>(state), static_cast<T&&>(t)... ); } }; } template <typename T, bool condition> struct fold_left_impl<T, when<condition>> : default_ { // with state template <typename Xs, typename S, typename F> static constexpr decltype(auto) apply(Xs&& xs, S&& s, F&& f) { return hana::unpack(static_cast<Xs&&>(xs), detail::variadic_foldl1<F, S>{f, s} ); } // without state template <typename Xs, typename F> static constexpr decltype(auto) apply(Xs&& xs, F&& f) { return hana::unpack(static_cast<Xs&&>(xs), hana::partial( detail::variadic::foldl1, static_cast<F&&>(f) ) ); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FOLD_LEFT_HPP PK �\�['�� � back.hppnu �[��� /*! @file Defines `boost::hana::back`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_BACK_HPP #define BOOST_HANA_BACK_HPP #include <boost/hana/fwd/back.hpp> #include <boost/hana/at.hpp> #include <boost/hana/concept/iterable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/length.hpp> #include <cstddef> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs> constexpr decltype(auto) back_t::operator()(Xs&& xs) const { using It = typename hana::tag_of<Xs>::type; using Back = BOOST_HANA_DISPATCH_IF(back_impl<It>, hana::Iterable<It>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Iterable<It>::value, "hana::back(xs) requires 'xs' to be an Iterable"); #endif return Back::apply(static_cast<Xs&&>(xs)); } //! @endcond template <typename It, bool condition> struct back_impl<It, when<condition>> : default_ { template <typename Xs> static constexpr decltype(auto) apply(Xs&& xs) { constexpr std::size_t len = decltype(hana::length(xs))::value; static_assert(len > 0, "hana::back(xs) requires 'xs' to be non-empty"); return hana::at_c<len - 1>(static_cast<Xs&&>(xs)); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_BACK_HPP PK �\�[�|� � is_empty.hppnu �[��� /*! @file Defines `boost::hana::is_empty`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_IS_EMPTY_HPP #define BOOST_HANA_IS_EMPTY_HPP #include <boost/hana/fwd/is_empty.hpp> #include <boost/hana/concept/iterable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs> constexpr auto is_empty_t::operator()(Xs const& xs) const { using It = typename hana::tag_of<Xs>::type; using IsEmpty = BOOST_HANA_DISPATCH_IF(is_empty_impl<It>, hana::Iterable<It>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Iterable<It>::value, "hana::is_empty(xs) requires 'xs' to be an Iterable"); #endif return IsEmpty::apply(xs); } //! @endcond template <typename It, bool condition> struct is_empty_impl<It, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_IS_EMPTY_HPP PK �\�[vN�� � not_equal.hppnu �[��� /*! @file Defines `boost::hana::not_equal`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_NOT_EQUAL_HPP #define BOOST_HANA_NOT_EQUAL_HPP #include <boost/hana/fwd/not_equal.hpp> #include <boost/hana/concept/comparable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/to.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/has_common_embedding.hpp> #include <boost/hana/detail/nested_to.hpp> // required by fwd decl #include <boost/hana/equal.hpp> #include <boost/hana/not.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename X, typename Y> constexpr auto not_equal_t::operator()(X&& x, Y&& y) const { using T = typename hana::tag_of<X>::type; using U = typename hana::tag_of<Y>::type; using NotEqual = not_equal_impl<T, U>; return NotEqual::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); } //! @endcond template <typename T, typename U, bool condition> struct not_equal_impl<T, U, when<condition>> : default_ { template <typename X, typename Y> static constexpr decltype(auto) apply(X&& x, Y&& y) { return hana::not_(hana::equal(static_cast<X&&>(x), static_cast<Y&&>(y))); } }; // Cross-type overload template <typename T, typename U> struct not_equal_impl<T, U, when< detail::has_nontrivial_common_embedding<Comparable, T, U>::value >> { using C = typename hana::common<T, U>::type; template <typename X, typename Y> static constexpr decltype(auto) apply(X&& x, Y&& y) { return hana::not_equal(hana::to<C>(static_cast<X&&>(x)), hana::to<C>(static_cast<Y&&>(y))); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_NOT_EQUAL_HPP PK �\�[?v��g g is_subset.hppnu �[��� /*! @file Defines `boost::hana::is_subset`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_IS_SUBSET_HPP #define BOOST_HANA_IS_SUBSET_HPP #include <boost/hana/fwd/is_subset.hpp> #include <boost/hana/all_of.hpp> #include <boost/hana/concept/searchable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/contains.hpp> #include <boost/hana/core/common.hpp> #include <boost/hana/core/to.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/has_common_embedding.hpp> #include <boost/hana/functional/partial.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Ys> constexpr auto is_subset_t::operator()(Xs&& xs, Ys&& ys) const { using S1 = typename hana::tag_of<Xs>::type; using S2 = typename hana::tag_of<Ys>::type; using IsSubset = BOOST_HANA_DISPATCH_IF( decltype(is_subset_impl<S1, S2>{}), hana::Searchable<S1>::value && hana::Searchable<S2>::value && !is_default<is_subset_impl<S1, S2>>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Searchable<S1>::value, "hana::is_subset(xs, ys) requires 'xs' to be Searchable"); static_assert(hana::Searchable<S2>::value, "hana::is_subset(xs, ys) requires 'ys' to be Searchable"); static_assert(!is_default<is_subset_impl<S1, S2>>::value, "hana::is_subset(xs, ys) requires 'xs' and 'ys' to be embeddable " "in a common Searchable"); #endif return IsSubset::apply(static_cast<Xs&&>(xs), static_cast<Ys&&>(ys)); } //! @endcond template <typename S1, typename S2, bool condition> struct is_subset_impl<S1, S2, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; template <typename S, bool condition> struct is_subset_impl<S, S, when<condition>> { template <typename Xs, typename Ys> static constexpr decltype(auto) apply(Xs&& xs, Ys&& ys) { return hana::all_of(static_cast<Xs&&>(xs), hana::partial(hana::contains, static_cast<Ys&&>(ys))); } }; // Cross-type overload template <typename S1, typename S2> struct is_subset_impl<S1, S2, when< detail::has_nontrivial_common_embedding<Searchable, S1, S2>::value >> { using C = typename common<S1, S2>::type; template <typename Xs, typename Ys> static constexpr decltype(auto) apply(Xs&& xs, Ys&& ys) { return hana::is_subset(hana::to<C>(static_cast<Xs&&>(xs)), hana::to<C>(static_cast<Ys&&>(ys))); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_IS_SUBSET_HPP PK �\�[�9�� � zero.hppnu �[��� /*! @file Defines `boost::hana::zero`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_ZERO_HPP #define BOOST_HANA_ZERO_HPP #include <boost/hana/fwd/zero.hpp> #include <boost/hana/concept/constant.hpp> #include <boost/hana/concept/monoid.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/to.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/canonical_constant.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename M> constexpr decltype(auto) zero_t<M>::operator()() const { #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Monoid<M>::value, "hana::zero<M>() requires 'M' to be a Monoid"); #endif using Zero = BOOST_HANA_DISPATCH_IF(zero_impl<M>, hana::Monoid<M>::value ); return Zero::apply(); } //! @endcond template <typename M, bool condition> struct zero_impl<M, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; ////////////////////////////////////////////////////////////////////////// // Model for non-boolean arithmetic data types ////////////////////////////////////////////////////////////////////////// template <typename T> struct zero_impl<T, when< std::is_arithmetic<T>::value && !std::is_same<T, bool>::value >> { static constexpr T apply() { return static_cast<T>(0); } }; ////////////////////////////////////////////////////////////////////////// // Model for Constants over a Monoid ////////////////////////////////////////////////////////////////////////// namespace detail { template <typename C> struct constant_from_zero { static constexpr auto value = hana::zero<typename C::value_type>(); using hana_tag = detail::CanonicalConstant<typename C::value_type>; }; } template <typename C> struct zero_impl<C, when< hana::Constant<C>::value && Monoid<typename C::value_type>::value >> { static constexpr decltype(auto) apply() { return hana::to<C>(detail::constant_from_zero<C>{}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_ZERO_HPP PK �\�[���D D prepend.hppnu �[��� /*! @file Defines `boost::hana::prepend`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_PREPEND_HPP #define BOOST_HANA_PREPEND_HPP #include <boost/hana/fwd/prepend.hpp> #include <boost/hana/at.hpp> #include <boost/hana/concat.hpp> #include <boost/hana/concept/monad_plus.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/length.hpp> #include <boost/hana/lift.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename X> constexpr auto prepend_t::operator()(Xs&& xs, X&& x) const { using M = typename hana::tag_of<Xs>::type; using Prepend = BOOST_HANA_DISPATCH_IF(prepend_impl<M>, hana::MonadPlus<M>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::MonadPlus<M>::value, "hana::prepend(xs, x) requires 'xs' to be a MonadPlus"); #endif return Prepend::apply(static_cast<Xs&&>(xs), static_cast<X&&>(x)); } //! @endcond template <typename M, bool condition> struct prepend_impl<M, when<condition>> : default_ { template <typename Xs, typename X> static constexpr auto apply(Xs&& xs, X&& x) { return hana::concat(hana::lift<M>(static_cast<X&&>(x)), static_cast<Xs&&>(xs)); } }; template <typename S> struct prepend_impl<S, when<Sequence<S>::value>> { template <typename Xs, typename X, std::size_t ...i> static constexpr auto prepend_helper(Xs&& xs, X&& x, std::index_sequence<i...>) { return hana::make<S>( static_cast<X&&>(x), hana::at_c<i>(static_cast<Xs&&>(xs))... ); } template <typename Xs, typename X> static constexpr auto apply(Xs&& xs, X&& x) { constexpr std::size_t N = decltype(hana::length(xs))::value; return prepend_helper(static_cast<Xs&&>(xs), static_cast<X&&>(x), std::make_index_sequence<N>{}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_PREPEND_HPP PK �\�[#tX X fwd/repeat.hppnu �[��� /*! @file Forward declares `boost::hana::repeat`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_REPEAT_HPP #define BOOST_HANA_FWD_REPEAT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Invokes a nullary function `n` times. //! @ingroup group-IntegralConstant //! //! Given an `IntegralConstant` `n` and a nullary function `f`, //! `repeat(n, f)` will call `f` `n` times. In particular, any //! decent compiler should expand `repeat(n, f)` to //! @code //! f(); f(); ... f(); // n times total //! @endcode //! //! //! @param n //! An `IntegralConstant` holding a non-negative value representing //! the number of times `f` should be repeatedly invoked. //! //! @param f //! A function to repeatedly invoke `n` times. `f` is allowed to have //! side effects. //! //! //! Example //! ------- //! @include example/repeat.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto repeat = [](auto const& n, auto&& f) -> void { f(); f(); ... f(); // n times total }; #else template <typename N, typename = void> struct repeat_impl : repeat_impl<N, when<true>> { }; struct repeat_t { template <typename N, typename F> constexpr void operator()(N const& n, F&& f) const; }; constexpr repeat_t repeat{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_REPEAT_HPP PK �\�[VTn�b b fwd/count_if.hppnu �[��� /*! @file Forward declares `boost::hana::count_if`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_COUNT_IF_HPP #define BOOST_HANA_FWD_COUNT_IF_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Return the number of elements in the structure for which the //! `predicate` is satisfied. //! @ingroup group-Foldable //! //! Specifically, returns an object of an unsigned integral type, or //! a `Constant` holding such an object, which represents the number //! of elements in the structure satisfying the given `predicate`. //! //! //! @param xs //! The structure whose elements are counted. //! //! @param predicate //! A function called as `predicate(x)`, where `x` is an element of the //! structure, and returning a `Logical` representing whether `x` should //! be counted. //! //! //! Example //! ------- //! @include example/count_if.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto count_if = [](auto&& xs, auto&& predicate) { return tag-dispatched; }; #else template <typename T, typename = void> struct count_if_impl : count_if_impl<T, when<true>> { }; struct count_if_t { template <typename Xs, typename Pred> constexpr auto operator()(Xs&& xs, Pred&& pred) const; }; constexpr count_if_t count_if{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_COUNT_IF_HPP PK �\�[+� fwd/group.hppnu �[��� /*! @file Forward declares `boost::hana::group`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_GROUP_HPP #define BOOST_HANA_FWD_GROUP_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/nested_by_fwd.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Group adjacent elements of a sequence that all respect a binary //! predicate, by default equality. //! @ingroup group-Sequence //! //! Given a _finite_ Sequence and an optional predicate (by default //! `equal`), `group` returns a sequence of subsequences representing //! groups of adjacent elements that are "equal" with respect to the //! predicate. In other words, the groups are such that the predicate is //! satisfied when it is applied to any two adjacent elements in that //! group. The sequence returned by `group` is such that the concatenation //! of its elements is equal to the original sequence, which is equivalent //! to saying that the order of the elements is not changed. //! //! If no predicate is provided, adjacent elements in the sequence must //! all be compile-time `Comparable`. //! //! //! Signature //! --------- //! Given a Sequence `s` with tag `S(T)`, an `IntegralConstant` `Bool` //! holding a value of type `bool`, and a predicate //! \f$ pred : T \times T \to Bool \f$, `group` has the following //! signatures. For the variant with a provided predicate, //! \f[ //! \mathtt{group} : S(T) \times (T \times T \to Bool) \to S(S(T)) //! \f] //! //! for the variant without a custom predicate, `T` is required to be //! Comparable. The signature is then //! \f[ //! \mathtt{group} : S(T) \to S(S(T)) //! \f] //! //! @param xs //! The sequence to split into groups. //! //! @param predicate //! A binary function called as `predicate(x, y)`, where `x` and `y` are //! _adjacent_ elements in the sequence, whether both elements should be //! in the same group (subsequence) of the result. In the current version //! of the library, the result returned by `predicate` must be an //! `IntegralConstant` holding a value of a type convertible to `bool`. //! Also, `predicate` has to define an equivalence relation as defined by //! the `Comparable` concept. When this predicate is not provided, it //! defaults to `equal`, which requires the comparison of any two adjacent //! elements in the sequence to return a boolean `IntegralConstant`. //! //! //! Syntactic sugar (`group.by`) //! ---------------------------- //! `group` can be called in a third way, which provides a nice syntax //! especially when working with the `comparing` combinator: //! @code //! group.by(predicate, xs) == group(xs, predicate) //! group.by(predicate) == group(-, predicate) //! @endcode //! //! where `group(-, predicate)` denotes the partial application of //! `group` to `predicate`. //! //! //! Example //! ------- //! @include example/group.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto group = [](auto&& xs[, auto&& predicate]) { return tag-dispatched; }; #else template <typename S, typename = void> struct group_impl : group_impl<S, when<true>> { }; struct group_t : detail::nested_by<group_t> { template <typename Xs> constexpr auto operator()(Xs&& xs) const; template <typename Xs, typename Predicate> constexpr auto operator()(Xs&& xs, Predicate&& pred) const; }; constexpr group_t group{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_GROUP_HPP PK �\�[��cy y fwd/front.hppnu �[��� /*! @file Forward declares `boost::hana::front`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_FRONT_HPP #define BOOST_HANA_FWD_FRONT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns the first element of a non-empty iterable. //! @ingroup group-Iterable //! //! Given a non-empty Iterable `xs` with a linearization of `[x1, ..., xN]`, //! `front(xs)` is equal to `x1`. If `xs` is empty, it is an error to //! use this function. Equivalently, `front(xs)` must be equivalent to //! `at_c<0>(xs)`, and that regardless of the value category of `xs` //! (`front` must respect the reference semantics of `at`). //! //! //! Example //! ------- //! @include example/front.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto front = [](auto&& xs) -> decltype(auto) { return tag-dispatched; }; #else template <typename It, typename = void> struct front_impl : front_impl<It, when<true>> { }; struct front_t { template <typename Xs> constexpr decltype(auto) operator()(Xs&& xs) const; }; constexpr front_t front{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_FRONT_HPP PK �\�[�'BF� � fwd/scan_right.hppnu �[��� /*! @file Forward declares `boost::hana::scan_right`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_SCAN_RIGHT_HPP #define BOOST_HANA_FWD_SCAN_RIGHT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Fold a Sequence to the right and return a list containing the //! successive reduction states. //! @ingroup group-Sequence //! //! Like `fold_right`, `scan_right` reduces a sequence to a single value //! using a binary operation. However, unlike `fold_right`, it builds up //! a sequence of the intermediary results computed along the way and //! returns that instead of only the final reduction state. Like //! `fold_right`, `scan_right` can be used with or without an initial //! reduction state. //! //! When the sequence is empty, two things may arise. If an initial state //! was provided, a singleton list containing that state is returned. //! Otherwise, if no initial state was provided, an empty list is //! returned. In particular, unlike for `fold_right`, using `scan_right` //! on an empty sequence without an initial state is not an error. //! //! More specifically, `scan_right([x1, ..., xn], state, f)` is a sequence //! whose `i`th element is equivalent to `fold_right([x1, ..., xi], state, f)`. //! The no-state variant is handled in an analogous way. For illustration, //! consider this right fold on a short sequence: //! @code //! fold_right([x1, x2, x3], state, f) == f(x1, f(x2, f(x3, state))) //! @endcode //! //! The analogous sequence generated with `scan_right` will be //! @code //! scan_right([x1, x2, x3], state, f) == [ //! f(x1, f(x2, f(x3, state))), //! f(x2, f(x3, state)), //! f(x3, state), //! state //! ] //! @endcode //! //! Similarly, consider this right fold (without an initial state) on //! a short sequence: //! @code //! fold_right([x1, x2, x3, x4], f) == f(x1, f(x2, f(x3, x4))) //! @endcode //! //! The analogous sequence generated with `scan_right` will be //! @code //! scan_right([x1, x2, x3, x4], f) == [ //! f(x1, f(x2, f(x3, x4))), //! f(x2, f(x3, x4)), //! f(x3, x4), //! x4 //! ] //! @endcode //! //! @param xs //! The sequence to scan from the right. //! //! @param state //! The (optional) initial reduction state. //! //! @param f //! A binary function called as `f(x, state)`, where `state` is the //! result accumulated so far and `x` is an element in the sequence. //! When no initial state is provided, `f` is called as `f(x1, x2)`, //! where `x1` and `x2` are elements of the sequence. //! //! //! Example //! ------- //! @include example/scan_right.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto scan_right = [](auto&& xs[, auto&& state], auto const& f) { return tag-dispatched; }; #else template <typename S, typename = void> struct scan_right_impl : scan_right_impl<S, when<true>> { }; struct scan_right_t { template <typename Xs, typename State, typename F> constexpr auto operator()(Xs&& xs, State&& state, F const& f) const; template <typename Xs, typename F> constexpr auto operator()(Xs&& xs, F const& f) const; }; constexpr scan_right_t scan_right{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_SCAN_RIGHT_HPP PK �\�[C�#?2 2 fwd/adapt_struct.hppnu �[��� /*! @file Documents the `BOOST_HANA_ADAPT_STRUCT` macro. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_ADAPT_STRUCT_HPP #define BOOST_HANA_FWD_ADAPT_STRUCT_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN // Note: // The weird definition as a variable seems to exploit a glitch in Doxygen // which makes the macro appear in the related objects of Struct (as we // want it to). //! Defines a model of `Struct` with the given members. //! @ingroup group-Struct //! //! Using this macro at _global scope_ will define a model of the `Struct` //! concept for the given type. This can be used to easily adapt existing //! user-defined types in a ad-hoc manner. Unlike the //! `BOOST_HANA_DEFINE_STRUCT` macro, this macro does not //! require the types of the members to be specified. //! //! @note //! This macro only works if the tag of the user-defined type `T` is `T` //! itself. This is the case unless you specifically asked for something //! different; see `tag_of`'s documentation. //! //! //! Example //! ------- //! @include example/adapt_struct.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED auto BOOST_HANA_ADAPT_STRUCT(...) = ; #define BOOST_HANA_ADAPT_STRUCT(Name, ...) see documentation #else // defined in <boost/hana/adapt_struct.hpp> #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ADAPT_STRUCT_HPP PK �\�[�:, , fwd/fuse.hppnu �[��� /*! @file Forward declares `boost::hana::fuse`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_FUSE_HPP #define BOOST_HANA_FWD_FUSE_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Transform a function taking multiple arguments into a function that //! can be called with a compile-time `Foldable`. //! @ingroup group-Foldable //! //! //! This function is provided for convenience as a different way of //! calling `unpack`. Specifically, `fuse(f)` is a function such that //! @code //! fuse(f)(foldable) == unpack(foldable, f) //! == f(x...) //! @endcode //! where `x...` are the elements in the foldable. This function is //! useful when one wants to create a function that accepts a foldable //! which is not known yet. //! //! @note //! This function is not tag-dispatched; customize `unpack` instead. //! //! //! Example //! ------- //! @include example/fuse.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto fuse = [](auto&& f) { return [perfect-capture](auto&& xs) -> decltype(auto) { return unpack(forwarded(xs), forwarded(f)); }; }; #else struct fuse_t { template <typename F> constexpr auto operator()(F&& f) const; }; constexpr fuse_t fuse{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_FUSE_HPP PK �\�[,f5ۥ � fwd/any_of.hppnu �[��� /*! @file Forward declares `boost::hana::any_of`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_ANY_OF_HPP #define BOOST_HANA_FWD_ANY_OF_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns whether any key of the structure satisfies the `predicate`. //! @ingroup group-Searchable //! //! If the structure is not finite, `predicate` has to be satisfied //! after looking at a finite number of keys for this method to finish. //! //! //! @param xs //! The structure to search. //! //! @param predicate //! A function called as `predicate(k)`, where `k` is a key of the //! structure, and returning a `Logical`. //! //! //! Example //! ------- //! @include example/any_of.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto any_of = [](auto&& xs, auto&& predicate) { return tag-dispatched; }; #else template <typename S, typename = void> struct any_of_impl : any_of_impl<S, when<true>> { }; struct any_of_t { template <typename Xs, typename Pred> constexpr auto operator()(Xs&& xs, Pred&& pred) const; }; constexpr any_of_t any_of{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ANY_OF_HPP PK �\�["��2� � fwd/lazy.hppnu �[��� /*! @file Forward declares `boost::hana::lazy`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_LAZY_HPP #define BOOST_HANA_FWD_LAZY_HPP #include <boost/hana/config.hpp> #include <boost/hana/fwd/core/make.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-datatypes //! `hana::lazy` implements superficial laziness via a monadic interface. //! //! It is important to understand that the laziness implemented by `lazy` //! is only superficial; only function applications made inside the `lazy` //! monad can be made lazy, not all their subexpressions. //! //! //! @note //! The actual representation of `hana::lazy` is completely //! implementation-defined. Lazy values may only be created through //! `hana::make_lazy`, and they can be stored in variables using //! `auto`, but any other assumption about the representation of //! `hana::lazy<...>` should be avoided. In particular, one should //! not rely on the fact that `hana::lazy<...>` can be pattern-matched //! on, because it may be a dependent type. //! //! //! Modeled concepts //! ---------------- //! 1. `Functor`\n //! Applying a function over a lazy value with `transform` returns the //! result of applying the function, as a lazy value. //! @include example/lazy/functor.cpp //! //! 2. `Applicative`\n //! A normal value can be lifted into a lazy value by using `lift<lazy_tag>`. //! A lazy function can be lazily applied to a lazy value by using `ap`. //! //! 3. `Monad`\n //! The `lazy` monad allows combining lazy computations into larger //! lazy computations. Note that the `|` operator can be used in place //! of the `chain` function. //! @include example/lazy/monad.cpp //! //! 4. `Comonad`\n //! The `lazy` comonad allows evaluating a lazy computation to get its //! result and lazily applying functions taking lazy inputs to lazy //! values. This [blog post][1] goes into more details about lazy //! evaluation and comonads. //! @include example/lazy/comonad.cpp //! //! //! @note //! `hana::lazy` only models a few concepts because providing more //! functionality would require evaluating the lazy values in most cases. //! Since this raises some issues such as side effects and memoization, //! the interface is kept minimal. //! //! //! [1]: http://ldionne.com/2015/03/16/laziness-as-a-comonad #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename implementation_defined> struct lazy { //! Equivalent to `hana::chain`. template <typename ...T, typename F> friend constexpr auto operator|(lazy<T...>, F); }; #else // We do not _actually_ define the lazy<...> type. Per the documentation, // users can't rely on it being anything, and so they should never use // it explicitly. The implementation in <boost/hana/lazy.hpp> is much // simpler if we use different types for lazy calls and lazy values. #endif //! Tag representing `hana::lazy`. //! @relates hana::lazy struct lazy_tag { }; //! Lifts a normal value to a lazy one. //! @relates hana::lazy //! //! `make<lazy_tag>` can be used to lift a normal value or a function call //! into a lazy expression. Precisely, `make<lazy_tag>(x)` is a lazy value //! equal to `x`, and `make<lazy_tag>(f)(x1, ..., xN)` is a lazy function //! call that is equal to `f(x1, ..., xN)` when it is `eval`uated. //! //! @note //! It is interesting to note that `make<lazy_tag>(f)(x1, ..., xN)` is //! equivalent to //! @code //! ap(make<lazy_tag>(f), lift<lazy_tag>(x1), ..., lift<lazy_tag>(xN)) //! @endcode //! which in turn is equivalent to `make<lazy_tag>(f(x1, ..., xN))`, except //! for the fact that the inner call to `f` is evaluated lazily. //! //! //! Example //! ------- //! @include example/lazy/make.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <> constexpr auto make<lazy_tag> = [](auto&& x) { return lazy<implementation_defined>{forwarded(x)}; }; #endif //! Alias to `make<lazy_tag>`; provided for convenience. //! @relates hana::lazy //! //! Example //! ------- //! @include example/lazy/make.cpp constexpr auto make_lazy = make<lazy_tag>; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_LAZY_HPP PK �\�[Ud;k k fwd/core.hppnu �[��� /*! @file Forward declares the @ref group-core module. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CORE_HPP #define BOOST_HANA_FWD_CORE_HPP #include <boost/hana/fwd/core/common.hpp> #include <boost/hana/fwd/core/to.hpp> #include <boost/hana/fwd/core/default.hpp> #include <boost/hana/fwd/core/is_a.hpp> #include <boost/hana/fwd/core/make.hpp> #include <boost/hana/fwd/core/tag_of.hpp> #include <boost/hana/fwd/core/when.hpp> #endif // !BOOST_HANA_FWD_CORE_HPP PK �\�[;���� � fwd/unfold_left.hppnu �[��� /*! @file Forward declares `boost::hana::unfold_left`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_UNFOLD_LEFT_HPP #define BOOST_HANA_FWD_UNFOLD_LEFT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Dual operation to `fold_left` for sequences. //! @ingroup group-Sequence //! //! While `fold_left` reduces a structure to a summary value from the left, //! `unfold_left` builds a sequence from a seed value and a function, //! starting from the left. //! //! //! Signature //! --------- //! Given a `Sequence` `S`, an initial value `state` of tag `I`, an //! arbitrary Product `P` and a function \f$ f : I \to P(I, T) \f$, //! `unfold_left<S>` has the following signature: //! \f[ //! \mathtt{unfold\_left}_S : I \times (I \to P(I, T)) \to S(T) //! \f] //! //! @tparam S //! The tag of the sequence to build up. //! //! @param state //! An initial value to build the sequence from. //! //! @param f //! A function called as `f(state)`, where `state` is an initial value, //! and returning //! 1. `nothing` if it is done producing the sequence. //! 2. otherwise, `just(make<P>(state, x))`, where `state` is the new //! initial value used in the next call to `f`, `x` is an element to //! be appended to the resulting sequence, and `P` is an arbitrary //! `Product`. //! //! //! Fun fact //! --------- //! In some cases, `unfold_left` can undo a `fold_left` operation: //! @code //! unfold_left<S>(fold_left(xs, state, f), g) == xs //! @endcode //! //! if the following holds //! @code //! g(f(x, y)) == just(make_pair(x, y)) //! g(state) == nothing //! @endcode //! //! //! Example //! ------- //! @include example/unfold_left.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename S> constexpr auto unfold_left = [](auto&& state, auto&& f) { return tag-dispatched; }; #else template <typename S, typename = void> struct unfold_left_impl : unfold_left_impl<S, when<true>> { }; template <typename S> struct unfold_left_t; template <typename S> constexpr unfold_left_t<S> unfold_left{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_UNFOLD_LEFT_HPP PK �\�[�pd\ \ fwd/one.hppnu �[��� /*! @file Forward declares `boost::hana::one`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_ONE_HPP #define BOOST_HANA_FWD_ONE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Identity of the `Ring` multiplication. //! @ingroup group-Ring //! //! @tparam R //! The tag (must be a model of `Ring`) of the returned identity. //! //! //! Example //! ------- //! @include example/one.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename R> constexpr auto one = []() -> decltype(auto) { return tag-dispatched; }; #else template <typename R, typename = void> struct one_impl : one_impl<R, when<true>> { }; template <typename R> struct one_t { constexpr decltype(auto) operator()() const; }; template <typename R> constexpr one_t<R> one{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ONE_HPP PK �\�[3ooϰ � fwd/monadic_fold_left.hppnu �[��� /*! @file Forward declares `boost::hana::monadic_fold_left`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_MONADIC_FOLD_LEFT_HPP #define BOOST_HANA_FWD_MONADIC_FOLD_LEFT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Monadic left-fold of a structure with a binary operation and an //! optional initial reduction state. //! @ingroup group-Foldable //! //! @note //! This assumes the reader to be accustomed to non-monadic left-folds as //! explained by `hana::fold_left`, and to have read the [primer] //! (@ref monadic-folds) on monadic folds. //! //! `monadic_fold_left<M>` is a left-associative monadic fold. Given a //! `Foldable` with linearization `[x1, ..., xn]`, a function `f` and an //! optional initial state, `monadic_fold_left<M>` applies `f` as follows: //! @code //! // with state //! ((((f(state, x1) | f(-, x2)) | f(-, x3)) | ...) | f(-, xn)) //! //! // without state //! ((((f(x1, x2) | f(-, x3)) | f(-, x4)) | ...) | f(-, xn)) //! @endcode //! //! where `f(-, xk)` denotes the partial application of `f` to `xk`, and //! `|` is just the operator version of the monadic `chain`. //! //! When the structure is empty, one of two things may happen. If an //! initial state was provided, it is lifted to the given Monad and //! returned as-is. Otherwise, if the no-state version of the function //! was used, an error is triggered. When the stucture contains a single //! element and the no-state version of the function was used, that //! single element is lifted into the given Monad and returned as is. //! //! //! Signature //! --------- //! Given a `Monad` `M`, a `Foldable` `F`, an initial state of tag `S`, //! and a function @f$ f : S \times T \to M(S) @f$, the signatures of //! `monadic_fold_left<M>` are //! \f[ //! \mathtt{monadic\_fold\_left}_M : //! F(T) \times S \times (S \times T \to M(S)) \to M(S) //! \f] //! //! for the version with an initial state, and //! \f[ //! \mathtt{monadic\_fold\_left}_M : //! F(T) \times (T \times T \to M(T)) \to M(T) //! \f] //! //! for the version without an initial state. //! //! @tparam M //! The Monad representing the monadic context in which the fold happens. //! The return type of `f` must be in that Monad. //! //! @param xs //! The structure to fold. //! //! @param state //! The initial value used for folding. If the structure is empty, this //! value is lifted in to the `M` Monad and then returned as-is. //! //! @param f //! A binary function called as `f(state, x)`, where `state` is the result //! accumulated so far and `x` is an element in the structure. The //! function must return its result inside the `M` Monad. //! //! //! Example //! ------- //! @include example/monadic_fold_left.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename M> constexpr auto monadic_fold_left = [](auto&& xs[, auto&& state], auto&& f) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename = void> struct monadic_fold_left_impl : monadic_fold_left_impl<T, when<true>> { }; template <typename M> struct monadic_fold_left_t { template <typename Xs, typename State, typename F> constexpr decltype(auto) operator()(Xs&& xs, State&& state, F&& f) const; template <typename Xs, typename F> constexpr decltype(auto) operator()(Xs&& xs, F&& f) const; }; template <typename M> constexpr monadic_fold_left_t<M> monadic_fold_left{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_MONADIC_FOLD_LEFT_HPP PK �\�[?��� � fwd/zip_with.hppnu �[��� /*! @file Forward declares `boost::hana::zip_with`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_ZIP_WITH_HPP #define BOOST_HANA_FWD_ZIP_WITH_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Zip one sequence or more with a given function. //! @ingroup group-Sequence //! //! Given a `n`-ary function `f` and `n` sequences `s1, ..., sn`, //! `zip_with` produces a sequence whose `i`-th element is //! `f(s1[i], ..., sn[i])`, where `sk[i]` denotes the `i`-th element of //! the `k`-th sequence. In other words, `zip_with` produces a sequence //! of the form //! @code //! [ //! f(s1[0], ..., sn[0]), //! f(s1[1], ..., sn[1]), //! ... //! f(s1[M], ..., sn[M]) //! ] //! @endcode //! where `M` is the length of the sequences, which are all assumed to //! have the same length. Assuming the sequences to all have the same size //! allows the library to perform some optimizations. To zip sequences //! that may have different lengths, `zip_shortest_with` should be used //! instead. Also note that it is an error to provide no sequence at all, //! i.e. `zip_with` expects at least one sequence. //! //! //! Example //! ------- //! @include example/zip_with.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto zip_with = [](auto&& f, auto&& x1, ..., auto&& xn) { return tag-dispatched; }; #else template <typename S, typename = void> struct zip_with_impl : zip_with_impl<S, when<true>> { }; struct zip_with_t { template <typename F, typename Xs, typename ...Ys> constexpr auto operator()(F&& f, Xs&& xs, Ys&& ...ys) const; }; constexpr zip_with_t zip_with{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ZIP_WITH_HPP PK �\�[?�h� � fwd/append.hppnu �[��� /*! @file Forward declares `boost::hana::append`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_APPEND_HPP #define BOOST_HANA_FWD_APPEND_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Append an element to a monadic structure. //! @ingroup group-MonadPlus //! //! Given an element `x` and a monadic structure `xs`, `append` returns a //! new monadic structure which is the result of lifting `x` into the //! monadic structure and then combining that (to the right) with `xs`. //! In other words, //! @code //! append(xs, x) == concat(xs, lift<Xs>(x)) //! @endcode //! where `Xs` is the tag of `xs`. For sequences, this has the intuitive //! behavior of simply appending an element to the end of the sequence, //! hence the name. //! //! > #### Rationale for not calling this `push_back` //! > See the rationale for using `prepend` instead of `push_front`. //! //! //! Signature //! --------- //! Given a MonadPlus `M`, the signature is //! @f$ \mathtt{append} : M(T) \times T \to M(T) @f$. //! //! @param xs //! A monadic structure that will be combined to the left of the element. //! //! @param x //! An element to combine to the right of the monadic structure. //! //! //! Example //! ------- //! @include example/append.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto append = [](auto&& xs, auto&& x) { return tag-dispatched; }; #else template <typename M, typename = void> struct append_impl : append_impl<M, when<true>> { }; struct append_t { template <typename Xs, typename X> constexpr auto operator()(Xs&& xs, X&& x) const; }; constexpr append_t append{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_APPEND_HPP PK �\�[!^m�� � fwd/flatten.hppnu �[��� /*! @file Forward declares `boost::hana::flatten`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_FLATTEN_HPP #define BOOST_HANA_FWD_FLATTEN_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Collapse two levels of monadic structure into a single level. //! @ingroup group-Monad //! //! Given a monadic value wrapped into two levels of monad, `flatten` //! removes one such level. An implementation of `flatten` must satisfy //! @code //! flatten(xs) == chain(xs, id) //! @endcode //! //! For `Sequence`s, this simply takes a `Sequence` of `Sequence`s, and //! returns a (non-recursively) flattened `Sequence`. //! //! //! Signature //! --------- //! For a `Monad` `M`, the signature of `flatten` is //! @f$ //! \mathtt{flatten} : M(M(T)) \to M(T) //! @f$ //! //! @param xs //! A value with two levels of monadic structure, which should be //! collapsed into a single level of structure. //! //! //! Example //! ------- //! @include example/flatten.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto flatten = [](auto&& xs) { return tag-dispatched; }; #else template <typename M, typename = void> struct flatten_impl : flatten_impl<M, when<true>> { }; struct flatten_t { template <typename Xs> constexpr auto operator()(Xs&& xs) const; }; constexpr flatten_t flatten{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_FLATTEN_HPP PK �\�[� >� � fwd/fill.hppnu �[��� /*! @file Forward declares `boost::hana::fill`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_FILL_HPP #define BOOST_HANA_FWD_FILL_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Replace all the elements of a structure with a fixed value. //! @ingroup group-Functor //! //! //! Signature //! --------- //! Given `F` a Functor, the signature is //! \f$ //! \mathtt{fill} : F(T) \times U \to F(U) //! \f$ //! //! @param xs //! The structure to fill with a `value`. //! //! @param value //! A value by which every element `x` of the structure is replaced, //! unconditionally. //! //! //! Example //! ------- //! @include example/fill.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto fill = [](auto&& xs, auto&& value) { return tag-dispatched; }; #else template <typename Xs, typename = void> struct fill_impl : fill_impl<Xs, when<true>> { }; struct fill_t { template <typename Xs, typename Value> constexpr auto operator()(Xs&& xs, Value&& value) const; }; constexpr fill_t fill{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_FILL_HPP PK �\�[���h h fwd/intersection.hppnu �[��� /*! @file Forward declares `boost::hana::intersection`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_INTERSECTION_HPP #define BOOST_HANA_FWD_INTERSECTION_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN // Note: This function is documented per datatype/concept only. //! @cond template <typename S, typename = void> struct intersection_impl : intersection_impl<S, when<true>> { }; //! @endcond struct intersection_t { template <typename Xs, typename Ys> constexpr auto operator()(Xs&&, Ys&&) const; }; constexpr intersection_t intersection{}; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_INTERSECTION_HPP PK �\�[ fwd/empty.hppnu �[��� /*! @file Forward declares `boost::hana::empty`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_EMPTY_HPP #define BOOST_HANA_FWD_EMPTY_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Identity of the monadic combination `concat`. //! @ingroup group-MonadPlus //! //! Signature //! --------- //! Given a MonadPlus `M`, the signature is //! @f$ \mathtt{empty}_M : \emptyset \to M(T) @f$. //! //! @tparam M //! The tag of the monadic structure to return. This must be //! a model of the MonadPlus concept. //! //! //! Example //! ------- //! @include example/empty.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename M> constexpr auto empty = []() { return tag-dispatched; }; #else template <typename M, typename = void> struct empty_impl : empty_impl<M, when<true>> { }; template <typename M> struct empty_t { constexpr auto operator()() const; }; template <typename M> constexpr empty_t<M> empty{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_EMPTY_HPP PK �\�[�5�� � fwd/min.hppnu �[��� /*! @file Forward declares `boost::hana::min`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_MIN_HPP #define BOOST_HANA_FWD_MIN_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns the smallest of its arguments according to the `less` ordering. //! @ingroup group-Orderable //! //! //! @todo //! We can't specify the signature right now, because the tag of the //! returned object depends on whether `x < y` or not. If we wanted to be //! mathematically correct, we should probably ask that `if_(cond, x, y)` //! returns a common data type of `x` and `y`, and then the behavior //! of `min` would follow naturally. However, I'm unsure whether this //! is desirable because that's a big requirement. //! //! //! Example //! ------- //! @include example/min.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto min = [](auto&& x, auto&& y) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename U, typename = void> struct min_impl : min_impl<T, U, when<true>> { }; struct min_t { template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) const; }; constexpr min_t min{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_MIN_HPP PK �\�[��qӷ � fwd/integral_constant.hppnu �[��� /*! @file Forward declares `boost::hana::integral_constant`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_INTEGRAL_CONSTANT_HPP #define BOOST_HANA_FWD_INTEGRAL_CONSTANT_HPP #include <boost/hana/config.hpp> #include <boost/hana/detail/integral_constant.hpp> #include <cstddef> BOOST_HANA_NAMESPACE_BEGIN //! Creates an `integral_constant` holding the given compile-time value. //! @relates hana::integral_constant //! //! Specifically, `integral_c<T, v>` is a `hana::integral_constant` //! holding the compile-time value `v` of an integral type `T`. //! //! //! @tparam T //! The type of the value to hold in the `integral_constant`. //! It must be an integral type. //! //! @tparam v //! The integral value to hold in the `integral_constant`. //! //! //! Example //! ------- //! @snippet example/integral_constant.cpp integral_c template <typename T, T v> constexpr integral_constant<T, v> integral_c{}; //! @relates hana::integral_constant template <bool b> using bool_ = integral_constant<bool, b>; //! @relates hana::integral_constant template <bool b> constexpr bool_<b> bool_c{}; //! @relates hana::integral_constant using true_ = bool_<true>; //! @relates hana::integral_constant constexpr auto true_c = bool_c<true>; //! @relates hana::integral_constant using false_ = bool_<false>; //! @relates hana::integral_constant constexpr auto false_c = bool_c<false>; //! @relates hana::integral_constant template <char c> using char_ = integral_constant<char, c>; //! @relates hana::integral_constant template <char c> constexpr char_<c> char_c{}; //! @relates hana::integral_constant template <short i> using short_ = integral_constant<short, i>; //! @relates hana::integral_constant template <short i> constexpr short_<i> short_c{}; //! @relates hana::integral_constant template <unsigned short i> using ushort_ = integral_constant<unsigned short, i>; //! @relates hana::integral_constant template <unsigned short i> constexpr ushort_<i> ushort_c{}; //! @relates hana::integral_constant template <int i> using int_ = integral_constant<int, i>; //! @relates hana::integral_constant template <int i> constexpr int_<i> int_c{}; //! @relates hana::integral_constant template <unsigned int i> using uint = integral_constant<unsigned int, i>; //! @relates hana::integral_constant template <unsigned int i> constexpr uint<i> uint_c{}; //! @relates hana::integral_constant template <long i> using long_ = integral_constant<long, i>; //! @relates hana::integral_constant template <long i> constexpr long_<i> long_c{}; //! @relates hana::integral_constant template <unsigned long i> using ulong = integral_constant<unsigned long, i>; //! @relates hana::integral_constant template <unsigned long i> constexpr ulong<i> ulong_c{}; //! @relates hana::integral_constant template <long long i> using llong = integral_constant<long long, i>; //! @relates hana::integral_constant template <long long i> constexpr llong<i> llong_c{}; //! @relates hana::integral_constant template <unsigned long long i> using ullong = integral_constant<unsigned long long, i>; //! @relates hana::integral_constant template <unsigned long long i> constexpr ullong<i> ullong_c{}; //! @relates hana::integral_constant template <std::size_t i> using size_t = integral_constant<std::size_t, i>; //! @relates hana::integral_constant template <std::size_t i> constexpr size_t<i> size_c{}; namespace literals { //! Creates a `hana::integral_constant` from a literal. //! @relatesalso boost::hana::integral_constant //! //! The literal is parsed at compile-time and the result is returned //! as a `llong<...>`. //! //! @note //! We use `llong<...>` instead of `ullong<...>` because using an //! unsigned type leads to unexpected behavior when doing stuff like //! `-1_c`. If we used an unsigned type, `-1_c` would be something //! like `ullong<-1>` which is actually `ullong<something huge>`. //! //! //! Example //! ------- //! @snippet example/integral_constant.cpp literals template <char ...c> constexpr auto operator"" _c(); } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_INTEGRAL_CONSTANT_HPP PK �\�[�S��� � fwd/transform.hppnu �[��� /*! @file Forward declares `boost::hana::transform`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_TRANSFORM_HPP #define BOOST_HANA_FWD_TRANSFORM_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Map a function over a `Functor`. //! @ingroup group-Functor //! //! //! Signature //! --------- //! Given `F` a Functor, the signature is //! \f$ //! \mathtt{transform} : F(T) \times (T \to U) \to F(U) //! \f$ //! //! @param xs //! The structure to map `f` over. //! //! @param f //! A function called as `f(x)` on element(s) `x` of the structure, //! and returning a new value to replace `x` in the structure. //! //! //! Example //! ------- //! @include example/transform.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto transform = [](auto&& xs, auto&& f) { return tag-dispatched; }; #else template <typename Xs, typename = void> struct transform_impl : transform_impl<Xs, when<true>> { }; struct transform_t { template <typename Xs, typename F> constexpr auto operator()(Xs&& xs, F&& f) const; }; constexpr transform_t transform{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_TRANSFORM_HPP PK �\�[��_/� � fwd/replicate.hppnu �[��� /*! @file Forward declares `boost::hana::replicate`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_REPLICATE_HPP #define BOOST_HANA_FWD_REPLICATE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Create a monadic structure by combining a lifted value with itself //! `n` times. //! @ingroup group-MonadPlus //! //! Given a value `x`, a non-negative `IntegralConstant` `n` and the tag //! of a monadic structure `M`, `replicate` creates a new monadic structure //! which is the result of combining `x` with itself `n` times inside the //! monadic structure. In other words, `replicate` simply `lift`s `x` into //! the monadic structure, and then combines that with itself `n` times: //! @code //! replicate<M>(x, n) == cycle(lift<M>(x), n) //! @endcode //! //! If `n` is zero, then the identity of the `concat` operation is returned. //! In the case of sequences, this corresponds to creating a new sequence //! holding `n` copies of `x`. //! //! //! Signature //! --------- //! Given an `IntegralConstant` `C` and MonadPlus `M`, the signature is //! @f$ \mathtt{replicate}_M : T \times C \to M(T) @f$. //! //! @tparam M //! The tag of the returned monadic structure. It must be a //! model of the MonadPlus concept. //! //! @param x //! The value to lift into a monadic structure and then combine with //! itself. //! //! @param n //! A non-negative `IntegralConstant` representing the number of times to //! combine `lift<M>(x)` with itself. If `n == 0`, `replicate` returns //! `empty<M>()`. //! //! //! Example //! ------- //! @include example/replicate.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename M> constexpr auto replicate = [](auto&& x, auto const& n) { return tag-dispatched; }; #else template <typename M, typename = void> struct replicate_impl : replicate_impl<M, when<true>> { }; template <typename M> struct replicate_t { template <typename X, typename N> constexpr auto operator()(X&& x, N const& n) const; }; template <typename M> constexpr replicate_t<M> replicate{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_REPLICATE_HPP PK �\�[s��h h fwd/range.hppnu �[��� /*! @file Forward declares `boost::hana::range`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_RANGE_HPP #define BOOST_HANA_FWD_RANGE_HPP #include <boost/hana/config.hpp> #include <boost/hana/fwd/core/make.hpp> #include <boost/hana/fwd/integral_constant.hpp> BOOST_HANA_NAMESPACE_BEGIN #ifdef BOOST_HANA_DOXYGEN_INVOKED //! @ingroup group-datatypes //! Compile-time half-open interval of `hana::integral_constant`s. //! //! A `range` represents a half-open interval of the form `[from, to)` //! containing `hana::integral_constant`s of a given type. The `[from, to)` //! notation represents the values starting at `from` (inclusively) up //! to but excluding `from`. In other words, it is a bit like the list //! `from, from+1, ..., to-1`. //! //! In particular, note that the bounds of the range can be any //! `hana::integral_constant`s (negative numbers are allowed) and the //! range does not have to start at zero. The only requirement is that //! `from <= to`. //! //! @note //! The representation of `hana::range` is implementation defined. In //! particular, one should not take for granted the number and types //! of template parameters. The proper way to create a `hana::range` //! is to use `hana::range_c` or `hana::make_range`. More details //! [in the tutorial](@ref tutorial-containers-types). //! //! //! Modeled concepts //! ---------------- //! 1. `Comparable`\n //! Two ranges are equal if and only if they are both empty or they both //! span the same interval. //! @include example/range/comparable.cpp //! //! 2. `Foldable`\n //! Folding a `range` is equivalent to folding a list of the //! `integral_constant`s in the interval it spans. //! @include example/range/foldable.cpp //! //! 3. `Iterable`\n //! Iterating over a `range` is equivalent to iterating over a list of //! the values it spans. In other words, iterating over the range //! `[from, to)` is equivalent to iterating over a list containing //! `from, from+1, from+2, ..., to-1`. Also note that `operator[]` can //! be used in place of the `at` function. //! @include example/range/iterable.cpp //! //! 4. `Searchable`\n //! Searching a `range` is equivalent to searching a list of the values //! in the range `[from, to)`, but it is much more compile-time efficient. //! @include example/range/searchable.cpp template <typename T, T from, T to> struct range { //! Equivalent to `hana::equal` template <typename X, typename Y> friend constexpr auto operator==(X&& x, Y&& y); //! Equivalent to `hana::not_equal` template <typename X, typename Y> friend constexpr auto operator!=(X&& x, Y&& y); //! Equivalent to `hana::at` template <typename N> constexpr decltype(auto) operator[](N&& n); }; #else template <typename T, T from, T to> struct range; #endif //! Tag representing a `hana::range`. //! @relates hana::range struct range_tag { }; #ifdef BOOST_HANA_DOXYGEN_INVOKED //! Create a `hana::range` representing a half-open interval of //! `integral_constant`s. //! @relates hana::range //! //! Given two `IntegralConstant`s `from` and `to`, `make<range_tag>` //! returns a `hana::range` representing the half-open interval of //! `integral_constant`s `[from, to)`. `from` and `to` must form a //! valid interval, which means that `from <= to` must be true. Otherwise, //! a compilation error is triggered. Also note that if `from` and `to` //! are `IntegralConstant`s with different underlying integral types, //! the created range contains `integral_constant`s whose underlying //! type is their common type. //! //! //! Example //! ------- //! @include example/range/make.cpp template <> constexpr auto make<range_tag> = [](auto const& from, auto const& to) { return range<implementation_defined>{implementation_defined}; }; #endif //! Alias to `make<range_tag>`; provided for convenience. //! @relates hana::range constexpr auto make_range = make<range_tag>; //! Shorthand to create a `hana::range` with the given bounds. //! @relates hana::range //! //! This shorthand is provided for convenience only and it is equivalent //! to `make_range`. Specifically, `range_c<T, from, to>` is such that //! @code //! range_c<T, from, to> == make_range(integral_c<T, from>, integral_c<T, to>) //! @endcode //! //! //! @tparam T //! The underlying integral type of the `integral_constant`s in the //! created range. //! //! @tparam from //! The inclusive lower bound of the created range. //! //! @tparam to //! The exclusive upper bound of the created range. //! //! //! Example //! ------- //! @include example/range/range_c.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename T, T from, T to> constexpr auto range_c = make_range(integral_c<T, from>, integral_c<T, to>); #else template <typename T, T from, T to> constexpr range<T, from, to> range_c{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_RANGE_HPP PK �\�[��ɀ � fwd/scan_left.hppnu �[��� /*! @file Forward declares `boost::hana::scan_left`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_SCAN_LEFT_HPP #define BOOST_HANA_FWD_SCAN_LEFT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Fold a Sequence to the left and return a list containing the //! successive reduction states. //! @ingroup group-Sequence //! //! Like `fold_left`, `scan_left` reduces a sequence to a single value //! using a binary operation. However, unlike `fold_left`, it builds up //! a sequence of the intermediary results computed along the way and //! returns that instead of only the final reduction state. Like //! `fold_left`, `scan_left` can be used with or without an initial //! reduction state. //! //! When the sequence is empty, two things may arise. If an initial state //! was provided, a singleton list containing that state is returned. //! Otherwise, if no initial state was provided, an empty list is //! returned. In particular, unlike for `fold_left`, using `scan_left` //! on an empty sequence without an initial state is not an error. //! //! More specifically, `scan_left([x1, ..., xn], state, f)` is a sequence //! whose `i`th element is equivalent to `fold_left([x1, ..., xi], state, f)`. //! The no-state variant is handled in an analogous way. For illustration, //! consider this left fold on a short sequence: //! @code //! fold_left([x1, x2, x3], state, f) == f(f(f(state, x1), x2), x3) //! @endcode //! //! The analogous sequence generated with `scan_left` will be //! @code //! scan_left([x1, x2, x3], state, f) == [ //! state, //! f(state, x1), //! f(f(state, x1), x2), //! f(f(f(state, x1), x2), x3) //! ] //! @endcode //! //! Similarly, consider this left fold (without an initial state) on //! a short sequence: //! @code //! fold_left([x1, x2, x3, x4], f) == f(f(f(x1, x2), x3), x4) //! @endcode //! //! The analogous sequence generated with `scan_left` will be //! @code //! scan_left([x1, x2, x3, x4], f) == [ //! x1, //! f(x1, x2), //! f(f(x1, x2), x3), //! f(f(f(x1, x2), x3), x4) //! ] //! @endcode //! //! @param xs //! The sequence to scan from the left. //! //! @param state //! The (optional) initial reduction state. //! //! @param f //! A binary function called as `f(state, x)`, where `state` is the //! result accumulated so far and `x` is an element in the sequence. //! If no initial state is provided, `f` is called as `f(x1, x2)`, //! where `x1` and `x2` are both elements of the sequence. //! //! //! Example //! ------- //! @include example/scan_left.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto scan_left = [](auto&& xs[, auto&& state], auto const& f) { return tag-dispatched; }; #else template <typename S, typename = void> struct scan_left_impl : scan_left_impl<S, when<true>> { }; struct scan_left_t { template <typename Xs, typename State, typename F> constexpr auto operator()(Xs&& xs, State&& state, F const& f) const; template <typename Xs, typename F> constexpr auto operator()(Xs&& xs, F const& f) const; }; constexpr scan_left_t scan_left{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_SCAN_LEFT_HPP PK �\�[ �� � fwd/none.hppnu �[��� /*! @file Forward declares `boost::hana::none`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_NONE_HPP #define BOOST_HANA_FWD_NONE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns whether all of the keys of the structure are false-valued. //! @ingroup group-Searchable //! //! The keys of the structure must be `Logical`s. If the structure is not //! finite, a true-valued key must appear at a finite "index" in order //! for this method to finish. //! //! //! Example //! ------- //! @include example/none.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto none = [](auto&& xs) -> decltype(auto) { return tag-dispatched; }; #else template <typename S, typename = void> struct none_impl : none_impl<S, when<true>> { }; struct none_t { template <typename Xs> constexpr auto operator()(Xs&& xs) const; }; constexpr none_t none{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_NONE_HPP PK �\�[� X� � fwd/find_if.hppnu �[��� /*! @file Forward declares `boost::hana::find_if`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_FIND_IF_HPP #define BOOST_HANA_FWD_FIND_IF_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Finds the value associated to the first key satisfying a predicate. //! @ingroup group-Searchable //! //! Given a `Searchable` structure `xs` and a predicate `pred`, //! `find_if(xs, pred)` returns `just` the first element whose key //! satisfies the predicate, or `nothing` if there is no such element. //! //! //! @param xs //! The structure to be searched. //! //! @param predicate //! A function called as `predicate(k)`, where `k` is a key of the //! structure, and returning whether `k` is the key of the element //! being searched for. In the current version of the library, the //! predicate has to return an `IntegralConstant` holding a value //! that can be converted to `bool`. //! //! //! Example //! ------- //! @include example/find_if.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto find_if = [](auto&& xs, auto&& predicate) { return tag-dispatched; }; #else template <typename S, typename = void> struct find_if_impl : find_if_impl<S, when<true>> { }; struct find_if_t { template <typename Xs, typename Pred> constexpr auto operator()(Xs&& xs, Pred&& pred) const; }; constexpr find_if_t find_if{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_FIND_IF_HPP PK �\�[� ��6 6 fwd/index_if.hppnu �[��� /*! @file Forward declares `boost::hana::index_if`. @copyright Louis Dionne 2013-2017 @copyright Jason Rice 2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_INDEX_IF_HPP #define BOOST_HANA_FWD_INDEX_IF_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Finds the value associated to the first key satisfying a predicate. //! @ingroup group-Iterable //! //! Given an `Iterable` structure `xs` and a predicate `pred`, //! `index_if(xs, pred)` returns a `hana::optional` containing an `IntegralConstant` //! of the index of the first element that satisfies the predicate or nothing //! if no element satisfies the predicate. //! //! //! @param xs //! The structure to be searched. //! //! @param predicate //! A function called as `predicate(x)`, where `x` is an element of the //! `Iterable` structure and returning whether `x` is the element being //! searched for. In the current version of the library, the predicate //! has to return an `IntegralConstant` holding a value that can be //! converted to `bool`. //! //! //! Example //! ------- //! @include example/index_if.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto index_if = [](auto&& xs, auto&& predicate) { return tag-dispatched; }; #else template <typename S, typename = void> struct index_if_impl : index_if_impl<S, when<true>> { }; struct index_if_t { template <typename Xs, typename Pred> constexpr auto operator()(Xs&& xs, Pred&& pred) const; }; constexpr index_if_t index_if{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_INDEX_IF_HPP PK �\�[&��G� � fwd/take_while.hppnu �[��� /*! @file Forward declares `boost::hana::take_while`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_TAKE_WHILE_HPP #define BOOST_HANA_FWD_TAKE_WHILE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Take elements from a sequence while the `predicate` is satisfied. //! @ingroup group-Sequence //! //! Specifically, `take_while` returns a new sequence containing the //! longest prefix of `xs` in which all the elements satisfy the given //! predicate. //! //! //! @param xs //! The sequence to take elements from. //! //! @param predicate //! A function called as `predicate(x)`, where `x` is an element of the //! sequence, and returning a `Logical` representing whether `x` should be //! included in the resulting sequence. In the current version of the //! library, `predicate` has to return a `Constant Logical`. //! //! //! Example //! ------- //! @include example/take_while.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto take_while = [](auto&& xs, auto&& predicate) { return tag-dispatched; }; #else template <typename S, typename = void> struct take_while_impl : take_while_impl<S, when<true>> { }; struct take_while_t { template <typename Xs, typename Pred> constexpr auto operator()(Xs&& xs, Pred&& pred) const; }; constexpr take_while_t take_while{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_TAKE_WHILE_HPP PK �\�[�m~< < fwd/adapt_adt.hppnu �[��� /*! @file Documents the `BOOST_HANA_ADAPT_ADT` macro. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_ADAPT_ADT_HPP #define BOOST_HANA_FWD_ADAPT_ADT_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN // Note: // The weird definition as a variable seems to exploit a glitch in Doxygen // which makes the macro appear in the related objects of Struct (as we // want it to). //! Defines a model of `Struct` with the given accessors. //! @ingroup group-Struct //! //! Using this macro at _global scope_ will define a model of the `Struct` //! concept for the given type. This can be used to easily adapt existing //! user-defined types in a ad-hoc manner. Unlike `BOOST_HANA_ADAPT_STRUCT`, //! this macro requires specifying the way to retrieve each member by //! providing a function that does the extraction. //! //! @note //! This macro only works if the tag of the user-defined type `T` is `T` //! itself. This is the case unless you specifically asked for something //! different; see `tag_of`'s documentation. //! //! //! Example //! ------- //! @include example/adapt_adt.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED auto BOOST_HANA_ADAPT_ADT(...) = ; #define BOOST_HANA_ADAPT_ADT(Name, ...) see documentation #else // defined in <boost/hana/adapt_adt.hpp> #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ADAPT_ADT_HPP PK �\�[7oqdI dI fwd/optional.hppnu �[��� /*! @file Forward declares `boost::hana::optional`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_OPTIONAL_HPP #define BOOST_HANA_FWD_OPTIONAL_HPP #include <boost/hana/config.hpp> #include <boost/hana/detail/operators/adl.hpp> #include <boost/hana/fwd/core/make.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-datatypes //! Optional value whose optional-ness is known at compile-time. //! //! An `optional` either contains a value (represented as `just(x)`), or //! it is empty (represented as `nothing`). In essence, `hana::optional` //! is pretty much like a `boost::optional` or the upcoming `std::optional`, //! except for the fact that whether a `hana::optional` is empty or not is //! known at compile-time. This can be particularly useful for returning //! from a function that might fail, but whose reason for failing is not //! important. Of course, whether the function will fail has to be known //! at compile-time. //! //! This is really an important difference between `hana::optional` and //! `std::optional`. Unlike `std::optional<T>{}` and `std::optional<T>{x}` //! who share the same type (`std::optional<T>`), `hana::just(x)` and //! `hana::nothing` do not share the same type, since the state of the //! optional has to be known at compile-time. Hence, whether a `hana::just` //! or a `hana::nothing` will be returned from a function has to be known //! at compile-time for the return type of that function to be computable //! by the compiler. This makes `hana::optional` well suited for static //! metaprogramming tasks, but very poor for anything dynamic. //! //! @note //! When you use a container, remember not to make assumptions about its //! representation, unless the documentation gives you those guarantees. //! More details [in the tutorial](@ref tutorial-containers-types). //! //! //! Interoperation with `type`s //! --------------------------- //! When a `just` contains an object of type `T` which is a `type`, //! it has a nested `::%type` alias equivalent to `T::%type`. `nothing`, //! however, never has a nested `::%type` alias. If `t` is a `type`, //! this allows `decltype(just(t))` to be seen as a nullary metafunction //! equivalent to `decltype(t)`. Along with the `sfinae` function, //! this allows `hana::optional` to interact seamlessly with //! SFINAE-friendly metafunctions. //! Example: //! @include example/optional/sfinae_friendly_metafunctions.cpp //! //! //! Modeled concepts //! ---------------- //! 1. `Comparable`\n //! Two `optional`s are equal if and only if they are both empty or they //! both contain a value and those values are equal. //! @include example/optional/comparable.cpp //! //! 2. `Orderable`\n //! Optional values can be ordered by considering the value they are //! holding, if any. To handle the case of an empty optional value, we //! arbitrarily set `nothing` as being less than any other `just`. Hence, //! @code //! just(x) < just(y) if and only if x < y //! nothing < just(anything) //! @endcode //! Example: //! @include example/optional/orderable.cpp //! //! 3. `Functor`\n //! An optional value can be seen as a list containing either one element //! (`just(x)`) or no elements at all (`nothing`). As such, mapping //! a function over an optional value is equivalent to applying it to //! its value if there is one, and to `nothing` otherwise: //! @code //! transform(just(x), f) == just(f(x)) //! transform(nothing, f) == nothing //! @endcode //! Example: //! @include example/optional/functor.cpp //! //! 4. `Applicative`\n //! First, a value can be made optional with `lift<optional_tag>`, which //! is equivalent to `just`. Second, one can feed an optional value to an //! optional function with `ap`, which will return `just(f(x))` if there //! is both a function _and_ a value, and `nothing` otherwise: //! @code //! ap(just(f), just(x)) == just(f(x)) //! ap(nothing, just(x)) == nothing //! ap(just(f), nothing) == nothing //! ap(nothing, nothing) == nothing //! @endcode //! A simple example: //! @include example/optional/applicative.cpp //! A more complex example: //! @include example/optional/applicative.complex.cpp //! //! 5. `Monad`\n //! The `Monad` model makes it easy to compose actions that might fail. //! One can feed an optional value if there is one into a function with //! `chain`, which will return `nothing` if there is no value. Finally, //! optional-optional values can have their redundant level of optionality //! removed with `flatten`. Also note that the `|` operator can be used in //! place of the `chain` function. //! Example: //! @include example/optional/monad.cpp //! //! 6. `MonadPlus`\n //! The `MonadPlus` model allows choosing the first valid value out of //! two optional values with `concat`. If both optional values are //! `nothing`s, `concat` will return `nothing`. //! Example: //! @include example/optional/monad_plus.cpp //! //! 7. `Foldable`\n //! Folding an optional value is equivalent to folding a list containing //! either no elements (for `nothing`) or `x` (for `just(x)`). //! Example: //! @include example/optional/foldable.cpp //! //! 8. `Searchable`\n //! Searching an optional value is equivalent to searching a list //! containing `x` for `just(x)` and an empty list for `nothing`. //! Example: //! @include example/optional/searchable.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename ...T> struct optional { // 5.3.1, Constructors //! Default-construct an `optional`. Only exists if the optional //! contains a value, and if that value is DefaultConstructible. constexpr optional() = default; //! Copy-construct an `optional`. //! An empty optional may only be copy-constructed from another //! empty `optional`, and an `optional` with a value may only be //! copy-constructed from another `optional` with a value. //! Furthermore, this constructor only exists if the value //! held in the `optional` is CopyConstructible. optional(optional const&) = default; //! Move-construct an `optional`. //! An empty optional may only be move-constructed from another //! empty `optional`, and an `optional` with a value may only be //! move-constructed from another `optional` with a value. //! Furthermore, this constructor only exists if the value //! held in the `optional` is MoveConstructible. optional(optional&&) = default; //! Construct an `optional` holding a value of type `T` from another //! object of type `T`. The value is copy-constructed. constexpr optional(T const& t) : value_(t) { } //! Construct an `optional` holding a value of type `T` from another //! object of type `T`. The value is move-constructed. constexpr optional(T&& t) : value_(static_cast<T&&>(t)) { } // 5.3.3, Assignment //! Copy-assign an `optional`. //! An empty optional may only be copy-assigned from another empty //! `optional`, and an `optional` with a value may only be copy-assigned //! from another `optional` with a value. Furthermore, this assignment //! operator only exists if the value held in the `optional` is //! CopyAssignable. constexpr optional& operator=(optional const&) = default; //! Move-assign an `optional`. //! An empty optional may only be move-assigned from another empty //! `optional`, and an `optional` with a value may only be move-assigned //! from another `optional` with a value. Furthermore, this assignment //! operator only exists if the value held in the `optional` is //! MoveAssignable. constexpr optional& operator=(optional&&) = default; // 5.3.5, Observers //! Returns a pointer to the contained value, or a `nullptr` if the //! `optional` is empty. //! //! //! @note Overloads of this method are provided for both the `const` //! and the non-`const` cases. //! //! //! Example //! ------- //! @include example/optional/value.cpp constexpr T* operator->(); //! Extract the content of an `optional`, or fail at compile-time. //! //! If `*this` contains a value, that value is returned. Otherwise, //! a static assertion is triggered. //! //! @note //! Overloads of this method are provided for the cases where `*this` //! is a reference, a rvalue-reference and their `const` counterparts. //! //! //! Example //! ------- //! @include example/optional/value.cpp constexpr T& value(); //! Equivalent to `value()`, provided for convenience. //! //! @note //! Overloads of this method are provided for the cases where `*this` //! is a reference, a rvalue-reference and their `const` counterparts. //! //! //! Example //! ------- //! @include example/optional/value.cpp constexpr T& operator*(); //! Return the contents of an `optional`, with a fallback result. //! //! If `*this` contains a value, that value is returned. Otherwise, //! the default value provided is returned. //! //! @note //! Overloads of this method are provided for the cases where `*this` //! is a reference, a rvalue-reference and their `const` counterparts. //! //! //! @param default_ //! The default value to return if `*this` does not contain a value. //! //! //! Example //! ------- //! @include example/optional/value_or.cpp template <typename U> constexpr decltype(auto) value_or(U&& default_); //! Equivalent to `hana::chain`. template <typename ...T, typename F> friend constexpr auto operator|(optional<T...>, F); //! Equivalent to `hana::equal` template <typename X, typename Y> friend constexpr auto operator==(X&& x, Y&& y); //! Equivalent to `hana::not_equal` template <typename X, typename Y> friend constexpr auto operator!=(X&& x, Y&& y); //! Equivalent to `hana::less` template <typename X, typename Y> friend constexpr auto operator<(X&& x, Y&& y); //! Equivalent to `hana::greater` template <typename X, typename Y> friend constexpr auto operator>(X&& x, Y&& y); //! Equivalent to `hana::less_equal` template <typename X, typename Y> friend constexpr auto operator<=(X&& x, Y&& y); //! Equivalent to `hana::greater_equal` template <typename X, typename Y> friend constexpr auto operator>=(X&& x, Y&& y); }; #else template <typename ...T> struct optional; #endif //! Tag representing a `hana::optional`. //! @relates hana::optional struct optional_tag { }; //! Create an optional value. //! @relates hana::optional //! //! Specifically, `make<optional_tag>()` is equivalent to `nothing`, and //! `make<optional_tag>(x)` is equivalent to `just(x)`. This is provided //! for consistency with the other `make<...>` functions. //! //! //! Example //! ------- //! @include example/optional/make.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <> constexpr auto make<optional_tag> = []([auto&& x]) { return optional<std::decay<decltype(x)>::type>{forwarded(x)}; }; #endif //! Alias to `make<optional_tag>`; provided for convenience. //! @relates hana::optional //! //! //! Example //! ------- //! @include example/optional/make.cpp constexpr auto make_optional = make<optional_tag>; //! Create an optional value containing `x`. //! @relates hana::optional //! //! //! Example //! ------- //! @include example/optional/just.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto just = [](auto&& x) { return optional<std::decay<decltype(x)>::type>{forwarded(x)}; }; #else struct make_just_t { template <typename T> constexpr auto operator()(T&&) const; }; constexpr make_just_t just{}; #endif //! An empty optional value. //! @relates hana::optional //! //! //! Example //! ------- //! @include example/optional/nothing.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr optional<> nothing{}; #else template <> struct optional<> : detail::operators::adl<optional<>> { // 5.3.1, Constructors constexpr optional() = default; constexpr optional(optional const&) = default; constexpr optional(optional&&) = default; // 5.3.3, Assignment constexpr optional& operator=(optional const&) = default; constexpr optional& operator=(optional&&) = default; // 5.3.5, Observers constexpr decltype(nullptr) operator->() const { return nullptr; } template <typename ...dummy> constexpr auto value() const; template <typename ...dummy> constexpr auto operator*() const; template <typename U> constexpr U&& value_or(U&& u) const; }; constexpr optional<> nothing{}; #endif //! Apply a function to the contents of an optional, with a fallback //! result. //! @relates hana::optional //! //! Specifically, `maybe` takes a default value, a function and an //! optional value. If the optional value is `nothing`, the default //! value is returned. Otherwise, the function is applied to the //! content of the `just`. //! //! //! @param default_ //! A default value returned if `m` is `nothing`. //! //! @param f //! A function called as `f(x)` if and only if `m` is an optional value //! of the form `just(x)`. In that case, the result returend by `maybe` //! is the result of `f`. //! //! @param m //! An optional value. //! //! //! Example //! ------- //! @include example/optional/maybe.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto maybe = [](auto&& default_, auto&& f, auto&& m) -> decltype(auto) { if (m is a just(x)) { return forwarded(f)(forwarded(x)); else return forwarded(default_); } }; #else struct maybe_t { template <typename Def, typename F, typename T> constexpr decltype(auto) operator()(Def&&, F&& f, optional<T> const& m) const { return static_cast<F&&>(f)(m.value_); } template <typename Def, typename F, typename T> constexpr decltype(auto) operator()(Def&&, F&& f, optional<T>& m) const { return static_cast<F&&>(f)(m.value_); } template <typename Def, typename F, typename T> constexpr decltype(auto) operator()(Def&&, F&& f, optional<T>&& m) const { return static_cast<F&&>(f)(static_cast<optional<T>&&>(m).value_); } template <typename Def, typename F> constexpr Def operator()(Def&& def, F&&, optional<> const&) const { return static_cast<Def&&>(def); } }; constexpr maybe_t maybe{}; #endif //! Calls a function if the call expression is well-formed. //! @relates hana::optional //! //! Given a function `f`, `sfinae` returns a new function applying `f` //! to its arguments and returning `just` the result if the call is //! well-formed, and `nothing` otherwise. In other words, `sfinae(f)(x...)` //! is `just(f(x...))` if that expression is well-formed, and `nothing` //! otherwise. Note, however, that it is possible for an expression //! `f(x...)` to be well-formed as far as SFINAE is concerned, but //! trying to actually compile `f(x...)` still fails. In this case, //! `sfinae` won't be able to detect it and a hard failure is likely //! to happen. //! //! //! @note //! The function given to `sfinae` must not return `void`, since //! `just(void)` does not make sense. A compilation error is //! triggered if the function returns void. //! //! //! Example //! ------- //! @include example/optional/sfinae.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED auto sfinae = [](auto&& f) { return [perfect-capture](auto&& ...x) { if (decltype(forwarded(f)(forwarded(x)...)) is well-formed) return just(forwarded(f)(forwarded(x)...)); else return nothing; }; }; #else struct sfinae_t { template <typename F> constexpr decltype(auto) operator()(F&& f) const; }; constexpr sfinae_t sfinae{}; #endif //! Return whether an `optional` contains a value. //! @relates hana::optional //! //! Specifically, returns a compile-time true-valued `Logical` if `m` is //! of the form `just(x)` for some `x`, and a false-valued one otherwise. //! //! //! Example //! ------- //! @include example/optional/is_just.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto is_just = [](auto const& m) { return m is a just(x); }; #else struct is_just_t { template <typename ...T> constexpr auto operator()(optional<T...> const&) const; }; constexpr is_just_t is_just{}; #endif //! Return whether an `optional` is empty. //! @relates hana::optional //! //! Specifically, returns a compile-time true-valued `Logical` if `m` is //! a `nothing`, and a false-valued one otherwise. //! //! //! Example //! ------- //! @include example/optional/is_nothing.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto is_nothing = [](auto const& m) { return m is a nothing; }; #else struct is_nothing_t { template <typename ...T> constexpr auto operator()(optional<T...> const&) const; }; constexpr is_nothing_t is_nothing{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_OPTIONAL_HPP PK �\�[m� fwd/at_key.hppnu �[��� /*! @file Forward declares `boost::hana::at_key`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_AT_KEY_HPP #define BOOST_HANA_FWD_AT_KEY_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns the value associated to the given key in a structure, or fail. //! @ingroup group-Searchable //! //! Given a `key` and a `Searchable` structure, `at_key` returns the first //! value whose key is equal to the given `key`, and fails at compile-time //! if no such key exists. This requires the `key` to be compile-time //! `Comparable`, exactly like for `find`. `at_key` satisfies the following: //! @code //! at_key(xs, key) == find(xs, key).value() //! @endcode //! //! If the `Searchable` actually stores the elements it contains, `at_key` //! is required to return a lvalue reference, a lvalue reference to const //! or a rvalue reference to the found value, where the type of reference //! must match that of the structure passed to `at_key`. If the `Searchable` //! does not store the elements it contains (i.e. it generates them on //! demand), this requirement is dropped. //! //! //! @param xs //! The structure to be searched. //! //! @param key //! A key to be searched for in the structure. The key has to be //! `Comparable` with the other keys of the structure. In the current //! version of the library, the comparison of `key` with any other key //! of the structure must return a compile-time `Logical`. //! //! //! Example //! ------- //! @include example/at_key.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto at_key = [](auto&& xs, auto const& key) -> decltype(auto) { return tag-dispatched; }; #else template <typename S, typename = void> struct at_key_impl : at_key_impl<S, when<true>> { }; struct at_key_t { template <typename Xs, typename Key> constexpr decltype(auto) operator()(Xs&& xs, Key const& key) const; }; constexpr at_key_t at_key{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_AT_KEY_HPP PK �\�[c�ӑi i fwd/drop_front_exactly.hppnu �[��� /*! @file Forward declares `boost::hana::drop_front_exactly`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_DROP_FRONT_EXACTLY_HPP #define BOOST_HANA_FWD_DROP_FRONT_EXACTLY_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Drop the first `n` elements of an iterable, and return the rest. //! @ingroup group-Iterable //! //! Given an `Iterable` `xs` with a linearization of `[x1, x2, ...]` and //! a non-negative `IntegralConstant` `n`, `drop_front_exactly(xs, n)` is //! an iterable with the same tag as `xs` whose linearization is //! `[xn+1, xn+2, ...]`. In particular, note that this function does not //! mutate the original iterable in any way. If `n` is not given, it //! defaults to an `IntegralConstant` with a value equal to `1`. //! //! It is an error to use `drop_front_exactly` with `n > length(xs)`. This //! additional guarantee allows `drop_front_exactly` to be better optimized //! than the `drop_front` function, which allows `n > length(xs)`. //! //! //! @param xs //! The iterable from which elements are dropped. //! //! @param n //! A non-negative `IntegralConstant` representing the number of elements //! to be dropped from the iterable. In addition to being non-negative, //! `n` must be less than or equal to the number of elements in `xs`. //! If `n` is not given, it defaults to an `IntegralConstant` with a value //! equal to `1`. //! //! //! Example //! ------- //! @include example/drop_front_exactly.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto drop_front_exactly = [](auto&& xs[, auto const& n]) { return tag-dispatched; }; #else template <typename It, typename = void> struct drop_front_exactly_impl : drop_front_exactly_impl<It, when<true>> { }; struct drop_front_exactly_t { template <typename Xs, typename N> constexpr auto operator()(Xs&& xs, N const& n) const; template <typename Xs> constexpr auto operator()(Xs&& xs) const; }; constexpr drop_front_exactly_t drop_front_exactly{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_DROP_FRONT_EXACTLY_HPP PK �\�[4?֎� � fwd/symmetric_difference.hppnu �[��� /*! @file Forward declares `boost::hana::symmetric_difference`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_SYMMETRIC_DIFFERENCE_HPP #define BOOST_HANA_FWD_SYMMETRIC_DIFFERENCE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN // Note: This function is documented per datatype/concept only. //! @cond template <typename S, typename = void> struct symmetric_difference_impl : symmetric_difference_impl<S, when<true>> { }; //! @endcond struct symmetric_difference_t { template <typename Xs, typename Ys> constexpr auto operator()(Xs&&, Ys&&) const; }; constexpr symmetric_difference_t symmetric_difference{}; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_SYMMETRIC_DIFFERENCE_HPP PK �\�[T�d�M �M fwd/type.hppnu �[��� /*! @file Forward declares `boost::hana::type` and related utilities. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_TYPE_HPP #define BOOST_HANA_FWD_TYPE_HPP #include <boost/hana/config.hpp> #include <boost/hana/fwd/core/make.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Base class of `hana::type`; used for pattern-matching. //! @relates hana::type //! //! Example //! ------- //! @include example/type/basic_type.cpp template <typename T> struct basic_type; //! @ingroup group-datatypes //! C++ type in value-level representation. //! //! A `type` is a special kind of object representing a C++ type like //! `int`, `void`, `std::vector<float>` or anything else you can imagine. //! //! This page explains how `type`s work at a low level. To gain //! intuition about type-level metaprogramming in Hana, you should //! read the [tutorial section](@ref tutorial-type) on type-level //! computations. //! //! //! @note //! For subtle reasons, the actual representation of `hana::type` is //! implementation-defined. In particular, `hana::type` may be a dependent //! type, so one should not attempt to do pattern matching on it. However, //! one can assume that `hana::type` _inherits_ from `hana::basic_type`, //! which can be useful when declaring overloaded functions: //! @code //! template <typename T> //! void f(hana::basic_type<T>) { //! // do something with T //! } //! @endcode //! The full story is that [ADL][] causes template arguments to be //! instantiated. Hence, if `hana::type` were defined naively, expressions //! like `hana::type<T>{} == hana::type<U>{}` would cause both `T` and `U` //! to be instantiated. This is usually not a problem, except when `T` or //! `U` should not be instantiated. To avoid these instantiations, //! `hana::type` is implemented using some cleverness, and that is //! why the representation is implementation-defined. When that //! behavior is not required, `hana::basic_type` can be used instead. //! //! //! @anchor type_lvalues_and_rvalues //! Lvalues and rvalues //! ------------------- //! When storing `type`s in heterogeneous containers, some algorithms //! will return references to those objects. Since we are primarily //! interested in accessing their nested `::%type`, receiving a reference //! is undesirable; we would end up trying to fetch the nested `::%type` //! inside a reference type, which is a compilation error: //! @code //! auto ts = make_tuple(type_c<int>, type_c<char>); //! using T = decltype(ts[0_c])::type; // error: 'ts[0_c]' is a reference! //! @endcode //! //! For this reason, `type`s provide an overload of the unary `+` //! operator that can be used to turn a lvalue into a rvalue. So when //! using a result which might be a reference to a `type` object, one //! can use `+` to make sure a rvalue is obtained before fetching its //! nested `::%type`: //! @code //! auto ts = make_tuple(type_c<int>, type_c<char>); //! using T = decltype(+ts[0_c])::type; // ok: '+ts[0_c]' is an rvalue //! @endcode //! //! //! Modeled concepts //! ---------------- //! 1. `Comparable`\n //! Two types are equal if and only if they represent the same C++ type. //! Hence, equality is equivalent to the `std::is_same` type trait. //! @include example/type/comparable.cpp //! //! 2. `Hashable`\n //! The hash of a type is just that type itself. In other words, `hash` //! is the identity function on `hana::type`s. //! @include example/type/hashable.cpp //! //! [ADL]: http://en.cppreference.com/w/cpp/language/adl #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename T> struct type { //! Returns rvalue of self. //! See @ref type_lvalues_and_rvalues "description". constexpr auto operator+() const; //! Equivalent to `hana::equal` template <typename X, typename Y> friend constexpr auto operator==(X&& x, Y&& y); //! Equivalent to `hana::not_equal` template <typename X, typename Y> friend constexpr auto operator!=(X&& x, Y&& y); }; #else template <typename T> struct type_impl; template <typename T> using type = typename type_impl<T>::_; #endif //! Tag representing `hana::type`. //! @relates hana::type struct type_tag { }; //! Creates an object representing the C++ type `T`. //! @relates hana::type template <typename T> constexpr type<T> type_c{}; //! `decltype` keyword, lifted to Hana. //! @relates hana::type //! //! @deprecated //! The semantics of `decltype_` can be confusing, and `hana::typeid_` //! should be preferred instead. `decltype_` may be removed in the next //! major version of the library. //! //! `decltype_` is somewhat equivalent to `decltype` in that it returns //! the type of an object, except it returns it as a `hana::type` which //! is a first-class citizen of Hana instead of a raw C++ type. //! Specifically, given an object `x`, `decltype_` satisfies //! @code //! decltype_(x) == type_c<decltype(x) with references stripped> //! @endcode //! //! As you can see, `decltype_` will strip any reference from the //! object's actual type. The reason for doing so is explained below. //! However, any `cv`-qualifiers will be retained. Also, when given a //! `hana::type`, `decltype_` is just the identity function. Hence, //! for any C++ type `T`, //! @code //! decltype_(type_c<T>) == type_c<T> //! @endcode //! //! In conjunction with the way `metafunction` & al. are specified, this //! behavior makes it easier to interact with both types and values at //! the same time. However, it does make it impossible to create a `type` //! containing another `type` with `decltype_`. In other words, it is //! not possible to create a `type_c<decltype(type_c<T>)>` with this //! utility, because `decltype_(type_c<T>)` would be just `type_c<T>` //! instead of `type_c<decltype(type_c<T>)>`. This use case is assumed //! to be rare and a hand-coded function can be used if this is needed. //! //! //! ### Rationale for stripping the references //! The rules for template argument deduction are such that a perfect //! solution that always matches `decltype` is impossible. Hence, we //! have to settle on a solution that's good and and consistent enough //! for our needs. One case where matching `decltype`'s behavior is //! impossible is when the argument is a plain, unparenthesized variable //! or function parameter. In that case, `decltype_`'s argument will be //! deduced as a reference to that variable, but `decltype` would have //! given us the actual type of that variable, without references. Also, //! given the current definition of `metafunction` & al., it would be //! mostly useless if `decltype_` could return a reference, because it //! is unlikely that `F` expects a reference in its simplest use case: //! @code //! int i = 0; //! auto result = metafunction<F>(i); //! @endcode //! //! Hence, always discarding references seems to be the least painful //! solution. //! //! //! Example //! ------- //! @include example/type/decltype.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto decltype_ = see documentation; #else struct decltype_t { template <typename T> constexpr auto operator()(T&&) const; }; constexpr decltype_t decltype_{}; #endif //! Returns a `hana::type` representing the type of a given object. //! @relates hana::type //! //! `hana::typeid_` is somewhat similar to `typeid` in that it returns //! something that represents the type of an object. However, what //! `typeid` returns represent the _runtime_ type of the object, while //! `hana::typeid_` returns the _static_ type of the object. Specifically, //! given an object `x`, `typeid_` satisfies //! @code //! typeid_(x) == type_c<decltype(x) with ref and cv-qualifiers stripped> //! @endcode //! //! As you can see, `typeid_` strips any reference and cv-qualifier from //! the object's actual type. The reason for doing so is that it faithfully //! models how the language's `typeid` behaves with respect to reference //! and cv-qualifiers, and it also turns out to be the desirable behavior //! most of the time. Also, when given a `hana::type`, `typeid_` is just //! the identity function. Hence, for any C++ type `T`, //! @code //! typeid_(type_c<T>) == type_c<T> //! @endcode //! //! In conjunction with the way `metafunction` & al. are specified, this //! behavior makes it easier to interact with both types and values at //! the same time. However, it does make it impossible to create a `type` //! containing another `type` using `typeid_`. This use case is assumed //! to be rare and a hand-coded function can be used if this is needed. //! //! //! Example //! ------- //! @include example/type/typeid.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto typeid_ = see documentation; #else struct typeid_t { template <typename T> constexpr auto operator()(T&&) const; }; constexpr typeid_t typeid_{}; #endif #ifdef BOOST_HANA_DOXYGEN_INVOKED //! Equivalent to `decltype_`, provided for convenience. //! @relates hana::type //! //! //! Example //! ------- //! @include example/type/make.cpp template <> constexpr auto make<type_tag> = hana::decltype_; #endif //! Equivalent to `make<type_tag>`, provided for convenience. //! @relates hana::type //! //! //! Example //! ------- //! @include example/type/make.cpp constexpr auto make_type = hana::make<type_tag>; //! `sizeof` keyword, lifted to Hana. //! @relates hana::type //! //! `sizeof_` is somewhat equivalent to `sizeof` in that it returns the //! size of an expression or type, but it takes an arbitrary expression //! or a `hana::type` and returns its size as an `integral_constant`. //! Specifically, given an expression `expr`, `sizeof_` satisfies //! @code //! sizeof_(expr) == size_t<sizeof(decltype(expr) with references stripped)> //! @endcode //! //! However, given a `type`, `sizeof_` will simply fetch the size //! of the C++ type represented by that object. In other words, //! @code //! sizeof_(type_c<T>) == size_t<sizeof(T)> //! @endcode //! //! The behavior of `sizeof_` is consistent with that of `decltype_`. //! In particular, see `decltype_`'s documentation to understand why //! references are always stripped by `sizeof_`. //! //! //! Example //! ------- //! @include example/type/sizeof.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto sizeof_ = [](auto&& x) { using T = typename decltype(hana::decltype_(x))::type; return hana::size_c<sizeof(T)>; }; #else struct sizeof_t { template <typename T> constexpr auto operator()(T&&) const; }; constexpr sizeof_t sizeof_{}; #endif //! `alignof` keyword, lifted to Hana. //! @relates hana::type //! //! `alignof_` is somewhat equivalent to `alignof` in that it returns the //! alignment required by any instance of a type, but it takes a `type` //! and returns its alignment as an `integral_constant`. Like `sizeof` //! which works for expressions and type-ids, `alignof_` can also be //! called on an arbitrary expression. Specifically, given an expression //! `expr` and a C++ type `T`, `alignof_` satisfies //! @code //! alignof_(expr) == size_t<alignof(decltype(expr) with references stripped)> //! alignof_(type_c<T>) == size_t<alignof(T)> //! @endcode //! //! The behavior of `alignof_` is consistent with that of `decltype_`. //! In particular, see `decltype_`'s documentation to understand why //! references are always stripped by `alignof_`. //! //! //! Example //! ------- //! @include example/type/alignof.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto alignof_ = [](auto&& x) { using T = typename decltype(hana::decltype_(x))::type; return hana::size_c<alignof(T)>; }; #else struct alignof_t { template <typename T> constexpr auto operator()(T&&) const; }; constexpr alignof_t alignof_{}; #endif //! Checks whether a SFINAE-friendly expression is valid. //! @relates hana::type //! //! Given a SFINAE-friendly function, `is_valid` returns whether the //! function call is valid with the given arguments. Specifically, given //! a function `f` and arguments `args...`, //! @code //! is_valid(f, args...) == whether f(args...) is valid //! @endcode //! //! The result is returned as a compile-time `Logical`. Furthermore, //! `is_valid` can be used in curried form as follows: //! @code //! is_valid(f)(args...) //! @endcode //! //! This syntax makes it easy to create functions that check the validity //! of a generic expression on any given argument(s). //! //! @warning //! To check whether calling a nullary function `f` is valid, one should //! use the `is_valid(f)()` syntax. Indeed, `is_valid(f /* no args */)` //! will be interpreted as the currying of `is_valid` to `f` rather than //! the application of `is_valid` to `f` and no arguments. //! //! //! Example //! ------- //! @include example/type/is_valid.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto is_valid = [](auto&& f) { return [](auto&& ...args) { return whether f(args...) is a valid expression; }; }; #else struct is_valid_t { template <typename F> constexpr auto operator()(F&&) const; template <typename F, typename ...Args> constexpr auto operator()(F&&, Args&&...) const; }; constexpr is_valid_t is_valid{}; #endif //! Lift a template to a Metafunction. //! @ingroup group-Metafunction //! //! Given a template class or template alias `f`, `template_<f>` is a //! `Metafunction` satisfying //! @code //! template_<f>(type_c<x>...) == type_c<f<x...>> //! decltype(template_<f>)::apply<x...>::type == f<x...> //! @endcode //! //! @note //! In a SFINAE context, the expression `template_<f>(type_c<x>...)` is //! valid whenever the expression `f<x...>` is valid. //! //! //! Example //! ------- //! @include example/type/template.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <template <typename ...> class F> constexpr auto template_ = [](basic_type<T>...) { return hana::type_c<F<T...>>; }; #else template <template <typename ...> class F> struct template_t; template <template <typename ...> class F> constexpr template_t<F> template_{}; #endif //! Lift a MPL-style metafunction to a Metafunction. //! @ingroup group-Metafunction //! //! Given a MPL-style metafunction, `metafunction<f>` is a `Metafunction` //! satisfying //! @code //! metafunction<f>(type_c<x>...) == type_c<f<x...>::type> //! decltype(metafunction<f>)::apply<x...>::type == f<x...>::type //! @endcode //! //! @note //! In a SFINAE context, the expression `metafunction<f>(type_c<x>...)` is //! valid whenever the expression `f<x...>::%type` is valid. //! //! //! Example //! ------- //! @include example/type/metafunction.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <template <typename ...> class F> constexpr auto metafunction = [](basic_type<T>...) { return hana::type_c<typename F<T...>::type>; }; #else template <template <typename ...> class f> struct metafunction_t; template <template <typename ...> class f> constexpr metafunction_t<f> metafunction{}; #endif //! Lift a MPL-style metafunction class to a Metafunction. //! @ingroup group-Metafunction //! //! Given a MPL-style metafunction class, `metafunction_class<f>` is a //! `Metafunction` satisfying //! @code //! metafunction_class<f>(type_c<x>...) == type_c<f::apply<x...>::type> //! decltype(metafunction_class<f>)::apply<x...>::type == f::apply<x...>::type //! @endcode //! //! @note //! In a SFINAE context, the expression `metafunction_class<f>(type_c<x>...)` //! is valid whenever the expression `f::apply<x...>::%type` is valid. //! //! //! Example //! ------- //! @include example/type/metafunction_class.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename F> constexpr auto metafunction_class = [](basic_type<T>...) { return hana::type_c<typename F::template apply<T...>::type>; }; #else template <typename F> struct metafunction_class_t; template <typename F> constexpr metafunction_class_t<F> metafunction_class{}; #endif //! Turn a `Metafunction` into a function taking `type`s and returning a //! default-constructed object. //! @ingroup group-Metafunction //! //! Given a `Metafunction` `f`, `integral` returns a new `Metafunction` //! that default-constructs an object of the type returned by `f`. More //! specifically, the following holds: //! @code //! integral(f)(t...) == decltype(f(t...))::type{} //! @endcode //! //! The principal use case for `integral` is to transform `Metafunction`s //! returning a type that inherits from a meaningful base like //! `std::integral_constant` into functions returning e.g. a //! `hana::integral_constant`. //! //! @note //! - This is not a `Metafunction` because it does not return a `type`. //! As such, it would not make sense to make `decltype(integral(f))` //! a MPL metafunction class like the usual `Metafunction`s are. //! //! - When using `integral` with metafunctions returning //! `std::integral_constant`s, don't forget to include the //! boost/hana/ext/std/integral_constant.hpp header to ensure //! Hana can interoperate with the result. //! //! - In a SFINAE context, the expression `integral(f)(t...)` is valid //! whenever the expression `decltype(f(t...))::%type` is valid. //! //! //! Example //! ------- //! @include example/type/integral.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto integral = [](auto f) { return [](basic_type<T>...) { return decltype(f)::apply<T...>::type{}; }; }; #else template <typename F> struct integral_t; struct make_integral_t { template <typename F> constexpr integral_t<F> operator()(F const&) const { return {}; } }; constexpr make_integral_t integral{}; #endif //! Alias to `integral(metafunction<F>)`, provided for convenience. //! @ingroup group-Metafunction //! //! //! Example //! ------- //! @include example/type/trait.cpp template <template <typename ...> class F> constexpr auto trait = hana::integral(hana::metafunction<F>); BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_TYPE_HPP PK �\�[��h� � fwd/bool.hppnu �[��� /*! @file Includes boost/hana/fwd/integral_constant.hpp. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_BOOL_HPP #define BOOST_HANA_FWD_BOOL_HPP #include <boost/hana/fwd/integral_constant.hpp> #endif // !BOOST_HANA_FWD_BOOL_HPP PK �\�[�8��� � fwd/or.hppnu �[��� /*! @file Forward declares `boost::hana::or_`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_OR_HPP #define BOOST_HANA_FWD_OR_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Return whether any of the arguments is true-valued. //! @ingroup group-Logical //! //! `or_` can be called with one argument or more. When called with //! two arguments, `or_` uses tag-dispatching to find the right //! implementation. Otherwise, //! @code //! or_(x) == x //! or_(x, y, ...z) == or_(or_(x, y), z...) //! @endcode //! //! //! Example //! ------- //! @include example/or.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto or_ = [](auto&& x, auto&& ...y) -> decltype(auto) { return tag-dispatched; }; #else template <typename L, typename = void> struct or_impl : or_impl<L, when<true>> { }; struct or_t { template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) const; template <typename X, typename ...Y> constexpr decltype(auto) operator()(X&& x, Y&& ...y) const; }; constexpr or_t or_{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_OR_HPP PK �\�[��I fwd/permutations.hppnu �[��� /*! @file Forward declares `boost::hana::permutations`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_PERMUTATIONS_HPP #define BOOST_HANA_FWD_PERMUTATIONS_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Return a sequence of all the permutations of the given sequence. //! @ingroup group-Sequence //! //! Specifically, `permutations(xs)` is a sequence whose elements are //! permutations of the original sequence `xs`. The permutations are not //! guaranteed to be in any specific order. Also note that the number //! of permutations grows very rapidly as the length of the original //! sequence increases. The growth rate is `O(length(xs)!)`; with a //! sequence `xs` of length only 8, `permutations(xs)` contains over //! 40 000 elements! //! //! //! Example //! ------- //! @include example/permutations.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto permutations = [](auto&& xs) { return tag-dispatched; }; #else template <typename S, typename = void> struct permutations_impl : permutations_impl<S, when<true>> { }; struct permutations_t { template <typename Xs> constexpr auto operator()(Xs&& xs) const; }; constexpr permutations_t permutations{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_PERMUTATIONS_HPP PK �\�[> fwd/greater_equal.hppnu �[��� /*! @file Forward declares `boost::hana::greater_equal`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_GREATER_EQUAL_HPP #define BOOST_HANA_FWD_GREATER_EQUAL_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/nested_than_fwd.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns a `Logical` representing whether `x` is greater than or //! equal to `y`. //! @ingroup group-Orderable //! //! //! Signature //! --------- //! Given a Logical `Bool` and two Orderables `A` and `B` with a common //! embedding, the signature is //! @f$ \mathrm{greater\_equal} : A \times B \to Bool @f$. //! //! @param x, y //! Two objects to compare. //! //! //! Example //! ------- //! @include example/greater_equal.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto greater_equal = [](auto&& x, auto&& y) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename U, typename = void> struct greater_equal_impl : greater_equal_impl<T, U, when<true>> { }; struct greater_equal_t : detail::nested_than<greater_equal_t> { template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) const; }; constexpr greater_equal_t greater_equal{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_GREATER_EQUAL_HPP PK �\�[]��y� � fwd/all.hppnu �[��� /*! @file Forward declares `boost::hana::all`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_ALL_HPP #define BOOST_HANA_FWD_ALL_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns whether all the keys of the structure are true-valued. //! @ingroup group-Searchable //! //! The keys of the structure must be `Logical`s. If the structure is not //! finite, a false-valued key must appear at a finite "index" in order //! for this method to finish. //! //! //! Example //! ------- //! @include example/all.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto all = [](auto&& xs) { return tag-dispatched; }; #else template <typename S, typename = void> struct all_impl : all_impl<S, when<true>> { }; struct all_t { template <typename Xs> constexpr auto operator()(Xs&& xs) const; }; constexpr all_t all{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ALL_HPP PK �\�[\g�� � fwd/greater.hppnu �[��� /*! @file Forward declares `boost::hana::greater`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_GREATER_HPP #define BOOST_HANA_FWD_GREATER_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/nested_than_fwd.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns a `Logical` representing whether `x` is greater than `y`. //! @ingroup group-Orderable //! //! //! Signature //! --------- //! Given a Logical `Bool` and two Orderables `A` and `B` with a common //! embedding, the signature is //! @f$ \mathrm{greater} : A \times B \to Bool @f$. //! //! @param x, y //! Two objects to compare. //! //! //! Example //! ------- //! @include example/greater.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto greater = [](auto&& x, auto&& y) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename U, typename = void> struct greater_impl : greater_impl<T, U, when<true>> { }; struct greater_t : detail::nested_than<greater_t> { template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) const; }; constexpr greater_t greater{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_GREATER_HPP PK �\�[�q3�� � fwd/extend.hppnu �[��� /*! @file Forward declares `boost::hana::extend`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_EXTEND_HPP #define BOOST_HANA_FWD_EXTEND_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Comonadic application of a function to a comonadic value. //! @ingroup group-Comonad //! //! Given a comonadic value and a function accepting a comonadic input, //! `extend` returns the result of applying the function to that input //! inside the comonadic context. //! //! //! Signature //! --------- //! Given a Comonad `W` and a function of type \f$ W(T) \to U \f$, the //! signature is //! \f$ //! \mathtt{extend} : W(T) \times (W(T) \to U) \to W(U) //! \f$ //! //! @param w //! A comonadic value to call the function with. //! //! @param f //! A function of signature \f$ W(T) \to U \f$ to be applied to its //! comonadic argument inside the comonadic context. //! //! //! Example //! ------- //! @include example/extend.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto extend = [](auto&& w, auto&& f) -> decltype(auto) { return tag-dispatched; }; #else template <typename W, typename = void> struct extend_impl : extend_impl<W, when<true>> { }; struct extend_t { template <typename W_, typename F> constexpr decltype(auto) operator()(W_&& w, F&& f) const; }; constexpr extend_t extend{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_EXTEND_HPP PK �\�[�T?� � fwd/all_of.hppnu �[��� /*! @file Forward declares `boost::hana::all_of`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_ALL_OF_HPP #define BOOST_HANA_FWD_ALL_OF_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns whether all the keys of the structure satisfy the `predicate`. //! @ingroup group-Searchable //! //! If the structure is not finite, `predicate` has to return a false- //! valued `Logical` after looking at a finite number of keys for this //! method to finish. //! //! //! @param xs //! The structure to search. //! //! @param predicate //! A function called as `predicate(k)`, where `k` is a key of the //! structure, and returning a `Logical`. //! //! //! Example //! ------- //! @include example/all_of.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto all_of = [](auto&& xs, auto&& predicate) { return tag-dispatched; }; #else template <typename S, typename = void> struct all_of_impl : all_of_impl<S, when<true>> { }; struct all_of_t { template <typename Xs, typename Pred> constexpr auto operator()(Xs&& xs, Pred&& pred) const; }; constexpr all_of_t all_of{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ALL_OF_HPP PK �\�['}-- - fwd/cartesian_product.hppnu �[��� /*! @file Forward declares `boost::hana::cartesian_product`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CARTESIAN_PRODUCT_HPP #define BOOST_HANA_FWD_CARTESIAN_PRODUCT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Computes the cartesian product of a sequence of sequences. //! @ingroup group-Sequence //! //! Given a sequence of sequences, `cartesian_product` returns a new //! sequence of sequences containing the cartesian product of the //! original sequences. For this method to finish, a finite number //! of finite sequences must be provided. //! //! @note //! All the sequences must have the same tag, and that tag must also match //! that of the top-level sequence. //! //! //! Signature //! --------- //! Given a `Sequence` `S(T)`, the signature is //! \f[ //! \mathtt{cartesian\_product} : S(S(T)) \to S(S(T)) //! \f] //! //! @param xs //! A sequence of sequences of which the cartesian product is computed. //! //! //! Example //! ------- //! @include example/cartesian_product.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto cartesian_product = [](auto&& xs) { return tag-dispatched; }; #else template <typename S, typename = void> struct cartesian_product_impl : cartesian_product_impl<S, when<true>> { }; struct cartesian_product_t { template <typename Xs> constexpr auto operator()(Xs&& xs) const; }; constexpr cartesian_product_t cartesian_product{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CARTESIAN_PRODUCT_HPP PK �\�[\��� � fwd/while.hppnu �[��� /*! @file Forward declares `boost::hana::while_`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_WHILE_HPP #define BOOST_HANA_FWD_WHILE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Apply a function to an initial state while some predicate is satisfied. //! @ingroup group-Logical //! //! This method is a natural extension of the `while` language construct //! to manipulate a state whose type may change from one iteration to //! another. However, note that having a state whose type changes from //! one iteration to the other is only possible as long as the predicate //! returns a `Logical` whose truth value is known at compile-time. //! //! Specifically, `while_(pred, state, f)` is equivalent to //! @code //! f(...f(f(state))) //! @endcode //! where `f` is iterated as long as `pred(f(...))` is a true-valued //! `Logical`. //! //! //! @param pred //! A predicate called on the state or on the result of applying `f` a //! certain number of times to the state, and returning whether `f` //! should be applied one more time. //! //! @param state //! The initial state on which `f` is applied. //! //! @param f //! A function that is iterated on the initial state. Note that the //! return type of `f` may change from one iteration to the other, //! but only while `pred` returns a compile-time `Logical`. In other //! words, `decltype(f(stateN))` may differ from `decltype(f(stateN+1))`, //! but only if `pred(f(stateN))` returns a compile-time `Logical`. //! //! //! Example //! ------- //! @include example/while.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto while_ = [](auto&& pred, auto&& state, auto&& f) -> decltype(auto) { return tag-dispatched; }; #else template <typename L, typename = void> struct while_impl : while_impl<L, when<true>> { }; struct while_t { template <typename Pred, typename State, typename F> constexpr decltype(auto) operator()(Pred&& pred, State&& state, F&& f) const; }; constexpr while_t while_{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_WHILE_HPP PK �\�[U�:j� � fwd/minimum.hppnu �[��� /*! @file Forward declares `boost::hana::minimum`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_MINIMUM_HPP #define BOOST_HANA_FWD_MINIMUM_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/nested_by_fwd.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Return the least element of a non-empty structure with respect to //! a `predicate`, by default `less`. //! @ingroup group-Foldable //! //! Given a non-empty structure and an optional binary predicate //! (`less` by default), `minimum` returns the least element of //! the structure, i.e. an element which is less than or equal to //! every other element in the structure, according to the predicate. //! //! If the structure contains heterogeneous objects, then the predicate //! must return a compile-time `Logical`. If no predicate is provided, //! the elements in the structure must be Orderable, or compile-time //! Orderable if the structure is heterogeneous. //! //! //! Signature //! --------- //! Given a `Foldable` `F`, a Logical `Bool` and a predicate //! \f$ \mathtt{pred} : T \times T \to Bool \f$, `minimum` has the //! following signatures. For the variant with a provided predicate, //! \f[ //! \mathtt{minimum} : F(T) \times (T \times T \to Bool) \to T //! \f] //! //! for the variant without a custom predicate, `T` is required to be //! Orderable. The signature is then //! \f[ //! \mathtt{minimum} : F(T) \to T //! \f] //! //! @param xs //! The structure to find the least element of. //! //! @param predicate //! A function called as `predicate(x, y)`, where `x` and `y` are elements //! of the structure. `predicate` should be a strict weak ordering on the //! elements of the structure and its return value should be a Logical, //! or a compile-time Logical if the structure is heterogeneous. //! //! ### Example //! @include example/minimum.cpp //! //! //! Syntactic sugar (`minimum.by`) //! ------------------------------ //! `minimum` can be called in a third way, which provides a nice syntax //! especially when working with the `ordering` combinator: //! @code //! minimum.by(predicate, xs) == minimum(xs, predicate) //! minimum.by(predicate) == minimum(-, predicate) //! @endcode //! //! where `minimum(-, predicate)` denotes the partial application of //! `minimum` to `predicate`. //! //! ### Example //! @include example/minimum_by.cpp //! //! //! Tag dispatching //! --------------- //! Both the non-predicated version and the predicated versions of //! `minimum` are tag-dispatched methods, and hence they can be //! customized independently. One reason for this is that some //! structures are able to provide a much more efficient implementation //! of `minimum` when the `less` predicate is used. Here is how the //! different versions of `minimum` are dispatched: //! @code //! minimum(xs) -> minimum_impl<tag of xs>::apply(xs) //! minimum(xs, pred) -> minimum_pred_impl<tag of xs>::apply(xs, pred) //! @endcode //! //! Also note that `minimum.by` is not tag-dispatched on its own, since it //! is just syntactic sugar for calling the corresponding `minimum`. #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto minimum = [](auto&& xs[, auto&& predicate]) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename = void> struct minimum_impl : minimum_impl<T, when<true>> { }; template <typename T, typename = void> struct minimum_pred_impl : minimum_pred_impl<T, when<true>> { }; struct minimum_t : detail::nested_by<minimum_t> { template <typename Xs> constexpr decltype(auto) operator()(Xs&& xs) const; template <typename Xs, typename Predicate> constexpr decltype(auto) operator()(Xs&& xs, Predicate&& pred) const; }; constexpr minimum_t minimum{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_MINIMUM_HPP PK �\�[� �� � fwd/chain.hppnu �[��� /*! @file Forward declares `boost::hana::chain`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CHAIN_HPP #define BOOST_HANA_FWD_CHAIN_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Feed a monadic value into a monadic computation. //! @ingroup group-Monad //! //! Given a monadic value and a monadic function, `chain` feeds the //! monadic value into the function, thus performing some Monad-specific //! effects, and returns the result. An implementation of `chain` must //! satisfy //! @code //! chain(xs, f) == flatten(transform(xs, f)) //! @endcode //! //! //! Signature //! --------- //! For a monad `M`, given a monadic value of type `M(A)` and a monadic //! function @f$ f : A \to M(B) @f$, `chain` has the signature //! @f$ //! \mathtt{chain} : M(A) \times (A \to M(B)) \to M(B) //! @f$. //! //! @param xs //! A monadic value to be fed to the function `f`. //! //! @param f //! A function taking a normal value in the `xs` structure, and returning //! a monadic value. This function is called as `f(x)`, where `x` is an //! element of the structure `xs`. //! //! //! Example //! ------- //! @include example/chain.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto chain = [](auto&& xs, auto&& f) -> decltype(auto) { return tag-dispatched; }; #else template <typename M, typename = void> struct chain_impl : chain_impl<M, when<true>> { }; struct chain_t { template <typename Xs, typename F> constexpr decltype(auto) operator()(Xs&& xs, F&& f) const; }; constexpr chain_t chain{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CHAIN_HPP PK �\�[ �?� � fwd/remove.hppnu �[��� /*! @file Forward declares `boost::hana::remove`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_REMOVE_HPP #define BOOST_HANA_FWD_REMOVE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Remove all the elements of a monadic structure that are equal to some //! value. //! @ingroup group-MonadPlus //! //! Given a monadic structure `xs` and a `value`, `remove` returns a new //! monadic structure equal to `xs` without all its elements that are //! equal to the given `value`. `remove` is equivalent to `remove_if` //! with the `equal.to(value)` predicate, i.e. //! @code //! remove(xs, value) == remove_if(xs, equal.to(value)) //! @endcode //! //! //! Signature //! --------- //! Given a MonadPlus `M` and a value of type `T`, the signature is //! \f$ //! \mathrm{remove} : M(T) \times T \to M(T) //! \f$ //! //! @param xs //! A monadic structure to remove some elements from. //! //! @param value //! A value that is compared to every element `x` of the structure. //! Elements of the structure that are equal to that value are removed //! from the structure. This requires every element to be Comparable //! with `value`. Furthermore, in the current version of the library, //! comparing `value` with any element of the structure must yield a //! compile-time Logical. //! //! //! Example //! ------- //! @include example/remove.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto remove = [](auto&& xs, auto&& value) { return tag-dispatched; }; #else template <typename M, typename = void> struct remove_impl : remove_impl<M, when<true>> { }; struct remove_t { template <typename Xs, typename Value> constexpr auto operator()(Xs&& xs, Value&& value) const; }; constexpr remove_t remove{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_REMOVE_HPP PK �\�[���0� � fwd/partition.hppnu �[��� /*! @file Forward declares `boost::hana::partition`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_PARTITION_HPP #define BOOST_HANA_FWD_PARTITION_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/nested_by_fwd.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Partition a sequence based on a `predicate`. //! @ingroup group-Sequence //! //! Specifically, returns an unspecified `Product` whose first element is //! a sequence of the elements satisfying the predicate, and whose second //! element is a sequence of the elements that do not satisfy the predicate. //! //! //! Signature //! --------- //! Given a Sequence `S(T)`, an `IntegralConstant` `Bool` holding a value //! of type `bool`, and a predicate \f$ T \to Bool \f$, `partition` has //! the following signature: //! \f[ //! \mathtt{partition} : S(T) \times (T \to Bool) \to S(T) \times S(T) //! \f] //! //! @param xs //! The sequence to be partitioned. //! //! @param predicate //! A function called as `predicate(x)` for each element `x` in the //! sequence, and returning whether `x` should be added to the sequence //! in the first component or in the second component of the resulting //! pair. In the current version of the library, `predicate` must return //! an `IntegralConstant` holding a value convertible to `bool`. //! //! //! Syntactic sugar (`partition.by`) //! -------------------------------- //! `partition` can be called in an alternate way, which provides a nice //! syntax in some cases where the predicate is short: //! @code //! partition.by(predicate, xs) == partition(xs, predicate) //! partition.by(predicate) == partition(-, predicate) //! @endcode //! //! where `partition(-, predicate)` denotes the partial application of //! `partition` to `predicate`. //! //! //! Example //! ------- //! @include example/partition.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto partition = [](auto&& xs, auto&& predicate) { return tag-dispatched; }; #else template <typename S, typename = void> struct partition_impl : partition_impl<S, when<true>> { }; struct partition_t : detail::nested_by<partition_t> { template <typename Xs, typename Pred> constexpr auto operator()(Xs&& xs, Pred&& pred) const; }; constexpr partition_t partition{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_PARTITION_HPP PK �\�[�d�** ** fwd/string.hppnu �[��� /*! @file Forward declares `boost::hana::string`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_STRING_HPP #define BOOST_HANA_FWD_STRING_HPP #include <boost/hana/config.hpp> #include <boost/hana/fwd/core/make.hpp> #include <boost/hana/fwd/core/to.hpp> BOOST_HANA_NAMESPACE_BEGIN #ifdef BOOST_HANA_DOXYGEN_INVOKED //! @ingroup group-datatypes //! Compile-time string. //! //! Conceptually, a `hana::string` is like a tuple holding //! `integral_constant`s of underlying type `char`. However, the //! interface of `hana::string` is not as rich as that of a tuple, //! because a string can only hold compile-time characters as opposed //! to any kind of object. //! //! Compile-time strings are used for simple purposes like being keys in a //! `hana::map` or tagging the members of a `Struct`. However, you might //! find that `hana::string` does not provide enough functionality to be //! used as a full-blown compile-time string implementation (e.g. regexp //! matching or substring finding). Indeed, providing a comprehensive //! string interface is a lot of job, and it is out of the scope of the //! library for the time being. //! //! //! @note //! The representation of `hana::string` is implementation-defined. //! In particular, one should not take for granted that the template //! parameters are `char`s. The proper way to access the contents of //! a `hana::string` as character constants is to use `hana::unpack`, //! `.c_str()` or `hana::to<char const*>`, as documented below. More //! details [in the tutorial](@ref tutorial-containers-types). //! //! //! Modeled concepts //! ---------------- //! For most purposes, a `hana::string` is functionally equivalent to a //! tuple holding `Constant`s of underlying type `char`. //! //! 1. `Comparable`\n //! Two strings are equal if and only if they have the same number of //! characters and characters at corresponding indices are equal. //! @include example/string/comparable.cpp //! //! 2. `Orderable`\n //! The total order implemented for `Orderable` is the usual //! lexicographical comparison of strings. //! @include example/string/orderable.cpp //! //! 3. `Monoid`\n //! Strings form a monoid under concatenation, with the neutral element //! being the empty string. //! @include example/string/monoid.cpp //! //! 4. `Foldable`\n //! Folding a string is equivalent to folding the sequence of its //! characters. //! @include example/string/foldable.cpp //! //! 5. `Iterable`\n //! Iterating over a string is equivalent to iterating over the sequence //! of its characters. Also note that `operator[]` can be used instead of //! the `at` function. //! @include example/string/iterable.cpp //! //! 6. `Searchable`\n //! Searching through a string is equivalent to searching through the //! sequence of its characters. //! @include example/string/searchable.cpp //! //! 7. `Hashable`\n //! The hash of a compile-time string is a type uniquely representing //! that string. //! @include example/string/hashable.cpp //! //! //! Conversion to `char const*` //! --------------------------- //! A `hana::string` can be converted to a `constexpr` null-delimited //! string of type `char const*` by using the `c_str()` method or //! `hana::to<char const*>`. This makes it easy to turn a compile-time //! string into a runtime string. However, note that this conversion is //! not an embedding, because `char const*` does not model the same //! concepts as `hana::string` does. //! @include example/string/to.cpp //! //! Conversion from any Constant holding a `char const*` //! ---------------------------------------------------- //! A `hana::string` can be created from any `Constant` whose underlying //! value is convertible to a `char const*` by using `hana::to`. The //! contents of the `char const*` are used to build the content of the //! `hana::string`. //! @include example/string/from_c_str.cpp //! //! Rationale for `hana::string` not being a `Constant` itself //! ---------------------------------------------------------- //! The underlying type held by a `hana::string` could be either `char const*` //! or some other constexpr-enabled string-like container. In the first case, //! `hana::string` can not be a `Constant` because the models of several //! concepts would not be respected by the underlying type, causing `value` //! not to be structure-preserving. Providing an underlying value of //! constexpr-enabled string-like container type like `std::string_view` //! would be great, but that's a bit complicated for the time being. template <typename implementation_defined> struct string { // Default-construct a `hana::string`; no-op since `hana::string` is stateless. constexpr string() = default; // Copy-construct a `hana::string`; no-op since `hana::string` is stateless. constexpr string(string const&) = default; //! Equivalent to `hana::equal` template <typename X, typename Y> friend constexpr auto operator==(X&& x, Y&& y); //! Equivalent to `hana::not_equal` template <typename X, typename Y> friend constexpr auto operator!=(X&& x, Y&& y); //! Equivalent to `hana::less` template <typename X, typename Y> friend constexpr auto operator<(X&& x, Y&& y); //! Equivalent to `hana::greater` template <typename X, typename Y> friend constexpr auto operator>(X&& x, Y&& y); //! Equivalent to `hana::less_equal` template <typename X, typename Y> friend constexpr auto operator<=(X&& x, Y&& y); //! Equivalent to `hana::greater_equal` template <typename X, typename Y> friend constexpr auto operator>=(X&& x, Y&& y); //! Performs concatenation; equivalent to `hana::plus` template <typename X, typename Y> friend constexpr auto operator+(X&& x, Y&& y); //! Equivalent to `hana::at` template <typename N> constexpr decltype(auto) operator[](N&& n); //! Returns a null-delimited C-style string. static constexpr char const* c_str(); }; #else template <char ...s> struct string; #endif //! Tag representing a compile-time string. //! @relates hana::string struct string_tag { }; #ifdef BOOST_HANA_DOXYGEN_INVOKED //! Create a compile-time `hana::string` from a parameter pack of `char` //! `integral_constant`s. //! @relates hana::string //! //! Given zero or more `integral_constant`s of underlying type `char`, //! `make<string_tag>` creates a `hana::string` containing those characters. //! This is provided mostly for consistency with the rest of the library, //! as `hana::string_c` is more convenient to use in most cases. //! //! //! Example //! ------- //! @include example/string/make.cpp template <> constexpr auto make<string_tag> = [](auto&& ...chars) { return string<implementation_defined>{}; }; #endif //! Alias to `make<string_tag>`; provided for convenience. //! @relates hana::string constexpr auto make_string = make<string_tag>; //! Equivalent to `to<string_tag>`; provided for convenience. //! @relates hana::string constexpr auto to_string = to<string_tag>; //! Create a compile-time string from a parameter pack of characters. //! @relates hana::string //! //! //! Example //! ------- //! @include example/string/string_c.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <char ...s> constexpr string<implementation_defined> string_c{}; #else template <char ...s> constexpr string<s...> string_c{}; #endif //! Create a compile-time string from a string literal. //! @relates hana::string //! //! This macro is a more convenient alternative to `string_c` for creating //! compile-time strings. However, since this macro uses a lambda //! internally, it can't be used in an unevaluated context, or where //! a constant expression is expected before C++17. //! //! //! Example //! ------- //! @include example/string/macro.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED auto BOOST_HANA_STRING(s) = see documentation; #define BOOST_HANA_STRING(s) see documentation // Note: // The trick above seems to exploit a bug in Doxygen, which makes the // BOOST_HANA_STRING macro appear in the related objects of hana::string // (as we want it to). #else // defined in <boost/hana/string.hpp> #endif #ifdef BOOST_HANA_CONFIG_ENABLE_STRING_UDL namespace literals { //! Creates a compile-time string from a string literal. //! @relatesalso boost::hana::string //! //! The string literal is parsed at compile-time and the result is //! returned as a `hana::string`. This feature is an extension that //! is disabled by default; see below for details. //! //! @note //! Only narrow string literals are supported right now; support for //! fancier types of string literals like wide or UTF-XX might be //! added in the future if there is a demand for it. See [this issue] //! [Hana.issue80] if you need this. //! //! @warning //! This user-defined literal is an extension which requires a special //! string literal operator that is not part of the standard yet. //! That operator is supported by both Clang and GCC, and several //! proposals were made for it to enter C++17. However, since it is //! not standard, it is disabled by default and defining the //! `BOOST_HANA_CONFIG_ENABLE_STRING_UDL` config macro is required //! to get this operator. Hence, if you want to stay safe, just use //! the `BOOST_HANA_STRING` macro instead. If you want to be fast and //! furious (I do), define `BOOST_HANA_CONFIG_ENABLE_STRING_UDL`. //! //! //! Example //! ------- //! @include example/string/literal.cpp //! //! [Hana.issue80]: https://github.com/boostorg/hana/issues/80 template <typename CharT, CharT ...s> constexpr auto operator"" _s(); } #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_STRING_HPP PK �\�[R���� � fwd/find.hppnu �[��� /*! @file Forward declares `boost::hana::find`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_FIND_HPP #define BOOST_HANA_FWD_FIND_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Finds the value associated to the given key in a structure. //! @ingroup group-Searchable //! //! Given a `key` and a `Searchable` structure, `find` returns the `just` //! the first value whose key is equal to the given `key`, or `nothing` if //! there is no such key. Comparison is done with `equal`. `find` satisfies //! the following: //! @code //! find(xs, key) == find_if(xs, equal.to(key)) //! @endcode //! //! //! @param xs //! The structure to be searched. //! //! @param key //! A key to be searched for in the structure. The key has to be //! `Comparable` with the other keys of the structure. In the current //! version of the library, the comparison of `key` with any other key //! of the structure must return a compile-time `Logical`. //! //! //! Example //! ------- //! @include example/find.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto find = [](auto&& xs, auto const& key) { return tag-dispatched; }; #else template <typename S, typename = void> struct find_impl : find_impl<S, when<true>> { }; struct find_t { template <typename Xs, typename Key> constexpr auto operator()(Xs&& xs, Key const& key) const; }; constexpr find_t find{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_FIND_HPP PK �\�[��i�~ ~ fwd/max.hppnu �[��� /*! @file Forward declares `boost::hana::max`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_MAX_HPP #define BOOST_HANA_FWD_MAX_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns the greatest of its arguments according to the `less` ordering. //! @ingroup group-Orderable //! //! //! @todo Can't specify the signature here either. See `min` for details. //! //! Example //! ------- //! @include example/max.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto max = [](auto&& x, auto&& y) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename U, typename = void> struct max_impl : max_impl<T, U, when<true>> { }; struct max_t { template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) const; }; constexpr max_t max{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_MAX_HPP PK �\�[]�eW W fwd/value.hppnu �[��� /*! @file Forward declares `boost::hana::value`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_VALUE_HPP #define BOOST_HANA_FWD_VALUE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Return the compile-time value associated to a constant. //! @ingroup group-Constant //! //! This function returns the value associated to a `Constant`. That //! value is always a constant expression. The normal way of using //! `value` on an object `c` is //! @code //! constexpr auto result = hana::value<decltype(c)>(); //! @endcode //! //! However, for convenience, an overload of `value` is provided so that //! it can be called as: //! @code //! constexpr auto result = hana::value(c); //! @endcode //! //! This overload works by taking a `const&` to its argument, and then //! forwarding to the first version of `value`. Since it does not use //! its argument, the result can still be a constant expression, even //! if the argument is not a constant expression. //! //! @note //! `value<T>()` is tag-dispatched as `value_impl<C>::%apply<T>()`, where //! `C` is the tag of `T`. //! //! @note //! `hana::value` is an overloaded function, not a function object. //! Hence, it can't be passed to higher-order algorithms. If you need //! an equivalent function object, use `hana::value_of` instead. //! //! //! Example //! ------- //! @include example/value.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename T> constexpr auto value = []() -> decltype(auto) { return tag-dispatched; }; #else template <typename C, typename = void> struct value_impl : value_impl<C, when<true>> { }; template <typename T> constexpr decltype(auto) value(); template <typename T> constexpr decltype(auto) value(T const&) { return hana::value<T>(); } #endif //! Equivalent to `value`, but can be passed to higher-order algorithms. //! @ingroup group-Constant //! //! This function object is equivalent to `value`, except it can be passed //! to higher order algorithms because it is a function object. `value` //! can't be passed to higher-order algorithms because it is implemented //! as an overloaded function. //! //! @note //! This function is a simple alias to `value`, and hence it is not //! tag-dispatched and can't be customized. //! //! //! Example //! ------- //! @include example/value_of.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto value_of = [](auto const& c) -> decltype(auto) { return hana::value(c); }; #else struct value_of_t { template <typename T> constexpr decltype(auto) operator()(T const&) const { return hana::value<T>(); } }; constexpr value_of_t value_of{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_VALUE_HPP PK �\�[�X� � fwd/mult.hppnu �[��� /*! @file Forward declares `boost::hana::mult`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_MULT_HPP #define BOOST_HANA_FWD_MULT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Associative operation of a `Ring`. //! @ingroup group-Ring //! //! @param x, y //! Two `Ring` elements to combine with the `Ring` binary operation. //! //! //! Cross-type version of the method //! -------------------------------- //! The `mult` method is "overloaded" to handle distinct data types //! with certain properties. Specifically, `mult` is defined for //! _distinct_ data types `A` and `B` such that //! 1. `A` and `B` share a common data type `C`, as determined by the //! `common` metafunction //! 2. `A`, `B` and `C` are all `Ring`s when taken individually //! 3. `to<C> : A -> B` and `to<C> : B -> C` are `Ring`-embeddings, as //! determined by the `is_embedding` metafunction. //! //! The definition of `mult` for data types satisfying the above //! properties is obtained by setting //! @code //! mult(x, y) = mult(to<C>(x), to<C>(y)) //! @endcode //! //! //! Example //! ------- //! @include example/mult.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto mult = [](auto&& x, auto&& y) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename U, typename = void> struct mult_impl : mult_impl<T, U, when<true>> { }; struct mult_t { template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) const; }; constexpr mult_t mult{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_MULT_HPP PK �\�[&�?� � fwd/insert.hppnu �[��� /*! @file Forward declares `boost::hana::insert`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_INSERT_HPP #define BOOST_HANA_FWD_INSERT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN // Note: This function is documented per datatype/concept only. //! @cond template <typename T, typename = void> struct insert_impl : insert_impl<T, when<true>> { }; //! @endcond struct insert_t { template <typename Set, typename ...Args> constexpr decltype(auto) operator()(Set&& set, Args&& ...args) const; }; constexpr insert_t insert{}; //! Insert a value at a given index in a sequence. //! @ingroup group-Sequence //! //! Given a sequence, an index and an element to insert, `insert` inserts //! the element at the given index. //! //! @param xs //! The sequence in which a value should be inserted. //! //! @param n //! The index at which an element should be inserted. This must be a //! non-negative `Constant` of an integral type, and it must also be //! true that `n < length(xs)` if `xs` is a finite sequence. //! //! @param element //! The element to insert in the sequence. //! //! //! Example //! ------- //! @include example/insert.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto insert = [](auto&& xs, auto&& n, auto&& element) { return tag-dispatched; }; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_INSERT_HPP PK �\�[�(pN N fwd/monadic_fold_right.hppnu �[��� /*! @file Forward declares `boost::hana::monadic_fold_right`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_MONADIC_FOLD_RIGHT_HPP #define BOOST_HANA_FWD_MONADIC_FOLD_RIGHT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Monadic right-fold of a structure with a binary operation and an //! optional initial reduction state. //! @ingroup group-Foldable //! //! @note //! This assumes the reader to be accustomed to non-monadic right-folds as //! explained by `hana::fold_right`, and to have read the [primer] //! (@ref monadic-folds) on monadic folds. //! //! `monadic_fold_right<M>` is a right-associative monadic fold. Given a //! structure containing `x1, ..., xn`, a function `f` and an optional //! initial state, `monadic_fold_right<M>` applies `f` as follows //! @code //! // with state //! (f(x1, -) | (f(x2, -) | (f(x3, -) | (... | f(xn, state))))) //! //! // without state //! (f(x1, -) | (f(x2, -) | (f(x3, -) | (... | f(xn-1, xn))))) //! @endcode //! //! where `f(xk, -)` denotes the partial application of `f` to `xk`, //! and `|` is just the operator version of the monadic `chain`. //! It is worth noting that the order in which the binary function should //! expect its arguments is reversed from `monadic_fold_left<M>`. //! //! When the structure is empty, one of two things may happen. If an //! initial state was provided, it is lifted to the given Monad and //! returned as-is. Otherwise, if the no-state version of the function //! was used, an error is triggered. When the stucture contains a single //! element and the no-state version of the function was used, that //! single element is lifted into the given Monad and returned as is. //! //! //! Signature //! --------- //! Given a `Monad` `M`, a `Foldable` `F`, an initial state of tag `S`, //! and a function @f$ f : T \times S \to M(S) @f$, the signatures of //! `monadic_fold_right<M>` are //! \f[ //! \mathtt{monadic\_fold\_right}_M : //! F(T) \times S \times (T \times S \to M(S)) \to M(S) //! \f] //! //! for the version with an initial state, and //! \f[ //! \mathtt{monadic\_fold\_right}_M : //! F(T) \times (T \times T \to M(T)) \to M(T) //! \f] //! //! for the version without an initial state. //! //! @tparam M //! The Monad representing the monadic context in which the fold happens. //! The return type of `f` must be in that Monad. //! //! @param xs //! The structure to fold. //! //! @param state //! The initial value used for folding. If the structure is empty, this //! value is lifted in to the `M` Monad and then returned as-is. //! //! @param f //! A binary function called as `f(x, state)`, where `state` is the result //! accumulated so far and `x` is an element in the structure. The //! function must return its result inside the `M` Monad. //! //! //! Example //! ------- //! @include example/monadic_fold_right.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename M> constexpr auto monadic_fold_right = [](auto&& xs[, auto&& state], auto&& f) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename = void> struct monadic_fold_right_impl : monadic_fold_right_impl<T, when<true>> { }; template <typename M> struct monadic_fold_right_t { template <typename Xs, typename State, typename F> constexpr decltype(auto) operator()(Xs&& xs, State&& state, F&& f) const; template <typename Xs, typename F> constexpr decltype(auto) operator()(Xs&& xs, F&& f) const; }; template <typename M> constexpr monadic_fold_right_t<M> monadic_fold_right{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_MONADIC_FOLD_RIGHT_HPP PK �\�[� 2 2 fwd/replace.hppnu �[��� /*! @file Forward declares `boost::hana::replace`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_REPLACE_HPP #define BOOST_HANA_FWD_REPLACE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Replace all the elements of a structure that compare equal //! to some `value` with some new fixed value. //! @ingroup group-Functor //! //! //! Signature //! --------- //! Given `F` a Functor and `U` a type that can be compared with `T`, //! the signature is //! \f$ //! \mathtt{replace} : F(T) \times U \times T \to F(T) //! \f$ //! //! @param xs //! The structure to replace elements of. //! //! @param oldval //! An object compared with each element of the structure. Elements //! of the structure that compare equal to `oldval` are replaced //! by `newval` in the new structure. //! //! @param newval //! A value by which every element `x` of the structure that compares //! equal to `oldval` is replaced. //! //! //! Example //! ------- //! @include example/replace.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto replace = [](auto&& xs, auto&& oldval, auto&& newval) { return tag-dispatched; }; #else template <typename Xs, typename = void> struct replace_impl : replace_impl<Xs, when<true>> { }; struct replace_t { template <typename Xs, typename OldVal, typename NewVal> constexpr auto operator()(Xs&& xs, OldVal&& oldval, NewVal&& newval) const; }; constexpr replace_t replace{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_REPLACE_HPP PK �\�[�?t}( ( fwd/filter.hppnu �[��� /*! @file Forward declares `boost::hana::filter`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_FILTER_HPP #define BOOST_HANA_FWD_FILTER_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Filter a monadic structure using a custom predicate. //! @ingroup group-MonadPlus //! //! Given a monadic structure and a predicate, `filter` returns a new //! monadic structure containing only those elements that satisfy the //! predicate. This is a generalization of the usual `filter` function //! for sequences; it works for any MonadPlus. Intuitively, `filter` is //! somewhat equivalent to: //! @code //! filter(xs, pred) == flatten(transform(xs, [](auto x) { //! return pred(x) ? lift<Xs>(x) : empty<Xs>(); //! }) //! @endcode //! In other words, we basically turn a monadic structure containing //! `[x1, ..., xn]` into a monadic structure containing //! @code //! [ //! pred(x1) ? [x1] : [], //! pred(x2) ? [x2] : [], //! ... //! pred(xn) ? [xn] : [] //! ] //! @endcode //! and we then `flatten` that. //! //! //! Signature //! --------- //! Given a `MonadPlus` `M` and an `IntegralConstant` `Bool` holding a //! value of type `bool`, the signature is //! @f$ \mathtt{filter} : M(T) \times (T \to \mathtt{Bool}) \to M(T) @f$. //! //! @param xs //! The monadic structure to filter. //! //! @param pred //! A function called as `pred(x)` for each element `x` in the monadic //! structure and returning whether that element should be __kept__ in //! the resulting structure. In the current version of the library, the //! predicate has to return an `IntegralConstant` holding a value //! convertible to a `bool`. //! //! //! Example //! ------- //! @include example/filter.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto filter = [](auto&& xs, auto&& pred) { return tag-dispatched; }; #else template <typename M, typename = void> struct filter_impl : filter_impl<M, when<true>> { }; struct filter_t { template <typename Xs, typename Pred> constexpr auto operator()(Xs&& xs, Pred&& pred) const; }; constexpr filter_t filter{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_FILTER_HPP PK �\�[U�)t. . fwd/define_struct.hppnu �[��� /*! @file Documents the `BOOST_HANA_DEFINE_STRUCT` macro. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_DEFINE_STRUCT_HPP #define BOOST_HANA_FWD_DEFINE_STRUCT_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN // Note: // The weird definition as a variable seems to exploit a glitch in Doxygen // which makes the macro appear in the related objects of Struct (as we // want it to). //! Defines members of a structure, while at the same time //! modeling `Struct`. //! @ingroup group-Struct //! //! Using this macro in the body of a user-defined type will define the //! given members inside that type, and will also provide a model of the //! `Struct` concept for that user-defined type. This macro is often the //! easiest way to define a model of the `Struct` concept. //! //! @note //! This macro only works if the tag of the user-defined type `T` is `T` //! itself. This is the case unless you specifically asked for something //! different; see `tag_of`'s documentation. //! //! //! Example //! ------- //! @include example/define_struct.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED auto BOOST_HANA_DEFINE_STRUCT(...) = ; #define BOOST_HANA_DEFINE_STRUCT(Name, ...) see documentation #else // defined in <boost/hana/define_struct.hpp> #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_DEFINE_STRUCT_HPP PK �\�[@��� � fwd/negate.hppnu �[��� /*! @file Forward declares `boost::hana::negate`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_NEGATE_HPP #define BOOST_HANA_FWD_NEGATE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Return the inverse of an element of a group. //! @ingroup group-Group //! //! //! Example //! ------- //! @include example/negate.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto negate = [](auto&& x) -> decltype(auto) { return tag-dispatched; }; #else template <typename G, typename = void> struct negate_impl : negate_impl<G, when<true>> { }; struct negate_t { template <typename X> constexpr decltype(auto) operator()(X&& x) const; }; constexpr negate_t negate{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_NEGATE_HPP PK �\�[��H�* * fwd/fold.hppnu �[��� /*! @file Forward declares `boost::hana::fold`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_FOLD_HPP #define BOOST_HANA_FWD_FOLD_HPP #include <boost/hana/config.hpp> #include <boost/hana/fwd/fold_left.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Equivalent to `fold_left`; provided for convenience. //! @ingroup group-Foldable //! //! `fold` is equivalent to `fold_left`. However, it is not tag-dispatched //! on its own because it is just an alias to `fold_left`. Also note that //! `fold` can be called with or without an initial state, just like //! `fold_left`: //! //! @code //! fold(xs, state, f) == fold_left(xs, state, f) //! fold(xs, f) == fold_left(xs, f) //! @endcode //! //! //! Example //! ------- //! @include example/fold.cpp constexpr auto fold = fold_left; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_FOLD_HPP PK �\�[D*�� � fwd/slice.hppnu �[��� /*! @file Forward declares `boost::hana::slice` and `boost::hana::slice_c`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_SLICE_HPP #define BOOST_HANA_FWD_SLICE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <cstddef> BOOST_HANA_NAMESPACE_BEGIN //! Extract the elements of a `Sequence` at the given indices. //! @ingroup group-Sequence //! //! Given an arbitrary sequence of `indices`, `slice` returns a new //! sequence of the elements of the original sequence that appear at //! those indices. In other words, //! @code //! slice([x1, ..., xn], [i1, ..., ik]) == [x_i1, ..., x_ik] //! @endcode //! //! The indices do not have to be ordered or contiguous in any particular //! way, but they must not be out of the bounds of the sequence. It is //! also possible to specify the same index multiple times, in which case //! the element at this index will be repeatedly included in the resulting //! sequence. //! //! //! @param xs //! The sequence from which a subsequence is extracted. //! //! @param indices //! A compile-time `Foldable` containing non-negative `IntegralConstant`s //! representing the indices. The indices are 0-based, and they must all //! be in bounds of the `xs` sequence. Note that any `Foldable` will //! really do (no need for an `Iterable`, for example); the linearization //! of the `indices` is used to determine the order of the elements //! included in the slice. //! //! //! Example //! ------- //! @include example/slice.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto slice = [](auto&& xs, auto&& indices) { return tag-dispatched; }; #else template <typename S, typename = void> struct slice_impl : slice_impl<S, when<true>> { }; struct slice_t { template <typename Xs, typename Indices> constexpr auto operator()(Xs&& xs, Indices&& indices) const; }; constexpr slice_t slice{}; #endif //! Shorthand to `slice` a contiguous range of elements. //! @ingroup group-Sequence //! //! `slice_c` is simply a shorthand to slice a contiguous range of //! elements. In particular, `slice_c<from, to>(xs)` is equivalent to //! `slice(xs, range_c<std::size_t, from, to>)`, which simply slices //! all the elements of `xs` contained in the half-open interval //! delimited by `[from, to)`. Like for `slice`, the indices used with //! `slice_c` are 0-based and they must be in the bounds of the sequence //! being sliced. //! //! //! @tparam from //! The index of the first element in the slice. //! //! @tparam to //! One-past the index of the last element in the slice. It must hold //! that `from <= to`. //! //! //! Example //! ------- //! @include example/slice_c.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <std::size_t from, std::size_t to> constexpr auto slice_c = [](auto&& xs) { return hana::slice(forwarded(xs), hana::range_c<std::size_t, from, to>); }; #else template <std::size_t from, std::size_t to> struct slice_c_t; template <std::size_t from, std::size_t to> constexpr slice_c_t<from, to> slice_c{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_SLICE_HPP PK �\�[��}#� � fwd/monadic_compose.hppnu �[��� /*! @file Forward declares `boost::hana::monadic_compose`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_MONADIC_COMPOSE_HPP #define BOOST_HANA_FWD_MONADIC_COMPOSE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Composition of monadic functions. //! @ingroup group-Monad //! //! Given two monadic functions `f` and `g`, `monadic_compose` returns //! a new function equivalent to the composition of `f` with `g`, except //! the result of `g` is `chain`ed into `f` instead of simply passed to //! it, as with normal composition. `monadic_compose` satisfies //! @code //! monadic_compose(f, g)(x) == chain(g(x), f) //! @endcode //! //! //! @note //! Unlike `compose`, `monadic_compose` does not generalize nicely to //! arities higher than one. Hence, only unary functions may be used //! with `monadic_compose`. //! //! //! Signature //! --------- //! Given a `Monad` `M` and two functions @f$ f : B \to M(C) @f$ and //! @f$ g : A \to M(B) @f$, the signature is //! @f$ //! \mathtt{monadic\_compose} //! : (B \to M(C)) \times (A \to M(B)) \to (A \to M(C)) //! @f$. //! //! @param f //! A monadic function with signature @f$ B \to M(C) @f$. //! //! @param g //! A monadic function with signature @f$ A \to M(B) @f$. //! //! //! @note //! This method is not tag-dispatched, so it can't be customized directly. //! //! //! Example //! ------- //! @include example/monadic_compose.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto monadic_compose = [](auto&& f, auto&& g) { return [perfect-capture](auto&& x) -> decltype(auto) { return hana::chain(forwarded(g)(forwarded(x)), forwarded(f)); }; }; #else struct monadic_compose_t { template <typename F, typename G> constexpr auto operator()(F&& f, G&& g) const; }; constexpr monadic_compose_t monadic_compose{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_MONADIC_COMPOSE_HPP PK �\�[?��j� � fwd/mod.hppnu �[��� /*! @file Forward declares `boost::hana::mod`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_MOD_HPP #define BOOST_HANA_FWD_MOD_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Generalized integer modulus. //! @ingroup group-EuclideanRing //! //! Given two elements of an EuclideanRing `x` and `y`, with `y` //! nonzero, `mod` returns the modulus of the division of `x` by `y`. //! In other words, `mod` can be seen as an equivalent to `%`. //! //! Cross-type version of the method //! -------------------------------- //! The `mod` method is "overloaded" to handle distinct data types //! with certain properties. Specifically, `mod` is defined for //! _distinct_ data types `A` and `B` such that //! 1. `A` and `B` share a common data type `C`, as determined by the //! `common` metafunction //! 2. `A`, `B` and `C` are all `EuclideanRing`s when taken individually //! 3. `to<C> : A -> B` and `to<C> : B -> C` are `Ring`-embeddings, as //! determined by the `is_embedding` metafunction. //! //! In that case, `mod` is defined as //! @code //! mod(x, y) = mod(to<C>(x), to<C>(y)) //! @endcode //! //! //! Example //! ------- //! @include example/mod.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto mod = [](auto&& x, auto&& y) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename U, typename = void> struct mod_impl : mod_impl<T, U, when<true>> { }; struct mod_t { template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) const; }; constexpr mod_t mod{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_MOD_HPP PK �\�[˗!#s s fwd/if.hppnu �[��� /*! @file Forward declares `boost::hana::if_`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_IF_HPP #define BOOST_HANA_FWD_IF_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Conditionally return one of two values based on a condition. //! @ingroup group-Logical //! //! Specifically, `then` is returned iff `cond` is true-valued, and //! `else_` is returned otherwise. Note that some `Logical` models may //! allow `then` and `else_` to have different types, while others may //! require both values to have the same type. //! //! //! @param cond //! The condition determining which of the two values is returned. //! //! @param then //! The value returned when `cond` is true-valued. //! //! @param else_ //! The value returned when `cond` is false-valued. //! //! //! Example //! ------- //! @include example/if.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto if_ = [](auto&& cond, auto&& then, auto&& else_) -> decltype(auto) { return tag-dispatched; }; #else template <typename L, typename = void> struct if_impl : if_impl<L, when<true>> { }; struct if_t { template <typename Cond, typename Then, typename Else> constexpr decltype(auto) operator()(Cond&& cond, Then&& then, Else&& else_) const; }; constexpr if_t if_{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_IF_HPP PK �\�[��h�s s fwd/zip_shortest_with.hppnu �[��� /*! @file Forward declares `boost::hana::zip_shortest_with`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_ZIP_SHORTEST_WITH_HPP #define BOOST_HANA_FWD_ZIP_SHORTEST_WITH_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Zip one sequence or more with a given function. //! @ingroup group-Sequence //! //! Given a `n`-ary function `f` and `n` sequences `s1, ..., sn`, //! `zip_shortest_with` produces a sequence whose `i`-th element is //! `f(s1[i], ..., sn[i])`, where `sk[i]` denotes the `i`-th element of //! the `k`-th sequence. In other words, `zip_shortest_with` produces a //! sequence of the form //! @code //! [ //! f(s1[0], ..., sn[0]), //! f(s1[1], ..., sn[1]), //! ... //! f(s1[M], ..., sn[M]) //! ] //! @endcode //! where `M` is the length of the shortest sequence. Hence, the returned //! sequence stops when the shortest input sequence is exhausted. If you //! know that all the sequences you are about to zip have the same length, //! you should use `zip_with` instead, since it can be more optimized. //! Also note that it is an error to provide no sequence at all, i.e. //! `zip_shortest_with` expects at least one sequence. //! //! //! Example //! ------- //! @include example/zip_shortest_with.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto zip_shortest_with = [](auto&& f, auto&& x1, ..., auto&& xn) { return tag-dispatched; }; #else template <typename S, typename = void> struct zip_shortest_with_impl : zip_shortest_with_impl<S, when<true>> { }; struct zip_shortest_with_t { template <typename F, typename Xs, typename ...Ys> constexpr auto operator()(F&& f, Xs&& xs, Ys&& ...ys) const; }; constexpr zip_shortest_with_t zip_shortest_with{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ZIP_SHORTEST_WITH_HPP PK �\�[tVz�� � fwd/size.hppnu �[��� /*! @file Forward declares `boost::hana::size`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_SIZE_HPP #define BOOST_HANA_FWD_SIZE_HPP #include <boost/hana/config.hpp> #include <boost/hana/fwd/length.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Equivalent to `length`; provided for consistency with the //! standard library. //! @ingroup group-Foldable //! //! This method is an alias to `length` provided for convenience and //! consistency with the standard library. As an alias, `size` is not //! tag-dispatched on its own and `length` should be customized instead. //! //! //! Example //! ------- //! @include example/size.cpp constexpr auto size = hana::length; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_SIZE_HPP PK �\�[+A�gC C fwd/remove_at.hppnu �[��� /*! @file Forward declares `boost::hana::remove_at` and `boost::hana::remove_at_c`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_REMOVE_AT_HPP #define BOOST_HANA_FWD_REMOVE_AT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <cstddef> BOOST_HANA_NAMESPACE_BEGIN //! Remove the element at a given index from a sequence. //! @ingroup group-Sequence //! //! `remove_at` returns a new sequence identical to the original, except //! that the element at the given index is removed. Specifically, //! `remove_at([x0, ..., xn-1, xn, xn+1, ..., xm], n)` is a new //! sequence equivalent to `[x0, ..., xn-1, xn+1, ..., xm]`. //! //! @note //! The behavior is undefined if the index is out of the bounds of the //! sequence. //! //! //! @param xs //! A sequence from which an element is to be removed. //! //! @param n //! An non-negative `IntegralConstant` representing the index of the //! element to be removed from the sequence. The behavior is undefined //! if that index is not in the bounds of the sequence. //! //! //! Example //! ------- //! @include example/remove_at.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto remove_at = [](auto&& xs, auto const& n) { return tag-dispatched; }; #else template <typename S, typename = void> struct remove_at_impl : remove_at_impl<S, when<true>> { }; struct remove_at_t { template <typename Xs, typename N> constexpr auto operator()(Xs&& xs, N const& n) const; }; constexpr remove_at_t remove_at{}; #endif //! Equivalent to `remove_at`; provided for convenience. //! @ingroup group-Sequence //! //! //! Example //! ------- //! @include example/remove_at_c.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <std::size_t n> constexpr auto remove_at_c = [](auto&& xs) { return hana::remove_at(forwarded(xs), hana::size_c<n>); }; #else template <std::size_t n> struct remove_at_c_t; template <std::size_t n> constexpr remove_at_c_t<n> remove_at_c{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_REMOVE_AT_HPP PK �\�[ ��n n fwd/ordering.hppnu �[��� /*! @file Forward declares `boost::hana::ordering`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_ORDERING_HPP #define BOOST_HANA_FWD_ORDERING_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns a function performing `less` after applying a transformation //! to both arguments. //! @ingroup group-Orderable //! //! `ordering` creates a total order based on the result of applying a //! function to some objects, which is especially useful in conjunction //! with algorithms that accept a custom predicate that must represent //! a total order. //! //! Specifically, `ordering` is such that //! @code //! ordering(f) == less ^on^ f //! @endcode //! or, equivalently, //! @code //! ordering(f)(x, y) == less(f(x), f(y)) //! @endcode //! //! @note //! This is not a tag-dispatched method (hence it can't be customized), //! but just a convenience function provided with the `Orderable` concept. //! //! //! Signature //! --------- //! Given a Logical `Bool` and an Orderable `B`, the signature is //! @f$ \mathrm{ordering} : (A \to B) \to (A \times A \to Bool) @f$. //! //! //! Example //! ------- //! @include example/ordering.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto ordering = [](auto&& f) { return [perfect-capture](auto&& x, auto&& y) -> decltype(auto) { return less(f(forwarded(x)), f(forwarded(y))); }; }; #else struct ordering_t { template <typename F> constexpr auto operator()(F&& f) const; }; constexpr ordering_t ordering{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ORDERING_HPP PK �\�[A�%ߵ � fwd/sum.hppnu �[��� /*! @file Forward declares `boost::hana::sum`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_SUM_HPP #define BOOST_HANA_FWD_SUM_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/fwd/integral_constant.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Compute the sum of the numbers of a structure. //! @ingroup group-Foldable //! //! More generally, `sum` will take any foldable structure containing //! objects forming a Monoid and reduce them using the Monoid's binary //! operation. The initial state for folding is the identity of the //! Monoid. It is sometimes necessary to specify the Monoid to use; //! this is possible by using `sum<M>`. If no Monoid is specified, //! the structure will use the Monoid formed by the elements it contains //! (if it knows it), or `integral_constant_tag<int>` otherwise. Hence, //! @code //! sum<M>(xs) = fold_left(xs, zero<M or inferred Monoid>(), plus) //! sum<> = sum<integral_constant_tag<int>> //! @endcode //! //! For numbers, this will just compute the sum of the numbers in the //! `xs` structure. //! //! //! @note //! The elements of the structure are not actually required to be in the //! same Monoid, but it must be possible to perform `plus` on any two //! adjacent elements of the structure, which requires each pair of //! adjacent element to at least have a common Monoid embedding. The //! meaning of "adjacent" as used here is that two elements of the //! structure `x` and `y` are adjacent if and only if they are adjacent //! in the linearization of that structure, as documented by the Iterable //! concept. //! //! //! Why must we sometimes specify the `Monoid` by using `sum<M>`? //! ------------------------------------------------------------- //! This is because sequence tags like `tuple_tag` are not parameterized //! (by design). Hence, we do not know what kind of objects are in the //! sequence, so we can't know a `0` value of which type should be //! returned when the sequence is empty. Therefore, the type of the //! `0` to return in the empty case must be specified explicitly. Other //! foldable structures like `hana::range`s will ignore the suggested //! Monoid because they know the tag of the objects they contain. This //! inconsistent behavior is a limitation of the current design with //! non-parameterized tags, but we have no good solution for now. //! //! //! Example //! ------- //! @include example/sum.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto sum = see documentation; #else template <typename T, typename = void> struct sum_impl : sum_impl<T, when<true>> { }; template <typename M> struct sum_t { template <typename Xs> constexpr decltype(auto) operator()(Xs&& xs) const; }; template <typename M = integral_constant_tag<int>> constexpr sum_t<M> sum{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_SUM_HPP PK �\�[b�H� � fwd/first.hppnu �[��� /*! @file Forward declares `boost::hana::first`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_FIRST_HPP #define BOOST_HANA_FWD_FIRST_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns the first element of a pair. //! @ingroup group-Product //! //! Note that if the `Product` actually stores the elements it contains, //! `hana::first` is required to return a lvalue reference, a lvalue //! reference to const or a rvalue reference to the first element, where //! the type of reference must match that of the pair passed to `first`. //! If the `Product` does not store the elements it contains (i.e. it //! generates them on demand), this requirement is dropped. //! //! //! Example //! ------- //! @include example/first.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto first = [](auto&& product) -> decltype(auto) { return tag-dispatched; }; #else template <typename P, typename = void> struct first_impl : first_impl<P, when<true>> { }; struct first_t { template <typename Pair> constexpr decltype(auto) operator()(Pair&& pair) const; }; constexpr first_t first{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_FIRST_HPP PK �\�[��q� � fwd/is_disjoint.hppnu �[��� /*! @file Forward declares `boost::hana::is_disjoint`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_IS_DISJOINT_HPP #define BOOST_HANA_FWD_IS_DISJOINT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns whether two `Searchable`s are disjoint. //! @ingroup group-Searchable //! //! Given two `Searchable`s `xs` and `ys`, `is_disjoint` returns a //! `Logical` representing whether the keys in `xs` are disjoint from //! the keys in `ys`, i.e. whether both structures have no keys in common. //! //! //! @param xs, ys //! Two `Searchable`s to test for disjointness. //! //! //! Example //! ------- //! @include example/is_disjoint.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto is_disjoint = [](auto const& xs, auto const& ys) { return tag-dispatched; }; #else template <typename S1, typename S2, typename = void> struct is_disjoint_impl : is_disjoint_impl<S1, S2, when<true>> { }; struct is_disjoint_t { template <typename Xs, typename Ys> constexpr auto operator()(Xs&& xs, Ys&& ys) const; }; constexpr is_disjoint_t is_disjoint{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_IS_DISJOINT_HPP PK �\�[�"�k k fwd/remove_if.hppnu �[��� /*! @file Forward declares `boost::hana::remove_if`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_REMOVE_IF_HPP #define BOOST_HANA_FWD_REMOVE_IF_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Remove all the elements of a monadic structure that satisfy some //! predicate. //! @ingroup group-MonadPlus //! //! Given a monadic structure `xs` and a unary predicate, `remove_if` //! returns a new monadic structure equal to `xs` without all its elements //! that satisfy the predicate. This is equivalent to `filter` with a //! negated predicate, i.e. //! @code //! remove_if(xs, predicate) == filter(xs, negated predicated) //! @endcode //! //! //! Signature //! --------- //! Given a MonadPlus `M` and a predicate of type \f$ T \to Bool \f$ for //! some compile-time Logical `Bool`, the signature is //! \f$ //! \mathrm{remove\_if} : M(T) \times (T \to Bool) \to M(T) //! \f$ //! //! @param xs //! A monadic structure to remove some elements from. //! //! @param predicate //! A unary predicate called as `predicate(x)`, where `x` is an element //! of the structure, and returning whether `x` should be removed from //! the structure. In the current version of the library, `predicate` //! must return a compile-time Logical. //! //! //! Example //! ------- //! @include example/remove_if.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto remove_if = [](auto&& xs, auto&& predicate) { return tag-dispatched; }; #else template <typename M, typename = void> struct remove_if_impl : remove_if_impl<M, when<true>> { }; struct remove_if_t { template <typename Xs, typename Pred> constexpr auto operator()(Xs&& xs, Pred&& pred) const; }; constexpr remove_if_t remove_if{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_REMOVE_IF_HPP PK �\�[� ��y y fwd/fold_right.hppnu �[��� /*! @file Forward declares `boost::hana::fold_right`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_FOLD_RIGHT_HPP #define BOOST_HANA_FWD_FOLD_RIGHT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Right-fold of a structure using a binary operation and an optional //! initial reduction state. //! @ingroup group-Foldable //! //! `fold_right` is a right-associative fold using a binary operation. //! Given a structure containing `x1, ..., xn`, a function `f` and //! an optional initial state, `fold_right` applies `f` as follows //! @code //! f(x1, f(x2, f(x3, f(x4, ... f(xn-1, xn) ... )))) // without state //! f(x1, f(x2, f(x3, f(x4, ... f(xn, state) ... )))) // with state //! @endcode //! //! @note //! It is worth noting that the order in which the binary function should //! expect its arguments is reversed from `fold_left`. //! //! When the structure is empty, two things may arise. If an initial //! state was provided, it is returned as-is. Otherwise, if the no-state //! version of the function was used, an error is triggered. When the //! stucture contains a single element and the no-state version of the //! function was used, that single element is returned as is. //! //! //! Signature //! --------- //! Given a `Foldable` `F` and an optional initial state of tag `S`, //! the signatures for `fold_right` are //! \f[ //! \mathtt{fold\_right} : F(T) \times S \times (T \times S \to S) \to S //! \f] //! //! for the variant with an initial state, and //! \f[ //! \mathtt{fold\_right} : F(T) \times (T \times T \to T) \to T //! \f] //! //! for the variant without an initial state. //! //! @param xs //! The structure to fold. //! //! @param state //! The initial value used for folding. //! //! @param f //! A binary function called as `f(x, state)`, where `state` is the //! result accumulated so far and `x` is an element in the structure. //! For right folds without an initial state, the function is called as //! `f(x1, x2)`, where `x1` and `x2` are elements of the structure. //! //! //! Example //! ------- //! @include example/fold_right.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto fold_right = [](auto&& xs[, auto&& state], auto&& f) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename = void> struct fold_right_impl : fold_right_impl<T, when<true>> { }; struct fold_right_t { template <typename Xs, typename State, typename F> constexpr decltype(auto) operator()(Xs&& xs, State&& state, F&& f) const; template <typename Xs, typename F> constexpr decltype(auto) operator()(Xs&& xs, F&& f) const; }; constexpr fold_right_t fold_right{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_FOLD_RIGHT_HPP PK �\�[G�/ � � fwd/accessors.hppnu �[��� /*! @file Forward declares `boost::hana::accessors`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_ACCESSORS_HPP #define BOOST_HANA_FWD_ACCESSORS_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns a `Sequence` of pairs representing the accessors of the //! data structure. //! @ingroup group-Struct //! //! Given a `Struct` `S`, `accessors<S>()` is a `Sequence` of `Product`s //! where the first element of each pair is the "name" of a member of //! the `Struct`, and the second element of each pair is a function that //! can be used to access that member when given an object of the proper //! data type. As described in the global documentation for `Struct`, the //! accessor functions in this sequence must be move-independent. //! //! //! Example //! ------- //! @include example/accessors.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename S> constexpr auto accessors = []() { return tag-dispatched; }; #else template <typename S, typename = void> struct accessors_impl : accessors_impl<S, when<true>> { }; template <typename S> struct accessors_t; template <typename S> constexpr accessors_t<S> accessors{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ACCESSORS_HPP PK �\�[_�B�� � fwd/drop_back.hppnu �[��� /*! @file Forward declares `boost::hana::drop_back`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_DROP_BACK_HPP #define BOOST_HANA_FWD_DROP_BACK_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Drop the last `n` elements of a finite sequence, and return the rest. //! @ingroup group-Sequence //! //! Given a finite `Sequence` `xs` with a linearization of `[x1, ..., xm]` //! and a non-negative `IntegralConstant` `n`, `drop_back(xs, n)` is a //! sequence with the same tag as `xs` whose linearization is //! `[x1, ..., xm-n]`. If `n` is not given, it defaults to an //! `IntegralConstant` with a value equal to `1`. //! //! In case `length(xs) <= n`, `drop_back` will simply drop the whole //! sequence without failing, thus returning an empty sequence. //! //! //! @param xs //! The sequence from which elements are dropped. //! //! @param n //! A non-negative `IntegralConstant` representing the number of elements //! to be dropped from the end of the sequence. If `n` is not given, it //! defaults to an `IntegralConstant` with a value equal to `1`. //! //! //! Example //! ------- //! @include example/drop_back.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto drop_back = [](auto&& xs[, auto const& n]) { return tag-dispatched; }; #else template <typename S, typename = void> struct drop_back_impl : drop_back_impl<S, when<true>> { }; struct drop_back_t { template <typename Xs, typename N> constexpr auto operator()(Xs&& xs, N const& n) const; template <typename Xs> constexpr auto operator()(Xs&& xs) const; }; constexpr drop_back_t drop_back{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_DROP_BACK_HPP PK �\�[�{�j� � fwd/unpack.hppnu �[��� /*! @file Forward declares `boost::hana::unpack`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_UNPACK_HPP #define BOOST_HANA_FWD_UNPACK_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Invoke a function with the elements of a Foldable as arguments. //! @ingroup group-Foldable //! //! Given a function and a foldable structure whose length can be known at //! compile-time, `unpack` invokes the function with the contents of that //! structure. In other words, `unpack(xs, f)` is equivalent to `f(x...)`, //! where `x...` are the elements of the structure. The length of the //! structure must be known at compile-time, because the version of `f`'s //! `operator()` that will be compiled depends on the number of arguments //! it is called with, which has to be known at compile-time. //! //! To create a function that accepts a foldable instead of variadic //! arguments, see `fuse` instead. //! //! //! @param xs //! The structure to expand into the function. //! //! @param f //! A function to be invoked as `f(x...)`, where `x...` are the elements //! of the structure as-if they had been linearized with `to<tuple_tag>`. //! //! //! Example //! ------- //! @include example/unpack.cpp //! //! //! Rationale: `unpack`'s name and parameter order //! ---------------------------------------------- //! It has been suggested a couple of times that `unpack` be called //! `apply` instead, and that the parameter order be reversed to match //! that of the [proposed std::apply function][1]. However, the name //! `apply` is already used to denote normal function application, an use //! which is consistent with the Boost MPL library and with the rest of //! the world, especially the functional programming community. //! Furthermore, the author of this library considers the proposed //! `std::apply` to have both an unfortunate name and an unfortunate //! parameter order. Indeed, taking the function as the first argument //! means that using `std::apply` with a lambda function looks like //! @code //! std::apply([](auto ...args) { //! use(args...); //! }, tuple); //! @endcode //! //! which is undeniably ugly because of the trailing `, tuple)` part //! on the last line. On the other hand, taking the function as a //! second argument allows one to write //! @code //! hana::unpack(tuple, [](auto ...args) { //! use(args...); //! }); //! @endcode //! //! which looks much nicer. Because of these observations, the author //! of this library feels justified to use `unpack` instead of `apply`, //! and to use a sane parameter order. //! //! [1]: http://en.cppreference.com/w/cpp/experimental/apply #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto unpack = [](auto&& xs, auto&& f) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename = void> struct unpack_impl : unpack_impl<T, when<true>> { }; struct unpack_t { template <typename Xs, typename F> constexpr decltype(auto) operator()(Xs&& xs, F&& f) const; }; constexpr unpack_t unpack{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_UNPACK_HPP PK �\�[�q!�� � fwd/insert_range.hppnu �[��� /*! @file Forward declares `boost::hana::insert_range`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_INSERT_RANGE_HPP #define BOOST_HANA_FWD_INSERT_RANGE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Insert several values at a given index in a sequence. //! @ingroup group-Sequence //! //! Given a sequence, an index and any `Foldable` containing elements to //! insert, `insert_range` inserts the elements in the `Foldable` at the //! given index of the sequence. //! //! @param xs //! The sequence in which values should be inserted. //! //! @param n //! The index at which elements should be inserted. This must be a //! non-negative `Constant` of an integral type, and it must also be //! true that `n < length(xs)` if `xs` is a finite sequence. //! //! @param elements //! A `Foldable` containing elements to insert in the sequence. //! //! //! Example //! ------- //! @include example/insert_range.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto insert_range = [](auto&& xs, auto&& n, auto&& elements) { return tag-dispatched; }; #else template <typename S, typename = void> struct insert_range_impl : insert_range_impl<S, when<true>> { }; struct insert_range_t { template <typename Xs, typename N, typename Elements> constexpr auto operator()(Xs&& xs, N&& n, Elements&& elements) const; }; constexpr insert_range_t insert_range{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_INSERT_RANGE_HPP PK �\�[��M� fwd/unfold_right.hppnu �[��� /*! @file Forward declares `boost::hana::unfold_right`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_UNFOLD_RIGHT_HPP #define BOOST_HANA_FWD_UNFOLD_RIGHT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Dual operation to `fold_right` for sequences. //! @ingroup group-Sequence //! //! While `fold_right` reduces a structure to a summary value from the //! right, `unfold_right` builds a sequence from a seed value and a //! function, starting from the right. //! //! //! Signature //! --------- //! Given a `Sequence` `S`, an initial value `state` of tag `I`, an //! arbitrary Product `P` and a function \f$ f : I \to P(T, I) \f$, //! `unfold_right<S>` has the following signature: //! \f[ //! \mathtt{unfold\_right}_S : I \times (I \to P(T, I)) \to S(T) //! \f] //! //! @tparam S //! The tag of the sequence to build up. //! //! @param state //! An initial value to build the sequence from. //! //! @param f //! A function called as `f(state)`, where `state` is an initial value, //! and returning //! 1. `nothing` if it is done producing the sequence. //! 2. otherwise, `just(make<P>(x, state))`, where `state` is the new //! initial value used in the next call to `f`, `x` is an element to //! be prepended to the resulting sequence, and `P` is an arbitrary //! `Product`. //! //! //! Fun fact //! --------- //! In some cases, `unfold_right` can undo a `fold_right` operation: //! @code //! unfold_right<S>(fold_right(xs, state, f), g) == xs //! @endcode //! //! if the following holds //! @code //! g(f(x, y)) == just(make_pair(x, y)) //! g(state) == nothing //! @endcode //! //! //! Example //! ------- //! @include example/unfold_right.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename S> constexpr auto unfold_right = [](auto&& state, auto&& f) { return tag-dispatched; }; #else template <typename S, typename = void> struct unfold_right_impl : unfold_right_impl<S, when<true>> { }; template <typename S> struct unfold_right_t; template <typename S> constexpr unfold_right_t<S> unfold_right{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_UNFOLD_RIGHT_HPP PK �\�[��O[� � fwd/lexicographical_compare.hppnu �[��� /*! @file Forward declares `boost::hana::lexicographical_compare`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_LEXICOGRAPHICAL_COMPARE_HPP #define BOOST_HANA_FWD_LEXICOGRAPHICAL_COMPARE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Short-circuiting lexicographical comparison of two `Iterable`s with //! an optional custom predicate, by default `hana::less`. //! @ingroup group-Iterable //! //! Given two `Iterable`s `xs` and `ys` and a binary predicate `pred`, //! `lexicographical_compare` returns whether `xs` is to be considered //! less than `ys` in a lexicographical ordering. Specifically, let's //! denote the linearizations of `xs` and `ys` by `[x1, x2, ...]` and //! `[y1, y2, ...]`, respectively. If the first couple satisfying the //! predicate is of the form `xi, yi`, `lexicographical_compare` returns //! true. Otherwise, if the first couple to satisfy the predicate is of //! the form `yi, xi`, `lexicographical_compare` returns false. If no //! such couple can be found, `lexicographical_compare` returns whether //! `xs` has fewer elements than `ys`. //! //! @note //! This algorithm will short-circuit as soon as it can determine that one //! sequence is lexicographically less than the other. Hence, it can be //! used to compare infinite sequences. However, for the procedure to //! terminate on infinite sequences, the predicate has to be satisfied //! at a finite index. //! //! //! Signature //! --------- //! Given two `Iterable`s `It1(T)` and `It2(T)` and a predicate //! \f$ pred : T \times T \to Bool \f$ (where `Bool` is some `Logical`), //! `lexicographical_compare` has the following signatures. For the //! variant with a provided predicate, //! \f[ //! \mathtt{lexicographical\_compare} //! : It1(T) \times It2(T) \times (T \times T \to Bool) \to Bool //! \f] //! //! for the variant without a custom predicate, `T` is required to be //! `Orderable`. The signature is then //! \f[ //! \mathtt{lexicographical\_compare} : It1(T) \times It2(T) \to Bool //! \f] //! //! @param xs, ys //! Two `Iterable`s to compare lexicographically. //! //! @param pred //! A binary function called as `pred(x, y)` and `pred(y, x)`, where `x` //! and `y` are elements of `xs` and `ys`, respectively. `pred` must //! return a `Logical` representing whether its first argument is to be //! considered as less than its second argument. Also note that `pred` //! must define a total ordering as defined by the `Orderable` concept. //! When `pred` is not provided, it defaults to `less`. //! //! //! Example //! ------- //! @include example/lexicographical_compare.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto lexicographical_compare = [](auto const& xs, auto const& ys, auto const& pred = hana::less) { return tag-dispatched; }; #else template <typename T, typename = void> struct lexicographical_compare_impl : lexicographical_compare_impl<T, when<true>> { }; struct lexicographical_compare_t { template <typename Xs, typename Ys> constexpr auto operator()(Xs const& xs, Ys const& ys) const; template <typename Xs, typename Ys, typename Pred> constexpr auto operator()(Xs const& xs, Ys const& ys, Pred const& pred) const; }; constexpr lexicographical_compare_t lexicographical_compare{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_LEXICOGRAPHICAL_COMPARE_HPP PK �\�[�� fwd/power.hppnu �[��� /*! @file Forward declares `boost::hana::power`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_POWER_HPP #define BOOST_HANA_FWD_POWER_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Elevate a ring element to its `n`th power. //! @ingroup group-Ring //! //! Specifically, `power(x, n)`, is equivalent to multiplying `x` with //! itself `n` times using the Ring's multiplication. If the power is //! equal to `zero`, the Ring's identity (`one`) is returned. //! //! @param x //! A `Ring` element that is elevated to its `n`th power. //! //! @param n //! A non-negative `IntegralConstant` representing the power to which `x` //! is elevated. //! //! //! @note //! Only the tag of `x` is used for tag-dispatching. //! //! Example //! ------- //! @include example/power.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto power = [](auto&& x, auto const& n) -> decltype(auto) { return tag-dispatched; }; #else template <typename R, typename = void> struct power_impl : power_impl<R, when<true>> { }; struct power_t { template <typename X, typename N> constexpr decltype(auto) operator()(X&& x, N const& n) const; }; constexpr power_t power{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_POWER_HPP PK �\�[�O;5 5 fwd/minus.hppnu �[��� /*! @file Forward declares `boost::hana::minus`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_MINUS_HPP #define BOOST_HANA_FWD_MINUS_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Subtract two elements of a group. //! @ingroup group-Group //! //! Specifically, this performs the `Monoid` operation on the first //! argument and on the inverse of the second argument, thus being //! equivalent to: //! @code //! minus(x, y) == plus(x, negate(y)) //! @endcode //! //! //! Cross-type version of the method //! -------------------------------- //! The `minus` method is "overloaded" to handle distinct data types //! with certain properties. Specifically, `minus` is defined for //! _distinct_ data types `A` and `B` such that //! 1. `A` and `B` share a common data type `C`, as determined by the //! `common` metafunction //! 2. `A`, `B` and `C` are all `Group`s when taken individually //! 3. `to<C> : A -> B` and `to<C> : B -> C` are `Group`-embeddings, as //! determined by the `is_embedding` metafunction. //! //! The definition of `minus` for data types satisfying the above //! properties is obtained by setting //! @code //! minus(x, y) = minus(to<C>(x), to<C>(y)) //! @endcode //! //! //! Example //! ------- //! @include example/minus.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto minus = [](auto&& x, auto&& y) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename U, typename = void> struct minus_impl : minus_impl<T, U, when<true>> { }; struct minus_t { template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) const; }; constexpr minus_t minus{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_MINUS_HPP PK �\�[E E\�& �& fwd/set.hppnu �[��� /*! @file Forward declares `boost::hana::set`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_SET_HPP #define BOOST_HANA_FWD_SET_HPP #include <boost/hana/config.hpp> #include <boost/hana/fwd/core/to.hpp> #include <boost/hana/fwd/core/make.hpp> #include <boost/hana/fwd/erase_key.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-datatypes //! Basic unordered container requiring unique, `Comparable` and //! `Hashable` keys. //! //! A set is an unordered container that can hold heterogeneous keys. //! A set requires (and ensures) that no duplicates are present when //! inserting new keys. //! //! @note //! The actual representation of a `hana::set` is implementation-defined. //! In particular, one should not take for granted the order of the //! template parameters and the presence of any additional constructors //! or assignment operators than what is documented. The canonical way of //! creating a `hana::set` is through `hana::make_set`. More details //! [in the tutorial](@ref tutorial-containers-types). //! //! //! Modeled concepts //! ---------------- //! 1. `Comparable`\n //! Two sets are equal iff they contain the same elements, regardless of //! the order. //! @include example/set/comparable.cpp //! //! 2. Foldable\n //! Folding a set is equivalent to folding the sequence of its values. //! However, note that the values are not required to be in any specific //! order, so using the folds provided here with an operation that is not //! both commutative and associative will yield non-deterministic behavior. //! @include example/set/foldable.cpp //! //! 3. Searchable\n //! The elements in a set act as both its keys and its values. Since the //! elements of a set are unique, searching for an element will return //! either the only element which is equal to the searched value, or //! `nothing`. Also note that `operator[]` can be used instead of the //! `at_key` function. //! @include example/set/searchable.cpp //! //! //! Conversion from any `Foldable` //! ------------------------------ //! Any `Foldable` structure can be converted into a `hana::set` with //! `to<set_tag>`. The elements of the structure must all be compile-time //! `Comparable`. If the structure contains duplicate elements, only //! the first occurence will appear in the resulting set. More //! specifically, conversion from a `Foldable` is equivalent to //! @code //! to<set_tag>(xs) == fold_left(xs, make_set(), insert) //! @endcode //! //! __Example__ //! @include example/set/to.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename implementation_defined> struct set { //! Default-construct a set. This constructor only exists when all the //! elements of the set are default-constructible. constexpr set() = default; //! Copy-construct a set from another set. This constructor only //! exists when all the elements of the set are copy-constructible. constexpr set(set const& other) = default; //! Move-construct a set from another set. This constructor only //! exists when all the elements of the set are move-constructible. constexpr set(set&& other) = default; //! Equivalent to `hana::equal` template <typename X, typename Y> friend constexpr auto operator==(X&& x, Y&& y); //! Equivalent to `hana::not_equal` template <typename X, typename Y> friend constexpr auto operator!=(X&& x, Y&& y); //! Equivalent to `hana::at_key` template <typename Key> constexpr decltype(auto) operator[](Key&& key); }; #else template <typename ...Xs> struct set; #endif //! Tag representing the `hana::set` container. //! @relates hana::set struct set_tag { }; //! Function object for creating a `hana::set`. //! @relates hana::set //! //! Given zero or more values `xs...`, `make<set_tag>` returns a `set` //! containing those values. The values must all be compile-time //! `Comparable`, and no duplicate values may be provided. To create //! a `set` from a sequence with possible duplicates, use `to<set_tag>` //! instead. //! //! //! Example //! ------- //! @include example/set/make.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <> constexpr auto make<set_tag> = [](auto&& ...xs) { return set<implementation_defined>{forwarded(xs)...}; }; #endif //! Equivalent to `make<set_tag>`; provided for convenience. //! @relates hana::set //! //! //! Example //! ------- //! @include example/set/make.cpp constexpr auto make_set = make<set_tag>; //! Insert an element in a `hana::set`. //! @relates hana::set //! //! If the set already contains an element that compares equal, then //! nothing is done and the set is returned as is. //! //! //! @param set //! The set in which to insert a value. //! //! @param element //! The value to insert. It must be compile-time `Comparable`. //! //! //! Example //! ------- //! @include example/set/insert.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto insert = [](auto&& set, auto&& element) { return tag-dispatched; }; #endif //! Remove an element from a `hana::set`. //! @relates hana::set //! //! Returns a new set containing all the elements of the original, //! except the one comparing `equal` to the given element. If the set //! does not contain such an element, a new set equal to the original //! set is returned. //! //! //! @param set //! The set in which to remove a value. //! //! @param element //! The value to remove. It must be compile-time `Comparable`. //! //! //! Example //! ------- //! @include example/set/erase_key.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto erase_key = [](auto&& set, auto&& element) { return tag-dispatched; }; #endif //! Returns the union of two sets. //! @relates hana::set //! //! Given two sets `xs` and `ys`, `union_(xs, ys)` is a new set containing //! all the elements of `xs` and all the elements of `ys`, without //! duplicates. For any object `x`, the following holds: `x` is in //! `hana::union_(xs, ys)` if and only if `x` is in `xs` or `x` is in `ys`. //! //! //! @param xs, ys //! Two sets to compute the union of. //! //! //! Example //! ------- //! @include example/set/union.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto union_ = [](auto&& xs, auto&& ys) { return tag-dispatched; }; #endif //! Returns the intersection of two sets. //! @relates hana::set //! //! Given two sets `xs` and `ys`, `intersection(xs, ys)` is a new set //! containing exactly those elements that are present both in `xs` and //! in `ys`. //! In other words, the following holds for any object `x`: //! @code //! x ^in^ intersection(xs, ys) if and only if x ^in^ xs && x ^in^ ys //! @endcode //! //! //! @param xs, ys //! Two sets to intersect. //! //! //! Example //! ------- //! @include example/set/intersection.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto intersection = [](auto&& xs, auto&& ys) { return tag-dispatched; }; #endif //! Equivalent to `to<set_tag>`; provided for convenience. //! @relates hana::set constexpr auto to_set = to<set_tag>; //! Returns the set-theoretic difference of two sets. //! @relates hana::set //! //! Given two sets `xs` and `ys`, `difference(xs, ys)` is a new set //! containing all the elements of `xs` that are _not_ contained in `ys`. //! For any object `x`, the following holds: //! @code //! x ^in^ difference(xs, ys) if and only if x ^in^ xs && !(x ^in^ ys) //! @endcode //! //! //! This operation is not commutative, i.e. `difference(xs, ys)` is not //! necessarily the same as `difference(ys, xs)`. Indeed, consider the //! case where `xs` is empty and `ys` isn't. Then, `difference(xs, ys)` //! is empty but `difference(ys, xs)` is equal to `ys`. For the symmetric //! version of this operation, see `symmetric_difference`. //! //! //! @param xs //! A set param to remove values from. //! //! @param ys //! The set whose values are removed from `xs`. //! //! //! Example //! ------- //! @include example/set/difference.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto difference = [](auto&& xs, auto&& ys) { return tag-dispatched; }; #endif //! Returns the symmetric set-theoretic difference of two sets. //! @relates hana::set //! //! Given two sets `xs` and `ys`, `symmetric_difference(xs, ys)` is a new //! set containing all the elements of `xs` that are not contained in `ys`, //! and all the elements of `ys` that are not contained in `xs`. The //! symmetric difference of two sets satisfies the following: //! @code //! symmetric_difference(xs, ys) == union_(difference(xs, ys), difference(ys, xs)) //! @endcode //! //! //! @param xs, ys //! Two sets to compute the symmetric difference of. //! //! //! Example //! ------- //! @include example/set/symmetric_difference.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto symmetric_difference = [](auto&& xs, auto&& ys) { return tag-dispatched; }; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_SET_HPP PK �\�[vh5�V3 V3 fwd/map.hppnu �[��� /*! @file Forward declares `boost::hana::map`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_MAP_HPP #define BOOST_HANA_FWD_MAP_HPP #include <boost/hana/config.hpp> #include <boost/hana/fwd/core/to.hpp> #include <boost/hana/fwd/core/make.hpp> #include <boost/hana/fwd/erase_key.hpp> #include <boost/hana/fwd/insert.hpp> #include <boost/hana/fwd/keys.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Tag representing `hana::map`s. //! @relates hana::map struct map_tag { }; namespace detail { template <typename ...Pairs> struct make_map_type; } //! @ingroup group-datatypes //! Basic associative container requiring unique, `Comparable` and //! `Hashable` keys. //! //! The order of the elements of the map is unspecified. Also, all the //! keys must be `Hashable`, and any two keys with equal hashes must be //! `Comparable` with each other at compile-time. //! //! @note //! The actual representation of a `hana::map` is an implementation //! detail. As such, one should not assume anything more than what is //! explicitly documented as being part of the interface of a map, //! such as: //! - the presence of additional constructors //! - the presence of additional assignment operators //! - the fact that `hana::map<Pairs...>` is, or is not, a dependent type //! . //! In particular, the last point is very important; `hana::map<Pairs...>` //! is basically equivalent to //! @code //! decltype(hana::make_pair(std::declval<Pairs>()...)) //! @endcode //! which is not something that can be pattern-matched on during template //! argument deduction, for example. More details [in the tutorial] //! (@ref tutorial-containers-types). //! //! //! Modeled concepts //! ---------------- //! 1. `Comparable`\n //! Two maps are equal iff all their keys are equal and are associated //! to equal values. //! @include example/map/comparable.cpp //! //! 2. `Searchable`\n //! A map can be searched by its keys with a predicate yielding a //! compile-time `Logical`. Also note that `operator[]` can be used //! instead of `at_key`. //! @include example/map/searchable.cpp //! //! 3. `Foldable`\n //! Folding a map is equivalent to folding a list of the key/value pairs //! it contains. In particular, since that list is not guaranteed to be //! in any specific order, folding a map with an operation that is not //! both commutative and associative will yield non-deterministic behavior. //! @include example/map/foldable.cpp //! //! //! Conversion from any `Foldable` //! ------------------------------ //! Any `Foldable` of `Product`s can be converted to a `hana::map` with //! `hana::to<hana::map_tag>` or, equivalently, `hana::to_map`. If the //! `Foldable` contains duplicate keys, only the value associated to the //! first occurence of each key is kept. //! @include example/map/to.cpp //! //! //! Example //! ------- //! @include example/map/map.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename ...Pairs> struct map { //! Default-construct a map. This constructor only exists when all the //! elements of the map are default-constructible. constexpr map() = default; //! Copy-construct a map from another map. This constructor only //! exists when all the elements of the map are copy-constructible. constexpr map(map const& other) = default; //! Move-construct a map from another map. This constructor only //! exists when all the elements of the map are move-constructible. constexpr map(map&& other) = default; //! Construct the map from the provided pairs. `P...` must be pairs of //! the same type (modulo ref and cv-qualifiers), and in the same order, //! as those appearing in `Pairs...`. The pairs provided to this //! constructor are emplaced into the map's storage using perfect //! forwarding. template <typename ...P> explicit constexpr map(P&& ...pairs); //! Assign a map to another map __with the exact same type__. Only //! exists when all the elements of the map are copy-assignable. constexpr map& operator=(map const& other); //! Move-assign a map to another map __with the exact same type__. //! Only exists when all the elements of the map are move-assignable. constexpr map& operator=(map&& other); //! Equivalent to `hana::equal` template <typename X, typename Y> friend constexpr auto operator==(X&& x, Y&& y); //! Equivalent to `hana::not_equal` template <typename X, typename Y> friend constexpr auto operator!=(X&& x, Y&& y); //! Equivalent to `hana::at_key` template <typename Key> constexpr decltype(auto) operator[](Key&& key); }; #else template <typename ...Pairs> using map = typename detail::make_map_type<Pairs...>::type; #endif //! Function object for creating a `hana::map`. //! @relates hana::map //! //! Given zero or more `Product`s representing key/value associations, //! `make<map_tag>` returns a `hana::map` associating these keys to these //! values. //! //! `make<map_tag>` requires all the keys to be unique and to have //! different hashes. If you need to create a map with duplicate keys //! or with keys whose hashes might collide, use `hana::to_map` or //! insert `(key, value)` pairs to an empty map successively. However, //! be aware that doing so will be much more compile-time intensive than //! using `make<map_tag>`, because the uniqueness of keys will have to be //! enforced. //! //! //! Example //! ------- //! @include example/map/make.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <> constexpr auto make<map_tag> = [](auto&& ...pairs) { return map<implementation_defined>{forwarded(pairs)...}; }; #endif //! Alias to `make<map_tag>`; provided for convenience. //! @relates hana::map //! //! //! Example //! ------- //! @include example/map/make.cpp constexpr auto make_map = make<map_tag>; //! Equivalent to `to<map_tag>`; provided for convenience. //! @relates hana::map constexpr auto to_map = to<map_tag>; //! Returns a `Sequence` of the keys of the map, in unspecified order. //! @relates hana::map //! //! //! Example //! ------- //! @include example/map/keys.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto keys = [](auto&& map) { return implementation_defined; }; #endif //! Returns a `Sequence` of the values of the map, in unspecified order. //! @relates hana::map //! //! //! Example //! ------- //! @include example/map/values.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto values = [](auto&& map) -> decltype(auto) { return implementation_defined; }; #else struct values_t { template <typename Map> constexpr decltype(auto) operator()(Map&& map) const; }; constexpr values_t values{}; #endif //! Inserts a new key/value pair in a map. //! @relates hana::map //! //! Given a `(key, value)` pair, `insert` inserts this new pair into a //! map. If the map already contains this key, nothing is done and the //! map is returned as-is. //! //! //! @param map //! The map in which to insert a `(key,value)` pair. //! //! @param pair //! An arbitrary `Product` representing a `(key, value)` pair to insert //! in the map. The `key` must be compile-time `Comparable`. //! //! //! Example //! ------- //! @include example/map/insert.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto insert = [](auto&& map, auto&& pair) { return tag-dispatched; }; #endif //! Removes a key/value pair from a map. //! @relates hana::map //! //! Returns a new `hana::map` containing all the elements of the original, //! except for the `(key, value)` pair whose `key` compares `equal` //! to the given key. If the map does not contain such an element, //! a new map equal to the original is returned. //! //! //! @param map //! The map in which to erase a `key`. //! //! @param key //! A key to remove from the map. It must be compile-time `Comparable`. //! //! //! Example //! ------- //! @include example/map/erase_key.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto erase_key = [](auto&& map, auto&& key) { return tag-dispatched; }; #endif //! Returns the union of two maps. //! @relates hana::map //! //! Given two maps `xs` and `ys`, `hana::union_(xs, ys)` is a new map //! containing all the elements of `xs` and all the elements of `ys`, //! without duplicates. If both `xs` and `ys` contain an element with the //! same `key`, the one in `ys` is taken. Functionally, //! `hana::union_(xs, ys)` is equivalent to //! @code //! hana::fold_left(xs, ys, hana::insert) //! @endcode //! //! @param xs, ys //! The two maps to compute the union of. //! //! //! Example //! ------- //! @include example/map/union.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto union_ = [](auto&& xs, auto&& ys) { return tag-dispatched; }; #endif //! Returns the intersection of two maps. //! @relates hana::map //! //! Given two maps `xs` and `ys`, `intersection(xs, ys)` is a new map //! containing exactly those (key, value) pairs from xs, for which key //! is present in `ys`. //! In other words, the following holds for any object `pair(k, v)`: //! @code //! pair(k, v) ^in^ intersection(xs, ys) if and only if (k, v) ^in^ xs && k ^in^ keys(ys) //! @endcode //! //! //! @note //! This function is not commutative, i.e. `intersection(xs, ys)` is not //! necessarily the same as `intersection(ys, xs)`. Indeed, the set of keys //! in `intersection(xs, ys)` is always the same as the set of keys in //! `intersection(ys, xs)`, but the value associated to each key may be //! different. `intersection(xs, ys)` contains values present in `xs`, and //! `intersection(ys, xs)` contains values present in `ys`. //! //! //! @param xs, ys //! Two maps to intersect. //! //! //! Example //! ------- //! @include example/map/intersection.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto intersection = [](auto&& xs, auto&& ys) { return tag-dispatched; }; #endif //! Returns the difference of two maps. //! @relates hana::map //! //! Given two maps `xs` and `ys`, `difference(xs, ys)` is a new map //! containing exactly those (key, value) pairs from xs, for which key //! is not present in `keys(ys)`. //! In other words, the following holds for any object `pair(k, v)`: //! @code //! pair(k, v) ^in^ difference(xs, ys) if and only if (k, v) ^in^ xs && k ^not in^ keys(ys) //! @endcode //! //! //! @note //! This function is not commutative, i.e. `difference(xs, ys)` is not //! necessarily the same as `difference(ys, xs)`. //! Indeed, consider the case where `xs` is empty and `ys` isn't. //! In that case, `difference(xs, ys)` is empty, but `difference(ys, xs)` //! is equal to `ys`. //! For symmetric version of this operation, see `symmetric_difference`. //! //! //! @param xs, ys //! Two maps to compute the difference of. //! //! //! Example //! ------- //! @include example/map/intersection.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto difference = [](auto&& xs, auto&& ys) { return tag-dispatched; }; #endif //! Returns the symmetric set-theoretic difference of two maps. //! @relates hana::map //! //! Given two sets `xs` and `ys`, `symmetric_difference(xs, ys)` is a new //! map containing all the elements of `xs` whose keys are not contained in `keys(ys)`, //! and all the elements of `ys` whose keys are not contained in `keys(xs)`. The //! symmetric difference of two maps satisfies the following: //! @code //! symmetric_difference(xs, ys) == union_(difference(xs, ys), difference(ys, xs)) //! @endcode //! //! //! @param xs, ys //! Two maps to compute the symmetric difference of. //! //! //! Example //! ------- //! @include example/map/symmetric_difference.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto symmetric_difference = [](auto&& xs, auto&& ys) { return tag-dispatched; }; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_MAP_HPP PK �\�[A��U� � fwd/div.hppnu �[��� /*! @file Forward declares `boost::hana::div`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_DIV_HPP #define BOOST_HANA_FWD_DIV_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Generalized integer division. //! @ingroup group-EuclideanRing //! //! //! Cross-type version of the method //! -------------------------------- //! The `div` method is "overloaded" to handle distinct data types //! with certain properties. Specifically, `div` is defined for //! _distinct_ data types `A` and `B` such that //! 1. `A` and `B` share a common data type `C`, as determined by the //! `common` metafunction //! 2. `A`, `B` and `C` are all `EuclideanRing`s when taken individually //! 3. `to<C> : A -> B` and `to<C> : B -> C` are `Ring`-embeddings, as //! determined by the `is_embedding` metafunction. //! //! In that case, the `div` method is defined as //! @code //! div(x, y) = div(to<C>(x), to<C>(y)) //! @endcode //! //! //! Example //! ------- //! @include example/div.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto div = [](auto&& x, auto&& y) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename U, typename = void> struct div_impl : div_impl<T, U, when<true>> { }; struct div_t { template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) const; }; constexpr div_t div{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_DIV_HPP PK �\�[}���n n fwd/hash.hppnu �[��� /*! @file Forward declares `boost::hana::hash`. @copyright Louis Dionne 2016 @copyright Jason Rice 2016 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_HASH_HPP #define BOOST_HANA_FWD_HASH_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns a `hana::type` representing the compile-time hash of an object. //! @ingroup group-Hashable //! //! Given an arbitrary object `x`, `hana::hash` returns a `hana::type` //! representing the hash of `x`. In normal programming, hashes are //! usually numerical values that can be used e.g. as indices in an //! array as part of the implementation of a hash table. In the context //! of metaprogramming, we are interested in type-level hashes instead. //! Thus, `hana::hash` must return a `hana::type` object instead of an //! integer. This `hana::type` must somehow summarize the object being //! hashed, but that summary may of course lose some information. //! //! In order for the `hash` function to be defined properly, it must be //! the case that whenever `x` is equal to `y`, then `hash(x)` is equal //! to `hash(y)`. This ensures that `hana::hash` is a function in the //! mathematical sense of the term. //! //! //! Signature //! --------- //! Given a `Hashable` `H`, the signature is //! \f$ //! \mathtt{hash} : H \to \mathtt{type\_tag} //! \f$ //! //! @param x //! An object whose hash is to be computed. //! //! //! Example //! ------- //! @include example/hash.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto hash = [](auto const& x) { return tag-dispatched; }; #else template <typename T, typename = void> struct hash_impl : hash_impl<T, when<true>> { }; struct hash_t { template <typename X> constexpr auto operator()(X const& x) const; }; constexpr hash_t hash{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_HASH_HPP PK �\�[��}c� � fwd/take_front.hppnu �[��� /*! @file Forward declares `boost::hana::take_front` and `boost::hana::take_front_c`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_TAKE_FRONT_HPP #define BOOST_HANA_FWD_TAKE_FRONT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <cstddef> BOOST_HANA_NAMESPACE_BEGIN //! Returns the first `n` elements of a sequence, or the whole sequence //! if the sequence has less than `n` elements. //! @ingroup group-Sequence //! //! Given a `Sequence` `xs` and an `IntegralConstant` `n`, `take_front(xs, n)` //! is a new sequence containing the first `n` elements of `xs`, in the //! same order. If `length(xs) <= n`, the whole sequence is returned and //! no error is triggered. //! //! //! @param xs //! The sequence to take the elements from. //! //! @param n //! A non-negative `IntegralConstant` representing the number of elements //! to keep in the resulting sequence. //! //! //! Example //! ------- //! @include example/take_front.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto take_front = [](auto&& xs, auto const& n) { return tag-dispatched; }; #else template <typename S, typename = void> struct take_front_impl : take_front_impl<S, when<true>> { }; struct take_front_t { template <typename Xs, typename N> constexpr auto operator()(Xs&& xs, N const& n) const; }; constexpr take_front_t take_front{}; #endif //! Equivalent to `take_front`; provided for convenience. //! @ingroup group-Sequence //! //! //! Example //! ------- //! @include example/take_front_c.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <std::size_t n> constexpr auto take_front_c = [](auto&& xs) { return hana::take_front(forwarded(xs), hana::size_c<n>); }; #else template <std::size_t n> struct take_front_c_t; template <std::size_t n> constexpr take_front_c_t<n> take_front_c{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_TAKE_FRONT_HPP PK �\�[ ��Q! ! fwd/suffix.hppnu �[��� /*! @file Forward declares `boost::hana::suffix`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_SUFFIX_HPP #define BOOST_HANA_FWD_SUFFIX_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Inserts a value after each element of a monadic structure. //! @ingroup group-MonadPlus //! //! Given a monadic structure `xs` and a value `z` (called the suffix), //! `suffix` returns a new monadic structure such that //! @code //! suffix(xs, z) == flatten(transform(xs, [](auto x) { //! return concat(lift<M>(x), lift<M>(z)); //! })) //! @endcode //! //! For sequences, this simply corresponds to inserting the suffix after //! each element of the sequence. For example, given a sequence //! `[x1, ..., xn]`, `suffix` will return //! @code //! [x1, z, x2, z, ..., xn, z] //! @endcode //! As explained above, this can be generalized to other MonadPlus models, //! with various levels of interest. //! //! //! Signature //! --------- //! Given a MonadPlus `M`, the signature is //! @f$ \mathtt{suffix} : M(T) \times T \to M(T) @f$. //! //! @param xs //! A monadic structure. //! //! @param sfx //! A value (the suffix) to insert after each element of a monadic //! structure. //! //! //! Example //! ------- //! @include example/suffix.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto suffix = [](auto&& xs, auto&& sfx) { return tag-dispatched; }; #else template <typename M, typename = void> struct suffix_impl : suffix_impl<M, when<true>> { }; struct suffix_t { template <typename Xs, typename Sfx> constexpr auto operator()(Xs&& xs, Sfx&& sfx) const; }; constexpr suffix_t suffix{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_SUFFIX_HPP PK �\�[��� � fwd/eval.hppnu �[��� /*! @file Forward declares `boost::hana::eval`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_EVAL_HPP #define BOOST_HANA_FWD_EVAL_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Evaluate a lazy value and return it. //! @relates hana::lazy //! //! Given a lazy expression `expr`, `eval` evaluates `expr` and returns //! the result as a normal value. However, for convenience, `eval` can //! also be used with nullary and unary function objects. Specifically, //! if `expr` is not a `hana::lazy`, it is called with no arguments at //! all and the result of that call (`expr()`) is returned. Otherwise, //! if `expr()` is ill-formed, then `expr(hana::id)` is returned instead. //! If that expression is ill-formed, then a compile-time error is //! triggered. //! //! The reason for allowing nullary callables in `eval` is because this //! allows using nullary lambdas as lazy branches to `eval_if`, which //! is convenient. The reason for allowing unary callables and calling //! them with `hana::id` is because this allows deferring the //! compile-time evaluation of selected expressions inside the callable. //! How this can be achieved is documented by `hana::eval_if`. //! //! //! Example //! ------- //! @include example/eval.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto eval = [](auto&& see_documentation) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename = void> struct eval_impl : eval_impl<T, when<true>> { }; struct eval_t { template <typename Expr> constexpr decltype(auto) operator()(Expr&& expr) const; }; constexpr eval_t eval{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_EVAL_HPP PK �\�[<*��* * fwd/span.hppnu �[��� /*! @file Forward declares `boost::hana::span`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_SPAN_HPP #define BOOST_HANA_FWD_SPAN_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/nested_by_fwd.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns a `Product` containing the longest prefix of a sequence //! satisfying a predicate, and the rest of the sequence. //! @ingroup group-Sequence //! //! The first component of the returned `Product` is a sequence for which //! all elements satisfy the given predicate. The second component of the //! returned `Product` is a sequence containing the remainder of the //! argument. Both or either sequences may be empty, depending on the //! input argument. More specifically, //! @code //! span(xs, predicate) == make_pair(take_while(xs, predicate), //! drop_while(xs, predicate)) //! @endcode //! except that `make_pair` may be an arbitrary `Product`. //! //! //! Signature //! --------- //! Given a `Sequence` `S(T)`, a `Logical` `Bool` and a predicate //! \f$ T \to Bool \f$, `span` has the following signature: //! \f[ //! \mathtt{span} : S(T) \times (T \to Bool) \to S(T) \times S(T) //! \f] //! //! @param xs //! The sequence to break into two parts. //! //! @param predicate //! A function called as `predicate(x)`, where `x` is an element of the //! sequence, and returning a `Logical. In the current implementation of //! the library, `predicate` has to return a compile-time `Logical`. //! //! //! Syntactic sugar (`span.by`) //! --------------------------- //! `span` can be called in an alternate way, which provides a nice syntax //! in some cases where the predicate is short: //! @code //! span.by(predicate, xs) == span(xs, predicate) //! span.by(predicate) == span(-, predicate) //! @endcode //! //! where `span(-, predicate)` denotes the partial application of //! `span` to `predicate`. //! //! //! Example //! ------- //! @include example/span.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto span = [](auto&& xs, auto&& predicate) { return tag-dispatched; }; #else template <typename S, typename = void> struct span_impl : span_impl<S, when<true>> { }; struct span_t : detail::nested_by<span_t> { template <typename Xs, typename Pred> constexpr auto operator()(Xs&& xs, Pred&& pred) const; }; constexpr span_t span{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_SPAN_HPP PK �\�[C� H1 1 fwd/prefix.hppnu �[��� /*! @file Forward declares `boost::hana::prefix`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_PREFIX_HPP #define BOOST_HANA_FWD_PREFIX_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Inserts a value before each element of a monadic structure. //! @ingroup group-MonadPlus //! //! Given a monadic structure `xs` and a value `z` called the prefix, //! `prefix` returns a new monadic structure. `prefix` satisfies //! @code //! prefix(xs, z) == flatten(transform(xs, [](auto x) { //! return concat(lift<M>(z), lift<M>(x)); //! })) //! @endcode //! //! For sequences, this simply corresponds to inserting the prefix before //! each element of the sequence. For example, given a sequence //! `[x1, ..., xn]`, `prefix` will return //! @code //! [z, x1, z, x2, ..., z, xn] //! @endcode //! As explained above, this can be generalized to other MonadPlus models, //! with various levels of interest. //! //! //! Signature //! --------- //! Given a MonadPlus `M`, the signature is //! @f$ \mathrm{prefix} : M(T) \times T \to M(T) @f$. //! //! @param xs //! A monadic structure. //! //! @param pref //! A value (the prefix) to insert before each element of a monadic //! structure. //! //! //! Example //! ------- //! @include example/prefix.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto prefix = [](auto&& xs, auto&& pref) { return tag-dispatched; }; #else template <typename M, typename = void> struct prefix_impl : prefix_impl<M, when<true>> { }; struct prefix_t { template <typename Xs, typename Pref> constexpr auto operator()(Xs&& xs, Pref&& pref) const; }; constexpr prefix_t prefix{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_PREFIX_HPP PK �\�[^We� � fwd/drop_front.hppnu �[��� /*! @file Forward declares `boost::hana::drop_front`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_DROP_FRONT_HPP #define BOOST_HANA_FWD_DROP_FRONT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Drop the first `n` elements of an iterable, and return the rest. //! @ingroup group-Iterable //! //! Given an `Iterable` `xs` with a linearization of `[x1, x2, ...]` and //! a non-negative `IntegralConstant` `n`, `drop_front(xs, n)` is an //! iterable with the same tag as `xs` whose linearization is //! `[xn+1, xn+2, ...]`. In particular, note that this function does not //! mutate the original iterable in any way. If `n` is not given, it //! defaults to an `IntegralConstant` with a value equal to `1`. //! //! In case `length(xs) <= n`, `drop_front` will simply drop the whole //! iterable without failing, thus returning an empty iterable. This is //! different from `drop_front_exactly`, which expects `n <= length(xs)` //! but can be better optimized because of this additional guarantee. //! //! //! @param xs //! The iterable from which elements are dropped. //! //! @param n //! A non-negative `IntegralConstant` representing the number of elements //! to be dropped from the iterable. If `n` is not given, it defaults to //! an `IntegralConstant` with a value equal to `1`. //! //! //! Example //! ------- //! @include example/drop_front.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto drop_front = [](auto&& xs[, auto const& n]) { return tag-dispatched; }; #else template <typename It, typename = void> struct drop_front_impl : drop_front_impl<It, when<true>> { }; struct drop_front_t { template <typename Xs, typename N> constexpr auto operator()(Xs&& xs, N const& n) const; template <typename Xs> constexpr auto operator()(Xs&& xs) const; }; constexpr drop_front_t drop_front{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_DROP_FRONT_HPP PK �\�[�Dӣ � fwd/reverse.hppnu �[��� /*! @file Forward declares `boost::hana::reverse`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_REVERSE_HPP #define BOOST_HANA_FWD_REVERSE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Reverse a sequence. //! @ingroup group-Sequence //! //! Specifically, `reverse(xs)` is a new sequence containing the same //! elements as `xs`, except in reverse order. //! //! //! @param xs //! The sequence to reverse. //! //! //! Example //! ------- //! @include example/reverse.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto reverse = [](auto&& xs) { return tag-dispatched; }; #else template <typename S, typename = void> struct reverse_impl : reverse_impl<S, when<true>> { }; struct reverse_t { template <typename Xs> constexpr auto operator()(Xs&& xs) const; }; constexpr reverse_t reverse{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_REVERSE_HPP PK �\�[��T�� � fwd/basic_tuple.hppnu �[��� /*! @file Forward declares `boost::hana::basic_tuple`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_BASIC_TUPLE_HPP #define BOOST_HANA_FWD_BASIC_TUPLE_HPP #include <boost/hana/config.hpp> #include <boost/hana/fwd/core/make.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-datatypes //! Stripped down version of `hana::tuple`. //! //! Whereas `hana::tuple` aims to provide an interface somewhat close to a //! `std::tuple`, `basic_tuple` provides the strict minimum required to //! implement a closure with maximum compile-time efficiency. //! //! @note //! When you use a container, remember not to make assumptions about its //! representation, unless the documentation gives you those guarantees. //! More details [in the tutorial](@ref tutorial-containers-types). //! //! //! Modeled concepts //! ---------------- //! `Sequence`, and all the concepts it refines template <typename ...Xs> struct basic_tuple; //! Tag representing `hana::basic_tuple`. //! @relates hana::basic_tuple struct basic_tuple_tag { }; #ifdef BOOST_HANA_DOXYGEN_INVOKED //! Function object for creating a `basic_tuple`. //! @relates hana::basic_tuple //! //! Given zero or more objects `xs...`, `make<basic_tuple_tag>` returns a //! new `basic_tuple` containing those objects. The elements are held by //! value inside the resulting tuple, and they are hence copied or moved //! in. This is analogous to `std::make_tuple` for creating `basic_tuple`s. //! //! //! Example //! ------- //! @include example/basic_tuple/make.cpp template <> constexpr auto make<basic_tuple_tag> = [](auto&& ...xs) { return basic_tuple<std::decay_t<decltype(xs)>...>{forwarded(xs)...}; }; #endif //! Alias to `make<basic_tuple_tag>`; provided for convenience. //! @relates hana::basic_tuple //! //! //! Example //! ------- //! @include example/basic_tuple/make.cpp constexpr auto make_basic_tuple = make<basic_tuple_tag>; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_BASIC_TUPLE_HPP PK �\�[.b��l l fwd/erase_key.hppnu �[��� /*! @file Forward declares `boost::hana::erase_key`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_ERASE_KEY_HPP #define BOOST_HANA_FWD_ERASE_KEY_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN // Note: This function is documented per datatype/concept only. //! @cond template <typename T, typename = void> struct erase_key_impl : erase_key_impl<T, when<true>> { }; //! @endcond struct erase_key_t { template <typename Set, typename ...Args> constexpr decltype(auto) operator()(Set&& set, Args&& ...args) const; }; constexpr erase_key_t erase_key{}; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ERASE_KEY_HPP PK �\�[H���� � fwd/members.hppnu �[��� /*! @file Forward declares `boost::hana::members`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_MEMBERS_HPP #define BOOST_HANA_FWD_MEMBERS_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns a `Sequence` containing the members of a `Struct`. //! @ingroup group-Struct //! //! Given a `Struct` object, `members` returns a `Sequence` containing //! all the members of the `Struct`, in the same order as their respective //! accessor appears in the `accessors` sequence. //! //! //! Example //! ------- //! @include example/members.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto members = [](auto&& object) { return tag-dispatched; }; #else template <typename S, typename = void> struct members_impl : members_impl<S, when<true>> { }; struct members_t { template <typename Object> constexpr auto operator()(Object&& object) const; }; constexpr members_t members{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_MEMBERS_HPP PK �\�[#�!�~ ~ fwd/zip.hppnu �[��� /*! @file Forward declares `boost::hana::zip`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_ZIP_HPP #define BOOST_HANA_FWD_ZIP_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Zip one sequence or more. //! @ingroup group-Sequence //! //! Given `n` sequences `s1, ..., sn`, `zip` produces a sequence whose //! `i`-th element is a tuple of `(s1[i], ..., sn[i])`, where `sk[i]` //! denotes the `i`-th element of the `k`-th sequence. In other words, //! `zip` produces a sequence of the form //! @code //! [ //! make_tuple(s1[0], ..., sn[0]), //! make_tuple(s1[1], ..., sn[1]), //! ... //! make_tuple(s1[M], ..., sn[M]) //! ] //! @endcode //! where `M` is the length of the sequences, which are all assumed to //! have the same length. Assuming the sequences to all have the same size //! allows the library to perform some optimizations. To zip sequences //! that may have different lengths, `zip_shortest` should be used //! instead. Also note that it is an error to provide no sequence at all, //! i.e. `zip` expects at least one sequence. //! //! //! Example //! ------- //! @include example/zip.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto zip = [](auto&& x1, ..., auto&& xn) { return tag-dispatched; }; #else template <typename S, typename = void> struct zip_impl : zip_impl<S, when<true>> { }; struct zip_t { template <typename Xs, typename ...Ys> constexpr auto operator()(Xs&& xs, Ys&& ...ys) const; }; constexpr zip_t zip{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ZIP_HPP PK �\�[�D�� � fwd/fold_left.hppnu �[��� /*! @file Forward declares `boost::hana::fold_left`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_FOLD_LEFT_HPP #define BOOST_HANA_FWD_FOLD_LEFT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Left-fold of a structure using a binary operation and an optional //! initial reduction state. //! @ingroup group-Foldable //! //! `fold_left` is a left-associative fold using a binary operation. //! Given a structure containing `x1, ..., xn`, a function `f` and //! an optional initial state, `fold_left` applies `f` as follows //! @code //! f(... f(f(f(x1, x2), x3), x4) ..., xn) // without state //! f(... f(f(f(f(state, x1), x2), x3), x4) ..., xn) // with state //! @endcode //! //! When the structure is empty, two things may arise. If an initial //! state was provided, it is returned as-is. Otherwise, if the no-state //! version of the function was used, an error is triggered. When the //! stucture contains a single element and the no-state version of the //! function was used, that single element is returned as is. //! //! //! Signature //! --------- //! Given a `Foldable` `F` and an optional initial state of tag `S`, //! the signatures for `fold_left` are //! \f[ //! \mathtt{fold\_left} : F(T) \times S \times (S \times T \to S) \to S //! \f] //! //! for the variant with an initial state, and //! \f[ //! \mathtt{fold\_left} : F(T) \times (T \times T \to T) \to T //! \f] //! //! for the variant without an initial state. //! //! @param xs //! The structure to fold. //! //! @param state //! The initial value used for folding. //! //! @param f //! A binary function called as `f(state, x)`, where `state` is the //! result accumulated so far and `x` is an element in the structure. //! For left folds without an initial state, the function is called as //! `f(x1, x2)`, where `x1` and `x2` are elements of the structure. //! //! //! Example //! ------- //! @include example/fold_left.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto fold_left = [](auto&& xs[, auto&& state], auto&& f) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename = void> struct fold_left_impl : fold_left_impl<T, when<true>> { }; struct fold_left_t { template <typename Xs, typename State, typename F> constexpr decltype(auto) operator()(Xs&& xs, State&& state, F&& f) const; template <typename Xs, typename F> constexpr decltype(auto) operator()(Xs&& xs, F&& f) const; }; constexpr fold_left_t fold_left{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_FOLD_LEFT_HPP PK �\�[�P�oK K fwd/back.hppnu �[��� /*! @file Forward declares `boost::hana::back`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_BACK_HPP #define BOOST_HANA_FWD_BACK_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns the last element of a non-empty and finite iterable. //! @ingroup group-Iterable //! //! Given a non-empty and finite iterable `xs` with a linearization of //! `[x1, ..., xN]`, `back(xs)` is equal to `xN`. Equivalently, `back(xs)` //! must be equivalent to `at_c<N-1>(xs)`, and that regardless of the //! value category of `xs` (`back` must respect the reference semantics //! of `at`). //! //! //! Example //! ------- //! @include example/back.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto back = [](auto&& xs) -> decltype(auto) { return tag-dispatched; }; #else template <typename It, typename = void> struct back_impl : back_impl<It, when<true>> { }; struct back_t { template <typename Xs> constexpr decltype(auto) operator()(Xs&& xs) const; }; constexpr back_t back{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_BACK_HPP PK �\�[ � ?� � fwd/is_empty.hppnu �[��� /*! @file Forward declares `boost::hana::is_empty`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_IS_EMPTY_HPP #define BOOST_HANA_FWD_IS_EMPTY_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns whether the iterable is empty. //! @ingroup group-Iterable //! //! Given an `Iterable` `xs`, `is_empty` returns whether `xs` contains //! no more elements. In other words, it returns whether trying to //! extract the tail of `xs` would be an error. In the current version //! of the library, `is_empty` must return an `IntegralConstant` holding //! a value convertible to `bool`. This is because only compile-time //! `Iterable`s are supported right now. //! //! //! Example //! ------- //! @include example/is_empty.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto is_empty = [](auto const& xs) { return tag-dispatched; }; #else template <typename It, typename = void> struct is_empty_impl : is_empty_impl<It, when<true>> { }; struct is_empty_t { template <typename Xs> constexpr auto operator()(Xs const& xs) const; }; constexpr is_empty_t is_empty{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_IS_EMPTY_HPP PK �\�[ ?�%C C fwd/not_equal.hppnu �[��� /*! @file Forward declares `boost::hana::not_equal`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_NOT_EQUAL_HPP #define BOOST_HANA_FWD_NOT_EQUAL_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/nested_to_fwd.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns a `Logical` representing whether `x` is not equal to `y`. //! @ingroup group-Comparable //! //! The `not_equal` function can be called in two different ways. First, //! it can be called like a normal function: //! @code //! not_equal(x, y) //! @endcode //! //! However, it may also be partially applied to an argument by using //! `not_equal.to`: //! @code //! not_equal.to(x)(y) == not_equal(x, y) //! @endcode //! //! In other words, `not_equal.to(x)` is a function object that is //! equivalent to `partial(not_equal, x)`. This is provided to enhance //! the readability of some constructs, especially when using higher //! order algorithms. //! //! //! Signature //! --------- //! Given a Logical `Bool` and two Comparables `A` and `B` that //! share a common embedding, the signature is //! @f$ \mathtt{not\_equal} : A \times B \to Bool @f$. //! //! @param x, y //! Two objects to compare for inequality. //! //! //! Example //! ------- //! @include example/not_equal.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto not_equal = [](auto&& x, auto&& y) { return tag-dispatched; }; #else template <typename T, typename U, typename = void> struct not_equal_impl : not_equal_impl<T, U, when<true>> { }; struct not_equal_t : detail::nested_to<not_equal_t> { template <typename X, typename Y> constexpr auto operator()(X&& x, Y&& y) const; }; constexpr not_equal_t not_equal{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_NOT_EQUAL_HPP PK �\�[˩W� � fwd/is_subset.hppnu �[��� /*! @file Forward declares `boost::hana::is_subset`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_IS_SUBSET_HPP #define BOOST_HANA_FWD_IS_SUBSET_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/functional/infix.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns whether a structure contains a subset of the keys of //! another structure. //! @ingroup group-Searchable //! //! Given two `Searchable`s `xs` and `ys`, `is_subset` returns a `Logical` //! representing whether `xs` is a subset of `ys`. In other words, it //! returns whether all the keys of `xs` are also present in `ys`. This //! method does not return whether `xs` is a _strict_ subset of `ys`; if //! `xs` and `ys` are equal, all the keys of `xs` are also present in //! `ys`, and `is_subset` returns true. //! //! @note //! For convenience, `is_subset` can also be applied in infix notation. //! //! //! Cross-type version of the method //! -------------------------------- //! This method is tag-dispatched using the tags of both arguments. //! It can be called with any two `Searchable`s sharing a common //! `Searchable` embedding, as defined in the main documentation //! of the `Searchable` concept. When `Searchable`s with two different //! tags but sharing a common embedding are sent to `is_subset`, they //! are first converted to this common `Searchable` and the `is_subset` //! method of the common embedding is then used. Of course, the method //! can be overriden for custom `Searchable`s for efficieny. //! //! @note //! While cross-type dispatching for `is_subset` is supported, it is //! not currently used by the library because there are no models //! of `Searchable` with a common embedding. //! //! //! @param xs //! The structure to check whether it is a subset of `ys`. //! //! @param ys //! The structure to check whether it is a superset of `xs`. //! //! //! Example //! ------- //! @include example/is_subset.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto is_subset = [](auto&& xs, auto&& ys) { return tag-dispatched; }; #else template <typename S1, typename S2, typename = void> struct is_subset_impl : is_subset_impl<S1, S2, when<true>> { }; struct is_subset_t { template <typename Xs, typename Ys> constexpr auto operator()(Xs&& xs, Ys&& ys) const; }; constexpr auto is_subset = hana::infix(is_subset_t{}); #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_IS_SUBSET_HPP PK �\�[ ZY>G G fwd/zero.hppnu �[��� /*! @file Forward declares `boost::hana::zero`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_ZERO_HPP #define BOOST_HANA_FWD_ZERO_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Identity of `plus`. //! @ingroup group-Monoid //! //! @tparam M //! The tag (a `Monoid`) of the returned identity. //! //! //! Example //! ------- //! @include example/zero.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename M> constexpr auto zero = []() -> decltype(auto) { return tag-dispatched; }; #else template <typename M, typename = void> struct zero_impl : zero_impl<M, when<true>> { }; template <typename M> struct zero_t { constexpr decltype(auto) operator()() const; }; template <typename M> constexpr zero_t<M> zero{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ZERO_HPP PK �\�[P��,o o fwd/prepend.hppnu �[��� /*! @file Forward declares `boost::hana::prepend`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_PREPEND_HPP #define BOOST_HANA_FWD_PREPEND_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Prepend an element to a monadic structure. //! @ingroup group-MonadPlus //! //! Given a monadic structure `xs` and an element `x`, `prepend` returns //! a new monadic structure which is the result of lifting `x` into the //! monadic structure and then combining that (to the left) with `xs`. //! In other words, //! @code //! prepend(xs, x) == concat(lift<Xs>(x), xs) //! @endcode //! //! For sequences, this has the intuitive behavior of simply prepending //! an element to the beginning of the sequence, hence the name. //! //! > #### Rationale for not calling this `push_front` //! > While `push_front` is the de-facto name used in the standard library, //! > it also strongly suggests mutation of the underlying sequence, which //! > is not the case here. The author also finds that `push_front` //! > suggests too strongly the sole interpretation of putting an //! > element to the front of a sequence, whereas `prepend` is slightly //! > more nuanced and bears its name better for e.g. `hana::optional`. //! //! //! Signature //! --------- //! Given a MonadPlus `M`, the signature is //! @f$ \mathtt{prepend} : M(T) \times T \to M(T) @f$. //! //! @param xs //! A monadic structure that will be combined to the right of the element. //! //! @param x //! An element to combine to the left of the monadic structure. //! //! //! Example //! ------- //! @include example/prepend.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto prepend = [](auto&& xs, auto&& x) { return tag-dispatched; }; #else template <typename M, typename = void> struct prepend_impl : prepend_impl<M, when<true>> { }; struct prepend_t { template <typename Xs, typename X> constexpr auto operator()(Xs&& xs, X&& x) const; }; constexpr prepend_t prepend{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_PREPEND_HPP PK �\�[�i݈ � fwd/pair.hppnu �[��� /*! @file Forward declares `boost::hana::pair`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_PAIR_HPP #define BOOST_HANA_FWD_PAIR_HPP #include <boost/hana/config.hpp> #include <boost/hana/fwd/core/make.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-datatypes //! Generic container for two elements. //! //! `hana::pair` is conceptually the same as `std::pair`. However, //! `hana::pair` automatically compresses the storage of empty types, //! and as a result it does not have the `.first` and `.second` members. //! Instead, one must use the `hana::first` and `hana::second` free //! functions to access the elements of a pair. //! //! @note //! When you use a container, remember not to make assumptions about its //! representation, unless the documentation gives you those guarantees. //! More details [in the tutorial](@ref tutorial-containers-types). //! //! //! Modeled concepts //! ---------------- //! 1. `Comparable`\n //! Two pairs `(x, y)` and `(x', y')` are equal if and only if both //! `x == x'` and `y == y'`. //! @include example/pair/comparable.cpp //! //! 2. `Orderable`\n //! Pairs are ordered as-if they were 2-element tuples, using a //! lexicographical ordering. //! @include example/pair/orderable.cpp //! //! 3. `Foldable`\n //! Folding a pair is equivalent to folding a 2-element tuple. In other //! words: //! @code //! fold_left(make_pair(x, y), s, f) == f(f(s, x), y) //! fold_right(make_pair(x, y), s, f) == f(x, f(y, s)) //! @endcode //! Example: //! @include example/pair/foldable.cpp //! //! 4. `Product`\n //! The model of `Product` is the simplest one possible; the first element //! of a pair `(x, y)` is `x`, and its second element is `y`. //! @include example/pair/product.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename First, typename Second> struct pair { //! Default constructs the `pair`. Only exists when both elements //! of the pair are default constructible. constexpr pair(); //! Initialize each element of the pair with the corresponding element. //! Only exists when both elements of the pair are copy-constructible. constexpr pair(First const& first, Second const& second); //! Initialize both elements of the pair by perfect-forwarding the //! corresponding argument. Only exists when both arguments are //! implicitly-convertible to the corresponding element of the pair. template <typename T, typename U> constexpr pair(T&& t, U&& u); //! Copy-initialize a pair from another pair. Only exists when both //! elements of the source pair are implicitly convertible to the //! corresponding element of the constructed pair. template <typename T, typename U> constexpr pair(pair<T, U> const& other); //! Move-initialize a pair from another pair. Only exists when both //! elements of the source pair are implicitly convertible to the //! corresponding element of the constructed pair. template <typename T, typename U> constexpr pair(pair<T, U>&& other); //! Assign a pair to another pair. Only exists when both elements //! of the destination pair are assignable from the corresponding //! element in the source pair. template <typename T, typename U> constexpr pair& operator=(pair<T, U> const& other); //! Move-assign a pair to another pair. Only exists when both elements //! of the destination pair are move-assignable from the corresponding //! element in the source pair. template <typename T, typename U> constexpr pair& operator=(pair<T, U>&& other); //! Equivalent to `hana::equal` template <typename X, typename Y> friend constexpr auto operator==(X&& x, Y&& y); //! Equivalent to `hana::not_equal` template <typename X, typename Y> friend constexpr auto operator!=(X&& x, Y&& y); //! Equivalent to `hana::less` template <typename X, typename Y> friend constexpr auto operator<(X&& x, Y&& y); //! Equivalent to `hana::greater` template <typename X, typename Y> friend constexpr auto operator>(X&& x, Y&& y); //! Equivalent to `hana::less_equal` template <typename X, typename Y> friend constexpr auto operator<=(X&& x, Y&& y); //! Equivalent to `hana::greater_equal` template <typename X, typename Y> friend constexpr auto operator>=(X&& x, Y&& y); }; #else template <typename First, typename Second> struct pair; #endif //! Tag representing `hana::pair`. //! @relates hana::pair struct pair_tag { }; #ifdef BOOST_HANA_DOXYGEN_INVOKED //! Creates a `hana::pair` with the given elements. //! @relates hana::pair //! //! //! Example //! ------- //! @include example/pair/make.cpp template <> constexpr auto make<pair_tag> = [](auto&& first, auto&& second) -> hana::pair<std::decay_t<decltype(first)>, std::decay_t<decltype(second)>> { return {forwarded(first), forwarded(second)}; }; #endif //! Alias to `make<pair_tag>`; provided for convenience. //! @relates hana::pair //! //! Example //! ------- //! @include example/pair/make.cpp constexpr auto make_pair = make<pair_tag>; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_PAIR_HPP PK �\�[�yݬ� � fwd/maximum.hppnu �[��� /*! @file Forward declares `boost::hana::maximum`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_MAXIMUM_HPP #define BOOST_HANA_FWD_MAXIMUM_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/nested_by_fwd.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Return the greatest element of a non-empty structure with respect to //! a `predicate`, by default `less`. //! @ingroup group-Foldable //! //! Given a non-empty structure and an optional binary predicate //! (`less` by default), `maximum` returns the greatest element of //! the structure, i.e. an element which is greater than or equal to //! every other element in the structure, according to the predicate. //! //! If the structure contains heterogeneous objects, then the predicate //! must return a compile-time `Logical`. If no predicate is provided, //! the elements in the structure must be Orderable, or compile-time //! Orderable if the structure is heterogeneous. //! //! //! Signature //! --------- //! Given a Foldable `F`, a Logical `Bool` and a predicate //! \f$ \mathtt{pred} : T \times T \to Bool \f$, `maximum` has the //! following signatures. For the variant with a provided predicate, //! \f[ //! \mathtt{maximum} : F(T) \times (T \times T \to Bool) \to T //! \f] //! //! for the variant without a custom predicate, `T` is required to be //! Orderable. The signature is then //! \f[ //! \mathtt{maximum} : F(T) \to T //! \f] //! //! @param xs //! The structure to find the greatest element of. //! //! @param predicate //! A function called as `predicate(x, y)`, where `x` and `y` are elements //! of the structure. `predicate` should be a strict weak ordering on the //! elements of the structure and its return value should be a Logical, //! or a compile-time Logical if the structure is heterogeneous. //! //! ### Example //! @include example/maximum.cpp //! //! //! Syntactic sugar (`maximum.by`) //! ------------------------------ //! `maximum` can be called in a third way, which provides a nice syntax //! especially when working with the `ordering` combinator: //! @code //! maximum.by(predicate, xs) == maximum(xs, predicate) //! maximum.by(predicate) == maximum(-, predicate) //! @endcode //! //! where `maximum(-, predicate)` denotes the partial application of //! `maximum` to `predicate`. //! //! ### Example //! @include example/maximum_by.cpp //! //! //! Tag dispatching //! --------------- //! Both the non-predicated version and the predicated versions of //! `maximum` are tag-dispatched methods, and hence they can be //! customized independently. One reason for this is that some //! structures are able to provide a much more efficient implementation //! of `maximum` when the `less` predicate is used. Here is how the //! different versions of `maximum` are dispatched: //! @code //! maximum(xs) -> maximum_impl<tag of xs>::apply(xs) //! maximum(xs, pred) -> maximum_pred_impl<tag of xs>::apply(xs, pred) //! @endcode //! //! Also note that `maximum.by` is not tag-dispatched on its own, since it //! is just syntactic sugar for calling the corresponding `maximum`. #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto maximum = [](auto&& xs[, auto&& predicate]) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename = void> struct maximum_impl : maximum_impl<T, when<true>> { }; template <typename T, typename = void> struct maximum_pred_impl : maximum_pred_impl<T, when<true>> { }; struct maximum_t : detail::nested_by<maximum_t> { template <typename Xs> constexpr decltype(auto) operator()(Xs&& xs) const; template <typename Xs, typename Predicate> constexpr decltype(auto) operator()(Xs&& xs, Predicate&& pred) const; }; constexpr maximum_t maximum{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_MAXIMUM_HPP PK �\�[ Z&� � fwd/drop_while.hppnu �[��� /*! @file Forward declares `boost::hana::drop_while`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_DROP_WHILE_HPP #define BOOST_HANA_FWD_DROP_WHILE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Drop elements from an iterable up to, but excluding, the first //! element for which the `predicate` is not satisfied. //! @ingroup group-Iterable //! //! Specifically, `drop_while` returns an iterable containing all the //! elements of the original iterable except for those in the range //! delimited by [`head`, `e`), where `head` is the first element and //! `e` is the first element for which the `predicate` is not satisfied. //! If the iterable is not finite, the `predicate` has to return a false- //! valued `Logical` at a finite index for this method to return. //! //! //! @param iterable //! The iterable from which elements are dropped. //! //! @param predicate //! A function called as `predicate(x)`, where `x` is an element of the //! structure, and returning a `Logical` representing whether `x` should //! be dropped from the structure. In the current version of the library, //! `predicate` should return a compile-time `Logical`. //! //! //! Example //! ------- //! @include example/drop_while.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto drop_while = [](auto&& iterable, auto&& predicate) { return tag-dispatched; }; #else template <typename It, typename = void> struct drop_while_impl : drop_while_impl<It, when<true>> { }; struct drop_while_t { template <typename Xs, typename Pred> constexpr auto operator()(Xs&& xs, Pred&& pred) const; }; constexpr drop_while_t drop_while{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWDDROP_WHILE_HPP PK �\�[���+� � fwd/adjust.hppnu �[��� /*! @file Forward declares `boost::hana::adjust`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_ADJUST_HPP #define BOOST_HANA_FWD_ADJUST_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Apply a function on all the elements of a structure that compare //! equal to some value. //! @ingroup group-Functor //! //! //! Signature //! --------- //! Given `F` a Functor and `U` a type that can be compared with `T`'s, //! the signature is //! \f$ //! \mathtt{adjust} : F(T) \times U \times (T \to T) \to F(T) //! \f$ //! //! @param xs //! The structure to adjust with `f`. //! //! @param value //! An object that is compared with each element `x` of the structure. //! Elements of the structure that compare equal to `value` are adjusted //! with the `f` function. //! //! @param f //! A function called as `f(x)` on the element(s) of the structure that //! compare equal to `value`. //! //! //! Example //! ------- //! @include example/adjust.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto adjust = [](auto&& xs, auto&& value, auto&& f) { return tag-dispatched; }; #else template <typename Xs, typename = void> struct adjust_impl : adjust_impl<Xs, when<true>> { }; struct adjust_t { template <typename Xs, typename Value, typename F> constexpr auto operator()(Xs&& xs, Value&& value, F&& f) const; }; constexpr adjust_t adjust{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ADJUST_HPP PK �\�[�-�� � fwd/cycle.hppnu �[��� /*! @file Forward declares `boost::hana::cycle`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CYCLE_HPP #define BOOST_HANA_FWD_CYCLE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Combine a monadic structure with itself `n` times. //! @ingroup group-MonadPlus //! //! Given a monadic structure `xs` and a non-negative number `n`, //! `cycle` returns a new monadic structure which is the result of //! combining `xs` with itself `n` times using the `concat` operation. //! In other words, //! @code //! cycle(xs, n) == concat(xs, concat(xs, ... concat(xs, xs))) //! // ^^^^^ n times total //! @endcode //! //! Also note that since `concat` is required to be associative, we //! could also have written //! @code //! cycle(xs, n) == concat(concat(... concat(xs, xs), xs), xs) //! // ^^^^^ n times total //! @endcode //! //! If `n` is zero, then the identity of `concat`, `empty`, is returned. //! In the case of sequences, this boils down to returning a sequence //! containing `n` copies of itself; for other models it might differ. //! //! //! Signature //! --------- //! Given an `IntegralConstant` `C` and a `MonadPlus` `M`, the signature is //! @f$ \mathrm{cycle} : M(T) \times C \to M(T) @f$. //! //! @param xs //! A monadic structure to combine with itself a certain number of times. //! //! @param n //! A non-negative `IntegralConstant` representing the number of times to //! combine the monadic structure with itself. If `n` is zero, `cycle` //! returns `empty`. //! //! //! Example //! ------- //! @include example/cycle.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto cycle = [](auto&& xs, auto const& n) { return tag-dispatched; }; #else template <typename M, typename = void> struct cycle_impl : cycle_impl<M, when<true>> { }; struct cycle_t { template <typename Xs, typename N> constexpr auto operator()(Xs&& xs, N const& n) const; }; constexpr cycle_t cycle{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CYCLE_HPP PK �\�[��o� � fwd/second.hppnu �[��� /*! @file Forward declares `boost::hana::second`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_SECOND_HPP #define BOOST_HANA_FWD_SECOND_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns the second element of a pair. //! @ingroup group-Product //! //! Note that if the `Product` actually stores the elements it contains, //! `hana::second` is required to return a lvalue reference, a lvalue //! reference to const or a rvalue reference to the second element, where //! the type of reference must match that of the pair passed to `second`. //! If the `Product` does not store the elements it contains (i.e. it //! generates them on demand), this requirement is dropped. //! //! Example //! ------- //! @include example/second.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto second = [](auto&& product) -> decltype(auto) { return tag-dispatched; }; #else template <typename P, typename = void> struct second_impl : second_impl<P, when<true>> { }; struct second_t { template <typename Pair> constexpr decltype(auto) operator()(Pair&& pair) const; }; constexpr second_t second{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_SECOND_HPP PK �\�[ ��2� � fwd/for_each.hppnu �[��� /*! @file Forward declares `boost::hana::for_each`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_FOR_EACH_HPP #define BOOST_HANA_FWD_FOR_EACH_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Perform an action on each element of a foldable, discarding //! the result each time. //! @ingroup group-Foldable //! //! Iteration is done from left to right, i.e. in the same order as when //! using `fold_left`. If the structure is not finite, this method will //! not terminate. //! //! //! @param xs //! The structure to iterate over. //! //! @param f //! A function called as `f(x)` for each element `x` of the structure. //! The result of `f(x)`, whatever it is, is ignored. //! //! //! Example //! ------- //! @include example/for_each.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto for_each = [](auto&& xs, auto&& f) -> void { tag-dispatched; }; #else template <typename T, typename = void> struct for_each_impl : for_each_impl<T, when<true>> { }; struct for_each_t { template <typename Xs, typename F> constexpr void operator()(Xs&& xs, F&& f) const; }; constexpr for_each_t for_each{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_FOR_EACH_HPP PK �\�[�;OKj! j! fwd/tuple.hppnu �[��� /*! @file Forward declares `boost::hana::tuple`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_TUPLE_HPP #define BOOST_HANA_FWD_TUPLE_HPP #include <boost/hana/config.hpp> #include <boost/hana/fwd/core/make.hpp> #include <boost/hana/fwd/core/to.hpp> #include <boost/hana/fwd/integral_constant.hpp> #include <boost/hana/fwd/type.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-datatypes //! General purpose index-based heterogeneous sequence with a fixed length. //! //! The tuple is the bread and butter for static metaprogramming. //! Conceptually, it is like a `std::tuple`; it is a container able //! of holding objects of different types and whose size is fixed at //! compile-time. However, Hana's tuple provides much more functionality //! than its `std` counterpart, and it is also much more efficient than //! all standard library implementations tested so far. //! //! Tuples are index-based sequences. If you need an associative //! sequence with a key-based access, then you should consider //! `hana::map` or `hana::set` instead. //! //! @note //! When you use a container, remember not to make assumptions about its //! representation, unless the documentation gives you those guarantees. //! More details [in the tutorial](@ref tutorial-containers-types). //! //! //! Modeled concepts //! ---------------- //! `Sequence`, and all the concepts it refines //! //! //! Provided operators //! ------------------ //! For convenience, the following operators are provided: //! @code //! xs == ys -> equal(xs, ys) //! xs != ys -> not_equal(xs, ys) //! //! xs < ys -> less(xs, ys) //! xs <= ys -> less_equal(xs, ys) //! xs > ys -> greater(xs, ys) //! xs >= ys -> greater_equal(xs, ys) //! //! xs | f -> chain(xs, f) //! //! xs[n] -> at(xs, n) //! @endcode //! //! //! Example //! ------- //! @include example/tuple/tuple.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename ...Xn> struct tuple { //! Default constructs the `tuple`. Only exists when all the elements //! of the tuple are default constructible. constexpr tuple(); //! Initialize each element of the tuple with the corresponding element //! from `xn...`. Only exists when all the elements of the tuple are //! copy-constructible. //! //! @note //! Unlike the corresponding constructor for `std::tuple`, this //! constructor is not explicit. This allows returning a tuple //! from a function with the brace-initialization syntax. constexpr tuple(Xn const& ...xn); //! Initialize each element of the tuple by perfect-forwarding the //! corresponding element in `yn...`. Only exists when all the //! elements of the created tuple are constructible from the //! corresponding perfect-forwarded value. //! //! @note //! Unlike the corresponding constructor for `std::tuple`, this //! constructor is not explicit. This allows returning a tuple //! from a function with the brace-initialization syntax. template <typename ...Yn> constexpr tuple(Yn&& ...yn); //! Copy-initialize a tuple from another tuple. Only exists when all //! the elements of the constructed tuple are copy-constructible from //! the corresponding element in the source tuple. template <typename ...Yn> constexpr tuple(tuple<Yn...> const& other); //! Move-initialize a tuple from another tuple. Only exists when all //! the elements of the constructed tuple are move-constructible from //! the corresponding element in the source tuple. template <typename ...Yn> constexpr tuple(tuple<Yn...>&& other); //! Assign a tuple to another tuple. Only exists when all the elements //! of the destination tuple are assignable from the corresponding //! element in the source tuple. template <typename ...Yn> constexpr tuple& operator=(tuple<Yn...> const& other); //! Move-assign a tuple to another tuple. Only exists when all the //! elements of the destination tuple are move-assignable from the //! corresponding element in the source tuple. template <typename ...Yn> constexpr tuple& operator=(tuple<Yn...>&& other); //! Equivalent to `hana::chain`. template <typename ...T, typename F> friend constexpr auto operator|(tuple<T...>, F); //! Equivalent to `hana::equal` template <typename X, typename Y> friend constexpr auto operator==(X&& x, Y&& y); //! Equivalent to `hana::not_equal` template <typename X, typename Y> friend constexpr auto operator!=(X&& x, Y&& y); //! Equivalent to `hana::less` template <typename X, typename Y> friend constexpr auto operator<(X&& x, Y&& y); //! Equivalent to `hana::greater` template <typename X, typename Y> friend constexpr auto operator>(X&& x, Y&& y); //! Equivalent to `hana::less_equal` template <typename X, typename Y> friend constexpr auto operator<=(X&& x, Y&& y); //! Equivalent to `hana::greater_equal` template <typename X, typename Y> friend constexpr auto operator>=(X&& x, Y&& y); //! Equivalent to `hana::at` template <typename N> constexpr decltype(auto) operator[](N&& n); }; #else template <typename ...Xn> struct tuple; #endif //! Tag representing `hana::tuple`s. //! @related tuple struct tuple_tag { }; #ifdef BOOST_HANA_DOXYGEN_INVOKED //! Function object for creating a `tuple`. //! @relates hana::tuple //! //! Given zero or more objects `xs...`, `make<tuple_tag>` returns a new tuple //! containing those objects. The elements are held by value inside the //! resulting tuple, and they are hence copied or moved in. This is //! analogous to `std::make_tuple` for creating Hana tuples. //! //! //! Example //! ------- //! @include example/tuple/make.cpp template <> constexpr auto make<tuple_tag> = [](auto&& ...xs) { return tuple<std::decay_t<decltype(xs)>...>{forwarded(xs)...}; }; #endif //! Alias to `make<tuple_tag>`; provided for convenience. //! @relates hana::tuple constexpr auto make_tuple = make<tuple_tag>; //! Equivalent to `to<tuple_tag>`; provided for convenience. //! @relates hana::tuple constexpr auto to_tuple = to<tuple_tag>; //! Create a tuple specialized for holding `hana::type`s. //! @relates hana::tuple //! //! This is functionally equivalent to `make<tuple_tag>(type_c<T>...)`, except //! that using `tuple_t` allows the library to perform some compile-time //! optimizations. Also note that the type of the objects returned by //! `tuple_t` and an equivalent call to `make<tuple_tag>` may differ. //! //! //! Example //! ------- //! @include example/tuple/tuple_t.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename ...T> constexpr implementation_defined tuple_t{}; #else template <typename ...T> constexpr hana::tuple<hana::type<T>...> tuple_t{}; #endif //! Create a tuple specialized for holding `hana::integral_constant`s. //! @relates hana::tuple //! //! This is functionally equivalent to `make<tuple_tag>(integral_c<T, v>...)`, //! except that using `tuple_c` allows the library to perform some //! compile-time optimizations. Also note that the type of the objects //! returned by `tuple_c` and an equivalent call to `make<tuple_tag>` may differ. //! //! //! Example //! ------- //! @include example/tuple/tuple_c.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename T, T ...v> constexpr implementation_defined tuple_c{}; #else template <typename T, T ...v> constexpr hana::tuple<hana::integral_constant<T, v>...> tuple_c{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_TUPLE_HPP PK �\�[KZ�� fwd/extract.hppnu �[��� /*! @file Forward declares `boost::hana::extract`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_EXTRACT_HPP #define BOOST_HANA_FWD_EXTRACT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Extract a value in a given comonadic context. //! @ingroup group-Comonad //! //! Given a value inside a comonadic context, extract it from that //! context, performing whatever effects are mandated by that context. //! This can be seen as the dual operation to the `lift` method of the //! Applicative concept. //! //! //! Signature //! --------- //! Given a Comonad `W`, the signature is //! \f$ //! \mathtt{extract} : W(T) \to T //! \f$ //! //! @param w //! The value to be extracted inside a comonadic context. //! //! //! Example //! ------- //! @include example/extract.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto extract = [](auto&& w) -> decltype(auto) { return tag-dispatched; }; #else template <typename W, typename = void> struct extract_impl : extract_impl<W, when<true>> { }; struct extract_t { template <typename W_> constexpr decltype(auto) operator()(W_&& w) const; }; constexpr extract_t extract{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_EXTRACT_HPP PK �\�[�1�� � fwd/and.hppnu �[��� /*! @file Forward declares `boost::hana::and_`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_AND_HPP #define BOOST_HANA_FWD_AND_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Return whether all the arguments are true-valued. //! @ingroup group-Logical //! //! `and_` can be called with one argument or more. When called with //! two arguments, `and_` uses tag-dispatching to find the right //! implementation. Otherwise, //! @code //! and_(x) == x //! and_(x, y, ...z) == and_(and_(x, y), z...) //! @endcode //! //! //! Example //! ------- //! @include example/and.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto and_ = [](auto&& x, auto&& ...y) -> decltype(auto) { return tag-dispatched; }; #else template <typename L, typename = void> struct and_impl : and_impl<L, when<true>> { }; struct and_t { template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) const; template <typename X, typename ...Y> constexpr decltype(auto) operator()(X&& x, Y&& ...y) const; }; constexpr and_t and_{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_AND_HPP PK �\�[���. . fwd/concat.hppnu �[��� /*! @file Forward declares `boost::hana::concat`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CONCAT_HPP #define BOOST_HANA_FWD_CONCAT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Combine two monadic structures together. //! @ingroup group-MonadPlus //! //! Given two monadic structures, `concat` combines them together and //! returns a new monadic structure. The exact definition of `concat` //! will depend on the exact model of MonadPlus at hand, but for //! sequences it corresponds intuitively to simple concatenation. //! //! Also note that combination is not required to be commutative. //! In other words, there is no requirement that //! @code //! concat(xs, ys) == concat(ys, xs) //! @endcode //! and indeed it does not hold in general. //! //! //! Signature //! --------- //! Given a `MonadPlus` `M`, the signature of `concat` is //! @f$ \mathtt{concat} : M(T) \times M(T) \to M(T) @f$. //! //! @param xs, ys //! Two monadic structures to combine together. //! //! //! Example //! ------- //! @include example/concat.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto concat = [](auto&& xs, auto&& ys) { return tag-dispatched; }; #else template <typename M, typename = void> struct concat_impl : concat_impl<M, when<true>> { }; struct concat_t { template <typename Xs, typename Ys> constexpr auto operator()(Xs&& xs, Ys&& ys) const; }; constexpr concat_t concat{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCAT_HPP PK �\�[ؙQΓ � fwd/count.hppnu �[��� /*! @file Forward declares `boost::hana::count`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_COUNT_HPP #define BOOST_HANA_FWD_COUNT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Return the number of elements in the structure that compare equal to //! a given value. //! @ingroup group-Foldable //! //! Given a Foldable structure `xs` and a value `value`, `count` returns //! an unsigned integral, or a Constant thereof, representing the number //! of elements of `xs` that compare equal to `value`. For this method to //! be well-defined, all the elements of the structure must be Comparable //! with the given value. //! //! //! @param xs //! The structure whose elements are counted. //! //! @param value //! A value compared with each element in the structure. Elements //! that compare equal to this value are counted, others are not. //! //! //! Example //! ------- //! @include example/count.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto count = [](auto&& xs, auto&& value) { return tag-dispatched; }; #else template <typename T, typename = void> struct count_impl : count_impl<T, when<true>> { }; struct count_t { template <typename Xs, typename Value> constexpr auto operator()(Xs&& xs, Value&& value) const; }; constexpr count_t count{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_COUNT_HPP PK �\�[��6�� � fwd/length.hppnu �[��� /*! @file Forward declares `boost::hana::length`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_LENGTH_HPP #define BOOST_HANA_FWD_LENGTH_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Return the number of elements in a foldable structure. //! @ingroup group-Foldable //! //! Given a `Foldable` `xs`, `length(xs)` must return an object of an //! unsigned integral type, or an `IntegralConstant` holding such an //! object, which represents the number of elements in the structure. //! //! @note //! Since only compile-time `Foldable`s are supported in the library //! right now, `length` must always return an `IntegralConstant`. //! //! //! Example //! ------- //! @include example/length.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto length = [](auto const& xs) { return tag-dispatched; }; #else template <typename T, typename = void> struct length_impl : length_impl<T, when<true>> { }; struct length_t { template <typename Xs> constexpr auto operator()(Xs const& xs) const; }; constexpr length_t length{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_LENGTH_HPP PK �\�[D�F� fwd/at.hppnu �[��� /*! @file Forward declares `boost::hana::at` and `boost::hana::at_c`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_AT_HPP #define BOOST_HANA_FWD_AT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <cstddef> BOOST_HANA_NAMESPACE_BEGIN //! Returns the `n`th element of an iterable. //! @ingroup group-Iterable //! //! Given an `Iterable` and an `IntegralConstant` index, `at` returns the //! element located at the index in the linearization of the iterable. //! Specifically, given an iterable `xs` with a linearization of //! `[x1, ..., xN]`, `at(xs, k)` is equivalent to `xk`. //! //! If the `Iterable` actually stores the elements it contains, `at` is //! required to return a lvalue reference, a lvalue reference to const //! or a rvalue reference to the matching element, where the type of //! reference must match that of the iterable passed to `at`. If the //! `Iterable` does not store the elements it contains (i.e. it generates //! them on demand), this requirement is dropped. //! //! //! @param xs //! The iterable in which an element is retrieved. The iterable must //! contain at least `n + 1` elements. //! //! @param n //! A non-negative `IntegralConstant` representing the 0-based index of //! the element to return. It is an error to call `at` with an index that //! out of bounds of the iterable. //! //! //! Example //! ------- //! @include example/at.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto at = [](auto&& xs, auto const& n) -> decltype(auto) { return tag-dispatched; }; #else template <typename It, typename = void> struct at_impl : at_impl<It, when<true>> { }; struct at_t { template <typename Xs, typename N> constexpr decltype(auto) operator()(Xs&& xs, N const& n) const; }; constexpr at_t at{}; #endif //! Equivalent to `at`; provided for convenience. //! @ingroup group-Iterable //! //! //! @note //! `hana::at_c<n>` is an overloaded function, not a function object. //! Hence, it can't be passed to higher-order algorithms. This is done //! for compile-time performance reasons. //! //! //! Example //! ------- //! @include example/at_c.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <std::size_t n> constexpr auto at_c = [](auto&& xs) { return hana::at(forwarded(xs), hana::size_c<n>); }; #else template <std::size_t n, typename Xs> constexpr decltype(auto) at_c(Xs&& xs); #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_AT_HPP PK �\�[�Ӏ�� � fwd/adjust_if.hppnu �[��� /*! @file Forward declares `boost::hana::adjust_if`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_ADJUST_IF_HPP #define BOOST_HANA_FWD_ADJUST_IF_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Apply a function on all the elements of a structure satisfying a predicate. //! @ingroup group-Functor //! //! Given a Functor, a predicate `pred` and a function `f`, `adjust_if` //! will _adjust_ the elements of the Functor that satisfy the predicate //! with the function `f`. In other words, `adjust_if` will return a new //! Functor equal to the original one, except that the elements satisfying //! the predicate will be transformed with the given function. Elements //! for which the predicate is not satisfied are left untouched, and they //! are kept as-is in the resulting Functor. //! //! //! Signature //! --------- //! Given a `Functor` `F` and a `Logical` `Bool`, the signature is //! \f$ //! \mathtt{adjust\_if} : F(T) \times (T \to Bool) \times (T \to T) \to F(T) //! \f$ //! //! @param xs //! The structure to adjust with `f`. //! //! @param pred //! A function called as `pred(x)` for each element of the Functor, //! and returning whether `f` should be applied on that element. //! //! @param f //! A function called as `f(x)` on the element(s) of the Functor that //! satisfy the predicate. //! //! //! Example //! ------- //! @include example/adjust_if.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto adjust_if = [](auto&& xs, auto const& pred, auto const& f) { return tag-dispatched; }; #else template <typename Xs, typename = void> struct adjust_if_impl : adjust_if_impl<Xs, when<true>> { }; struct adjust_if_t { template <typename Xs, typename Pred, typename F> constexpr auto operator()(Xs&& xs, Pred const& pred, F const& f) const; }; constexpr adjust_if_t adjust_if{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ADJUST_IF_HPP PK �\�[�Ⓥ� � fwd/zip_shortest.hppnu �[��� /*! @file Forward declares `boost::hana::zip_shortest`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_ZIP_SHORTEST_HPP #define BOOST_HANA_FWD_ZIP_SHORTEST_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Zip one sequence or more. //! @ingroup group-Sequence //! //! Given `n` sequences `s1, ..., sn`, `zip_shortest` produces a sequence //! whose `i`-th element is a tuple of `(s1[i], ..., sn[i])`, where `sk[i]` //! denotes the `i`-th element of the `k`-th sequence. In other words, //! `zip_shortest` produces a sequence of the form //! @code //! [ //! make_tuple(s1[0], ..., sn[0]), //! make_tuple(s1[1], ..., sn[1]), //! ... //! make_tuple(s1[M], ..., sn[M]) //! ] //! @endcode //! where `M` is the length of the shortest sequence. Hence, the returned //! sequence stops when the shortest input sequence is exhausted. If you //! know that all the sequences you are about to zip have the same length, //! you should use `zip` instead, since it can be more optimized. Also //! note that it is an error to provide no sequence at all, i.e. //! `zip_shortest` expects at least one sequence. //! //! //! Example //! ------- //! @include example/zip_shortest.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto zip_shortest = [](auto&& x1, ..., auto&& xn) { return tag-dispatched; }; #else template <typename S, typename = void> struct zip_shortest_impl : zip_shortest_impl<S, when<true>> { }; struct zip_shortest_t { template <typename Xs, typename ...Ys> constexpr auto operator()(Xs&& xs, Ys&& ...ys) const; }; constexpr zip_shortest_t zip_shortest{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ZIP_SHORTEST_HPP PK �\�[ �SW fwd/equal.hppnu �[��� /*! @file Forward declares `boost::hana::equal`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_EQUAL_HPP #define BOOST_HANA_FWD_EQUAL_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/nested_to_fwd.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns a `Logical` representing whether `x` is equal to `y`. //! @ingroup group-Comparable //! //! The `equal` function can be called in two different ways. First, it //! can be called like a normal function: //! @code //! equal(x, y) //! @endcode //! //! However, it may also be partially applied to an argument by using //! `equal.to`: //! @code //! equal.to(x)(y) == equal(x, y) //! @endcode //! //! In other words, `equal.to(x)` is a function object that is equivalent //! to `partial(equal, x)`. This is provided to enhance the readability of //! some constructs, especially when using higher order algorithms. //! //! //! Signature //! --------- //! Given a Logical `Bool` and two Comparables `A` and `B` that //! share a common embedding, the signature is //! @f$ \mathtt{equal} : A \times B \to Bool @f$. //! //! @param x, y //! Two objects to compare for equality. //! //! //! Example //! ------- //! @include example/equal.cpp //! //! //! > #### Rationale for the arity of `equal` //! > It is a valid question whether `equal` should accept more than 2 //! > arguments and have semantics matching those of Python's `==`. This //! > is not supported right now for the following reasons: //! > - It was implemented in the MPL11, but it was not shown to be useful //! > so far. //! > - It does not make sense for `not_equal` to have an arity of more //! > than 2, only `equal` could maybe have those semantics, which would //! > break symmetry. #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto equal = [](auto&& x, auto&& y) { return tag-dispatched; }; #else template <typename T, typename U, typename = void> struct equal_impl : equal_impl<T, U, when<true>> { }; struct equal_t : detail::nested_to<equal_t> { template <typename X, typename Y> constexpr auto operator()(X&& x, Y&& y) const; }; constexpr equal_t equal{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_EQUAL_HPP PK �\�[�V�J� � fwd/not.hppnu �[��� /*! @file Forward declares `boost::hana::not_`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_NOT_HPP #define BOOST_HANA_FWD_NOT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Negates a `Logical`. //! @ingroup group-Logical //! //! This method returns a `Logical` with the same tag, but whose //! truth-value is negated. Specifically, `not_(x)` returns a false-valued //! `Logical` if `x` is a true-valued `Logical`, and a true-valued one //! otherwise. //! //! //! Example //! ------- //! @include example/not.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto not_ = [](auto&& x) -> decltype(auto) { return tag-dispatched; }; #else template <typename L, typename = void> struct not_impl : not_impl<L, when<true>> { }; struct not_t { template <typename X> constexpr decltype(auto) operator()(X&& x) const; }; constexpr not_t not_{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_NOT_HPP PK �\�[�_6� � fwd/none_of.hppnu �[��� /*! @file Forward declares `boost::hana::none_of`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_NONE_OF_HPP #define BOOST_HANA_FWD_NONE_OF_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns whether none of the keys of the structure satisfy the //! `predicate`. //! @ingroup group-Searchable //! //! If the structure is not finite, `predicate` has to return a true- //! valued `Logical` after looking at a finite number of keys for this //! method to finish. //! //! //! @param xs //! The structure to search. //! //! @param predicate //! A function called as `predicate(k)`, where `k` is a key of the //! structure, and returning a `Logical`. //! //! //! Example //! ------- //! @include example/none_of.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto none_of = [](auto&& xs, auto&& predicate) { return tag-dispatched; }; #else template <typename S, typename = void> struct none_of_impl : none_of_impl<S, when<true>> { }; struct none_of_t { template <typename Xs, typename Pred> constexpr auto operator()(Xs&& xs, Pred&& pred) const; }; constexpr none_of_t none_of{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_NONE_OF_HPP PK �\�[;��L L fwd/product.hppnu �[��� /*! @file Forward declares `boost::hana::product`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_PRODUCT_HPP #define BOOST_HANA_FWD_PRODUCT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/fwd/integral_constant.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Compute the product of the numbers of a structure. //! @ingroup group-Foldable //! //! More generally, `product` will take any foldable structure containing //! objects forming a Ring and reduce them using the Ring's binary //! operation. The initial state for folding is the identity of the //! Ring's operation. It is sometimes necessary to specify the Ring to //! use; this is possible by using `product<R>`. If no Ring is specified, //! the structure will use the Ring formed by the elements it contains //! (if it knows it), or `integral_constant_tag<int>` otherwise. //! Hence, //! @code //! product<R>(xs) = fold_left(xs, one<R or inferred Ring>(), mult) //! product<> = product<integral_constant_tag<int>> //! @endcode //! //! For numbers, this will just compute the product of the numbers in the //! `xs` structure. //! //! @note //! The elements of the structure are not actually required to be in the //! same Ring, but it must be possible to perform `mult` on any two //! adjacent elements of the structure, which requires each pair of //! adjacent element to at least have a common Ring embedding. The //! meaning of "adjacent" as used here is that two elements of the //! structure `x` and `y` are adjacent if and only if they are adjacent //! in the linearization of that structure, as documented by the Iterable //! concept. //! //! @note //! See the documentation for `sum` to understand why the Ring must //! sometimes be specified explicitly. //! //! //! Example //! ------- //! @include example/product.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto product = see documentation; #else template <typename T, typename = void> struct product_impl : product_impl<T, when<true>> { }; template <typename R> struct product_t { template <typename Xs> constexpr decltype(auto) operator()(Xs&& xs) const; }; template <typename R = integral_constant_tag<int>> constexpr product_t<R> product{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_PRODUCT_HPP PK �\�[S(��� � fwd/intersperse.hppnu �[��� /*! @file Forward declares `boost::hana::intersperse`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_INTERSPERSE_HPP #define BOOST_HANA_FWD_INTERSPERSE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Insert a value between each pair of elements in a finite sequence. //! @ingroup group-Sequence //! //! Given a finite `Sequence` `xs` with a linearization of //! `[x1, x2, ..., xn]`, `intersperse(xs, z)` is a new sequence with a //! linearization of `[x1, z, x2, z, x3, ..., xn-1, z, xn]`. In other //! words, it inserts the `z` element between every pair of elements of //! the original sequence. If the sequence is empty or has a single //! element, `intersperse` returns the sequence as-is. In all cases, //! the sequence must be finite. //! //! //! @param xs //! The sequence in which a value is interspersed. //! //! @param z //! The value to be inserted between every pair of elements of the sequence. //! //! //! Example //! ------- //! @include example/intersperse.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto intersperse = [](auto&& xs, auto&& z) { return tag-dispatched; }; #else template <typename S, typename = void> struct intersperse_impl : intersperse_impl<S, when<true>> { }; struct intersperse_t { template <typename Xs, typename Z> constexpr auto operator()(Xs&& xs, Z&& z) const; }; constexpr intersperse_t intersperse{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_INTERSPERSE_HPP PK �\�[2�� fwd/unique.hppnu �[��� /*! @file Forward declares `boost::hana::unique`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_UNIQUE_HPP #define BOOST_HANA_FWD_UNIQUE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/nested_by_fwd.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Removes all consecutive duplicate elements from a Sequence. //! @ingroup group-Sequence //! //! Given a `Sequence` and an optional binary predicate, `unique` returns //! a new sequence containing only the first element of every subrange //! of the original sequence whose elements are all equal. In other words, //! it turns a sequence of the form `[a, a, b, c, c, c, d, d, d, a]` into //! a sequence `[a, b, c, d, a]`. The equality of two elements is //! determined by the provided `predicate`, or by `equal` if no //! `predicate` is provided. //! //! //! Signature //! --------- //! Given a `Sequence` `S(T)`, a `Logical` `Bool` and a binary predicate //! \f$ T \times T \to Bool \f$, `unique` has the following signature: //! \f[ //! \mathtt{unique} : S(T) \times (T \times T \to Bool) \to S(T) //! \f] //! //! @param xs //! The sequence from which to remove consecutive duplicates. //! //! @param predicate //! A function called as `predicate(x, y)`, where `x` and `y` are adjacent //! elements of the sequence, and returning a `Logical` representing //! whether `x` and `y` should be considered equal. `predicate` should //! define an [equivalence relation][1] over the elements of the sequence. //! In the current implementation of the library, `predicate` has to //! return a compile-time `Logical`. This parameter is optional; it //! defaults to `equal` if it is not provided, which then requires the //! elements of the sequence to be compile-time `Comparable`. //! //! //! Syntactic sugar (`unique.by`) //! ----------------------------- //! `unique` can be called in an alternate way, which provides a nice //! syntax, especially in conjunction with the `comparing` combinator: //! @code //! unique.by(predicate, xs) == unique(xs, predicate) //! unique.by(predicate) == unique(-, predicate) //! @endcode //! //! where `unique(-, predicate)` denotes the partial application of //! `unique` to `predicate`. //! //! //! Example //! ------- //! @include example/unique.cpp //! //! [1]: http://en.wikipedia.org/wiki/Equivalence_relation#Definition #if defined(BOOST_HANA_DOXYGEN_INVOKED) constexpr auto unique = [](auto&& xs[, auto&& predicate]) { return tag-dispatched; }; #else template <typename S, typename = void> struct unique_impl : unique_impl<S, when<true>> { }; struct unique_t : detail::nested_by<unique_t> { template <typename Xs> constexpr auto operator()(Xs&& xs) const; template <typename Xs, typename Predicate> constexpr auto operator()(Xs&& xs, Predicate&& predicate) const; }; constexpr unique_t unique{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_UNIQUE_HPP PK �\�[ ( : : fwd/keys.hppnu �[��� /*! @file Forward declares `boost::hana::keys`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_KEYS_HPP #define BOOST_HANA_FWD_KEYS_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN // Note: This function is documented per datatype/concept only. //! @cond template <typename T, typename = void> struct keys_impl : keys_impl<T, when<true>> { }; //! @endcond struct keys_t { template <typename Map> constexpr auto operator()(Map&& map) const; }; constexpr keys_t keys{}; //! Returns a `Sequence` containing the name of the members of //! the data structure. //! @ingroup group-Struct //! //! Given a `Struct` object, `keys` returns a `Sequence` containing the //! name of all the members of the `Struct`, in the same order as they //! appear in the `accessors` sequence. //! //! //! Example //! ------- //! @include example/struct/keys.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto keys = [](auto&& object) { return implementation_defined; }; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_KEYS_HPP PK �\�[a��& & fwd/duplicate.hppnu �[��� /*! @file Forward declares `boost::hana::duplicate`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_DUPLICATE_HPP #define BOOST_HANA_FWD_DUPLICATE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Add an extra layer of comonadic context to a comonadic value. //! @ingroup group-Comonad //! //! Given a value already in a comonadic context, `duplicate` wraps this //! value with an additional layer of comonadic context. This can be seen //! as the dual operation to `flatten` from the Monad concept. //! //! //! Signature //! --------- //! Given a Comonad `W`, the signature is //! \f$ //! \mathtt{duplicate} : W(T) \to W(W(T)) //! \f$ //! //! @param w //! The value to wrap in an additional level of comonadic context. //! //! //! Example //! ------- //! @include example/duplicate.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto duplicate = [](auto&& w) -> decltype(auto) { return tag-dispatched; }; #else template <typename W, typename = void> struct duplicate_impl : duplicate_impl<W, when<true>> { }; struct duplicate_t { template <typename W_> constexpr decltype(auto) operator()(W_&& w) const; }; constexpr duplicate_t duplicate{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_DUPLICATE_HPP PK �\�[& �� � fwd/sort.hppnu �[��� /*! @file Forward declares `boost::hana::sort`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_SORT_HPP #define BOOST_HANA_FWD_SORT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/nested_by_fwd.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Sort a sequence, optionally based on a custom `predicate`. //! @ingroup group-Sequence //! //! Given a Sequence and an optional predicate (by default `less`), `sort` //! returns a new sequence containing the same elements as the original, //! except they are ordered in such a way that if `x` comes before `y` in //! the sequence, then either `predicate(x, y)` is true, or both //! `predicate(x, y)` and `predicate(y, x)` are false. //! //! Also note that the sort is guaranteed to be stable. Hence, if `x` //! comes before `y` in the original sequence and both `predicate(x, y)` //! and `predicate(y, x)` are false, then `x` will come before `y` in the //! resulting sequence. //! //! If no predicate is provided, the elements in the sequence must all be //! compile-time `Orderable`. //! //! Signature //! --------- //! Given a `Sequence` `S(T)`, a boolean `IntegralConstant` `Bool` and a //! binary predicate \f$ T \times T \to Bool \f$, `sort` has the following //! signatures. For the variant with a provided predicate, //! \f[ //! \mathtt{sort} : S(T) \times (T \times T \to Bool) \to S(T) //! \f] //! //! for the variant without a custom predicate, `T` is required to be //! `Orderable`. The signature is then //! \f[ //! \mathtt{sort} : S(T) \to S(T) //! \f] //! //! @param xs //! The sequence to sort. //! //! @param predicate //! A function called as `predicate(x, y)` for two elements `x` and `y` of //! the sequence, and returning a boolean `IntegralConstant` representing //! whether `x` is to be considered _less_ than `y`, i.e. whether `x` should //! appear _before_ `y` in the resulting sequence. More specifically, //! `predicate` must define a [strict weak ordering][1] on the elements //! of the sequence. When the predicate is not specified, this defaults //! to `less`. In the current version of the library, the predicate has //! to return an `IntegralConstant` holding a value convertible to a `bool`. //! //! //! Syntactic sugar (`sort.by`) //! --------------------------- //! `sort` can be called in a third way, which provides a nice syntax //! especially when working with the `ordering` combinator: //! @code //! sort.by(predicate, xs) == sort(xs, predicate) //! sort.by(predicate) == sort(-, predicate) //! @endcode //! //! where `sort(-, predicate)` denotes the partial application of //! `sort` to `predicate`. //! //! //! Example //! ------- //! @include example/sort.cpp //! //! [1]: http://en.wikipedia.org/wiki/Strict_weak_ordering #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto sort = [](auto&& xs[, auto&& predicate]) { return tag-dispatched; }; #else template <typename S, typename = void> struct sort_impl : sort_impl<S, when<true>> { }; struct sort_t : detail::nested_by<sort_t> { template <typename Xs> constexpr auto operator()(Xs&& xs) const; template <typename Xs, typename Predicate> constexpr auto operator()(Xs&& xs, Predicate&& pred) const; }; constexpr sort_t sort{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_SORT_HPP PK �\�[42��� � fwd/take_back.hppnu �[��� /*! @file Forward declares `boost::hana::take_back`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_TAKE_BACK_HPP #define BOOST_HANA_FWD_TAKE_BACK_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <cstddef> BOOST_HANA_NAMESPACE_BEGIN //! Returns the last `n` elements of a sequence, or the whole sequence //! if the sequence has less than `n` elements. //! @ingroup group-Sequence //! //! Given a `Sequence` `xs` and an `IntegralConstant` `n`, `take_back(xs, n)` //! is a new sequence containing the last `n` elements of `xs`, in the //! same order. If `length(xs) <= n`, the whole sequence is returned and //! no error is triggered. //! //! //! @param xs //! The sequence to take the elements from. //! //! @param n //! A non-negative `IntegralConstant` representing the number of elements //! to keep in the resulting sequence. //! //! //! Example //! ------- //! @include example/take_back.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto take_back = [](auto&& xs, auto const& n) { return tag-dispatched; }; #else template <typename S, typename = void> struct take_back_impl : take_back_impl<S, when<true>> { }; struct take_back_t { template <typename Xs, typename N> constexpr auto operator()(Xs&& xs, N const& n) const; }; constexpr take_back_t take_back{}; #endif //! Equivalent to `take_back`; provided for convenience. //! @ingroup group-Sequence //! //! //! Example //! ------- //! @include example/take_back_c.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <std::size_t n> constexpr auto take_back_c = [](auto&& xs) { return hana::take_back(forwarded(xs), hana::size_c<n>); }; #else template <std::size_t n> struct take_back_c_t; template <std::size_t n> constexpr take_back_c_t<n> take_back_c{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_TAKE_BACK_HPP PK �\�[����F F fwd/reverse_fold.hppnu �[��� /*! @file Forward declares `boost::hana::reverse_fold`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_REVERSE_FOLD_HPP #define BOOST_HANA_FWD_REVERSE_FOLD_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Equivalent to `reverse_fold` in Boost.Fusion and Boost.MPL. //! @ingroup group-Foldable //! //! This method has the same semantics as `reverse_fold` in Boost.Fusion //! and Boost.MPL, with the extension that an initial state is not //! required. This method is equivalent to `fold_right`, except that //! the accumulating function must take its arguments in reverse order, //! to match the order used in Fusion. In other words, //! @code //! reverse_fold(sequence, state, f) == fold_right(sequence, state, flip(f)) //! reverse_fold(sequence, f) == fold_right(sequence, flip(f)) //! @endcode //! //! @note //! This method is a convenience alias to `fold_right`. As an alias, //! `reverse_fold` is not tag-dispatched on its own and `fold_right` //! should be customized instead. //! //! //! Signature //! --------- //! Given a `Foldable` `F` and an optional initial state of tag `S`, //! the signatures for `reverse_fold` are //! \f[ //! \mathtt{reverse\_fold} : F(T) \times S \times (S \times T \to S) \to S //! \f] //! //! for the variant with an initial state, and //! \f[ //! \mathtt{reverse\_fold} : F(T) \times (T \times T \to T) \to T //! \f] //! //! for the variant without an initial state. //! //! @param xs //! The structure to fold. //! //! @param state //! The initial value used for folding. //! //! @param f //! A binary function called as `f(state, x)`, where `state` is the //! result accumulated so far and `x` is an element in the structure. //! For reverse folds without an initial state, the function is called as //! `f(x1, x2)`, where `x1` and `x2` are elements of the structure. //! //! //! Example //! ------- //! @include example/reverse_fold.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto reverse_fold = [](auto&& xs[, auto&& state], auto&& f) -> decltype(auto) { return fold_right(forwarded(xs), forwarded(state), flip(forwarded(f))); }; #else struct reverse_fold_t { template <typename Xs, typename S, typename F> constexpr decltype(auto) operator()(Xs&& xs, S&& s, F&& f) const; template <typename Xs, typename F> constexpr decltype(auto) operator()(Xs&& xs, F&& f) const; }; constexpr reverse_fold_t reverse_fold{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_REVERSE_FOLD_HPP PK �\�[Q��r r fwd/less.hppnu �[��� /*! @file Forward declares `boost::hana::less`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_LESS_HPP #define BOOST_HANA_FWD_LESS_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/nested_than_fwd.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns a `Logical` representing whether `x` is less than `y`. //! @ingroup group-Orderable //! //! //! Signature //! --------- //! Given a Logical `Bool` and two Orderables `A` and `B` with a common //! embedding, the signature is //! @f$ \mathrm{less} : A \times B \to Bool @f$. //! //! @param x, y //! Two objects to compare. //! //! //! Example //! ------- //! @include example/less.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto less = [](auto&& x, auto&& y) { return tag-dispatched; }; #else template <typename T, typename U, typename = void> struct less_impl : less_impl<T, U, when<true>> { }; struct less_t : detail::nested_than<less_t> { template <typename X, typename Y> constexpr auto operator()(X&& x, Y&& y) const; }; constexpr less_t less{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_LESS_HPP PK �\�[�� � fwd/tap.hppnu �[��� /*! @file Forward declares `boost::hana::tap`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_TAP_HPP #define BOOST_HANA_FWD_TAP_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Tap inside a monadic chain. //! @ingroup group-Monad //! //! Given a function `f`, `tap<M>` returns a new function which performs //! `f` on its argument and then returns the argument lifted in the `M` //! `Monad`. Combined with the property that `chain(m, lift<M>) == m`, //! this provides a way of executing an action inside a monadic chain //! without influencing its overall result. This is useful to e.g. insert //! debug statements or perform actions that are not tied to the chain but //! that need to be executed inside of it. //! //! @note //! Since C++ is not a pure language, it is possible to perform side //! effects inside the `f` function. Actually, side effects are the //! only reason why one might want to use `tap`. However, one should //! not rely on the side effects being done in any specific order. //! //! //! @tparam M //! The tag (a `Monad`) of the monads in the tapped monadic chain. //! //! @param f //! A function to be executed inside a monadic chain. It will be called //! as `f(x)`, where `x` is a value inside the previous monad in the //! chain. The result of `f` is always discarded. //! //! //! Example //! ------- //! @include example/tap.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename M> constexpr auto tap = [](auto&& f) { return tag-dispatched; }; #else template <typename M, typename = void> struct tap_impl : tap_impl<M, when<true>> { }; template <typename M> struct tap_t { template <typename F> constexpr auto operator()(F&& f) const; }; template <typename M> constexpr tap_t<M> tap{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_TAP_HPP PK �\�[d��-� � fwd/remove_range.hppnu �[��� /*! @file Forward declares `boost::hana::remove_range` and `boost::hana::remove_range_c`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_REMOVE_RANGE_HPP #define BOOST_HANA_FWD_REMOVE_RANGE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <cstddef> BOOST_HANA_NAMESPACE_BEGIN //! Remove the elements inside a given range of indices from a sequence. //! @ingroup group-Sequence //! //! `remove_range` returns a new sequence identical to the original, //! except that elements at indices in the provided range are removed. //! Specifically, `remove_range([x0, ..., xn], from, to)` is a new //! sequence equivalent to `[x0, ..., x_from-1, x_to, ..., xn]`. //! //! //! @note //! The behavior is undefined if the range contains any index out of the //! bounds of the sequence. //! //! //! @param xs //! A sequence from which elements are removed. //! //! @param [from, to) //! An half-open interval of `IntegralConstant`s representing the indices //! of the elements to be removed from the sequence. The `IntegralConstant`s //! in the half-open interval must be non-negative and in the bounds of //! the sequence. The half-open interval must also be valid, meaning that //! `from <= to`. //! //! //! Example //! ------- //! @include example/remove_range.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto remove_range = [](auto&& xs, auto const& from, auto const& to) { return tag-dispatched; }; #else template <typename S, typename = void> struct remove_range_impl : remove_range_impl<S, when<true>> { }; struct remove_range_t { template <typename Xs, typename From, typename To> constexpr auto operator()(Xs&& xs, From const& from, To const& to) const; }; constexpr remove_range_t remove_range{}; #endif //! Equivalent to `remove_range`; provided for convenience. //! @ingroup group-Sequence //! //! //! Example //! ------- //! @include example/remove_range_c.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <std::size_t from, std::size_t to> constexpr auto remove_range_c = [](auto&& xs) { return hana::remove_range(forwarded(xs), hana::size_c<from>, hana::size_c<to>); }; #else template <std::size_t from, std::size_t to> struct remove_range_c_t; template <std::size_t from, std::size_t to> constexpr remove_range_c_t<from, to> remove_range_c{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_REMOVE_RANGE_HPP PK �\�[k�oJ J fwd/contains.hppnu �[��� /*! @file Forward declares `boost::hana::contains` and `boost::hana::in`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CONTAINS_HPP #define BOOST_HANA_FWD_CONTAINS_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/functional/flip.hpp> #include <boost/hana/functional/infix.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns whether the key occurs in the structure. //! @ingroup group-Searchable //! //! Given a `Searchable` structure `xs` and a `key`, `contains` returns //! whether any of the keys of the structure is equal to the given `key`. //! If the structure is not finite, an equal key has to appear at a finite //! position in the structure for this method to finish. For convenience, //! `contains` can also be applied in infix notation. //! //! //! @param xs //! The structure to search. //! //! @param key //! A key to be searched for in the structure. The key has to be //! `Comparable` with the other keys of the structure. //! //! //! Example //! ------- //! @include example/contains.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto contains = [](auto&& xs, auto&& key) { return tag-dispatched; }; #else template <typename S, typename = void> struct contains_impl : contains_impl<S, when<true>> { }; struct contains_t { template <typename Xs, typename Key> constexpr auto operator()(Xs&& xs, Key&& key) const; }; constexpr auto contains = hana::infix(contains_t{}); #endif //! Return whether the key occurs in the structure. //! @ingroup group-Searchable //! //! Specifically, this is equivalent to `contains`, except `in` takes its //! arguments in reverse order. Like `contains`, `in` can also be applied //! in infix notation for increased expressiveness. This function is not a //! method that can be overriden; it is just a convenience function //! provided with the concept. //! //! //! Example //! ------- //! @include example/in.cpp constexpr auto in = hana::infix(hana::flip(hana::contains)); BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONTAINS_HPP PK �\�[QP?� � fwd/concept/group.hppnu �[��� /*! @file Forward declares `boost::hana::Group`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CONCEPT_GROUP_HPP #define BOOST_HANA_FWD_CONCEPT_GROUP_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Group Group //! The `Group` concept represents `Monoid`s where all objects have //! an inverse w.r.t. the `Monoid`'s binary operation. //! //! A [Group][1] is an algebraic structure built on top of a `Monoid` //! which adds the ability to invert the action of the `Monoid`'s binary //! operation on any element of the set. Specifically, a `Group` is a //! `Monoid` `(S, +)` such that every element `s` in `S` has an inverse //! (say `s'`) which is such that //! @code //! s + s' == s' + s == identity of the Monoid //! @endcode //! //! There are many examples of `Group`s, one of which would be the //! additive `Monoid` on integers, where the inverse of any integer //! `n` is the integer `-n`. The method names used here refer to //! exactly this model. //! //! //! Minimal complete definitions //! ---------------------------- //! 1. `minus`\n //! When `minus` is specified, the `negate` method is defaulted by setting //! @code //! negate(x) = minus(zero<G>(), x) //! @endcode //! //! 2. `negate`\n //! When `negate` is specified, the `minus` method is defaulted by setting //! @code //! minus(x, y) = plus(x, negate(y)) //! @endcode //! //! //! Laws //! ---- //! For all objects `x` of a `Group` `G`, the following laws must be //! satisfied: //! @code //! plus(x, negate(x)) == zero<G>() // right inverse //! plus(negate(x), x) == zero<G>() // left inverse //! @endcode //! //! //! Refined concept //! --------------- //! `Monoid` //! //! //! Concrete models //! --------------- //! `hana::integral_constant` //! //! //! Free model for non-boolean arithmetic data types //! ------------------------------------------------ //! A data type `T` is arithmetic if `std::is_arithmetic<T>::%value` is //! true. For a non-boolean arithmetic data type `T`, a model of `Group` //! is automatically defined by setting //! @code //! minus(x, y) = (x - y) //! negate(x) = -x //! @endcode //! //! @note //! The rationale for not providing a Group model for `bool` is the same //! as for not providing a `Monoid` model. //! //! //! Structure-preserving functions //! ------------------------------ //! Let `A` and `B` be two `Group`s. A function `f : A -> B` is said to //! be a [Group morphism][2] if it preserves the group structure between //! `A` and `B`. Rigorously, for all objects `x, y` of data type `A`, //! @code //! f(plus(x, y)) == plus(f(x), f(y)) //! @endcode //! Because of the `Group` structure, it is easy to prove that the //! following will then also be satisfied: //! @code //! f(negate(x)) == negate(f(x)) //! f(zero<A>()) == zero<B>() //! @endcode //! Functions with these properties interact nicely with `Group`s, which //! is why they are given such a special treatment. //! //! //! [1]: http://en.wikipedia.org/wiki/Group_(mathematics) //! [2]: http://en.wikipedia.org/wiki/Group_homomorphism template <typename G> struct Group; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_GROUP_HPP PK �\�[�J�J J ! fwd/concept/integral_constant.hppnu �[��� /*! @file Forward declares `boost::hana::IntegralConstant`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CONCEPT_INTEGRAL_CONSTANT_HPP #define BOOST_HANA_FWD_CONCEPT_INTEGRAL_CONSTANT_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! The `IntegralConstant` concept represents compile-time integral values. //! //! The `IntegralConstant` concept represents objects that hold a //! `constexpr` value of an integral type. In other words, it describes //! the essential functionality provided by `std::integral_constant`. //! An `IntegralConstant` is also just a special kind of `Constant` //! whose inner value is of an integral type. //! //! //! Minimal complete definition //! --------------------------- //! The requirements for being an `IntegralConstant` are quite simple. //! First, an `IntegralConstant` `C` must be a `Constant` such that //! `Tag::value_type` is an integral type, where `Tag` is the tag of `C`. //! //! Secondly, `C` must have a nested `static constexpr` member named //! `value`, such that the following code is valid: //! @code //! constexpr auto v = C::value; //! @endcode //! Because of the requirement that `Tag::value_type` be an integral type, //! it follows that `C::value` must be an integral value. //! //! Finally, it is necessary to specialize the `IntegralConstant` template //! in the `boost::hana` namespace to tell Hana that a type is a model //! of `IntegralConstant`: //! @code //! namespace boost { namespace hana { //! template <> //! struct IntegralConstant<your_custom_tag> { //! static constexpr bool value = true; //! }; //! }} //! @endcode //! //! //! Refined concept //! --------------- //! 1. `Constant` (free implementation of `value`)\n //! The `value` function required to be a `Constant` can be implemented //! as follows for `IntegralConstant`s: //! @code //! value<C>() == C::value //! @endcode //! The `to` function must still be provided explicitly for the model //! of `Constant` to be complete. //! //! //! Concrete models //! --------------- //! `hana::integral_constant` template <typename C> struct IntegralConstant; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_INTEGRAL_CONSTANT_HPP PK �\�[л�K� � fwd/concept/foldable.hppnu �[��� /*! @file Forward declares `boost::hana::Foldable`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CONCEPT_FOLDABLE_HPP #define BOOST_HANA_FWD_CONCEPT_FOLDABLE_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Foldable Foldable //! The `Foldable` concept represents data structures that can be reduced //! to a single value. //! //! Generally speaking, folding refers to the concept of summarizing a //! complex structure as a single value, by successively applying a //! binary operation which reduces two elements of the structure to a //! single value. Folds come in many flavors; left folds, right folds, //! folds with and without an initial reduction state, and their monadic //! variants. This concept is able to express all of these fold variants. //! //! Another way of seeing `Foldable` is as data structures supporting //! internal iteration with the ability to accumulate a result. By //! internal iteration, we mean that the _loop control_ is in the hand //! of the structure, not the caller. Hence, it is the structure who //! decides when the iteration stops, which is normally when the whole //! structure has been consumed. Since C++ is an eager language, this //! requires `Foldable` structures to be finite, or otherwise one would //! need to loop indefinitely to consume the whole structure. //! //! @note //! While the fact that `Foldable` only works for finite structures may //! seem overly restrictive in comparison to the Haskell definition of //! `Foldable`, a finer grained separation of the concepts should //! mitigate the issue. For iterating over possibly infinite data //! structures, see the `Iterable` concept. For searching a possibly //! infinite data structure, see the `Searchable` concept. //! //! //! Minimal complete definition //! --------------------------- //! `fold_left` or `unpack` //! //! However, please note that a minimal complete definition provided //! through `unpack` will be much more compile-time efficient than one //! provided through `fold_left`. //! //! //! Concrete models //! --------------- //! `hana::map`, `hana::optional`, `hana::pair`, `hana::set`, //! `hana::range`, `hana::tuple` //! //! //! @anchor Foldable-lin //! The linearization of a `Foldable` //! --------------------------------- //! Intuitively, for a `Foldable` structure `xs`, the _linearization_ of //! `xs` is the sequence of all the elements in `xs` as if they had been //! put in a list: //! @code //! linearization(xs) = [x1, x2, ..., xn] //! @endcode //! //! Note that it is always possible to produce such a linearization //! for a finite `Foldable` by setting //! @code //! linearization(xs) = fold_left(xs, [], flip(prepend)) //! @endcode //! for an appropriate definition of `[]` and `prepend`. The notion of //! linearization is useful for expressing various properties of //! `Foldable` structures, and is used across the documentation. Also //! note that `Iterable`s define an [extended version](@ref Iterable-lin) //! of this allowing for infinite structures. //! //! //! Compile-time Foldables //! ---------------------- //! A compile-time `Foldable` is a `Foldable` whose total length is known //! at compile-time. In other words, it is a `Foldable` whose `length` //! method returns a `Constant` of an unsigned integral type. When //! folding a compile-time `Foldable`, the folding can be unrolled, //! because the final number of steps of the algorithm is known at //! compile-time. //! //! Additionally, the `unpack` method is only available to compile-time //! `Foldable`s. This is because the return _type_ of `unpack` depends //! on the number of objects in the structure. Being able to resolve //! `unpack`'s return type at compile-time hence requires the length of //! the structure to be known at compile-time too. //! //! __In the current version of the library, only compile-time `Foldable`s //! are supported.__ While it would be possible in theory to support //! runtime `Foldable`s too, doing so efficiently requires more research. //! //! //! Provided conversion to `Sequence`s //! ---------------------------------- //! Given a tag `S` which is a `Sequence`, an object whose tag is a model //! of the `Foldable` concept can be converted to an object of tag `S`. //! In other words, a `Foldable` can be converted to a `Sequence` `S`, by //! simply taking the linearization of the `Foldable` and creating the //! sequence with that. More specifically, given a `Foldable` `xs` with a //! linearization of `[x1, ..., xn]` and a `Sequence` tag `S`, `to<S>(xs)` //! is equivalent to `make<S>(x1, ..., xn)`. //! @include example/foldable/to.cpp //! //! //! Free model for builtin arrays //! ----------------------------- //! Builtin arrays whose size is known can be folded as-if they were //! homogeneous tuples. However, note that builtin arrays can't be //! made more than `Foldable` (e.g. `Iterable`) because they can't //! be empty and they also can't be returned from functions. //! //! //! @anchor monadic-folds //! Primer on monadic folds //! ----------------------- //! A monadic fold is a fold in which subsequent calls to the binary //! function are chained with the monadic `chain` operator of the //! corresponding Monad. This allows a structure to be folded in a //! custom monadic context. For example, performing a monadic fold with //! the `hana::optional` monad would require the binary function to return //! the result as a `hana::optional`, and the fold would abort and return //! `nothing` whenever one of the accumulation step would fail (i.e. //! return `nothing`). If, however, all the reduction steps succeed, //! then `just` the result would be returned. Different monads will of //! course result in different effects. template <typename T> struct Foldable; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_FOLDABLE_HPP PK �\�[�q� fwd/concept/logical.hppnu �[��� /*! @file Forward declares `boost::hana::Logical`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CONCEPT_LOGICAL_HPP #define BOOST_HANA_FWD_CONCEPT_LOGICAL_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Logical Logical //! The `Logical` concept represents types with a truth value. //! //! Intuitively, a `Logical` is just a `bool`, or something that can act //! like one. However, in the context of programming with heterogeneous //! objects, it becomes extremely important to distinguish between those //! objects whose truth value is known at compile-time, and those whose //! truth value is only known at runtime. The reason why this is so //! important is because it is possible to branch at compile-time on //! a condition whose truth value is known at compile-time, and hence //! the return type of the enclosing function can depend on that truth //! value. However, if the truth value is only known at runtime, then //! the compiler has to compile both branches (because any or both of //! them may end up being used), which creates the additional requirement //! that both branches must evaluate to the same type. //! //! More specifically, `Logical` (almost) represents a [boolean algebra][1], //! which is a mathematical structure encoding the usual properties that //! allow us to reason with `bool`. The exact properties that must be //! satisfied by any model of `Logical` are rigorously stated in the laws //! below. //! //! //! Truth, falsity and logical equivalence //! -------------------------------------- //! A `Logical` `x` is said to be _true-valued_, or sometimes also just //! _true_ as an abuse of notation, if //! @code //! if_(x, true, false) == true //! @endcode //! //! Similarly, `x` is _false-valued_, or sometimes just _false_, if //! @code //! if_(x, true, false) == false //! @endcode //! //! This provides a standard way of converting any `Logical` to a straight //! `bool`. The notion of truth value suggests another definition, which //! is that of logical equivalence. We will say that two `Logical`s `x` //! and `y` are _logically equivalent_ if they have the same truth value. //! To denote that some expressions `p` and `q` of a Logical data type are //! logically equivalent, we will sometimes also write //! @code //! p if and only if q //! @endcode //! which is very common in mathematics. The intuition behind this notation //! is that whenever `p` is true-valued, then `q` should be; but when `p` //! is false-valued, then `q` should be too. Hence, `p` should be //! true-valued when (and only when) `q` is true-valued. //! //! //! Minimal complete definition //! --------------------------- //! `eval_if`, `not_` and `while_` //! //! All the other functions can be defined in those terms: //! @code //! if_(cond, x, y) = eval_if(cond, lazy(x), lazy(y)) //! and_(x, y) = if_(x, y, x) //! or_(x, y) = if_(x, x, y) //! etc... //! @endcode //! //! //! Laws //! ---- //! As outlined above, the `Logical` concept almost represents a boolean //! algebra. The rationale for this laxity is to allow things like integers //! to act like `Logical`s, which is aligned with C++, even though they do //! not form a boolean algebra. Even though we depart from the usual //! axiomatization of boolean algebras, we have found through experience //! that the definition of a Logical given here is largely compatible with //! intuition. //! //! The following laws must be satisfied for any data type `L` modeling //! the `Logical` concept. Let `a`, `b` and `c` be objects of a `Logical` //! data type, and let `t` and `f` be arbitrary _true-valued_ and //! _false-valued_ `Logical`s of that data type, respectively. Then, //! @code //! // associativity //! or_(a, or_(b, c)) == or_(or_(a, b), c) //! and_(a, and_(b, c)) == and_(and_(a, b), c) //! //! // equivalence through commutativity //! or_(a, b) if and only if or_(b, a) //! and_(a, b) if and only if and_(b, a) //! //! // absorption //! or_(a, and_(a, b)) == a //! and_(a, or_(a, b)) == a //! //! // left identity //! or_(a, f) == a //! and_(a, t) == a //! //! // distributivity //! or_(a, and_(b, c)) == and_(or_(a, b), or_(a, c)) //! and_(a, or_(b, c)) == or_(and_(a, b), and_(a, c)) //! //! // complements //! or_(a, not_(a)) is true-valued //! and_(a, not_(a)) is false-valued //! @endcode //! //! > #### Why is the above not a boolean algebra? //! > If you look closely, you will find that we depart from the usual //! > boolean algebras because: //! > 1. we do not require the elements representing truth and falsity to //! > be unique //! > 2. we do not enforce commutativity of the `and_` and `or_` operations //! > 3. because we do not enforce commutativity, the identity laws become //! > left-identity laws //! //! //! Concrete models //! --------------- //! `hana::integral_constant` //! //! //! Free model for arithmetic data types //! ------------------------------------ //! A data type `T` is arithmetic if `std::is_arithmetic<T>::%value` is //! true. For an arithmetic data type `T`, a model of `Logical` is //! provided automatically by using the result of the builtin implicit //! conversion to `bool` as a truth value. Specifically, the minimal //! complete definition for those data types is //! @code //! eval_if(cond, then, else_) = cond ? then(id) : else(id) //! not_(cond) = static_cast<T>(cond ? false : true) //! while_(pred, state, f) = equivalent to a normal while loop //! @endcode //! //! > #### Rationale for not providing a model for all contextually convertible to bool data types //! > The `not_` method can not be implemented in a meaningful way for all //! > of those types. For example, one can not cast a pointer type `T*` //! > to bool and then back again to `T*` in a meaningful way. With an //! > arithmetic type `T`, however, it is possible to cast from `T` to //! > bool and then to `T` again; the result will be `0` or `1` depending //! > on the truth value. If you want to use a pointer type or something //! > similar in a conditional, it is suggested to explicitly convert it //! > to bool by using `to<bool>`. //! //! //! [1]: http://en.wikipedia.org/wiki/Boolean_algebra_(structure) template <typename L> struct Logical; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_LOGICAL_HPP PK �\�[b�#l< < fwd/concept/searchable.hppnu �[��� /*! @file Forward declares `boost::hana::Searchable`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CONCEPT_SEARCHABLE_HPP #define BOOST_HANA_FWD_CONCEPT_SEARCHABLE_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Searchable Searchable //! The `Searchable` concept represents structures that can be searched. //! //! Intuitively, a `Searchable` is any structure, finite or infinite, //! containing elements that can be searched using a predicate. Sometimes, //! `Searchable`s will associate keys to values; one can search for a key //! with a predicate, and the value associated to it is returned. This //! gives rise to map-like data structures. Other times, the elements of //! the structure that are searched (i.e. those to which the predicate is //! applied) are the same that are returned, which gives rise to set-like //! data structures. In general, we will refer to the _keys_ of a //! `Searchable` structure as those elements that are used for searching, //! and to the _values_ of a `Searchable` as those elements that are //! returned when a search is successful. As was explained, there is no //! requirement that both notions differ, and it is often useful to have //! keys and values coincide (think about `std::set`). //! //! Some methods like `any_of`, `all_of` and `none_of` allow simple queries //! to be performed on the keys of the structure, while other methods like //! `find` and `find_if` make it possible to find the value associated //! to a key. The most specific method should always be used if one //! cares about performance, because it is usually the case that heavy //! optimizations can be performed in more specific methods. For example, //! an associative data structure implemented as a hash table will be much //! faster to access using `find` than `find_if`, because in the second //! case it will have to do a linear search through all the entries. //! Similarly, using `contains` will likely be much faster than `any_of` //! with an equivalent predicate. //! //! > __Insight__\n //! > In a lazy evaluation context, any `Foldable` can also become a model //! > of `Searchable` because we can search lazily through the structure //! > with `fold_right`. However, in the context of C++, some `Searchable`s //! > can not be folded; think for example of an infinite set. //! //! //! Minimal complete definition //! --------------------------- //! `find_if` and `any_of` //! //! When `find_if` and `any_of` are provided, the other functions are //! implemented according to the laws explained below. //! //! @note //! We could implement `any_of(xs, pred)` by checking whether //! `find_if(xs, pred)` is an empty `optional` or not, and then reduce //! the minimal complete definition to `find_if`. However, this is not //! done because that implementation requires the predicate of `any_of` //! to return a compile-time `Logical`, which is more restrictive than //! what we have right now. //! //! //! Laws //! ---- //! In order for the semantics of the methods to be consistent, some //! properties must be satisfied by any model of the `Searchable` concept. //! Rigorously, for any `Searchable`s `xs` and `ys` and any predicate `p`, //! the following laws should be satisfied: //! @code //! any_of(xs, p) <=> !all_of(xs, negated p) //! <=> !none_of(xs, p) //! //! contains(xs, x) <=> any_of(xs, equal.to(x)) //! //! find(xs, x) == find_if(xs, equal.to(x)) //! find_if(xs, always(false_)) == nothing //! //! is_subset(xs, ys) <=> all_of(xs, [](auto x) { return contains(ys, x); }) //! is_disjoint(xs, ys) <=> none_of(xs, [](auto x) { return contains(ys, x); }) //! @endcode //! //! Additionally, if all the keys of the `Searchable` are `Logical`s, //! the following laws should be satisfied: //! @code //! any(xs) <=> any_of(xs, id) //! all(xs) <=> all_of(xs, id) //! none(xs) <=> none_of(xs, id) //! @endcode //! //! //! Concrete models //! --------------- //! `hana::map`, `hana::optional`, `hana::range`, `hana::set`, //! `hana::string`, `hana::tuple` //! //! //! Free model for builtin arrays //! ----------------------------- //! Builtin arrays whose size is known can be searched as-if they were //! homogeneous tuples. However, since arrays can only hold objects of //! a single type and the predicate to `find_if` must return a compile-time //! `Logical`, the `find_if` method is fairly useless. For similar reasons, //! the `find` method is also fairly useless. This model is provided mainly //! because of the `any_of` method & friends, which are both useful and //! compile-time efficient. //! //! //! Structure preserving functions //! ------------------------------ //! Given two `Searchables` `S1` and `S2`, a function //! @f$ f : S_1(X) \to S_2(X) @f$ is said to preserve the `Searchable` //! structure if for all `xs` of data type `S1(X)` and predicates //! @f$ \mathtt{pred} : X \to Bool @f$ (for a `Logical` `Bool`), //! @code //! any_of(xs, pred) if and only if any_of(f(xs), pred) //! find_if(xs, pred) == find_if(f(xs), pred) //! @endcode //! //! This is really just a generalization of the following, more intuitive //! requirements. For all `xs` of data type `S1(X)` and `x` of data type //! `X`, //! @code //! x ^in^ xs if and only if x ^in^ f(xs) //! find(xs, x) == find(f(xs), x) //! @endcode //! //! These requirements can be understood as saying that `f` does not //! change the content of `xs`, although it may reorder elements. //! As usual, such a structure-preserving transformation is said to //! be an embedding if it is also injective, i.e. if it is a lossless //! transformation. template <typename S> struct Searchable; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_SEARCHABLE_HPP PK �\�[��� � fwd/concept/comonad.hppnu �[��� /*! @file Forward declares `boost::hana::Comonad`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CONCEPT_COMONAD_HPP #define BOOST_HANA_FWD_CONCEPT_COMONAD_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN // Note: We use a multiline C++ comment because there's a double backslash // symbol in the documentation (for LaTeX), which triggers // warning: multi-line comment [-Wcomment] // on GCC. /*! @ingroup group-concepts @defgroup group-Comonad Comonad The `Comonad` concept represents context-sensitive computations and data. Formally, the Comonad concept is dual to the Monad concept. But unless you're a mathematician, you don't care about that and it's fine. So intuitively, a Comonad represents context sensitive values and computations. First, Comonads make it possible to extract context-sensitive values from their context with `extract`. In contrast, Monads make it possible to wrap raw values into a given context with `lift` (from Applicative). Secondly, Comonads make it possible to apply context-sensitive values to functions accepting those, and to return the result as a context-sensitive value using `extend`. In contrast, Monads make it possible to apply a monadic value to a function accepting a normal value and returning a monadic value, and to return the result as a monadic value (with `chain`). Finally, Comonads make it possible to wrap a context-sensitive value into an extra layer of context using `duplicate`, while Monads make it possible to take a value with an extra layer of context and to strip it with `flatten`. Whereas `lift`, `chain` and `flatten` from Applicative and Monad have signatures \f{align*}{ \mathtt{lift}_M &: T \to M(T) \\ \mathtt{chain} &: M(T) \times (T \to M(U)) \to M(U) \\ \mathtt{flatten} &: M(M(T)) \to M(T) \f} `extract`, `extend` and `duplicate` from Comonad have signatures \f{align*}{ \mathtt{extract} &: W(T) \to T \\ \mathtt{extend} &: W(T) \times (W(T) \to U) \to W(U) \\ \mathtt{duplicate} &: W(T) \to W(W(T)) \f} Notice how the "arrows" are reversed. This symmetry is essentially what we mean by Comonad being the _dual_ of Monad. @note The [Typeclassopedia][1] is a nice Haskell-oriented resource for further reading about Comonads. Minimal complete definition --------------------------- `extract` and (`extend` or `duplicate`) satisfying the laws below. A `Comonad` must also be a `Functor`. Laws ---- For all Comonads `w`, the following laws must be satisfied: @code extract(duplicate(w)) == w transform(duplicate(w), extract) == w duplicate(duplicate(w)) == transform(duplicate(w), duplicate) @endcode @note There are several equivalent ways of defining Comonads, and this one is just one that was picked arbitrarily for simplicity. Refined concept --------------- 1. Functor\n Every Comonad is also required to be a Functor. At first, one might think that it should instead be some imaginary concept CoFunctor. However, it turns out that a CoFunctor is the same as a `Functor`, hence the requirement that a `Comonad` also is a `Functor`. Concrete models --------------- `hana::lazy` [1]: https://wiki.haskell.org/Typeclassopedia#Comonad */ template <typename W> struct Comonad; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_COMONAD_HPP PK �\�[�{�� � fwd/concept/hashable.hppnu �[��� /*! @file Forward declares `boost::hana::Hashable`. @copyright Louis Dionne 2016 @copyright Jason Rice 2016 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CONCEPT_HASHABLE_HPP #define BOOST_HANA_FWD_CONCEPT_HASHABLE_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Hashable Hashable //! The `Hashable` concept represents objects that can be normalized to //! a type-level hash. //! //! In day to day programming, hashes are very important as a way to //! efficiently lookup objects in maps. While the implementation of //! maps is very different, the same idea of using hashes for efficient //! lookup applies in metaprogramming. The `Hashable` concept represents //! objects that can be summarized (possibly with loss of information) to //! a type, in a way suitable for use in hash-based data structures. Of //! course, in order for a hash to be well-behaved, it must obey some laws //! that are explained below. //! //! //! Minimal complete definition //! --------------------------- //! `hash`, satisfying the laws below //! //! //! Laws //! ---- //! First, `hana::hash` must return a `hana::type`. Furthermore, for any //! two `Hashable` objects `x` and `y`, it must be the case that //! @code //! x == y implies hash(x) == hash(y) //! @endcode //! //! where `==` denotes `hana::equal`. In other words, any two objects that //! compare equal (with `hana::equal`) must also have the same hash. //! However, the reverse is not true, and two different objects may have //! the same hash. This situation of two different objects having the same //! hash is called a _collision_. //! //! //! Concrete models //! --------------- //! `hana::integral_constant`, `hana::type`, `hana::string` //! //! //! Free model for `IntegralConstant`s //! ---------------------------------- //! Any `IntegralConstant` is `Hashable`, by normalizing its value to a //! `hana::integral_constant`. The type of the value held in the normalized //! `integral_constant` is `unsigned long long` for unsigned integral //! types, and `signed long long` for signed integral types. template <typename T> struct Hashable; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_HASHABLE_HPP PK �\�[%t��`$ `$ fwd/concept/monad.hppnu �[��� /*! @file Forward declares `boost::hana::Monad`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CONCEPT_MONAD_HPP #define BOOST_HANA_FWD_CONCEPT_MONAD_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Monad Monad //! The `Monad` concept represents `Applicative`s with the ability to //! flatten nested levels of structure. //! //! Historically, Monads are a construction coming from category theory, //! an abstract branch of mathematics. The functional programming //! community eventually discovered how Monads could be used to //! formalize several useful things like side effects, which led //! to the wide adoption of Monads in that community. However, even //! in a multi-paradigm language like C++, there are several constructs //! which turn out to be Monads, like `std::optional`, `std::vector` and //! others. //! //! Everybody tries to introduce `Monad`s with a different analogy, and //! most people fail. This is called the [Monad tutorial fallacy][1]. We //! will try to avoid this trap by not presenting a specific intuition, //! and we will instead present what monads are mathematically. //! For specific intuitions, we will let readers who are new to this //! concept read one of the many excellent tutorials available online. //! Understanding Monads might take time at first, but once you get it, //! a lot of patterns will become obvious Monads; this enlightening will //! be your reward for the hard work. //! //! There are different ways of defining a Monad; Haskell uses a function //! called `bind` (`>>=`) and another one called `return` (it has nothing //! to do with C++'s `return` statement). They then introduce relationships //! that must be satisfied for a type to be a Monad with those functions. //! Mathematicians sometimes use a function called `join` and another one //! called `unit`, or they also sometimes use other category theoretic //! constructions like functor adjunctions and the Kleisli category. //! //! This library uses a composite approach. First, we use the `flatten` //! function (equivalent to `join`) along with the `lift` function from //! `Applicative` (equivalent to `unit`) to introduce the notion of //! monadic function composition. We then write the properties that must //! be satisfied by a Monad using this monadic composition operator, //! because we feel it shows the link between Monads and Monoids more //! clearly than other approaches. //! //! Roughly speaking, we will say that a `Monad` is an `Applicative` which //! also defines a way to compose functions returning a monadic result, //! as opposed to only being able to compose functions returning a normal //! result. We will then ask for this composition to be associative and to //! have a neutral element, just like normal function composition. For //! usual composition, the neutral element is the identity function `id`. //! For monadic composition, the neutral element is the `lift` function //! defined by `Applicative`. This construction is made clearer in the //! laws below. //! //! @note //! Monads are known to be a big chunk to swallow. However, it is out of //! the scope of this documentation to provide a full-blown explanation //! of the concept. The [Typeclassopedia][2] is a nice Haskell-oriented //! resource where more information about Monads can be found. //! //! //! Minimal complete definitions //! ---------------------------- //! First, a `Monad` must be both a `Functor` and an `Applicative`. //! Also, an implementation of `flatten` or `chain` satisfying the //! laws below for monadic composition must be provided. //! //! @note //! The `ap` method for `Applicatives` may be derived from the minimal //! complete definition of `Monad` and `Functor`; see below for more //! information. //! //! //! Laws //! ---- //! To simplify writing the laws, we use the comparison between functions. //! For two functions `f` and `g`, we define //! @code //! f == g if and only if f(x) == g(x) for all x //! @endcode //! //! With the usual composition of functions, we are given two functions //! @f$ f : A \to B @f$ and @f$ g : B \to C @f$, and we must produce a //! new function @f$ compose(g, f) : A \to C @f$. This composition of //! functions is associative, which means that //! @code //! compose(h, compose(g, f)) == compose(compose(h, g), f) //! @endcode //! //! Also, this composition has an identity element, which is the identity //! function. This simply means that //! @code //! compose(f, id) == compose(id, f) == f //! @endcode //! //! This is probably nothing new if you are reading the `Monad` laws. //! Now, we can observe that the above is equivalent to saying that //! functions with the composition operator form a `Monoid`, where the //! neutral element is the identity function. //! //! Given an `Applicative` `F`, what if we wanted to compose two functions //! @f$ f : A \to F(B) @f$ and @f$ g : B \to F(C) @f$? When the //! `Applicative` `F` is also a `Monad`, such functions taking normal //! values but returning monadic values are called _monadic functions_. //! To compose them, we obviously can't use normal function composition, //! since the domains and codomains of `f` and `g` do not match properly. //! Instead, we'll need a new operator -- let's call it `monadic_compose`: //! @f[ //! \mathtt{monadic\_compose} : //! (B \to F(C)) \times (A \to F(B)) \to (A \to F(C)) //! @f] //! //! How could we go about implementing this function? Well, since we know //! `F` is an `Applicative`, the only functions we have are `transform` //! (from `Functor`), and `lift` and `ap` (from `Applicative`). Hence, //! the only thing we can do at this point while respecting the signatures //! of `f` and `g` is to set (for `x` of type `A`) //! @code //! monadic_compose(g, f)(x) = transform(f(x), g) //! @endcode //! //! Indeed, `f(x)` is of type `F(B)`, so we can map `g` (which takes `B`'s) //! on it. Doing so will leave us with a result of type `F(F(C))`, but what //! we wanted was a result of type `F(C)` to respect the signature of //! `monadic_compose`. If we had a joker of type @f$ F(F(C)) \to F(C) @f$, //! we could simply set //! @code //! monadic_compose(g, f)(x) = joker(transform(f(x), g)) //! @endcode //! //! and we would be happy. It turns out that `flatten` is precisely this //! joker. Now, we'll want our joker to satisfy some properties to make //! sure this composition is associative, just like our normal composition //! was. These properties are slightly cumbersome to specify, so we won't //! do it here. Also, we'll need some kind of neutral element for the //! composition. This neutral element can't be the usual identity function, //! because it does not have the right type: our neutral element needs to //! be a function of type @f$ X \to F(X) @f$ but the identity function has //! type @f$ X \to X @f$. It is now the right time to observe that `lift` //! from `Applicative` has exactly the right signature, and so we'll take //! this for our neutral element. //! //! We are now ready to formulate the `Monad` laws using this composition //! operator. For a `Monad` `M` and functions @f$ f : A \to M(B) @f$, //! @f$ g : B \to M(C) @f$ and @f$ h : C \to M(D) @f$, the following //! must be satisfied: //! @code //! // associativity //! monadic_compose(h, monadic_compose(g, f)) == monadic_compose(monadic_compose(h, g), f) //! //! // right identity //! monadic_compose(f, lift<M(A)>) == f //! //! // left identity //! monadic_compose(lift<M(B)>, f) == f //! @endcode //! //! which is to say that `M` along with monadic composition is a Monoid //! where the neutral element is `lift`. //! //! //! Refined concepts //! ---------------- //! 1. `Functor` //! 2. `Applicative` (free implementation of `ap`)\n //! When the minimal complete definition for `Monad` and `Functor` are //! both satisfied, it is possible to implement `ap` by setting //! @code //! ap(fs, xs) = chain(fs, [](auto f) { //! return transform(xs, f); //! }) //! @endcode //! //! //! Concrete models //! --------------- //! `hana::lazy`, `hana::optional`, `hana::tuple` //! //! //! [1]: https://byorgey.wordpress.com/2009/01/12/abstraction-intuition-and-the-monad-tutorial-fallacy/ //! [2]: https://wiki.haskell.org/Typeclassopedia#Monad template <typename M> struct Monad; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_MONAD_HPP PK �\�[Xx=_ _ fwd/concept/iterable.hppnu �[��� /*! @file Forward declares `boost::hana::Iterable`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CONCEPT_ITERABLE_HPP #define BOOST_HANA_FWD_CONCEPT_ITERABLE_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Iterable Iterable //! The `Iterable` concept represents data structures supporting external //! iteration. //! //! Intuitively, an `Iterable` can be seen as a kind of container whose //! elements can be pulled out one at a time. An `Iterable` also provides //! a way to know when the _container_ is empty, i.e. when there are no //! more elements to pull out. //! //! Whereas `Foldable` represents data structures supporting internal //! iteration with the ability to accumulate a result, the `Iterable` //! concept allows inverting the control of the iteration. This is more //! flexible than `Foldable`, since it allows iterating over only some //! part of the structure. This, in turn, allows `Iterable` to work on //! infinite structures, while trying to fold such a structure would //! never finish. //! //! //! Minimal complete definition //! --------------------------- //! `at`, `drop_front` and `is_empty` //! //! //! @anchor Iterable-lin //! The linearization of an `Iterable` //! ---------------------------------- //! Intuitively, for an `Iterable` structure `xs`, the _linearization_ of //! `xs` is the sequence of all the elements in `xs` as if they had been //! put in a (possibly infinite) list: //! @code //! linearization(xs) = [x1, x2, x3, ...] //! @endcode //! //! The `n`th element of the linearization of an `Iterable` can be //! accessed with the `at` function. In other words, `at(xs, n) == xn`. //! //! Note that this notion is precisely the extension of the [linearization] //! (@ref Foldable-lin) notion of `Foldable`s to the infinite case. This //! notion is useful for expressing various properties of `Iterable`s, //! and is used for that elsewhere in the documentation. //! //! //! Compile-time `Iterable`s //! ------------------------ //! A _compile-time_ `Iterable` is an `Iterable` for which `is_empty` //! returns a compile-time `Logical`. These structures allow iteration //! to be done at compile-time, in the sense that the "loop" doing the //! iteration can be unrolled because the total length of the structure //! is kown at compile-time. //! //! In particular, note that being a compile-time `Iterable` has nothing //! to do with being finite or infinite. For example, it would be possible //! to create a sequence representing the Pythagorean triples as //! `integral_constant`s. Such a sequence would be infinite, but iteration //! on the sequence would still be done at compile-time. However, if one //! tried to iterate over _all_ the elements of the sequence, the compiler //! would loop indefinitely, in contrast to your program looping //! indefinitely if the sequence was a runtime one. //! //! __In the current version of the library, only compile-time `Iterable`s //! are supported.__ While it would be possible in theory to support //! runtime `Iterable`s, doing it efficiently is the subject of some //! research. In particular, follow [this issue][1] for the current //! status of runtime `Iterable`s. //! //! //! Laws //! ---- //! First, we require the equality of two `Iterable`s to be related to the //! equality of the elements in their linearizations. More specifically, //! if `xs` and `ys` are two `Iterable`s of data type `It`, then //! @code //! xs == ys => at(xs, i) == at(ys, i) for all i //! @endcode //! //! This conveys that two `Iterable`s must have the same linearization //! in order to be considered equal. //! //! Secondly, since every `Iterable` is also a `Searchable`, we require //! the models of `Iterable` and `Searchable` to be consistent. This is //! made precise by the following laws. For any `Iterable` `xs` with a //! linearization of `[x1, x2, x3, ...]`, //! @code //! any_of(xs, equal.to(z)) <=> xi == z //! @endcode //! for some _finite_ index `i`. Furthermore, //! @code //! find_if(xs, pred) == just(the first xi such that pred(xi) is satisfied) //! @endcode //! or `nothing` if no such `xi` exists. //! //! //! Refined concepts //! ---------------- //! 1. `Searchable` (free model)\n //! Any `Iterable` gives rise to a model of `Searchable`, where the keys //! and the values are both the elements in the structure. Searching for //! a key is just doing a linear search through the elements of the //! structure. //! @include example/iterable/searchable.cpp //! //! 2. `Foldable` for finite `Iterable`s\n //! Every finite `Iterable` gives rise to a model of `Foldable`. For //! these models to be consistent, we require the models of both `Foldable` //! and `Iterable` to have the same linearization. //! //! @note //! As explained above, `Iterable`s are also `Searchable`s and their //! models have to be consistent. By the laws presented here, it also //! means that the `Foldable` model for finite `Iterable`s has to be //! consistent with the `Searchable` model. //! //! For convenience, finite `Iterable`s must only provide a definition of //! `length` to model the `Foldable` concept; defining the more powerful //! `unpack` or `fold_left` is not necessary (but still possible). The //! default implementation of `unpack` derived from `Iterable` + `length` //! uses the fact that `at(xs, i)` denotes the `i`th element of `xs`'s //! linearization, and that the linearization of a finite `Iterable` must //! be the same as its linearization as a `Foldable`. //! //! //! Concrete models //! --------------- //! `hana::tuple`, `hana::string`, `hana::range` //! //! //! [1]: https://github.com/boostorg/hana/issues/40 template <typename It> struct Iterable; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_ITERABLE_HPP PK �\�[u��*�' �' fwd/concept/constant.hppnu �[��� /*! @file Forward declares `boost::hana::Constant`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CONCEPT_CONSTANT_HPP #define BOOST_HANA_FWD_CONCEPT_CONSTANT_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Constant Constant //! The `Constant` concept represents data that can be manipulated at //! compile-time. //! //! At its core, `Constant` is simply a generalization of the principle //! behind `std::integral_constant` to all types that can be constructed //! at compile-time, i.e. to all types with a `constexpr` constructor //! (also called [Literal types][1]). More specifically, a `Constant` is //! an object from which a `constexpr` value may be obtained (through the //! `value` method) regardless of the `constexpr`ness of the object itself. //! //! All `Constant`s must be somewhat equivalent, in the following sense. //! Let `C(T)` and `D(U)` denote the tags of `Constant`s holding objects //! of type `T` and `U`, respectively. Then, an object with tag `D(U)` //! must be convertible to an object with tag `C(T)` whenever `U` is //! convertible to `T`, as determined by `is_convertible`. The //! interpretation here is that a `Constant` is just a box holding //! an object of some type, and it should be possible to swap between //! boxes whenever the objects inside the boxes can be swapped. //! //! Because of this last requirement, one could be tempted to think that //! specialized "boxes" like `std::integral_constant` are prevented from //! being `Constant`s because they are not able to hold objects of any //! type `T` (`std::integral_constant` may only hold integral types). //! This is false; the requirement should be interpreted as saying that //! whenever `C(T)` is _meaningful_ (e.g. only when `T` is integral for //! `std::integral_constant`) _and_ there exists a conversion from `U` //! to `T`, then a conversion from `D(U)` to `C(T)` should also exist. //! The precise requirements for being a `Constant` are embodied in the //! following laws. //! //! //! Minimal complete definition //! --------------------------- //! `value` and `to`, satisfying the laws below. //! //! //! Laws //! ---- //! Let `c` be an object of with tag `C`, which represents a `Constant` //! holding an object with tag `T`. The first law ensures that the value //! of the wrapped object is always a constant expression by requiring //! the following to be well-formed: //! @code //! constexpr auto x = hana::value<decltype(c)>(); //! @endcode //! //! This means that the `value` function must return an object that can //! be constructed at compile-time. It is important to note how `value` //! only receives the type of the object and not the object itself. //! This is the core of the `Constant` concept; it means that the only //! information required to implement `value` must be stored in the _type_ //! of its argument, and hence be available statically. //! //! The second law that must be satisfied ensures that `Constant`s are //! basically dumb boxes, which makes it possible to provide models for //! many concepts without much work from the user. The law simply asks //! for the following expression to be valid: //! @code //! to<C>(i) //! @endcode //! where, `i` is an _arbitrary_ `Constant` holding an internal value //! with a tag that can be converted to `T`, as determined by the //! `hana::is_convertible` metafunction. In other words, whenever `U` is //! convertible to `T`, a `Constant` holding a `U` is convertible to //! a `Constant` holding a `T`, if such a `Constant` can be created. //! //! Finally, the tag `C` must provide a nested `value_type` alias to `T`, //! which allows us to query the tag of the inner value held by objects //! with tag `C`. In other words, the following must be true for any //! object `c` with tag `C`: //! @code //! std::is_same< //! C::value_type, //! tag_of<decltype(hana::value(c))>::type //! >::value //! @endcode //! //! //! Refined concepts //! ---------------- //! In certain cases, a `Constant` can automatically be made a model of //! another concept. In particular, if a `Constant` `C` is holding an //! object of tag `T`, and if `T` models a concept `X`, then `C` may //! in most cases model `X` by simply performing whatever operation is //! required on its underlying value, and then wrapping the result back //! in a `C`. //! //! More specifically, if a `Constant` `C` has an underlying value //! (`C::value_type`) which is a model of `Comparable`, `Orderable`, //! `Logical`, or `Monoid` up to `EuclideanRing`, then `C` must also //! be a model of those concepts. In other words, when `C::value_type` //! models one of the listed concepts, `C` itself must also model that //! concept. However, note that free models are provided for all of //! those concepts, so no additional work must be done. //! //! While it would be possible in theory to provide models for concepts //! like `Foldable` too, only a couple of concepts are useful to have as //! `Constant` in practice. Providing free models for the concepts listed //! above is useful because it allows various types of integral constants //! (`std::integral_constant`, `mpl::integral_c`, etc...) to easily have //! models for them just by defining the `Constant` concept. //! //! @remark //! An interesting observation is that `Constant` is actually the //! canonical embedding of the subcategory of `constexpr` things //! into the Hana category, which contains everything in this library. //! Hence, whatever is true in that subcategory is also true here, via //! this functor. This is why we can provide models of any concept that //! works on `constexpr` things for Constants, by simply passing them //! through that embedding. //! //! //! Concrete models //! --------------- //! `hana::integral_constant` //! //! //! Provided conversion to the tag of the underlying value //! ------------------------------------------------------ //! Any `Constant` `c` holding an underlying value of tag `T` is //! convertible to any tag `U` such that `T` is convertible to `U`. //! Specifically, the conversion is equivalent to //! @code //! to<U>(c) == to<U>(value<decltype(c)>()) //! @endcode //! //! Also, those conversions are marked as an embedding whenever the //! conversion of underlying types is an embedding. This is to allow //! Constants to inter-operate with `constexpr` objects easily: //! @code //! plus(int_c<1>, 1) == 2 //! @endcode //! //! Strictly speaking, __this is sometimes a violation__ of what it means //! to be an embedding. Indeed, while there exists an embedding from any //! Constant to a `constexpr` object (since Constant is just the canonical //! inclusion), there is no embedding from a Constant to a runtime //! object since we would lose the ability to define the `value` method //! (the `constexpr`ness of the object would have been lost). Since there //! is no way to distinguish `constexpr` and non-`constexpr` objects based //! on their type, Hana has no way to know whether the conversion is to a //! `constexpr` object of not. In other words, the `to` method has no way //! to differentiate between //! @code //! constexpr int i = hana::to<int>(int_c<1>); //! @endcode //! which is an embedding, and //! @code //! int i = hana::to<int>(int_c<1>); //! @endcode //! //! which isn't. To be on the safer side, we could mark the conversion //! as not-an-embedding. However, if e.g. the conversion from //! `integral_constant_tag<int>` to `int` was not marked as an embedding, //! we would have to write `plus(to<int>(int_c<1>), 1)` instead of just //! `plus(int_c<1>, 1)`, which is cumbersome. Hence, the conversion is //! marked as an embedding, but this also means that code like //! @code //! int i = 1; //! plus(int_c<1>, i); //! @endcode //! will be considered valid, which implicitly loses the fact that //! `int_c<1>` is a Constant, and hence does not follow the usual rules //! for cross-type operations in Hana. //! //! //! Provided common data type //! ------------------------- //! Because of the requirement that `Constant`s be interchangeable when //! their contents are compatible, two `Constant`s `A` and `B` will have //! a common data type whenever `A::value_type` and `B::value_type` have //! one. Their common data type is an unspecified `Constant` `C` such //! that `C::value_type` is exactly `common_t<A::value_type, B::value_type>`. //! A specialization of the `common` metafunction is provided for //! `Constant`s to reflect this. //! //! In the same vein, a common data type is also provided from any //! constant `A` to a type `T` such that `A::value_type` and `T` share //! a common type. The common type between `A` and `T` is obviously the //! common type between `A::value_type` and `T`. As explained above in //! the section on conversions, this is sometimes a violation of the //! definition of a common type, because there must be an embedding //! to the common type, which is not always the case. For the same //! reasons as explained above, this common type is still provided. //! //! //! [1]: http://en.cppreference.com/w/cpp/named_req/LiteralType template <typename C> struct Constant; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_CONSTANT_HPP PK �\�[��1�� � fwd/concept/sequence.hppnu �[��� /*! @file Forward declares `boost::hana::Sequence`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CONCEPT_SEQUENCE_HPP #define BOOST_HANA_FWD_CONCEPT_SEQUENCE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Sequence Sequence //! The `Sequence` concept represents generic index-based sequences. //! //! Compared to other abstract concepts, the Sequence concept is very //! specific. It represents generic index-based sequences. The reason //! why such a specific concept is provided is because there are a lot //! of models that behave exactly the same while being implemented in //! wildly different ways. It is useful to regroup all those data types //! under the same umbrella for the purpose of generic programming. //! //! In fact, models of this concept are not only _similar_. They are //! actually _isomorphic_, in a sense that we define below, which is //! a fancy way of rigorously saying that they behave exactly the same //! to an external observer. //! //! //! Minimal complete definition //! --------------------------- //! `Iterable`, `Foldable`, and `make` //! //! The `Sequence` concept does not provide basic methods that could be //! used as a minimal complete definition; instead, it borrows methods //! from other concepts and add laws to them. For this reason, it is //! necessary to specialize the `Sequence` metafunction in Hana's //! namespace to tell Hana that a type is indeed a `Sequence`. Explicitly //! specializing the `Sequence` metafunction can be seen like a seal //! saying "this data type satisfies the additional laws of a `Sequence`", //! since those can't be checked by Hana automatically. //! //! //! Laws //! ---- //! The laws for being a `Sequence` are simple, and their goal is to //! restrict the semantics that can be associated to the functions //! provided by other concepts. First, a `Sequence` must be a finite //! `Iterable` (thus a `Foldable` too). Secondly, for a `Sequence` tag //! `S`, `make<S>(x1, ..., xn)` must be an object of tag `S` and whose //! linearization is `[x1, ..., xn]`. This basically ensures that objects //! of tag `S` are equivalent to their linearization, and that they can //! be created from such a linearization (with `make`). //! //! While it would be possible in theory to handle infinite sequences, //! doing so complicates the implementation of many algorithms. For //! simplicity, the current version of the library only handles finite //! sequences. However, note that this does not affect in any way the //! potential for having infinite `Searchable`s and `Iterable`s. //! //! //! Refined concepts //! ---------------- //! 1. `Comparable` (definition provided automatically)\n //! Two `Sequence`s are equal if and only if they contain the same number //! of elements and their elements at any given index are equal. //! @include example/sequence/comparable.cpp //! //! 2. `Orderable` (definition provided automatically)\n //! `Sequence`s are ordered using the traditional lexicographical ordering. //! @include example/sequence/orderable.cpp //! //! 3. `Functor` (definition provided automatically)\n //! `Sequence`s implement `transform` as the mapping of a function over //! each element of the sequence. This is somewhat equivalent to what //! `std::transform` does to ranges of iterators. Also note that mapping //! a function over an empty sequence returns an empty sequence and never //! applies the function, as would be expected. //! @include example/sequence/functor.cpp //! //! 4. `Applicative` (definition provided automatically)\n //! First, `lift`ing a value into a `Sequence` is the same as creating a //! singleton sequence containing that value. Second, applying a sequence //! of functions to a sequence of values will apply each function to //! all the values in the sequence, and then return a list of all the //! results. In other words, //! @code //! ap([f1, ..., fN], [x1, ..., xM]) == [ //! f1(x1), ..., f1(xM), //! ... //! fN(x1), ..., fN(xM) //! ] //! @endcode //! Example: //! @include example/sequence/applicative.cpp //! //! 5. `Monad` (definition provided automatically)\n //! First, `flaten`ning a `Sequence` takes a sequence of sequences and //! concatenates them to get a larger sequence. In other words, //! @code //! flatten([[a1, ..., aN], ..., [z1, ..., zM]]) == [ //! a1, ..., aN, ..., z1, ..., zM //! ] //! @endcode //! This acts like a `std::tuple_cat` function, except it receives a //! sequence of sequences instead of a variadic pack of sequences to //! flatten.\n //! __Example__: //! @include example/sequence/monad.ints.cpp //! Also note that the model of `Monad` for `Sequence`s can be seen as //! modeling nondeterminism. A nondeterministic computation can be //! modeled as a function which returns a sequence of possible results. //! In this line of thought, `chain`ing a sequence of values into such //! a function will return a sequence of all the possible output values, //! i.e. a sequence of all the values applied to all the functions in //! the sequences.\n //! __Example__: //! @include example/sequence/monad.types.cpp //! //! 6. `MonadPlus` (definition provided automatically)\n //! `Sequence`s are models of the `MonadPlus` concept by considering the //! empty sequence as the unit of `concat`, and sequence concatenation //! as `concat`. //! @include example/sequence/monad_plus.cpp //! //! 7. `Foldable`\n //! The model of `Foldable` for `Sequence`s is uniquely determined by the //! model of `Iterable`. //! @include example/sequence/foldable.cpp //! //! 8. `Iterable`\n //! The model of `Iterable` for `Sequence`s corresponds to iteration over //! each element of the sequence, in order. This model is not provided //! automatically, and it is in fact part of the minimal complete //! definition for the `Sequence` concept. //! @include example/sequence/iterable.cpp //! //! 9. `Searchable` (definition provided automatically)\n //! Searching through a `Sequence` is equivalent to just searching through //! a list of the values it contains. The keys and the values on which //! the search is performed are both the elements of the sequence. //! @include example/sequence/searchable.cpp //! //! //! Concrete models //! --------------- //! `hana::tuple` //! //! //! [1]: http://en.wikipedia.org/wiki/Isomorphism#Isomorphism_vs._bijective_morphism #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename S> struct Sequence; #else template <typename S, typename = void> struct Sequence : Sequence<S, when<true>> { }; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_SEQUENCE_HPP PK �\�[�k[�q q fwd/concept/applicative.hppnu �[��� /*! @file Forward declares `boost::hana::Applicative`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CONCEPT_APPLICATIVE_HPP #define BOOST_HANA_FWD_CONCEPT_APPLICATIVE_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Applicative Applicative //! The `Applicative` concept represents `Functor`s with the ability //! to lift values and combine computations. //! //! A `Functor` can only take a normal function and map it over a //! structure containing values to obtain a new structure containing //! values. Intuitively, an `Applicative` can also take a value and //! lift it into the structure. In addition, an `Applicative` can take //! a structure containing functions and apply it to a structure //! containing values to obtain a new structure containing values. //! By currying the function(s) inside the structure, it is then //! also possible to apply n-ary functions to n structures containing //! values. //! //! @note //! This documentation does not go into much details about the nature //! of applicatives. However, the [Typeclassopedia][1] is a nice //! Haskell-oriented resource where such information can be found. //! //! //! Minimal complete definition //! --------------------------- //! `lift` and `ap` satisfying the laws below. An `Applicative` must //! also be a `Functor`. //! //! //! Laws //! ---- //! Given an `Applicative` `F`, the following laws must be satisfied: //! 1. Identity\n //! For all objects `xs` of tag `F(A)`, //! @code //! ap(lift<F>(id), xs) == xs //! @endcode //! //! 2. Composition\n //! For all objects `xs` of tag `F(A)` and functions-in-an-applicative //! @f$ fs : F(B \to C) @f$, //! @f$ gs : F(A \to B) @f$, //! @code //! ap(ap(lift<F>(compose), fs, gs), xs) == ap(fs, ap(gs, xs)) //! @endcode //! //! 3. Homomorphism\n //! For all objects `x` of tag `A` and functions @f$ f : A \to B @f$, //! @code //! ap(lift<F>(f), lift<F>(x)) == lift<F>(f(x)) //! @endcode //! //! 4. Interchange\n //! For all objects `x` of tag `A` and functions-in-an-applicative //! @f$ fs : F(A \to B) @f$, //! @code //! ap(fs, lift<F>(x)) == ap(lift<F>(apply(-, x)), fs) //! @endcode //! where `apply(-, x)` denotes the partial application of the `apply` //! function from the @ref group-functional module to the `x` argument. //! //! As a consequence of these laws, the model of `Functor` for `F` will //! satisfy the following for all objects `xs` of tag `F(A)` and functions //! @f$ f : A \to B @f$: //! @code //! transform(xs, f) == ap(lift<F>(f), xs) //! @endcode //! //! //! Refined concept //! --------------- //! 1. `Functor` (free model)\n //! As a consequence of the laws, any `Applicative F` can be made a //! `Functor` by setting //! @code //! transform(xs, f) = ap(lift<F>(f), xs) //! @endcode //! //! //! Concrete models //! --------------- //! `hana::lazy`, `hana::optional`, `hana::tuple` //! //! //! @anchor applicative-transformation //! Structure-preserving functions //! ------------------------------ //! An _applicative transformation_ is a function @f$ t : F(X) \to G(X) @f$ //! between two Applicatives `F` and `G`, where `X` can be any tag, and //! which preserves the operations of an Applicative. In other words, for //! all objects `x` of tag `X`, functions-in-an-applicative //! @f$ fs : F(X \to Y) @f$ and objects `xs` of tag `F(X)`, //! @code //! t(lift<F>(x)) == lift<G>(x) //! t(ap(fs, xs)) == ap(t(fs), t(xs)) //! @endcode //! //! [1]: https://wiki.haskell.org/Typeclassopedia#Applicative template <typename A> struct Applicative; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_APPLICATIVE_HPP PK �\�[��"� � fwd/concept/functor.hppnu �[��� /*! @file Forward declares `boost::hana::Functor`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CONCEPT_FUNCTOR_HPP #define BOOST_HANA_FWD_CONCEPT_FUNCTOR_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Functor Functor //! The `Functor` concept represents types that can be mapped over. //! //! Intuitively, a [Functor][1] is some kind of box that can hold generic //! data and map a function over this data to create a new, transformed //! box. Because we are only interested in mapping a function over the //! contents of a black box, the only real requirement for being a functor //! is to provide a function which can do the mapping, along with a couple //! of guarantees that the mapping is well-behaved. Those requirements are //! made precise in the laws below. The pattern captured by `Functor` is //! very general, which makes it widely useful. A lot of objects can be //! made `Functor`s in one way or another, the most obvious example being //! sequences with the usual mapping of the function on each element. //! While this documentation will not go into much more details about //! the nature of functors, the [Typeclassopedia][2] is a nice //! Haskell-oriented resource for such information. //! //! Functors are parametric data types which are parameterized over the //! data type of the objects they contain. Like everywhere else in Hana, //! this parametricity is only at the documentation level and it is not //! enforced. //! //! In this library, the mapping function is called `transform` after the //! `std::transform` algorithm, but other programming languages have given //! it different names (usually `map`). //! //! @note //! The word _functor_ comes from functional programming, where the //! concept has been used for a while, notably in the Haskell programming //! language. Haskell people borrowed the term from [category theory][3], //! which, broadly speaking, is a field of mathematics dealing with //! abstract structures and transformations between those structures. //! //! //! Minimal complete definitions //! ---------------------------- //! 1. `transform`\n //! When `transform` is specified, `adjust_if` is defined analogously to //! @code //! adjust_if(xs, pred, f) = transform(xs, [](x){ //! if pred(x) then f(x) else x //! }) //! @endcode //! //! 2. `adjust_if`\n //! When `adjust_if` is specified, `transform` is defined analogously to //! @code //! transform(xs, f) = adjust_if(xs, always(true), f) //! @endcode //! //! //! Laws //! ---- //! Let `xs` be a Functor with tag `F(A)`, //! \f$ f : A \to B \f$ and //! \f$ g : B \to C \f$. //! The following laws must be satisfied: //! @code //! transform(xs, id) == xs //! transform(xs, compose(g, f)) == transform(transform(xs, f), g) //! @endcode //! The first line says that mapping the identity function should not do //! anything, which precludes the functor from doing something nasty //! behind the scenes. The second line states that mapping the composition //! of two functions is the same as mapping the first function, and then //! the second on the result. While the usual functor laws are usually //! restricted to the above, this library includes other convenience //! methods and they should satisfy the following equations. //! Let `xs` be a Functor with tag `F(A)`, //! \f$ f : A \to A \f$, //! \f$ \mathrm{pred} : A \to \mathrm{Bool} \f$ //! for some `Logical` `Bool`, and `oldval`, `newval`, `value` objects //! of tag `A`. Then, //! @code //! adjust(xs, value, f) == adjust_if(xs, equal.to(value), f) //! adjust_if(xs, pred, f) == transform(xs, [](x){ //! if pred(x) then f(x) else x //! }) //! replace_if(xs, pred, value) == adjust_if(xs, pred, always(value)) //! replace(xs, oldval, newval) == replace_if(xs, equal.to(oldval), newval) //! fill(xs, value) == replace_if(xs, always(true), value) //! @endcode //! The default definition of the methods will satisfy these equations. //! //! //! Concrete models //! --------------- //! `hana::lazy`, `hana::optional`, `hana::tuple` //! //! //! Structure-preserving functions for Functors //! ------------------------------------------- //! A mapping between two functors which also preserves the functor //! laws is called a natural transformation (the term comes from //! category theory). A natural transformation is a function `f` //! from a functor `F` to a functor `G` such that for every other //! function `g` with an appropriate signature and for every object //! `xs` of tag `F(X)`, //! @code //! f(transform(xs, g)) == transform(f(xs), g) //! @endcode //! //! There are several examples of such transformations, like `to<tuple_tag>` //! when applied to an optional value. Indeed, for any function `g` and //! `hana::optional` `opt`, //! @code //! to<tuple_tag>(transform(opt, g)) == transform(to<tuple_tag>(opt), g) //! @endcode //! //! Of course, natural transformations are not limited to the `to<...>` //! functions. However, note that any conversion function between Functors //! should be natural for the behavior of the conversion to be intuitive. //! //! //! [1]: http://en.wikipedia.org/wiki/Functor //! [2]: https://wiki.haskell.org/Typeclassopedia#Functor //! [3]: http://en.wikipedia.org/wiki/Category_theory template <typename F> struct Functor; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_FUNCTOR_HPP PK �\�[�|R�n n fwd/concept/struct.hppnu �[��� /*! @file Forward declares `boost::hana::Struct`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CONCEPT_STRUCT_HPP #define BOOST_HANA_FWD_CONCEPT_STRUCT_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Struct Struct //! The `Struct` concept represents `struct`-like user-defined types. //! //! The `Struct` concept allows restricted compile-time reflection over //! user-defined types. In particular, it allows accessing the names of //! the members of a user-defined type, and also the value of those //! members. `Struct`s can also be folded, searched and converted to //! some types of containers, where more advanced transformations can //! be performed. //! //! While all types can _in theory_ be made `Struct`s, only a subset of //! them are actually interesting to see as such. More precisely, it is //! only interesting to make a type a `Struct` when it is conceptually //! a C++ `struct`, i.e. a mostly dumb aggregate of named data. The way //! this data is accessed is mostly unimportant to the `Struct` concept; //! it could be through getters and setters, through public members, //! through non-member functions or it could even be generated on-the-fly. //! The important part, which is made precise below, is that those accessor //! methods should be move-independent. //! //! Another way to see a `Struct` is as a map where the keys are the names //! of the members and the values are the values of those members. However, //! there are subtle differences like the fact that one can't add a member //! to a `Struct`, and also that the order of the members inside a `Struct` //! plays a role in determining the equality of `Struct`s, which is not //! the case for maps. //! //! //! Minimal complete definition //! --------------------------- //! `accessors` //! //! A model of `Struct` is created by specifying a sequence of key/value //! pairs with the `accessors` function. The first element of a pair in //! this sequence represents the "name" of a member of the `Struct`, while //! the second element is a function which retrieves this member from an //! object. The "names" do not have to be in any special form; they just //! have to be compile-time `Comparable`. For example, it is common to //! provide "names" that are `hana::string`s representing the actual names //! of the members, but one could provide `hana::integral_constant`s just //! as well. The values must be functions which, when given an object, //! retrieve the appropriate member from it. //! //! There are several ways of providing the `accessors` method, some of //! which are more flexible and others which are more convenient. First, //! one can define it through tag-dispatching, as usual. //! @snippet example/struct.mcd.tag_dispatching.cpp main //! //! Secondly, it is possible to provide a nested `hana_accessors_impl` //! type, which should be equivalent to a specialization of //! `accessors_impl` for tag-dispatching. However, for a type `S`, this //! technique only works when the data type of `S` is `S` itself, which //! is the case unless you explicitly asked for something else. //! @snippet example/struct.mcd.nested.cpp main //! //! Finally, the most convenient (but least flexible) option is to use //! the `BOOST_HANA_DEFINE_STRUCT`, the `BOOST_HANA_ADAPT_STRUCT` or the //! `BOOST_HANA_ADAPT_ADT` macro, which provide a minimal syntactic //! overhead. See the documentation of these macros for details on how //! to use them. //! //! Also note that it is not important that the accessor functions retrieve //! an actual member of the struct (e.g. `x.member`). Indeed, an accessor //! function could call a custom getter or even compute the value of the //! member on the fly: //! @snippet example/struct.custom_accessor.cpp main //! //! The only important thing is that the accessor functions are //! move-independent, a notion which is defined below. //! //! //! @anchor move-independence //! Move-independence //! ----------------- //! The notion of move-independence presented here defines rigorously //! when it is legitimate to "double-move" from an object. //! //! A collection of functions `f1, ..., fn` sharing the same domain is //! said to be _move-independent_ if for every fresh (not moved-from) //! object `x` in the domain, any permutation of the following statements //! is valid and leaves the `zk` objects in a fresh (not moved-from) state: //! @code //! auto z1 = f1(std::move(x)); //! ... //! auto zn = fn(std::move(x)); //! @endcode //! //! @note //! In the special case where some functions return objects that can't be //! bound to with `auto zk =` (like `void` or a non-movable, non-copyable //! type), just pretend the return value is ignored. //! //! Intuitively, this ensures that we can treat `f1, ..., fn` as //! "accessors" that decompose `x` into independent subobjects, and //! that do so without moving from `x` more than that subobject. This //! is important because it allows us to optimally decompose `Struct`s //! into their subparts inside the library. //! //! //! Laws //! ---- //! For any `Struct` `S`, the accessors in the `accessors<S>()` sequence //! must be move-independent, as defined above. //! //! //! Refined concepts //! ---------------- //! 1. `Comparable` (free model)\n //! `Struct`s are required to be `Comparable`. Specifically, two `Struct`s //! of the same data type `S` must be equal if and only if all of their //! members are equal. By default, a model of `Comparable` doing just that //! is provided for models of `Struct`. In particular, note that the //! comparison of the members is made in the same order as they appear in //! the `hana::members` sequence. //! @include example/struct/comparable.cpp //! //! 2. `Foldable` (free model)\n //! A `Struct` can be folded by considering it as a list of pairs each //! containing the name of a member and the value associated to that //! member, in the same order as they appear in the `hana::members` //! sequence. By default, a model of `Foldable` doing just that is //! provided for models of the `Struct` concept. //! @include example/struct/foldable.cpp //! Being a model of `Foldable` makes it possible to turn a `Struct` //! into basically any `Sequence`, but also into a `hana::map` by simply //! using the `to<...>` function! //! @include example/struct/to.cpp //! //! 3. `Searchable` (free model)\n //! A `Struct` can be searched by considering it as a map where the keys //! are the names of the members of the `Struct`, and the values are the //! members associated to those names. By default, a model of `Searchable` //! is provided for any model of the `Struct` concept. //! @include example/struct/searchable.cpp template <typename S> struct Struct; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_STRUCT_HPP PK �\�[n�=�� � fwd/concept/comparable.hppnu �[��� /*! @file Forward declares `boost::hana::Comparable`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CONCEPT_COMPARABLE_HPP #define BOOST_HANA_FWD_CONCEPT_COMPARABLE_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Comparable Comparable //! The `Comparable` concept defines equality and inequality. //! //! Intuitively, `Comparable` objects must define a binary predicate named //! `equal` that returns whether both objects represent the same abstract //! value. In other words, `equal` must check for deep equality. Since //! "representing the same abstract value" is difficult to express //! formally, the exact meaning of equality is partially left to //! interpretation by the programmer with the following guidelines:\n //! 1. Equality should be compatible with copy construction; copy //! constructing a value yields an `equal` value. //! 2. Equality should be independent of representation; an object //! representing a fraction as `4/8` should be `equal` to an object //! representing a fraction as `2/4`, because they both represent //! the mathematical object `1/2`. //! //! Moreover, `equal` must exhibit properties that make it intuitive to //! use for determining the equivalence of objects, which is formalized //! by the laws for `Comparable`. //! //! //! Minimal complete definition //! --------------------------- //! 1. `equal`\n //! When `equal` is defined, `not_equal` is implemented by default as its //! complement. For all objects `x`, `y` of a `Comparable` tag, //! @code //! not_equal(x, y) == not_(equal(x, y)) //! @endcode //! //! //! Laws //! ---- //! `equal` must define an [equivalence relation][1], and `not_equal` must //! be its complement. In other words, for all objects `a`, `b`, `c` with //! a `Comparable` tag, the following must hold: //! @code //! equal(a, a) // Reflexivity //! if equal(a, b) then equal(b, a) // Symmetry //! if equal(a, b) && equal(b, c) then equal(a, c) // Transitivity //! not_equal(a, b) is equivalent to not_(equal(a, b)) //! @endcode //! //! //! Concrete models //! --------------- //! `hana::integral_constant`, `hana::map`, `hana::optional`, `hana::pair`, //! `hana::range`, `hana::set`, `hana::string`, `hana::tuple`, //! `hana::type` //! //! //! Free model for `EqualityComparable` data types //! ---------------------------------------------- //! Two data types `T` and `U` that model the cross-type EqualityComparable //! concept presented in [N3351][2] automatically model the `Comparable` //! concept by setting //! @code //! equal(x, y) = (x == y) //! @endcode //! Note that this also makes EqualityComparable types in the //! [usual sense][3] models of `Comparable` in the same way. //! //! //! Equality-preserving functions //! ----------------------------- //! Let `A` and `B` be two `Comparable` tags. A function @f$f : A \to B@f$ //! is said to be equality-preserving if it preserves the structure of the //! `Comparable` concept, which can be rigorously stated as follows. For //! all objects `x`, `y` of tag `A`, //! @code //! if equal(x, y) then equal(f(x), f(y)) //! @endcode //! Equivalently, we simply require that `f` is a function in the usual //! mathematical sense. Another property is [injectivity][4], which can be //! viewed as being a "lossless" mapping. This property can be stated as //! @code //! if equal(f(x), f(y)) then equal(x, y) //! @endcode //! This is equivalent to saying that `f` maps distinct elements to //! distinct elements, hence the "lossless" analogy. In other words, `f` //! will not collapse distinct elements from its domain into a single //! element in its image, thus losing information. //! //! These functions are very important, especially equality-preserving //! ones, because they allow us to reason simply about programs. Also //! note that the property of being equality-preserving is taken for //! granted in mathematics because it is part of the definition of a //! function. We feel it is important to make the distinction here //! because programming has evolved differently and as a result //! programmers are used to work with functions that do not preserve //! equality. //! //! //! Cross-type version of the methods //! --------------------------------- //! The `equal` and `not_equal` methods are "overloaded" to handle //! distinct tags with certain properties. Specifically, they are //! defined for _distinct_ tags `A` and `B` such that //! 1. `A` and `B` share a common tag `C`, as determined by the //! `common` metafunction //! 2. `A`, `B` and `C` are all `Comparable` when taken individually //! 3. @f$ \mathtt{to<C>} : A \to C @f$ and @f$\mathtt{to<C>} : B \to C@f$ //! are both equality-preserving and injective (i.e. they are embeddings), //! as determined by the `is_embedding` metafunction. //! //! The method definitions for tags satisfying the above properties are //! @code //! equal(x, y) = equal(to<C>(x), to<C>(y)) //! not_equal(x, y) = not_equal(to<C>(x), to<C>(y)) //! @endcode //! //! //! Important note: special behavior of `equal` //! ------------------------------------------- //! In the context of programming with heterogeneous values, it is useful //! to have unrelated objects compare `false` instead of triggering an //! error. For this reason, `equal` adopts a special behavior for //! unrelated objects of tags `T` and `U` that do not satisfy the above //! requirements for the cross-type overloads. Specifically, when `T` and //! `U` are unrelated (i.e. `T` can't be converted to `U` and vice-versa), //! comparing objects with those tags yields a compile-time false value. //! This has the effect that unrelated objects like `float` and //! `std::string` will compare false, while comparing related objects that //! can not be safely embedded into the same super structure (like //! `long long` and `float` because of the precision loss) will trigger a //! compile-time assertion. Also note that for any tag `T` for which the //! minimal complete definition of `Comparable` is not provided, a //! compile-time assertion will also be triggered because `T` and `T` //! trivially share the common tag `T`, which is the expected behavior. //! This design choice aims to provide more flexibility for comparing //! objects, while still rejecting usage patterns that are most likely //! programming errors. //! //! //! [1]: http://en.wikipedia.org/wiki/Equivalence_relation#Definition //! [2]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3351.pdf //! [3]: http://en.cppreference.com/w/cpp/named_req/EqualityComparable //! [4]: http://en.wikipedia.org/wiki/Injective_function template <typename T> struct Comparable; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_COMPARABLE_HPP PK �\�[DD�g g fwd/concept/euclidean_ring.hppnu �[��� /*! @file Forward declares `boost::hana::EuclideanRing`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CONCEPT_EUCLIDEAN_RING_HPP #define BOOST_HANA_FWD_CONCEPT_EUCLIDEAN_RING_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-EuclideanRing Euclidean Ring //! The `EuclideanRing` concept represents a commutative `Ring` that //! can also be endowed with a division algorithm. //! //! A Ring defines a binary operation often called _multiplication_ that //! can be used to combine two elements of the ring into a new element of //! the ring. An [Euclidean ring][1], also called an Euclidean domain, adds //! the ability to define a special function that generalizes the Euclidean //! division of integers. //! //! However, an Euclidean ring must also satisfy one more property, which //! is that of having no non-zero zero divisors. In a Ring `(R, +, *)`, it //! follows quite easily from the axioms that `x * 0 == 0` for any ring //! element `x`. However, there is nothing that mandates `0` to be the //! only ring element sending other elements to `0`. Hence, in some Rings, //! it is possible to have elements `x` and `y` such that `x * y == 0` //! while not having `x == 0` nor `y == 0`. We call these elements divisors //! of zero, or zero divisors. For example, this situation arises in the //! Ring of integers modulo 4 (the set `{0, 1, 2, 3}`) with addition and //! multiplication `mod 4` as binary operations. In this case, we have that //! @code //! 2 * 2 == 4 //! == 0 (mod 4) //! @endcode //! even though `2 != 0 (mod 4)`. //! //! Following this line of thought, an Euclidean ring requires its only //! zero divisor is zero itself. In other words, the multiplication in an //! Euclidean won't send two non-zero elements to zero. Also note that //! since multiplication in a `Ring` is not necessarily commutative, it //! is not always the case that //! @code //! x * y == 0 implies y * x == 0 //! @endcode //! To be rigorous, we should then distinguish between elements that are //! zero divisors when multiplied to the right and to the left. //! Fortunately, the concept of an Euclidean ring requires the Ring //! multiplication to be commutative. Hence, //! @code //! x * y == y * x //! @endcode //! and we do not have to distinguish between left and right zero divisors. //! //! Typical examples of Euclidean rings include integers and polynomials //! over a field. The method names used here refer to the Euclidean ring //! of integers under the usual addition, multiplication and division //! operations. //! //! //! Minimal complete definition //! --------------------------- //! `div` and `mod` satisfying the laws below //! //! //! Laws //! ---- //! To simplify the reading, we will use the `+`, `*`, `/` and `%` //! operators with infix notation to denote the application of the //! corresponding methods in Monoid, Group, Ring and EuclideanRing. //! For all objects `a` and `b` of an `EuclideanRing` `R`, the //! following laws must be satisfied: //! @code //! a * b == b * a // commutativity //! (a / b) * b + a % b == a if b is non-zero //! zero<R>() % b == zero<R>() if b is non-zero //! @endcode //! //! //! Refined concepts //! ---------------- //! `Monoid`, `Group`, `Ring` //! //! //! Concrete models //! --------------- //! `hana::integral_constant` //! //! //! Free model for non-boolean integral data types //! ---------------------------------------------- //! A data type `T` is integral if `std::is_integral<T>::%value` is true. //! For a non-boolean integral data type `T`, a model of `EuclideanRing` //! is automatically defined by using the `Ring` model provided for //! arithmetic data types and setting //! @code //! div(x, y) = (x / y) //! mod(x, y) = (x % y) //! @endcode //! //! @note //! The rationale for not providing an EuclideanRing model for `bool` is //! the same as for not providing Monoid, Group and Ring models. //! //! //! [1]: https://en.wikipedia.org/wiki/Euclidean_domain template <typename R> struct EuclideanRing; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_EUCLIDEAN_RING_HPP PK �\�[��� fwd/concept/metafunction.hppnu �[��� /*! @file Forward declares `boost::hana::Metafunction`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CONCEPT_METAFUNCTION_HPP #define BOOST_HANA_FWD_CONCEPT_METAFUNCTION_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Metafunction Metafunction //! A `Metafunction` is a function that takes `hana::type`s as inputs and //! returns a `hana::type` as output. //! //! A `Metafunction` is an object satisfying the [FunctionObject][1] //! concept, but with additional requirements. First, it must be possible //! to apply a `Metafunction` to arguments whose tag is `type_tag`, and //! the result of such an application must be an object whose tag is also //! `type_tag`. Note that `hana::type` and `hana::basic_type` are the //! only such types. //! //! Secondly, a `Metafunction` must provide a nested `::%apply` template //! which allows performing the same type-level computation as is done by //! the call operator. In Boost.MPL parlance, a `Metafunction` `F` is //! hence a [MetafunctionClass][2] in addition to being a `FunctionObject`. //! Rigorously, the following must be satisfied by any object `f` of type //! `F` which is a `Metafunction`, and for arbitrary types `T...`: //! @code //! f(hana::type_c<T>...) == hana::type_c<F::apply<T...>::type> //! @endcode //! //! Thirdly, to ease the inter-operation of values and types, //! `Metafunction`s must also allow being called with arguments that //! are not `hana::type`s. In that case, the result is equivalent to //! calling the metafunction on the types of the arguments. Rigorously, //! this means that for arbitrary objects `x...`, //! @code //! f(x...) == f(hana::type_c<decltype(x)>...) //! @endcode //! //! //! Minimal complete definition //! --------------------------- //! The `Metafunction` concept does not have a minimal complete definition //! in terms of tag-dispatched methods. Instead, the syntactic requirements //! documented above should be satisfied, and the `Metafunction` struct //! should be specialized explicitly in Hana's namespace. //! //! //! Concrete models //! --------------- //! `hana::metafunction`, `hana::metafunction_class`, `hana::template_` //! //! //! Rationale: Why aren't `Metafunction`s `Comparable`? //! --------------------------------------------------- //! When seeing `hana::template_`, a question that naturally arises is //! whether `Metafunction`s should be made `Comparable`. Indeed, it //! would seem to make sense to compare two templates `F` and `G` with //! `template_<F> == template_<G>`. However, in the case where `F` and/or //! `G` are alias templates, it makes sense to talk about two types of //! comparisons. The first one is _shallow_ comparison, and it determines //! that two alias templates are equal if they are the same alias //! template. The second one is _deep_ comparison, and it determines //! that two template aliases are equal if they alias the same type for //! any template argument. For example, given `F` and `G` defined as //! @code //! template <typename T> //! using F = void; //! //! template <typename T> //! using G = void; //! @endcode //! //! shallow comparison would determine that `F` and `G` are different //! because they are two different template aliases, while deep comparison //! would determine that `F` and `G` are equal because they always //! expand to the same type, `void`. Unfortunately, deep comparison is //! impossible to implement because one would have to check `F` and `G` //! on all possible types. On the other hand, shallow comparison is not //! satisfactory because `Metafunction`s are nothing but functions on //! `type`s, and the equality of two functions is normally defined with //! deep comparison. Hence, we adopt a conservative stance and avoid //! providing comparison for `Metafunction`s. //! //! [1]: http://en.cppreference.com/w/cpp/named_req/FunctionObject //! [2]: http://www.boost.org/doc/libs/release/libs/mpl/doc/refmanual/metafunction-class.html template <typename F> struct Metafunction; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_METAFUNCTION_HPP PK �\�[bzy�� � fwd/concept/monoid.hppnu �[��� /*! @file Forward declares `boost::hana::Monoid`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CONCEPT_MONOID_HPP #define BOOST_HANA_FWD_CONCEPT_MONOID_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Monoid Monoid //! The `Monoid` concept represents data types with an associative //! binary operation that has an identity. //! //! Specifically, a [Monoid][1] is a basic algebraic structure typically //! used in mathematics to construct more complex algebraic structures //! like `Group`s, `Ring`s and so on. They are useful in several contexts, //! notably to define the properties of numbers in a granular way. At its //! core, a `Monoid` is a set `S` of objects along with a binary operation //! (let's say `+`) that is associative and that has an identity in `S`. //! There are many examples of `Monoid`s: //! - strings with concatenation and the empty string as the identity //! - integers with addition and `0` as the identity //! - integers with multiplication and `1` as the identity //! - many others... //! //! As you can see with the integers, there are some sets that can be //! viewed as a monoid in more than one way, depending on the choice //! of the binary operation and identity. The method names used here //! refer to the monoid of integers under addition; `plus` is the binary //! operation and `zero` is the identity element of that operation. //! //! //! Minimal complete definition //! --------------------------- //! `plus` and `zero` satisfying the laws //! //! //! Laws //! ---- //! For all objects `x`, `y` and `z` of a `Monoid` `M`, the following //! laws must be satisfied: //! @code //! plus(zero<M>(), x) == x // left zero //! plus(x, zero<M>()) == x // right zero //! plus(x, plus(y, z)) == plus(plus(x, y), z) // associativity //! @endcode //! //! //! Concrete models //! --------------- //! `hana::integral_constant` //! //! //! Free model for non-boolean arithmetic data types //! ------------------------------------------------ //! A data type `T` is arithmetic if `std::is_arithmetic<T>::%value` is //! true. For a non-boolean arithmetic data type `T`, a model of `Monoid` //! is automatically defined by setting //! @code //! plus(x, y) = (x + y) //! zero<T>() = static_cast<T>(0) //! @endcode //! //! > #### Rationale for not making `bool` a `Monoid` by default //! > First, it makes no sense whatsoever to define an additive `Monoid` //! > over the `bool` type. Also, it could make sense to define a `Monoid` //! > with logical conjunction or disjunction. However, C++ allows `bool`s //! > to be added, and the method names of this concept really suggest //! > addition. In line with the principle of least surprise, no model //! > is provided by default. //! //! //! Structure-preserving functions //! ------------------------------ //! Let `A` and `B` be two `Monoid`s. A function `f : A -> B` is said //! to be a [Monoid morphism][2] if it preserves the monoidal structure //! between `A` and `B`. Rigorously, for all objects `x, y` of data //! type `A`, //! @code //! f(plus(x, y)) == plus(f(x), f(y)) //! f(zero<A>()) == zero<B>() //! @endcode //! Functions with these properties interact nicely with `Monoid`s, which //! is why they are given such a special treatment. //! //! //! [1]: http://en.wikipedia.org/wiki/Monoid //! [2]: http://en.wikipedia.org/wiki/Monoid#Monoid_homomorphisms template <typename M> struct Monoid; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_MONOID_HPP PK �\�[C Vu fwd/concept/orderable.hppnu �[��� /*! @file Forward declares `boost::hana::Orderable`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CONCEPT_ORDERABLE_HPP #define BOOST_HANA_FWD_CONCEPT_ORDERABLE_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Orderable Orderable //! The `Orderable` concept represents totally ordered data types. //! //! Intuitively, `Orderable` objects must define a binary predicate named //! `less` returning whether the first argument is to be considered less //! than the second argument. The word "total" means that _distinct_ //! objects must always be ordered; if `a` and `b` are not equal, then //! exactly one of `less(a, b)` and `less(b, a)` must be true. This is //! a contrast with weaker kinds of orders that would allow some objects //! to be incomparable (neither less than nor greater than). Also note //! that a non-strict total order may always be obtained from a strict //! total order (and vice-versa) by setting //! @code //! a <= b = !(b < a) //! a < b = !(b <= a) //! @endcode //! The non-strict version is used in the description of the laws because //! it makes them easier to parse for humans, but they could be formulated //! equivalently using the strict order. //! //! //! Minimal complete definition //! --------------------------- //! `less` //! //! When `less` is defined, the other methods are defined from it using //! the same definition as mandated in the laws below. //! //! //! Laws //! ---- //! Rigorously speaking, a [total order][1] `<=` on a set `S` is a binary //! predicate @f$ <= \;: S \times S \to bool @f$ such that for all //! `a`, `b`, `c` in `S`, //! @code //! if a <= b and b <= a then a == b // Antisymmetry //! if a <= b and b <= c then a <= c // Transitivity //! either a <= b or b <= a // Totality //! @endcode //! Additionally, the `less`, `greater` and `greater_equal` methods should //! have the following intuitive meanings: //! @code //! a < b if and only if !(b <= a) //! a > b if and only if b < a //! a >= b if and only if !(a < b) //! @endcode //! //! //! Refined concept //! --------------- //! 1. `Comparable` (free model)\n //! Since `Orderable` requires `less_equal` to be a total order, a model //! of `Comparable` may always be obtained by setting //! @code //! equal(x, y) = less_equal(x, y) && less_equal(y, x) //! @endcode //! //! //! Concrete models //! --------------- //! `hana::integral_constant`, `hana::optional`, `hana::pair`, //! `hana::string`, `hana::tuple` //! //! //! Free model for `LessThanComparable` data types //! ---------------------------------------------- //! Two data types `T` and `U` that model the cross-type version of the //! usual [LessThanComparable][2] C++ concept are automatically a model //! of `Orderable` by setting //! @code //! less(x, y) = (x < y) //! @endcode //! The cross-type version of the LessThanComparable concept is analogous //! to the cross-type version of the EqualityComparable concept presented //! in [N3351][3], which is compatible with the usual single type //! definition. //! However, note that the LessThanComparable concept only requires `<` //! to be a [strict weak ordering][4], which is a weaker requirement //! than being a total order. Hence, if `less` is used with objects //! of a LessThanComparable data type that do not define a total order, //! some algorithms may have an unexpected behavior. It is the author's //! opinion that defining `operator<` as a non-total order is a bad idea, //! but this is debatable and so the design choice of providing a model //! for LessThanComparable data types is open to debate. Waiting for //! some user input. //! //! //! Order-preserving functions //! -------------------------- //! Let `A` and `B` be two `Orderable` data types. A function //! @f$ f : A \to B@f$ is said to be order-preserving (also called //! monotone) if it preserves the structure of the `Orderable` concept, //! which can be rigorously stated as follows. For all objects `x`, `y` //! of data type `A`, //! @code //! if less(x, y) then less(f(x), f(y)) //! @endcode //! Another important property is that of being order-reflecting, which //! can be stated as //! @code //! if less(f(x), f(y)) then less(x, y) //! @endcode //! We say that a function is an order-embedding if it is both //! order-preserving and order-reflecting, i.e. if //! @code //! less(x, y) if and only if less(f(x), f(y)) //! @endcode //! //! //! Cross-type version of the methods //! --------------------------------- //! The comparison methods (`less`, `less_equal`, `greater` and //! `greater_equal`) are "overloaded" to handle distinct data types //! with certain properties. Specifically, they are defined for //! _distinct_ data types `A` and `B` such that //! 1. `A` and `B` share a common data type `C`, as determined by the //! `common` metafunction //! 2. `A`, `B` and `C` are all `Orderable` when taken individually //! 3. @f$\mathrm{to<C>} : A \to C@f$ and @f$\mathrm{to<C>} : B \to C@f$ //! are both order-embeddings as determined by the `is_embedding` //! metafunction. //! //! The method definitions for data types satisfying the above //! properties are //! @code //! less(x, y) = less(to<C>(x), to<C>(y)) //! less_equal(x, y) = less_equal(to<C>(x), to<C>(y)) //! greater_equal(x, y) = greater_equal(to<C>(x), to<C>(y)) //! greater(x, y) = greater(to<C>(x), to<C>(y)) //! @endcode //! //! //! Partial application of the methods //! ---------------------------------- //! The `less`, `greater`, `less_equal` and `greater_equal` methods can //! be called in two different ways. First, they can be called like //! normal functions: //! @code //! less(x, y) //! greater(x, y) //! //! less_equal(x, y) //! greater_equal(x, y) //! @endcode //! //! However, they may also be partially applied to an argument as follows: //! @code //! less.than(x)(y) == less(y, x) //! greater.than(x)(y) == greater(y, x) //! //! less_equal.than(x)(y) == less_equal(y, x) //! greater_equal.than(x)(y) == greater_equal(y, x) //! @endcode //! //! Take good note that the order of the arguments is reversed, so //! for example `less.than(x)(y)` is equivalent to `less(y, x)`, not //! `less(x, y)`. This is because those variants are meant to be used //! with higher order algorithms, where the chosen application order //! makes sense. //! //! //! [1]: http://en.wikipedia.org/wiki/Total_order //! [2]: http://en.cppreference.com/w/cpp/named_req/LessThanComparable //! [3]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3351.pdf //! [4]: http://en.wikipedia.org/wiki/Strict_weak_ordering template <typename Ord> struct Orderable; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_ORDERABLE_HPP PK �\�[�t��o o fwd/concept/product.hppnu �[��� /*! @file Forward declares `boost::hana::Product`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CONCEPT_PRODUCT_HPP #define BOOST_HANA_FWD_CONCEPT_PRODUCT_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Product Product //! Represents types that are generic containers of two elements. //! //! This concept basically represents types that are like `std::pair`. //! The motivation for making such a precise concept is similar to the //! motivation behind the `Sequence` concept; there are many different //! implementations of `std::pair` in different libraries, and we would //! like to manipulate any of them generically. //! //! Since a `Product` is basically a pair, it is unsurprising that the //! operations provided by this concept are getting the first and second //! element of a pair, creating a pair from two elements and other //! simmilar operations. //! //! @note //! Mathematically, this concept represents types that are category //! theoretical [products][1]. This is also where the name comes //! from. //! //! //! Minimal complete definition //! --------------------------- //! `first`, `second` and `make` //! //! `first` and `second` must obviously return the first and the second //! element of the pair, respectively. `make` must take two arguments `x` //! and `y` representing the first and the second element of the pair, //! and return a pair `p` such that `first(p) == x` and `second(p) == y`. //! @include example/product/make.cpp //! //! //! Laws //! ---- //! For a model `P` of `Product`, the following laws must be satisfied. //! For every data types `X` and `Y`, there must be a unique function //! @f$ \mathtt{make} : X \times Y \to P @f$ such that for every `x`, `y`, //! @code //! x == first(make<P>(x, y)) //! y == second(make<P>(x, y)) //! @endcode //! //! @note //! This law is less general than the universal property typically used to //! define category theoretical products, but it is vastly enough for what //! we need. //! //! This is basically saying that a `Product` must be the most general //! object able to contain a pair of objects `(P1, P2)`, but nothing //! more. Since the categorical product is defined by a universal //! property, all the models of this concept are isomorphic, and //! the isomorphism is unique. In other words, there is one and only //! one way to convert one `Product` to another. //! //! Another property that must be satisfied by `first` and `second` is //! that of @ref move-independence, which ensures that we can optimally //! decompose a `Product` into its two members without making redundant //! copies. //! //! //! Refined concepts //! ---------------- //! 1. `Comparable` (free model)\n //! Two products `x` and `y` are equal iff they are equal element-wise, //! by comparing the first element before the second element. //! @include example/product/comparable.cpp //! //! 2. `Orderable` (free model)\n //! Products are ordered using a lexicographical ordering as-if they //! were 2-element tuples. //! //! 3. `Foldable` (free model)\n //! Folding a `Product` `p` is equivalent to folding a list containing //! `first(p)` and `second(p)`, in that order. //! //! //! Concrete models //! --------------- //! `hana::pair` //! //! //! [1]: http://en.wikipedia.org/wiki/Product_(category_theory) template <typename P> struct Product; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_PRODUCT_HPP PK �\�[�ǧ. . fwd/concept/ring.hppnu �[��� /*! @file Forward declares `boost::hana::Ring`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CONCEPT_RING_HPP #define BOOST_HANA_FWD_CONCEPT_RING_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Ring Ring //! The `Ring` concept represents `Group`s that also form a `Monoid` //! under a second binary operation that distributes over the first. //! //! A [Ring][1] is an algebraic structure built on top of a `Group` //! which requires a monoidal structure with respect to a second binary //! operation. This second binary operation must distribute over the //! first one. Specifically, a `Ring` is a triple `(S, +, *)` such that //! `(S, +)` is a `Group`, `(S, *)` is a `Monoid` and `*` distributes //! over `+`, i.e. //! @code //! x * (y + z) == (x * y) + (x * z) //! @endcode //! //! The second binary operation is often written `*` with its identity //! written `1`, in reference to the `Ring` of integers under //! multiplication. The method names used here refer to this exact ring. //! //! //! Minimal complete definintion //! ---------------------------- //! `one` and `mult` satisfying the laws //! //! //! Laws //! ---- //! For all objects `x`, `y`, `z` of a `Ring` `R`, the following laws must //! be satisfied: //! @code //! mult(x, mult(y, z)) == mult(mult(x, y), z) // associativity //! mult(x, one<R>()) == x // right identity //! mult(one<R>(), x) == x // left identity //! mult(x, plus(y, z)) == plus(mult(x, y), mult(x, z)) // distributivity //! @endcode //! //! //! Refined concepts //! ---------------- //! `Monoid`, `Group` //! //! //! Concrete models //! --------------- //! `hana::integral_constant` //! //! //! Free model for non-boolean arithmetic data types //! ------------------------------------------------ //! A data type `T` is arithmetic if `std::is_arithmetic<T>::%value` is //! true. For a non-boolean arithmetic data type `T`, a model of `Ring` is //! automatically defined by using the provided `Group` model and setting //! @code //! mult(x, y) = (x * y) //! one<T>() = static_cast<T>(1) //! @endcode //! //! @note //! The rationale for not providing a Ring model for `bool` is the same //! as for not providing Monoid and Group models. //! //! //! Structure-preserving functions //! ------------------------------ //! Let `A` and `B` be two `Ring`s. A function `f : A -> B` is said to //! be a [Ring morphism][2] if it preserves the ring structure between //! `A` and `B`. Rigorously, for all objects `x, y` of data type `A`, //! @code //! f(plus(x, y)) == plus(f(x), f(y)) //! f(mult(x, y)) == mult(f(x), f(y)) //! f(one<A>()) == one<B>() //! @endcode //! Because of the `Ring` structure, it is easy to prove that the //! following will then also be satisfied: //! @code //! f(zero<A>()) == zero<B>() //! f(negate(x)) == negate(f(x)) //! @endcode //! which is to say that `f` will then also be a `Group` morphism. //! Functions with these properties interact nicely with `Ring`s, //! which is why they are given such a special treatment. //! //! //! [1]: http://en.wikipedia.org/wiki/Ring_(mathematics) //! [2]: http://en.wikipedia.org/wiki/Ring_homomorphism template <typename R> struct Ring; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_RING_HPP PK �\�[�O��L L fwd/concept/monad_plus.hppnu �[��� /*! @file Forward declares `boost::hana::MonadPlus`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CONCEPT_MONAD_PLUS_HPP #define BOOST_HANA_FWD_CONCEPT_MONAD_PLUS_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-MonadPlus MonadPlus //! The `MonadPlus` concept represents Monads with a monoidal structure. //! //! Intuitively, whereas a Monad can be seen as some kind of container //! or context, a MonadPlus can be seen as a container or a context that //! can be concatenated with other containers or contexts. There must //! also be an identity element for this combining operation. For example, //! a tuple is a MonadPlus, because tuples can be concatenated and the //! empty tuple would act as an identity for concatenation. How is this //! different from a Monad which is also a Monoid? The answer is that the //! monoidal structure on a MonadPlus must _not_ depend of the contents //! of the structure; it must not require the contents to be a Monoid //! in order to work. //! //! While sequences are not the only possible model for MonadPlus, the //! method names used here refer to the MonadPlus of sequences under //! concatenation. Several useful functions generalizing operations on //! sequences are included with this concept, like `append`, `prepend` //! and `filter`. //! //! @note //! This documentation does not go into much details about the nature //! of the MonadPlus concept. However, there is a nice Haskell-oriented //! [WikiBook][1] going into further details. //! //! //! Minimal complete definition //! --------------------------- //! `concat` and `empty` //! //! //! Laws //! ---- //! First, a MonadPlus is required to have a monoidal structure. Hence, it //! is no surprise that for any MonadPlus `M`, we require `M(T)` to be a //! valid monoid. However, we do not enforce that `M(T)` actually models //! the Monoid concept provided by Hana. Further, for all objects `a, b, c` //! of data type `M(T)`, //! @code //! // identity //! concat(empty<M(T)>(), a) == a //! concat(a, empty<M(T)>()) == a //! //! // associativity //! concat(a, concat(b, c)) == concat(concat(a, b), c) //! @endcode //! //! Secondly, a MonadPlus is also required to obey the following laws, //! which represent the fact that `empty<M(T)>()` must be some kind of //! absorbing element for the `chain` operation. For all objects `a` of //! data type `M(T)` and functions @f$ f : T \to M(U) @f$, //! @code //! chain(empty<M(T)>(), f) == empty<M(U)>() //! chain(a, always(empty<M(T)>())) == empty<M(U)>() //! @endcode //! //! //! Refined concepts //! ---------------- //! `Functor`, `Applicative` and `Monad` //! //! //! Concrete models //! --------------- //! `hana::optional`, `hana::tuple` //! //! [1]: https://en.wikibooks.org/wiki/Haskell/MonadPlus template <typename M> struct MonadPlus; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_MONAD_PLUS_HPP PK �\�[�5�+ + fwd/union.hppnu �[��� /*! @file Forward declares `boost::hana::union_`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_UNION_HPP #define BOOST_HANA_FWD_UNION_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN // Note: This function is documented per datatype/concept only. //! @cond template <typename T, typename = void> struct union_impl : union_impl<T, when<true>> { }; //! @endcond struct union_t { template <typename Xs, typename Ys> constexpr auto operator()(Xs&&, Ys&&) const; }; constexpr union_t union_{}; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_UNION_HPP PK �\�[Zi��Y Y fwd/ap.hppnu �[��� /*! @file Forward declares `boost::hana::ap`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_AP_HPP #define BOOST_HANA_FWD_AP_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Lifted application. //! @ingroup group-Applicative //! //! Specifically, `ap` applies a structure containing functions to a //! structure containing values, and returns a new structure containing //! values. The exact way in which the functions are applied to the values //! depends on the `Applicative`. //! //! `ap` can be called with two arguments or more; the functions in the `f` //! structure are curried and then applied to the values in each `x...` //! structure using the binary form of `ap`. Note that this requires the //! number of `x...` must match the arity of the functions in the `f` //! structure. In other words, `ap(f, x1, ..., xN)` is equivalent to //! @code //! ((curry(f) ap x1) ap x2) ... ap xN //! @endcode //! where `x ap y` is just `ap(x, y)` written in infix notation to //! emphasize the left associativity. //! //! //! Signature //! --------- //! Given an Applicative `A`, the signature is //! @f$ \mathtt{ap} : A(T_1 \times \cdots \times T_n \to U) //! \times A(T_1) \times \cdots \times A(T_n) //! \to A(U) @f$. //! //! @param f //! A structure containing function(s). //! //! @param x... //! Structure(s) containing value(s) and on which `f` is applied. The //! number of structures must match the arity of the functions in the //! `f` structure. //! //! //! Example //! ------- //! @include example/ap.cpp //! //! @todo //! Consider giving access to all the arguments to the tag-dispatched //! implementation for performance purposes. #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto ap = [](auto&& f, auto&& ...x) -> decltype(auto) { return tag-dispatched; }; #else template <typename A, typename = void> struct ap_impl : ap_impl<A, when<true>> { }; struct ap_t { template <typename F, typename X> constexpr decltype(auto) operator()(F&& f, X&& x) const; template <typename F, typename ...Xs> constexpr decltype(auto) operator()(F&& f, Xs&& ...xs) const; }; constexpr ap_t ap{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_AP_HPP PK �\�[D�ێ� � fwd/less_equal.hppnu �[��� /*! @file Forward declares `boost::hana::less_equal`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_LESS_EQUAL_HPP #define BOOST_HANA_FWD_LESS_EQUAL_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/nested_than_fwd.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns a `Logical` representing whether `x` is less than or //! equal to `y`. //! @ingroup group-Orderable //! //! //! Signature //! --------- //! Given a Logical `Bool` and two Orderables `A` and `B` with a common //! embedding, the signature is //! @f$ \mathrm{less\_equal} : A \times B \to Bool @f$. //! //! @param x, y //! Two objects to compare. //! //! //! Example //! ------- //! @include example/less_equal.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto less_equal = [](auto&& x, auto&& y) { return tag-dispatched; }; #else template <typename T, typename U, typename = void> struct less_equal_impl : less_equal_impl<T, U, when<true>> { }; struct less_equal_t : detail::nested_than<less_equal_t> { template <typename X, typename Y> constexpr auto operator()(X&& x, Y&& y) const; }; constexpr less_equal_t less_equal{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_LESS_EQUAL_HPP PK �\�[)^WT T fwd/core/make.hppnu �[��� /*! @file Forward declares `boost::hana::make`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CORE_MAKE_HPP #define BOOST_HANA_FWD_CORE_MAKE_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-core //! Create an object of the given tag with the given arguments. //! //! This function serves the same purpose as constructors in usual C++. //! However, instead of creating an object of a specific C++ type, it //! creates an object of a specific tag, regardless of the C++ type //! of that object. //! //! This function is actually a variable template, so `make<T>` can be //! passed around as a function object creating an object of tag `T`. //! Also, it uses tag-dispatching so this is how it should be customized //! for user-defined tags. //! //! Finally, the default implementation of `make` is equivalent to calling //! the constructor of the given tag with the corresponding arguments. //! In other words, by default, //! @code //! make<T>(args...) == T(args...) //! @endcode //! //! Note that the arguments are perfectly forwarded and the form of //! construction which is used is exactly as documented, i.e. `T(args...)`. //! However, if `T(args...)` is not a valid expression, a compilation //! error is triggered. This default behavior is useful because it makes //! foreign C++ types that have no notion of tag constructible with `make` //! out-of-the-box, since their tag is exactly themselves. //! //! //! Example //! ------- //! @include example/core/make.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename Tag> constexpr auto make = [](auto&& ...x) -> decltype(auto) { return tag-dispatched; }; #else template <typename Tag, typename = void> struct make_impl; template <typename Tag> struct make_t { template <typename ...X> constexpr decltype(auto) operator()(X&& ...x) const { return make_impl<Tag>::apply(static_cast<X&&>(x)...); } }; template <typename Tag> constexpr make_t<Tag> make{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CORE_MAKE_HPP PK �\�[�$ � � fwd/core/when.hppnu �[��� /*! @file Forward declares `boost::hana::when` and `boost::hana::when_valid`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CORE_WHEN_HPP #define BOOST_HANA_FWD_CORE_WHEN_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-core //! Enable a partial specialization only if a boolean condition is true. //! //! You might also want to take a look at `when_valid`, which provides //! similar functionality but enables a specialziation only when some //! expression is well-formed. //! //! > #### Rationale for using `when` instead of `std::enable_if` //! > `when` is used to control the priority of partial specializations //! > in a finer grained manner than what can be achieved with the usual //! > `typename Enable = void` and `std::enable_if` pattern. For example, //! > a partially specialized tag-dispatched method will have a higher //! > priority than an equivalent specialization that uses `when`. For //! > more details, see the tutorial section on [tag-dispatching][1]. //! //! //! Example //! ------- //! @include example/core/when.cpp //! //! [1]: @ref tutorial-core-tag_dispatching template <bool condition> struct when; namespace core_detail { template <typename ...> struct always_true { static constexpr bool value = true; }; } //! @ingroup group-core //! Variant of `when` allowing specializations to be enabled only if an //! expression is well-formed. //! //! `when_valid<...>` is always equivalent to `when<true>`. However, when //! used inside a partial specialization, SFINAE will cause the partial //! specialization to be ignored when the expression is ill-formed. //! //! //! Example //! ------- //! @include example/core/when_valid.cpp //! //! //! @bug //! Using `when_valid` seems to trigger ambiguous partial specializations //! on GCC. #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename ...> using when_valid = when<true>; #else template <typename ...Dummy> using when_valid = when< core_detail::always_true<Dummy...>::value >; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CORE_WHEN_HPP PK �\�[W�\�B B fwd/core/is_a.hppnu �[��� /*! @file Forward declares `boost::hana::is_a` and `boost::hana::is_an`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CORE_IS_A_HPP #define BOOST_HANA_FWD_CORE_IS_A_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-core //! Returns whether the tag of an object matches a given tag. //! //! Given a tag `Tag` and a C++ type `T`, `is_a<Tag, T>` is a compile-time //! Logical representing whether the tag of `T` is exactly `Tag`. In other //! words, it is equivalent to //! @code //! std::is_same<Tag, tag_of<T>::type> //! @endcode //! //! For convenience, an alternate syntax is provided for using `is_a`. //! Specifically, `is_a<Tag>` is a function object returning whether the //! argument it is passed has the given tag. In other words, //! @code //! is_a<Tag>(x) == is_a<Tag, decltype(x)> //! @endcode //! //! //! Example //! ------- //! @include example/core/is_a.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename Tag, typename optional_T> constexpr auto is_a = see-documentation; #else template <typename Tag, typename ...T> struct is_a_t; template <typename Tag, typename ...T> constexpr is_a_t<Tag, T...> is_a{}; #endif //! @ingroup group-core //! Equivalent to `is_a`; provided for consistency with the rules of the //! English language. #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename Tag, typename ...T> constexpr auto is_an = is_a<Tag, T...>; #else template <typename Tag, typename ...T> constexpr is_a_t<Tag, T...> is_an{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CORE_IS_A_HPP PK �\�[ ���G G fwd/core/default.hppnu �[��� /*! @file Forward declares `boost::hana::default_` and `boost::hana::is_default`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CORE_DEFAULT_HPP #define BOOST_HANA_FWD_CORE_DEFAULT_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-core //! Mark a tag-dispatched method implementation as a default implementation. //! //! When defining a new concept with tag-dispatched methods, it is //! sometimes possible to provide a default implementation for some //! method(s). Making `default_` a base class of such a default //! implementation makes it possible to detect whether the method //! was dispatched to the default implementation afterwards. //! //! //! Example //! ------- //! @include example/core/default.cpp struct default_ { }; //! @ingroup group-core //! Returns whether a tag-dispatched method implementation is a default //! implementation. //! //! Given a tag-dispatched method implementation `method_impl<T...>`, //! `is_default<method_impl<T...>>` returns whether `method_impl<T...>` //! is a default implementation. Note that if there is no default //! implementation for the method, then `is_default` should not be //! used unless a static assertion saying that "the method is not //! implemented" is acceptable. //! //! //! Example //! ------- //! @include example/core/default.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename Method> struct is_default { see documentation }; #else template <typename T, typename = void> struct is_default; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CORE_DEFAULT_HPP PK �\�[c1%� � fwd/core/tag_of.hppnu �[��� /*! @file Forward declares `boost::hana::tag_of` and `boost::hana::tag_of_t`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CORE_TAG_OF_HPP #define BOOST_HANA_FWD_CORE_TAG_OF_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-core //! %Metafunction returning the tag associated to `T`. //! //! There are several ways to specify the tag of a C++ type. If it's a //! user-defined type, one can define a nested `hana_tag` alias: //! @code //! struct MyUserDefinedType { //! using hana_tag = MyTag; //! }; //! @endcode //! //! Sometimes, however, the C++ type can't be modified (if it's in a //! foreign library) or simply can't have nested types (if it's not a //! struct or class). In those cases, using a nested alias is impossible //! and so ad-hoc customization is also supported by specializing //! `tag_of` in the `boost::hana` namespace: //! @code //! struct i_cant_modify_this; //! //! namespace boost { namespace hana { //! template <> //! struct tag_of<i_cant_modify_this> { //! using type = MyTag; //! }; //! }} //! @endcode //! //! `tag_of` can also be specialized for all C++ types satisfying some //! boolean condition using `when`. `when` accepts a single compile-time //! boolean and enables the specialization of `tag_of` if and only if //! that boolean is `true`. This is similar to the well known C++ idiom //! of using a dummy template parameter with `std::enable_if` and relying //! on SFINAE. For example, we could specify the tag of all //! `fusion::vector`s by doing: //! @code //! struct BoostFusionVector; //! //! namespace boost { namespace hana { //! template <typename T> //! struct tag_of<T, when< //! std::is_same< //! typename fusion::traits::tag_of<T>::type, //! fusion::traits::tag_of<fusion::vector<>>::type //! >::value //! >> { //! using type = BoostFusionVector; //! }; //! }} //! @endcode //! //! Also, when it is not specialized and when the given C++ type does not //! have a nested `hana_tag` alias, `tag_of<T>` returns `T` itself. This //! makes tags a simple extension of normal C++ types. This is _super_ //! useful, mainly for two reasons. First, this allows Hana to adopt a //! reasonable default behavior for some operations involving types that //! have no notion of tags. For example, Hana allows comparing with `equal` //! any two objects for which a valid `operator==` is defined, and that //! without any work on the user side. Second, it also means that you can //! ignore tags completely if you don't need their functionality; just use //! the normal C++ type of your objects and everything will "just work". //! //! Finally, also note that `tag_of<T>` is always equivalent to `tag_of<U>`, //! where `U` is the type `T` after being stripped of all references and //! cv-qualifiers. This makes it unnecessary to specialize `tag_of` for //! all reference and cv combinations, which would be a real pain. Also, //! `tag_of` is required to be idempotent. In other words, it must always //! be the case that `tag_of<tag_of<T>::%type>::%type` is equivalent to //! `tag_of<T>::%type`. //! //! > __Tip 1__\n //! > If compile-time performance is a serious concern, consider //! > specializing the `tag_of` metafunction in Hana's namespace. //! > When unspecialized, the metafunction has to use SFINAE, which //! > tends to incur a larger compile-time overhead. For heavily used //! > templated types, this can potentially make a difference. //! //! > __Tip 2__\n //! > Consider using `tag_of_t` alias instead of `tag_of`, which //! > reduces the amount of typing in dependent contexts. //! //! //! Example //! ------- //! @include example/core/tag_of.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename T, optional when-based enabler> struct tag_of { unspecified }; #else template <typename T, typename = void> struct tag_of; #endif //! @ingroup group-core //! Alias to `tag_of<T>::%type`, provided for convenience. //! //! //! Example //! ------- //! @include example/core/tag_of_t.cpp template <typename T> using tag_of_t = typename hana::tag_of<T>::type; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CORE_TAG_OF_HPP PK �\�[�b��_ _ fwd/core/to.hppnu �[��� /*! @file Forward declares `boost::hana::to` and related utilities. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CORE_TO_HPP #define BOOST_HANA_FWD_CORE_TO_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-core //! Converts an object from one data type to another. //! //! `to` is a natural extension of the `static_cast` language construct to //! data types. Given a destination data type `To` and an object `x`, `to` //! creates a new object of data type `To` from `x`. Note, however, that //! `to` is not required to actually create a new object, and may return a //! reference to the original object (for example when trying to convert //! an object to its own data type). //! //! As a natural extension to `static_cast`, `to` provides a default //! behavior. For the purpose of what follows, let `To` be the destination //! data type and `From` be the data type of `x`, i.e. the source data type. //! Then, `to` has the following default behavior: //! 1. If the `To` and `From` data types are the same, then the object //! is forwarded as-is. //! 2. Otherwise, if `From` is convertible to `To` using `static_cast`, //! `x` is converted to `From` using `static_cast`. //! 3. Otherwise, calling `to<From>(x)` triggers a static assertion. //! //! However, `to` is a tag-dispatched function, which means that `to_impl` //! may be specialized in the `boost::hana` namespace to customize its //! behavior for arbitrary data types. Also note that `to` is tag-dispatched //! using both the `To` and the `From` data types, which means that `to_impl` //! is called as `to_impl<To, From>::%apply(x)`. Also note that some //! concepts provide conversions to or from their models. For example, //! any `Foldable` may be converted into a `Sequence`. This is achieved //! by specializing `to_impl<To, From>` whenever `To` is a `Sequence` and //! `From` is a `Foldable`. When such conversions are provided, they are //! documented in the source concept, in this case `Foldable`. //! //! //! Hana-convertibility //! ------------------- //! When an object `x` of data type `From` can be converted to a data type //! `To` using `to`, we say that `x` is Hana-convertible to the data type //! `To`. We also say that there is a Hana-conversion from `From` to `To`. //! This bit of terminology is useful to avoid mistaking the various kinds //! of conversions C++ offers. //! //! //! Embeddings //! ---------- //! As you might have seen by now, Hana uses algebraic and category- //! theoretical structures all around the place to help specify concepts //! in a rigorous way. These structures always have operations associated //! to them, which is why they are useful. The notion of embedding captures //! the idea of injecting a smaller structure into a larger one while //! preserving the operations of the structure. In other words, an //! embedding is an injective mapping that is also structure-preserving. //! Exactly what it means for a structure's operations to be preserved is //! left to explain by the documentation of each structure. For example, //! when we talk of a Monoid-embedding from a Monoid `A` to a Monoid `B`, //! we simply mean an injective transformation that preserves the identity //! and the associative operation, as documented in `Monoid`. //! //! But what does this have to do with the `to` function? Quite simply, //! the `to` function is a mapping between two data types, which will //! sometimes be some kind of structure, and it is sometimes useful to //! know whether such a mapping is well-behaved, i.e. lossless and //! structure preserving. The criterion for this conversion to be well- //! behaved is exactly that of being an embedding. To specify that a //! conversion is an embedding, simply use the `embedding` type as a //! base class of the corresponding `to_impl` specialization. Obviously, //! you should make sure the conversion is really an embedding, unless //! you want to shoot yourself in the foot. //! //! //! @tparam To //! The data type to which `x` should be converted. //! //! @param x //! The object to convert to the given data type. //! //! //! Example //! ------- //! @include example/core/convert/to.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename To> constexpr auto to = [](auto&& x) -> decltype(auto) { return tag-dispatched; }; #else template <typename To, typename From, typename = void> struct to_impl; template <typename To> struct to_t { template <typename X> constexpr decltype(auto) operator()(X&& x) const; }; template <typename To> constexpr to_t<To> to{}; #endif //! @ingroup group-core //! Returns whether there is a Hana-conversion from a data type to another. //! //! Specifically, `is_convertible<From, To>` is whether calling `to<To>` //! with an object of data type `From` would _not_ trigger a static //! assertion. //! //! //! Example //! ------- //! @include example/core/convert/is_convertible.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename From, typename To> struct is_convertible { see documentation }; #else template <typename From, typename To, typename = void> struct is_convertible; #endif //! @ingroup group-core //! Marks a conversion between data types as being an embedding. //! //! To mark a conversion between two data types `To` and `From` as //! an embedding, simply use `embedding<true>` (or simply `embedding<>`) //! as a base class of the corresponding `to_impl` specialization. //! If a `to_impl` specialization does not inherit `embedding<true>` //! or `embedding<>`, then it is not considered an embedding by the //! `is_embedded` metafunction. //! //! > #### Tip //! > The boolean template parameter is useful for marking a conversion //! > as an embedding only when some condition is satisfied. //! //! //! Example //! ------- //! @include example/core/convert/embedding.cpp template <bool = true> struct embedding { }; //! @ingroup group-core //! Returns whether a data type can be embedded into another data type. //! //! Given two data types `To` and `From`, `is_embedded<From, To>` returns //! whether `From` is convertible to `To`, and whether that conversion is //! also an embedding, as signaled by the `embedding` type. //! //! //! Example //! ------- //! @include example/core/convert/is_embedded.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename From, typename To> struct is_embedded { see documentation }; #else template <typename From, typename To, typename = void> struct is_embedded; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CORE_TO_HPP PK �\�[�T� � � fwd/core/common.hppnu �[��� /*! @file Forward declares `boost::hana::common` and `boost::hana::common_t`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_CORE_COMMON_HPP #define BOOST_HANA_FWD_CORE_COMMON_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-core //! %Metafunction returning the common data type between two data types. //! //! `common` is a natural extension of the `std::common_type` metafunction //! to data types. Given two data types `T` and `U`, we say that they share //! a common type `C` if both objects of data type `T` and objects of data //! type `U` may be converted (using `to`) to an object of data type `C`, //! and if that conversion is equality preserving. In other words, this //! means that for any objects `t1, t2` of data type `T` and `u1, u2` of //! data type `U`, the following law is satisfied: //! @code //! to<C>(t1) == to<C>(t2) if and only if t1 == t2 //! to<C>(u1) == to<C>(u2) if and only if u1 == u2 //! @endcode //! //! The role of `common` is to provide an alias to such a `C` if it exists. //! In other words, if `T` and `U` have a common data type `C`, //! `common<T, U>::%type` is an alias to `C`. Otherwise, `common<T, U>` //! has no nested `type` and can be used in dependent contexts to exploit //! SFINAE. By default, the exact steps followed by `common` to determine //! the common type `C` of `T` and `U` are //! 1. If `T` and `U` are the same, then `C` is `T`. //! 2. Otherwise, if `true ? std::declval<T>() : std::declval<U>()` is //! well-formed, then `C` is the type of this expression after using //! `std::decay` on it. This is exactly the type that would have been //! returned by `std::common_type`, except that custom specializations //! of `std::common_type` are not taken into account. //! 3. Otherwise, no common data type is detected and `common<T, U>` does //! not have a nested `type` alias, unless it is specialized explicitly. //! //! As point 3 suggests, it is also possible (and sometimes necessary) to //! specialize `common` in the `boost::hana` namespace for pairs of custom //! data types when the default behavior of `common` is not sufficient. //! Note that `when`-based specialization is supported when specializing //! `common` in the `boost::hana` namespace. //! //! > #### Rationale for requiring the conversion to be equality-preserving //! > This decision is aligned with a proposed concept design for the //! > standard library ([N3351][1]). Also, if we did not require this, //! > then all data types would trivially share the common data type //! > `void`, since all objects can be converted to it. //! //! //! Example //! ------- //! @include example/core/common/common.cpp //! //! //! [1]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3351.pdf #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename T, typename U, optional when-based enabler> struct common { see documentation }; #else template <typename T, typename U, typename = void> struct common; #endif //! @ingroup group-core //! %Metafunction returning whether two data types share a common data type. //! //! Given two data types `T` and `U`, this metafunction simply returns //! whether `common<T, U>::%type` is well-formed. //! //! //! Example //! ------- //! @include example/core/common/has_common.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename T, typename U> struct has_common { whether common<T, U>::type is well-formed }; #else template <typename T, typename U, typename = void> struct has_common; #endif //! @ingroup group-core //! Alias to `common<T, U>::%type`, provided for convenience. //! //! //! Example //! ------- //! @include example/core/common/common_t.cpp template <typename T, typename U> using common_t = typename common<T, U>::type; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CORE_COMMON_HPP PK �\�[��= = fwd/replace_if.hppnu �[��� /*! @file Forward declares `boost::hana::replace_if`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_REPLACE_IF_HPP #define BOOST_HANA_FWD_REPLACE_IF_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Replace all the elements of a structure satisfying a `predicate` //! with a fixed value. //! @ingroup group-Functor //! //! //! Signature //! --------- //! Given `F` a Functor and `Bool` a Logical, the signature is //! \f$ //! \mathtt{replace\_if} : F(T) \times (T \to Bool) \times T \to F(T) //! \f$ //! //! @param xs //! The structure to replace elements of. //! //! @param predicate //! A function called as `predicate(x)` for element(s) `x` of the //! structure and returning a `Logical` representing whether `x` //! should be replaced by `value`. //! //! @param value //! A value by which every element `x` of the structure for which //! `predicate` returns a true-valued `Logical` is replaced. //! //! //! Example //! ------- //! @include example/replace_if.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto replace_if = [](auto&& xs, auto&& predicate, auto&& value) { return tag-dispatched; }; #else template <typename Xs, typename = void> struct replace_if_impl : replace_if_impl<Xs, when<true>> { }; struct replace_if_t { template <typename Xs, typename Pred, typename Value> constexpr auto operator()(Xs&& xs, Pred&& pred, Value&& value) const; }; constexpr replace_if_t replace_if{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_REPLACE_IF_HPP PK �\�[8�~� � fwd/comparing.hppnu �[��� /*! @file Forward declares `boost::hana::comparing`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_COMPARING_HPP #define BOOST_HANA_FWD_COMPARING_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns a function performing `equal` after applying a transformation //! to both arguments. //! @ingroup group-Comparable //! //! `comparing` creates an equivalence relation based on the result of //! applying a function to some objects, which is especially useful in //! conjunction with algorithms that accept a custom predicate that must //! represent an equivalence relation. //! //! Specifically, `comparing` is such that //! @code //! comparing(f) == equal ^on^ f //! @endcode //! or, equivalently, //! @code //! comparing(f)(x, y) == equal(f(x), f(y)) //! @endcode //! //! @note //! This is not a tag-dispatched method (hence it can't be customized), //! but just a convenience function provided with the `Comparable` concept. //! //! //! Signature //! --------- //! Given a Logical `Bool` and a Comparable `B`, the signature is //! @f$ \mathtt{comparing} : (A \to B) \to (A \times A \to Bool) @f$. //! //! //! Example //! ------- //! @include example/comparing.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto comparing = [](auto&& f) { return [perfect-capture](auto&& x, auto&& y) { return equal(f(forwarded(x)), f(forwarded(y))); }; }; #else struct comparing_t { template <typename F> constexpr auto operator()(F&& f) const; }; constexpr comparing_t comparing{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_COMPARING_HPP PK �\�[�3�U5 5 fwd/eval_if.hppnu �[��� /*! @file Forward declares `boost::hana::eval_if`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_EVAL_IF_HPP #define BOOST_HANA_FWD_EVAL_IF_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Conditionally execute one of two branches based on a condition. //! @ingroup group-Logical //! //! Given a condition and two branches in the form of lambdas or //! `hana::lazy`s, `eval_if` will evaluate the branch selected by the //! condition with `eval` and return the result. The exact requirements //! for what the branches may be are the same requirements as those for //! the `eval` function. //! //! //! Deferring compile-time evaluation inside `eval_if` //! -------------------------------------------------- //! By passing a unary callable to `eval_if`, it is possible to defer //! the compile-time evaluation of selected expressions inside the //! lambda. This is useful when instantiating a branch would trigger //! a compile-time error; we only want the branch to be instantiated //! when that branch is selected. Here's how it can be achieved. //! //! For simplicity, we'll use a unary lambda as our unary callable. //! Our lambda must accept a parameter (usually called `_`), which //! can be used to defer the compile-time evaluation of expressions //! as required. For example, //! @code //! template <typename N> //! auto fact(N n) { //! return hana::eval_if(n == hana::int_c<0>, //! [] { return hana::int_c<1>; }, //! [=](auto _) { return n * fact(_(n) - hana::int_c<1>); } //! ); //! } //! @endcode //! //! What happens here is that `eval_if` will call `eval` on the selected //! branch. In turn, `eval` will call the selected branch either with //! nothing -- for the _then_ branch -- or with `hana::id` -- for the //! _else_ branch. Hence, `_(x)` is always the same as `x`, but the //! compiler can't tell until the lambda has been called! Hence, the //! compiler has to wait before it instantiates the body of the lambda //! and no infinite recursion happens. However, this trick to delay the //! instantiation of the lambda's body can only be used when the condition //! is known at compile-time, because otherwise both branches have to be //! instantiated inside the `eval_if` anyway. //! //! There are several caveats to note with this approach to lazy branching. //! First, because we're using lambdas, it means that the function's //! result can't be used in a constant expression. This is a limitation //! of the current language. //! //! The second caveat is that compilers currently have several bugs //! regarding deeply nested lambdas with captures. So you always risk //! crashing the compiler, but this is a question of time before it is //! not a problem anymore. //! //! Finally, it means that conditionals can't be written directly inside //! unevaluated contexts. The reason is that a lambda can't appear in an //! unevaluated context, for example in `decltype`. One way to workaround //! this is to completely lift your type computations into variable //! templates instead. For example, instead of writing //! @code //! template <typename T> //! struct pointerize : decltype( //! hana::eval_if(hana::traits::is_pointer(hana::type_c<T>), //! [] { return hana::type_c<T>; }, //! [](auto _) { return _(hana::traits::add_pointer)(hana::type_c<T>); } //! )) //! { }; //! @endcode //! //! you could instead write //! //! @code //! template <typename T> //! auto pointerize_impl(T t) { //! return hana::eval_if(hana::traits::is_pointer(t), //! [] { return hana::type_c<T>; }, //! [](auto _) { return _(hana::traits::add_pointer)(hana::type_c<T>); } //! ); //! } //! //! template <typename T> //! using pointerize = decltype(pointerize_impl(hana::type_c<T>)); //! @endcode //! //! > __Note__: This example would actually be implemented more easily //! > with partial specializations, but my bag of good examples is empty //! > at the time of writing this. //! //! Now, this hoop-jumping only has to be done in one place, because //! you should use normal function notation everywhere else in your //! metaprogram to perform type computations. So the syntactic //! cost is amortized over the whole program. //! //! Another way to work around this limitation of the language would be //! to use `hana::lazy` for the branches. However, this is only suitable //! when the branches are not too complicated. With `hana::lazy`, you //! could write the previous example as //! @code //! template <typename T> //! struct pointerize : decltype( //! hana::eval_if(hana::traits::is_pointer(hana::type_c<T>), //! hana::make_lazy(hana::type_c<T>), //! hana::make_lazy(hana::traits::add_pointer)(hana::type_c<T>) //! )) //! { }; //! @endcode //! //! //! @param cond //! The condition determining which of the two branches is selected. //! //! @param then //! An expression called as `eval(then)` if `cond` is true-valued. //! //! @param else_ //! A function called as `eval(else_)` if `cond` is false-valued. //! //! //! Example //! ------- //! @include example/eval_if.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto eval_if = [](auto&& cond, auto&& then, auto&& else_) -> decltype(auto) { return tag-dispatched; }; #else template <typename L, typename = void> struct eval_if_impl : eval_if_impl<L, when<true>> { }; struct eval_if_t { template <typename Cond, typename Then, typename Else> constexpr decltype(auto) operator()(Cond&& cond, Then&& then, Else&& else_) const; }; constexpr eval_if_t eval_if{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_EVAL_IF_HPP PK �\�[{!V V fwd/difference.hppnu �[��� /*! @file Forward declares `boost::hana::difference`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_DIFFERENCE_HPP #define BOOST_HANA_FWD_DIFFERENCE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN // Note: This function is documented per datatype/concept only. //! @cond template <typename S, typename = void> struct difference_impl : difference_impl<S, when<true>> { }; //! @endcond struct difference_t { template <typename Xs, typename Ys> constexpr auto operator()(Xs&&, Ys&&) const; }; constexpr difference_t difference{}; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_DIFFERENCE_HPP PK �\�[�Hy� � fwd/lift.hppnu �[��� /*! @file Forward declares `boost::hana::lift`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_LIFT_HPP #define BOOST_HANA_FWD_LIFT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Lift a value into an `Applicative` structure. //! @ingroup group-Applicative //! //! `lift<A>` takes a normal value and embeds it into a structure whose //! shape is represented by the `A` `Applicative`. Note that the value //! may be a function, in which case the created structure may be //! `ap`plied to another `Applicative` structure containing values. //! //! //! Signature //! --------- //! Given an Applicative `A`, the signature is //! @f$ \mathtt{lift}_A : T \to A(T) @f$. //! //! @tparam A //! A tag representing the `Applicative` into which the value is lifted. //! //! @param x //! The value to lift into the applicative. //! //! //! Example //! ------- //! @include example/lift.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename A> constexpr auto lift = [](auto&& x) { return tag-dispatched; }; #else template <typename A, typename = void> struct lift_impl : lift_impl<A, when<true>> { }; template <typename A> struct lift_t { template <typename X> constexpr auto operator()(X&& x) const; }; template <typename A> constexpr lift_t<A> lift{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_LIFT_HPP PK �\�[���� � fwd/then.hppnu �[��� /*! @file Forward declares `boost::hana::then`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_THEN_HPP #define BOOST_HANA_FWD_THEN_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Sequentially compose two monadic actions, discarding any value //! produced by the first but not its effects. //! @ingroup group-Monad //! //! //! @param before //! The first `Monad` in the monadic composition chain. The result of //! this monad is ignored, but its effects are combined with that of the //! second monad. //! //! @param xs //! The second `Monad` in the monadic composition chain. //! //! //! Example //! ------- //! @include example/then.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto then = [](auto&& before, auto&& xs) -> decltype(auto) { return tag-dispatched; }; #else template <typename M, typename = void> struct then_impl : then_impl<M, when<true>> { }; struct then_t { template <typename Before, typename Xs> constexpr decltype(auto) operator()(Before&& before, Xs&& xs) const; }; constexpr then_t then{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_THEN_HPP PK �\�[��� � fwd/plus.hppnu �[��� /*! @file Forward declares `boost::hana::plus`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_PLUS_HPP #define BOOST_HANA_FWD_PLUS_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Associative binary operation on a `Monoid`. //! @ingroup group-Monoid //! //! @param x, y //! Two objects to combine with the `Monoid`'s binary operation. //! //! //! Cross-type version of the method //! -------------------------------- //! The `plus` method is "overloaded" to handle distinct data types //! with certain properties. Specifically, `plus` is defined for //! _distinct_ data types `A` and `B` such that //! 1. `A` and `B` share a common data type `C`, as determined by the //! `common` metafunction //! 2. `A`, `B` and `C` are all `Monoid`s when taken individually //! 3. `to<C> : A -> B` and `to<C> : B -> C` are `Monoid`-embeddings, as //! determined by the `is_embedding` metafunction. //! //! The definition of `plus` for data types satisfying the above //! properties is obtained by setting //! @code //! plus(x, y) = plus(to<C>(x), to<C>(y)) //! @endcode //! //! //! Example //! ------- //! @include example/plus.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto plus = [](auto&& x, auto&& y) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename U, typename = void> struct plus_impl : plus_impl<T, U, when<true>> { }; struct plus_t { template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) const; }; constexpr plus_t plus{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_PLUS_HPP PK �\�[�� њ � fwd/any.hppnu �[��� /*! @file Forward declares `boost::hana::any`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FWD_ANY_HPP #define BOOST_HANA_FWD_ANY_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns whether any key of the structure is true-valued. //! @ingroup group-Searchable //! //! The keys of the structure must be `Logical`s. If the structure is not //! finite, a true-valued key must appear at a finite "index" in order for //! this method to finish. //! //! //! Example //! ------- //! @include example/any.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto any = [](auto&& xs) { return tag-dispatched; }; #else template <typename S, typename = void> struct any_impl : any_impl<S, when<true>> { }; struct any_t { template <typename Xs> constexpr auto operator()(Xs&& xs) const; }; constexpr any_t any{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ANY_HPP PK �\�[��{�p p pair.hppnu �[��� /*! @file Defines `boost::hana::pair`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_PAIR_HPP #define BOOST_HANA_PAIR_HPP #include <boost/hana/fwd/pair.hpp> #include <boost/hana/config.hpp> #include <boost/hana/detail/decay.hpp> #include <boost/hana/detail/ebo.hpp> #include <boost/hana/detail/intrinsics.hpp> #include <boost/hana/detail/operators/adl.hpp> #include <boost/hana/detail/operators/comparable.hpp> #include <boost/hana/detail/operators/orderable.hpp> #include <boost/hana/fwd/core/make.hpp> #include <boost/hana/fwd/first.hpp> #include <boost/hana/fwd/second.hpp> #include <type_traits> #include <utility> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <int> struct pix; // pair index } ////////////////////////////////////////////////////////////////////////// // pair ////////////////////////////////////////////////////////////////////////// //! @cond template <typename First, typename Second> #ifdef BOOST_HANA_WORKAROUND_MSVC_EMPTYBASE struct __declspec(empty_bases) pair : detail::operators::adl<pair<First, Second>> #else struct pair : detail::operators::adl<pair<First, Second>> #endif , private detail::ebo<detail::pix<0>, First> , private detail::ebo<detail::pix<1>, Second> { // Default constructor template <typename ...dummy, typename = typename std::enable_if< BOOST_HANA_TT_IS_CONSTRUCTIBLE(First, dummy...) && BOOST_HANA_TT_IS_CONSTRUCTIBLE(Second, dummy...) >::type> constexpr pair() : detail::ebo<detail::pix<0>, First>() , detail::ebo<detail::pix<1>, Second>() { } // Variadic constructors template <typename ...dummy, typename = typename std::enable_if< BOOST_HANA_TT_IS_CONSTRUCTIBLE(First, First const&, dummy...) && BOOST_HANA_TT_IS_CONSTRUCTIBLE(Second, Second const&, dummy...) >::type> constexpr pair(First const& fst, Second const& snd) : detail::ebo<detail::pix<0>, First>(fst) , detail::ebo<detail::pix<1>, Second>(snd) { } template <typename T, typename U, typename = typename std::enable_if< BOOST_HANA_TT_IS_CONVERTIBLE(T&&, First) && BOOST_HANA_TT_IS_CONVERTIBLE(U&&, Second) >::type> constexpr pair(T&& t, U&& u) : detail::ebo<detail::pix<0>, First>(static_cast<T&&>(t)) , detail::ebo<detail::pix<1>, Second>(static_cast<U&&>(u)) { } // Possibly converting copy and move constructors template <typename T, typename U, typename = typename std::enable_if< BOOST_HANA_TT_IS_CONSTRUCTIBLE(First, T const&) && BOOST_HANA_TT_IS_CONSTRUCTIBLE(Second, U const&) && BOOST_HANA_TT_IS_CONVERTIBLE(T const&, First) && BOOST_HANA_TT_IS_CONVERTIBLE(U const&, Second) >::type> constexpr pair(pair<T, U> const& other) : detail::ebo<detail::pix<0>, First>(hana::first(other)) , detail::ebo<detail::pix<1>, Second>(hana::second(other)) { } template <typename T, typename U, typename = typename std::enable_if< BOOST_HANA_TT_IS_CONSTRUCTIBLE(First, T&&) && BOOST_HANA_TT_IS_CONSTRUCTIBLE(Second, U&&) && BOOST_HANA_TT_IS_CONVERTIBLE(T&&, First) && BOOST_HANA_TT_IS_CONVERTIBLE(U&&, Second) >::type> constexpr pair(pair<T, U>&& other) : detail::ebo<detail::pix<0>, First>(hana::first(static_cast<pair<T, U>&&>(other))) , detail::ebo<detail::pix<1>, Second>(hana::second(static_cast<pair<T, U>&&>(other))) { } // Copy and move assignment template <typename T, typename U, typename = typename std::enable_if< BOOST_HANA_TT_IS_ASSIGNABLE(First&, T const&) && BOOST_HANA_TT_IS_ASSIGNABLE(Second&, U const&) >::type> constexpr pair& operator=(pair<T, U> const& other) { hana::first(*this) = hana::first(other); hana::second(*this) = hana::second(other); return *this; } template <typename T, typename U, typename = typename std::enable_if< BOOST_HANA_TT_IS_ASSIGNABLE(First&, T&&) && BOOST_HANA_TT_IS_ASSIGNABLE(Second&, U&&) >::type> constexpr pair& operator=(pair<T, U>&& other) { hana::first(*this) = hana::first(static_cast<pair<T, U>&&>(other)); hana::second(*this) = hana::second(static_cast<pair<T, U>&&>(other)); return *this; } // Prevent the compiler from defining the default copy and move // constructors, which interfere with the SFINAE above. ~pair() = default; friend struct first_impl<pair_tag>; friend struct second_impl<pair_tag>; template <typename F, typename S> friend struct pair; }; //! @endcond template <typename First, typename Second> struct tag_of<pair<First, Second>> { using type = pair_tag; }; ////////////////////////////////////////////////////////////////////////// // Operators ////////////////////////////////////////////////////////////////////////// namespace detail { template <> struct comparable_operators<pair_tag> { static constexpr bool value = true; }; template <> struct orderable_operators<pair_tag> { static constexpr bool value = true; }; } ////////////////////////////////////////////////////////////////////////// // Product ////////////////////////////////////////////////////////////////////////// template <> struct make_impl<pair_tag> { template <typename F, typename S> static constexpr pair< typename detail::decay<F>::type, typename detail::decay<S>::type > apply(F&& f, S&& s) { return {static_cast<F&&>(f), static_cast<S&&>(s)}; } }; template <> struct first_impl<pair_tag> { template <typename First, typename Second> static constexpr decltype(auto) apply(hana::pair<First, Second>& p) { return detail::ebo_get<detail::pix<0>>( static_cast<detail::ebo<detail::pix<0>, First>&>(p) ); } template <typename First, typename Second> static constexpr decltype(auto) apply(hana::pair<First, Second> const& p) { return detail::ebo_get<detail::pix<0>>( static_cast<detail::ebo<detail::pix<0>, First> const&>(p) ); } template <typename First, typename Second> static constexpr decltype(auto) apply(hana::pair<First, Second>&& p) { return detail::ebo_get<detail::pix<0>>( static_cast<detail::ebo<detail::pix<0>, First>&&>(p) ); } }; template <> struct second_impl<pair_tag> { template <typename First, typename Second> static constexpr decltype(auto) apply(hana::pair<First, Second>& p) { return detail::ebo_get<detail::pix<1>>( static_cast<detail::ebo<detail::pix<1>, Second>&>(p) ); } template <typename First, typename Second> static constexpr decltype(auto) apply(hana::pair<First, Second> const& p) { return detail::ebo_get<detail::pix<1>>( static_cast<detail::ebo<detail::pix<1>, Second> const&>(p) ); } template <typename First, typename Second> static constexpr decltype(auto) apply(hana::pair<First, Second>&& p) { return detail::ebo_get<detail::pix<1>>( static_cast<detail::ebo<detail::pix<1>, Second>&&>(p) ); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_PAIR_HPP PK �\�[�a�� maximum.hppnu �[��� /*! @file Defines `boost::hana::maximum`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_MAXIMUM_HPP #define BOOST_HANA_MAXIMUM_HPP #include <boost/hana/fwd/maximum.hpp> #include <boost/hana/concept/foldable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/nested_by.hpp> // required by fwd decl #include <boost/hana/fold_left.hpp> #include <boost/hana/if.hpp> #include <boost/hana/less.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs> constexpr decltype(auto) maximum_t::operator()(Xs&& xs) const { using S = typename hana::tag_of<Xs>::type; using Maximum = BOOST_HANA_DISPATCH_IF(maximum_impl<S>, hana::Foldable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Foldable<S>::value, "hana::maximum(xs) requires 'xs' to be Foldable"); #endif return Maximum::apply(static_cast<Xs&&>(xs)); } template <typename Xs, typename Predicate> constexpr decltype(auto) maximum_t::operator()(Xs&& xs, Predicate&& pred) const { using S = typename hana::tag_of<Xs>::type; using Maximum = BOOST_HANA_DISPATCH_IF(maximum_pred_impl<S>, hana::Foldable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Foldable<S>::value, "hana::maximum(xs, predicate) requires 'xs' to be Foldable"); #endif return Maximum::apply(static_cast<Xs&&>(xs), static_cast<Predicate&&>(pred)); } //! @endcond ////////////////////////////////////////////////////////////////////////// // maximum (with a custom predicate) ////////////////////////////////////////////////////////////////////////// namespace detail { template <typename Pred> struct max_by { Pred pred; template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) const { auto result = (*pred)(x, y); return hana::if_(result, static_cast<Y&&>(y), static_cast<X&&>(x)); } }; } template <typename T, bool condition> struct maximum_pred_impl<T, when<condition>> : default_ { template <typename Xs, typename Pred> static constexpr decltype(auto) apply(Xs&& xs, Pred&& pred) { // We use a pointer instead of a reference to avoid a Clang ICE. return hana::fold_left(static_cast<Xs&&>(xs), detail::max_by<decltype(&pred)>{&pred} ); } }; ////////////////////////////////////////////////////////////////////////// // maximum (without a custom predicate) ////////////////////////////////////////////////////////////////////////// template <typename T, bool condition> struct maximum_impl<T, when<condition>> : default_ { template <typename Xs> static constexpr decltype(auto) apply(Xs&& xs) { return hana::maximum(static_cast<Xs&&>(xs), hana::less); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_MAXIMUM_HPP PK �\�[�,Q�f f drop_while.hppnu �[��� /*! @file Defines `boost::hana::drop_while`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DROP_WHILE_HPP #define BOOST_HANA_DROP_WHILE_HPP #include <boost/hana/fwd/drop_while.hpp> #include <boost/hana/concept/foldable.hpp> #include <boost/hana/concept/iterable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/first_unsatisfied_index.hpp> #include <boost/hana/drop_front.hpp> #include <boost/hana/eval_if.hpp> #include <boost/hana/front.hpp> #include <boost/hana/is_empty.hpp> #include <boost/hana/lazy.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Pred> constexpr auto drop_while_t::operator()(Xs&& xs, Pred&& pred) const { using It = typename hana::tag_of<Xs>::type; using DropWhile = BOOST_HANA_DISPATCH_IF(drop_while_impl<It>, hana::Iterable<It>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Iterable<It>::value, "hana::drop_while(xs, pred) requires 'xs' to be an Iterable"); #endif return DropWhile::apply(static_cast<Xs&&>(xs), static_cast<Pred&&>(pred)); } //! @endcond namespace iterable_detail { struct drop_while_helper { struct next { template <typename Xs, typename Pred> constexpr decltype(auto) operator()(Xs&& xs, Pred&& pred) const { return hana::drop_while( hana::drop_front(static_cast<Xs&&>(xs)), static_cast<Pred&&>(pred) ); } }; template <typename Xs, typename Pred> constexpr decltype(auto) operator()(Xs&& xs, Pred&& pred) const { return hana::eval_if(pred(hana::front(xs)), hana::make_lazy(next{})(xs, pred), hana::make_lazy(xs) ); } }; } template <typename It, bool condition> struct drop_while_impl<It, when<condition>> : default_ { template <typename Xs, typename Pred> static constexpr auto apply(Xs&& xs, Pred&& pred) { return hana::eval_if(hana::is_empty(xs), hana::make_lazy(xs), hana::make_lazy(iterable_detail::drop_while_helper{})( xs, static_cast<Pred&&>(pred)) ); } }; template <typename S> struct drop_while_impl<S, when<hana::Foldable<S>::value>> { template <typename Xs, typename Pred> static constexpr auto apply(Xs&& xs, Pred&&) { using FirstUnsatisfied = decltype( hana::unpack(static_cast<Xs&&>(xs), detail::first_unsatisfied_index<Pred&&>{}) ); return hana::drop_front(static_cast<Xs&&>(xs), FirstUnsatisfied{}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DROP_WHILE_HPP PK �\�[ ��� � adjust.hppnu �[��� /*! @file Defines `boost::hana::adjust`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_ADJUST_HPP #define BOOST_HANA_ADJUST_HPP #include <boost/hana/fwd/adjust.hpp> #include <boost/hana/adjust_if.hpp> #include <boost/hana/concept/functor.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/equal.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Value, typename F> constexpr auto adjust_t::operator()(Xs&& xs, Value&& value, F&& f) const { using S = typename hana::tag_of<Xs>::type; using Adjust = BOOST_HANA_DISPATCH_IF(adjust_impl<S>, hana::Functor<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Functor<S>::value, "hana::adjust(xs, value, f) requires 'xs' to be a Functor"); #endif return Adjust::apply(static_cast<Xs&&>(xs), static_cast<Value&&>(value), static_cast<F&&>(f)); } //! @endcond template <typename Fun, bool condition> struct adjust_impl<Fun, when<condition>> : default_ { template <typename Xs, typename Value, typename F> static constexpr auto apply(Xs&& xs, Value&& value, F&& f) { return hana::adjust_if( static_cast<Xs&&>(xs), hana::equal.to(static_cast<Value&&>(value)), static_cast<F&&>(f) ); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_ADJUST_HPP PK �\�[6��(� � cycle.hppnu �[��� /*! @file Defines `boost::hana::cycle`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CYCLE_HPP #define BOOST_HANA_CYCLE_HPP #include <boost/hana/fwd/cycle.hpp> #include <boost/hana/at.hpp> #include <boost/hana/concat.hpp> #include <boost/hana/concept/integral_constant.hpp> #include <boost/hana/concept/monad_plus.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/detail/array.hpp> #include <boost/hana/empty.hpp> #include <boost/hana/length.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename N> constexpr auto cycle_t::operator()(Xs&& xs, N const& n) const { using M = typename hana::tag_of<Xs>::type; using Cycle = BOOST_HANA_DISPATCH_IF(cycle_impl<M>, hana::MonadPlus<M>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::MonadPlus<M>::value, "hana::cycle(xs, n) requires 'xs' to be a MonadPlus"); static_assert(hana::IntegralConstant<N>::value, "hana::cycle(xs, n) requires 'n' to be an IntegralConstant"); #endif static_assert(N::value >= 0, "hana::cycle(xs, n) requires 'n' to be non-negative"); return Cycle::apply(static_cast<Xs&&>(xs), n); } //! @endcond namespace detail { template <typename M, std::size_t n, bool = n % 2 == 0> struct cycle_helper; template <typename M> struct cycle_helper<M, 0, true> { template <typename Xs> static constexpr auto apply(Xs const&) { return hana::empty<M>(); } }; template <typename M, std::size_t n> struct cycle_helper<M, n, true> { template <typename Xs> static constexpr auto apply(Xs const& xs) { return cycle_helper<M, n/2>::apply(hana::concat(xs, xs)); } }; template <typename M, std::size_t n> struct cycle_helper<M, n, false> { template <typename Xs> static constexpr auto apply(Xs const& xs) { return hana::concat(xs, cycle_helper<M, n-1>::apply(xs)); } }; } template <typename M, bool condition> struct cycle_impl<M, when<condition>> : default_ { template <typename Xs, typename N> static constexpr auto apply(Xs const& xs, N const&) { constexpr std::size_t n = N::value; return detail::cycle_helper<M, n>::apply(xs); } }; namespace detail { template <std::size_t N, std::size_t Len> struct cycle_indices { static constexpr auto compute_value() { detail::array<std::size_t, N * Len> indices{}; // Avoid (incorrect) Clang warning about remainder by zero // in the loop below. std::size_t len = Len; for (std::size_t i = 0; i < N * Len; ++i) indices[i] = i % len; return indices; } static constexpr auto value = compute_value(); }; } template <typename S> struct cycle_impl<S, when<Sequence<S>::value>> { template <typename Indices, typename Xs, std::size_t ...i> static constexpr auto cycle_helper(Xs&& xs, std::index_sequence<i...>) { constexpr auto indices = Indices::value; (void)indices; // workaround GCC warning when sizeof...(i) == 0 return hana::make<S>(hana::at_c<indices[i]>(xs)...); } template <typename Xs, typename N> static constexpr auto apply(Xs&& xs, N const&) { constexpr std::size_t n = N::value; constexpr std::size_t len = decltype(hana::length(xs))::value; using Indices = detail::cycle_indices<n, len>; return cycle_helper<Indices>(static_cast<Xs&&>(xs), std::make_index_sequence<n * len>{}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CYCLE_HPP PK �\�[Ӫ�� � second.hppnu �[��� /*! @file Defines `boost::hana::second`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_SECOND_HPP #define BOOST_HANA_SECOND_HPP #include <boost/hana/fwd/second.hpp> #include <boost/hana/concept/product.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Pair> constexpr decltype(auto) second_t::operator()(Pair&& pair) const { using P = typename hana::tag_of<Pair>::type; using Second = BOOST_HANA_DISPATCH_IF(second_impl<P>, hana::Product<P>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Product<P>::value, "hana::second(pair) requires 'pair' to be a Product"); #endif return Second::apply(static_cast<Pair&&>(pair)); } //! @endcond template <typename P, bool condition> struct second_impl<P, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_SECOND_HPP PK �\�[���G G for_each.hppnu �[��� /*! @file Defines `boost::hana::for_each`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_FOR_EACH_HPP #define BOOST_HANA_FOR_EACH_HPP #include <boost/hana/fwd/for_each.hpp> #include <boost/hana/concept/foldable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/unpack.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename F> constexpr void for_each_t::operator()(Xs&& xs, F&& f) const { using S = typename hana::tag_of<Xs>::type; using ForEach = BOOST_HANA_DISPATCH_IF(for_each_impl<S>, hana::Foldable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Foldable<S>::value, "hana::for_each(xs, f) requires 'xs' to be Foldable"); #endif return ForEach::apply(static_cast<Xs&&>(xs), static_cast<F&&>(f)); } //! @endcond namespace detail { template <typename F> struct on_each { F f; template <typename ...Xs> constexpr void operator()(Xs&& ...xs) const { using Swallow = int[]; (void)Swallow{0, ((void)(*f)(static_cast<Xs&&>(xs)), 0)...}; } }; } template <typename T, bool condition> struct for_each_impl<T, when<condition>> : default_ { template <typename Xs, typename F> static constexpr void apply(Xs&& xs, F&& f) { // We use a pointer instead of a reference to avoid a Clang ICE. hana::unpack(static_cast<Xs&&>(xs), detail::on_each<decltype(&f)>{&f}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FOR_EACH_HPP PK �\�[Z�~��- �- tuple.hppnu �[��� /*! @file Defines `boost::hana::tuple`. @copyright Louis Dionne 2013-2017 @copyright Jason Rice 2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_TUPLE_HPP #define BOOST_HANA_TUPLE_HPP #include <boost/hana/fwd/tuple.hpp> #include <boost/hana/basic_tuple.hpp> #include <boost/hana/bool.hpp> #include <boost/hana/config.hpp> #include <boost/hana/detail/decay.hpp> #include <boost/hana/detail/fast_and.hpp> #include <boost/hana/detail/index_if.hpp> #include <boost/hana/detail/intrinsics.hpp> #include <boost/hana/detail/operators/adl.hpp> #include <boost/hana/detail/operators/comparable.hpp> #include <boost/hana/detail/operators/iterable.hpp> #include <boost/hana/detail/operators/monad.hpp> #include <boost/hana/detail/operators/orderable.hpp> #include <boost/hana/fwd/at.hpp> #include <boost/hana/fwd/core/make.hpp> #include <boost/hana/fwd/drop_front.hpp> #include <boost/hana/fwd/index_if.hpp> #include <boost/hana/fwd/is_empty.hpp> #include <boost/hana/fwd/length.hpp> #include <boost/hana/fwd/optional.hpp> #include <boost/hana/fwd/unpack.hpp> #include <boost/hana/type.hpp> // required by fwd decl of tuple_t #include <cstddef> #include <type_traits> #include <utility> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <typename Xs, typename Ys, std::size_t ...n> constexpr void assign(Xs& xs, Ys&& ys, std::index_sequence<n...>) { int sequence[] = {int{}, ((void)( hana::at_c<n>(xs) = hana::at_c<n>(static_cast<Ys&&>(ys)) ), int{})...}; (void)sequence; } struct from_index_sequence_t { }; template <typename Tuple, typename ...Yn> struct is_same_tuple : std::false_type { }; template <typename Tuple> struct is_same_tuple<typename detail::decay<Tuple>::type, Tuple> : std::true_type { }; template <bool SameTuple, bool SameNumberOfElements, typename Tuple, typename ...Yn> struct enable_tuple_variadic_ctor; template <typename ...Xn, typename ...Yn> struct enable_tuple_variadic_ctor<false, true, hana::tuple<Xn...>, Yn...> : std::enable_if< detail::fast_and<BOOST_HANA_TT_IS_CONSTRUCTIBLE(Xn, Yn&&)...>::value > { }; } ////////////////////////////////////////////////////////////////////////// // tuple ////////////////////////////////////////////////////////////////////////// template <> #ifdef BOOST_HANA_WORKAROUND_MSVC_EMPTYBASE struct __declspec(empty_bases) tuple<> final #else struct tuple<> final #endif : detail::operators::adl<tuple<>> , detail::iterable_operators<tuple<>> { constexpr tuple() { } using hana_tag = tuple_tag; }; template <typename ...Xn> #ifdef BOOST_HANA_WORKAROUND_MSVC_EMPTYBASE struct __declspec(empty_bases) tuple final #else struct tuple final #endif : detail::operators::adl<tuple<Xn...>> , detail::iterable_operators<tuple<Xn...>> { basic_tuple<Xn...> storage_; using hana_tag = tuple_tag; private: template <typename Other, std::size_t ...n> explicit constexpr tuple(detail::from_index_sequence_t, std::index_sequence<n...>, Other&& other) : storage_(hana::at_c<n>(static_cast<Other&&>(other))...) { } public: template <typename ...dummy, typename = typename std::enable_if< detail::fast_and<BOOST_HANA_TT_IS_CONSTRUCTIBLE(Xn, dummy...)...>::value >::type> constexpr tuple() : storage_() { } template <typename ...dummy, typename = typename std::enable_if< detail::fast_and<BOOST_HANA_TT_IS_CONSTRUCTIBLE(Xn, Xn const&, dummy...)...>::value >::type> constexpr tuple(Xn const& ...xn) : storage_(xn...) { } template <typename ...Yn, typename = typename detail::enable_tuple_variadic_ctor< detail::is_same_tuple<tuple, Yn...>::value, sizeof...(Xn) == sizeof...(Yn), tuple, Yn... >::type> constexpr tuple(Yn&& ...yn) : storage_(static_cast<Yn&&>(yn)...) { } template <typename ...Yn, typename = typename std::enable_if< detail::fast_and<BOOST_HANA_TT_IS_CONSTRUCTIBLE(Xn, Yn const&)...>::value >::type> constexpr tuple(tuple<Yn...> const& other) : tuple(detail::from_index_sequence_t{}, std::make_index_sequence<sizeof...(Xn)>{}, other.storage_) { } template <typename ...Yn, typename = typename std::enable_if< detail::fast_and<BOOST_HANA_TT_IS_CONSTRUCTIBLE(Xn, Yn&&)...>::value >::type> constexpr tuple(tuple<Yn...>&& other) : tuple(detail::from_index_sequence_t{}, std::make_index_sequence<sizeof...(Xn)>{}, static_cast<tuple<Yn...>&&>(other).storage_) { } // The three following constructors are required to make sure that // the tuple(Yn&&...) constructor is _not_ preferred over the copy // constructor for unary tuples containing a type that is constructible // from tuple<...>. See test/tuple/cnstr.trap.cpp template <typename ...dummy, typename = typename std::enable_if< detail::fast_and<BOOST_HANA_TT_IS_CONSTRUCTIBLE(Xn, Xn const&, dummy...)...>::value >::type> constexpr tuple(tuple const& other) : tuple(detail::from_index_sequence_t{}, std::make_index_sequence<sizeof...(Xn)>{}, other.storage_) { } template <typename ...dummy, typename = typename std::enable_if< detail::fast_and<BOOST_HANA_TT_IS_CONSTRUCTIBLE(Xn, Xn const&, dummy...)...>::value >::type> constexpr tuple(tuple& other) : tuple(const_cast<tuple const&>(other)) { } template <typename ...dummy, typename = typename std::enable_if< detail::fast_and<BOOST_HANA_TT_IS_CONSTRUCTIBLE(Xn, Xn&&, dummy...)...>::value >::type> constexpr tuple(tuple&& other) : tuple(detail::from_index_sequence_t{}, std::make_index_sequence<sizeof...(Xn)>{}, static_cast<tuple&&>(other).storage_) { } template <typename ...Yn, typename = typename std::enable_if< detail::fast_and<BOOST_HANA_TT_IS_ASSIGNABLE(Xn&, Yn const&)...>::value >::type> constexpr tuple& operator=(tuple<Yn...> const& other) { detail::assign(this->storage_, other.storage_, std::make_index_sequence<sizeof...(Xn)>{}); return *this; } template <typename ...Yn, typename = typename std::enable_if< detail::fast_and<BOOST_HANA_TT_IS_ASSIGNABLE(Xn&, Yn&&)...>::value >::type> constexpr tuple& operator=(tuple<Yn...>&& other) { detail::assign(this->storage_, static_cast<tuple<Yn...>&&>(other).storage_, std::make_index_sequence<sizeof...(Xn)>{}); return *this; } }; ////////////////////////////////////////////////////////////////////////// // Operators ////////////////////////////////////////////////////////////////////////// namespace detail { template <> struct comparable_operators<tuple_tag> { static constexpr bool value = true; }; template <> struct orderable_operators<tuple_tag> { static constexpr bool value = true; }; template <> struct monad_operators<tuple_tag> { static constexpr bool value = true; }; } ////////////////////////////////////////////////////////////////////////// // Foldable ////////////////////////////////////////////////////////////////////////// template <> struct unpack_impl<tuple_tag> { template <typename F> static constexpr decltype(auto) apply(tuple<>&&, F&& f) { return static_cast<F&&>(f)(); } template <typename F> static constexpr decltype(auto) apply(tuple<>&, F&& f) { return static_cast<F&&>(f)(); } template <typename F> static constexpr decltype(auto) apply(tuple<> const&, F&& f) { return static_cast<F&&>(f)(); } template <typename Xs, typename F> static constexpr decltype(auto) apply(Xs&& xs, F&& f) { return hana::unpack(static_cast<Xs&&>(xs).storage_, static_cast<F&&>(f)); } }; template <> struct length_impl<tuple_tag> { template <typename ...Xs> static constexpr auto apply(tuple<Xs...> const&) { return hana::size_c<sizeof...(Xs)>; } }; ////////////////////////////////////////////////////////////////////////// // Iterable ////////////////////////////////////////////////////////////////////////// template <> struct at_impl<tuple_tag> { template <typename Xs, typename N> static constexpr decltype(auto) apply(Xs&& xs, N const&) { constexpr std::size_t index = N::value; return hana::at_c<index>(static_cast<Xs&&>(xs).storage_); } }; template <> struct drop_front_impl<tuple_tag> { template <std::size_t N, typename Xs, std::size_t ...i> static constexpr auto helper(Xs&& xs, std::index_sequence<i...>) { return hana::make<tuple_tag>(hana::at_c<i+N>(static_cast<Xs&&>(xs))...); } template <typename Xs, typename N> static constexpr auto apply(Xs&& xs, N const&) { constexpr std::size_t len = decltype(hana::length(xs))::value; return helper<N::value>(static_cast<Xs&&>(xs), std::make_index_sequence< (N::value < len) ? len - N::value : 0 >{}); } }; template <> struct is_empty_impl<tuple_tag> { template <typename ...Xs> static constexpr auto apply(tuple<Xs...> const&) { return hana::bool_c<sizeof...(Xs) == 0>; } }; // compile-time optimizations (to reduce the # of function instantiations) template <std::size_t n, typename ...Xs> constexpr decltype(auto) at_c(tuple<Xs...> const& xs) { return hana::at_c<n>(xs.storage_); } template <std::size_t n, typename ...Xs> constexpr decltype(auto) at_c(tuple<Xs...>& xs) { return hana::at_c<n>(xs.storage_); } template <std::size_t n, typename ...Xs> constexpr decltype(auto) at_c(tuple<Xs...>&& xs) { return hana::at_c<n>(static_cast<tuple<Xs...>&&>(xs).storage_); } template <> struct index_if_impl<tuple_tag> { template <typename ...Xs, typename Pred> static constexpr auto apply(tuple<Xs...> const&, Pred const&) -> typename detail::index_if<Pred, Xs...>::type { return {}; } }; ////////////////////////////////////////////////////////////////////////// // Sequence ////////////////////////////////////////////////////////////////////////// template <> struct Sequence<tuple_tag> { static constexpr bool value = true; }; template <> struct make_impl<tuple_tag> { template <typename ...Xs> static constexpr tuple<typename detail::decay<Xs>::type...> apply(Xs&& ...xs) { return {static_cast<Xs&&>(xs)...}; } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_TUPLE_HPP PK �\�[]��� � extract.hppnu �[��� /*! @file Defines `boost::hana::extract`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EXTRACT_HPP #define BOOST_HANA_EXTRACT_HPP #include <boost/hana/fwd/extract.hpp> #include <boost/hana/concept/comonad.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename W_> constexpr decltype(auto) extract_t::operator()(W_&& w) const { using W = typename hana::tag_of<W_>::type; using Extract = BOOST_HANA_DISPATCH_IF(extract_impl<W>, hana::Comonad<W>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Comonad<W>::value, "hana::extract(w) requires 'w' to be a Comonad"); #endif return Extract::apply(static_cast<W_&&>(w)); } //! @endcond template <typename W, bool condition> struct extract_impl<W, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...args) = delete; }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_EXTRACT_HPP PK �\�[�y'Z� � and.hppnu �[��� /*! @file Defines `boost::hana::and_`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_AND_HPP #define BOOST_HANA_AND_HPP #include <boost/hana/fwd/and.hpp> #include <boost/hana/concept/logical.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/variadic/foldl1.hpp> #include <boost/hana/if.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename X, typename Y> constexpr decltype(auto) and_t::operator()(X&& x, Y&& y) const { using Bool = typename hana::tag_of<X>::type; using And = BOOST_HANA_DISPATCH_IF(and_impl<Bool>, hana::Logical<Bool>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Logical<Bool>::value, "hana::and_(x, y) requires 'x' to be a Logical"); #endif return And::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); } template <typename X, typename ...Y> constexpr decltype(auto) and_t::operator()(X&& x, Y&& ...y) const { return detail::variadic::foldl1( *this, static_cast<X&&>(x), static_cast<Y&&>(y)... ); } //! @endcond template <typename L, bool condition> struct and_impl<L, when<condition>> : default_ { template <typename X, typename Y> static constexpr decltype(auto) apply(X&& x, Y&& y) { return hana::if_(x, static_cast<Y&&>(y), x); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_AND_HPP PK �\�[�y�� � concat.hppnu �[��� /*! @file Defines `boost::hana::concat`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CONCAT_HPP #define BOOST_HANA_CONCAT_HPP #include <boost/hana/fwd/concat.hpp> #include <boost/hana/at.hpp> #include <boost/hana/concept/monad_plus.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/length.hpp> #include <cstddef> #include <type_traits> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Ys> constexpr auto concat_t::operator()(Xs&& xs, Ys&& ys) const { using M = typename hana::tag_of<Xs>::type; using Concat = BOOST_HANA_DISPATCH_IF(concat_impl<M>, hana::MonadPlus<M>::value && std::is_same<typename hana::tag_of<Ys>::type, M>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(std::is_same<typename hana::tag_of<Ys>::type, M>::value, "hana::concat(xs, ys) requires 'xs' and 'ys' to have the same tag"); static_assert(hana::MonadPlus<M>::value, "hana::concat(xs, ys) requires 'xs' and 'ys' to be MonadPlus"); #endif return Concat::apply(static_cast<Xs&&>(xs), static_cast<Ys&&>(ys)); } //! @endcond template <typename M, bool condition> struct concat_impl<M, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; template <typename S> struct concat_impl<S, when<Sequence<S>::value>> { template <typename Xs, typename Ys, std::size_t ...xi, std::size_t ...yi> static constexpr auto concat_helper(Xs&& xs, Ys&& ys, std::index_sequence<xi...>, std::index_sequence<yi...>) { return hana::make<S>( hana::at_c<xi>(static_cast<Xs&&>(xs))..., hana::at_c<yi>(static_cast<Ys&&>(ys))... ); } template <typename Xs, typename Ys> static constexpr auto apply(Xs&& xs, Ys&& ys) { constexpr std::size_t xi = decltype(hana::length(xs))::value; constexpr std::size_t yi = decltype(hana::length(ys))::value; return concat_helper(static_cast<Xs&&>(xs), static_cast<Ys&&>(ys), std::make_index_sequence<xi>{}, std::make_index_sequence<yi>{}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CONCAT_HPP PK �\�[��>o� � count.hppnu �[��� /*! @file Defines `boost::hana::count`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_COUNT_HPP #define BOOST_HANA_COUNT_HPP #include <boost/hana/fwd/count.hpp> #include <boost/hana/concept/foldable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/count_if.hpp> #include <boost/hana/equal.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Value> constexpr auto count_t::operator()(Xs&& xs, Value&& value) const { using S = typename hana::tag_of<Xs>::type; using Count = BOOST_HANA_DISPATCH_IF(count_impl<S>, hana::Foldable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Foldable<S>::value, "hana::count(xs, value) requires 'xs' to be Foldable"); #endif return Count::apply(static_cast<Xs&&>(xs), static_cast<Value&&>(value)); } //! @endcond template <typename T, bool condition> struct count_impl<T, when<condition>> : default_ { template <typename Xs, typename Value> static constexpr auto apply(Xs&& xs, Value&& value) { return hana::count_if(static_cast<Xs&&>(xs), hana::equal.to(static_cast<Value&&>(value))); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_COUNT_HPP PK �\�[�h�N length.hppnu �[��� /*! @file Defines `boost::hana::length`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_LENGTH_HPP #define BOOST_HANA_LENGTH_HPP #include <boost/hana/fwd/length.hpp> #include <boost/hana/concept/foldable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/integral_constant.hpp> #include <boost/hana/unpack.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs> constexpr auto length_t::operator()(Xs const& xs) const { using S = typename hana::tag_of<Xs>::type; using Length = BOOST_HANA_DISPATCH_IF(length_impl<S>, hana::Foldable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Foldable<S>::value, "hana::length(xs) requires 'xs' to be Foldable"); #endif return Length::apply(xs); } //! @endcond namespace detail { struct argn { template <typename ...Xs> constexpr hana::size_t<sizeof...(Xs)> operator()(Xs const& ...) const { return {}; } }; } template <typename T, bool condition> struct length_impl<T, when<condition>> : default_ { template <typename Xs> static constexpr auto apply(Xs const& xs) { return hana::unpack(xs, detail::argn{}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_LENGTH_HPP PK �\�[% { { at.hppnu �[��� /*! @file Defines `boost::hana::at` and `boost::hana::at_c`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_AT_HPP #define BOOST_HANA_AT_HPP #include <boost/hana/fwd/at.hpp> #include <boost/hana/concept/integral_constant.hpp> #include <boost/hana/concept/iterable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/integral_constant.hpp> #include <cstddef> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename N> constexpr decltype(auto) at_t::operator()(Xs&& xs, N const& n) const { using It = typename hana::tag_of<Xs>::type; using At = BOOST_HANA_DISPATCH_IF(at_impl<It>, hana::Iterable<It>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Iterable<It>::value, "hana::at(xs, n) requires 'xs' to be an Iterable"); static_assert(hana::IntegralConstant<N>::value, "hana::at(xs, n) requires 'n' to be an IntegralConstant"); #endif return At::apply(static_cast<Xs&&>(xs), n); } //! @endcond template <typename It, bool condition> struct at_impl<It, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; template <std::size_t n, typename Xs> constexpr decltype(auto) at_c(Xs&& xs) { return hana::at(static_cast<Xs&&>(xs), hana::size_t<n>{}); } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_AT_HPP PK �\�[�d� � adjust_if.hppnu �[��� /*! @file Defines `boost::hana::adjust_if`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_ADJUST_IF_HPP #define BOOST_HANA_ADJUST_IF_HPP #include <boost/hana/fwd/adjust_if.hpp> #include <boost/hana/bool.hpp> #include <boost/hana/concept/functor.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/if.hpp> #include <boost/hana/transform.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Pred, typename F> constexpr auto adjust_if_t::operator()(Xs&& xs, Pred const& pred, F const& f) const { using S = typename hana::tag_of<Xs>::type; using AdjustIf = BOOST_HANA_DISPATCH_IF(adjust_if_impl<S>, hana::Functor<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Functor<S>::value, "hana::adjust_if(xs, pred, f) requires 'xs' to be a Functor"); #endif return AdjustIf::apply(static_cast<Xs&&>(xs), pred, f); } //! @endcond namespace detail { template <typename Pred, typename F> struct apply_if { Pred const& pred; F const& f; template <typename X> constexpr decltype(auto) helper(bool cond, X&& x) const { return cond ? f(static_cast<X&&>(x)) : static_cast<X&&>(x); } template <typename X> constexpr decltype(auto) helper(hana::true_, X&& x) const { return f(static_cast<X&&>(x)); } template <typename X> constexpr decltype(auto) helper(hana::false_, X&& x) const { return static_cast<X&&>(x); } template <typename X> constexpr decltype(auto) operator()(X&& x) const { auto cond = hana::if_(pred(x), hana::true_c, hana::false_c); return this->helper(cond, static_cast<X&&>(x)); } }; } template <typename Fun, bool condition> struct adjust_if_impl<Fun, when<condition>> : default_ { template <typename Xs, typename Pred, typename F> static constexpr auto apply(Xs&& xs, Pred const& pred, F const& f) { return hana::transform(static_cast<Xs&&>(xs), detail::apply_if<Pred, F>{pred, f}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_ADJUST_IF_HPP PK �\�[7X�D D zip_shortest.hppnu �[��� /*! @file Defines `boost::hana::zip_shortest`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_ZIP_SHORTEST_HPP #define BOOST_HANA_ZIP_SHORTEST_HPP #include <boost/hana/fwd/zip_shortest.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/fast_and.hpp> #include <boost/hana/tuple.hpp> #include <boost/hana/zip_shortest_with.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename ...Ys> constexpr auto zip_shortest_t::operator()(Xs&& xs, Ys&& ...ys) const { #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(detail::fast_and< hana::Sequence<Xs>::value, hana::Sequence<Ys>::value... >::value, "hana::zip_shortest(xs, ys...) requires 'xs' and 'ys...' to be Sequences"); #endif return zip_shortest_impl<typename hana::tag_of<Xs>::type>::apply( static_cast<Xs&&>(xs), static_cast<Ys&&>(ys)... ); } //! @endcond template <typename S, bool condition> struct zip_shortest_impl<S, when<condition>> : default_ { template <typename ...Xs> static constexpr decltype(auto) apply(Xs&& ...xs) { return hana::zip_shortest_with(hana::make_tuple, static_cast<Xs&&>(xs)...); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_ZIP_SHORTEST_HPP PK �\�[�m�� � equal.hppnu �[��� /*! @file Defines `boost::hana::equal`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EQUAL_HPP #define BOOST_HANA_EQUAL_HPP #include <boost/hana/fwd/equal.hpp> #include <boost/hana/accessors.hpp> #include <boost/hana/all_of.hpp> #include <boost/hana/and.hpp> #include <boost/hana/at.hpp> #include <boost/hana/bool.hpp> #include <boost/hana/concept/comparable.hpp> #include <boost/hana/concept/constant.hpp> #include <boost/hana/concept/product.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/concept/struct.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/common.hpp> #include <boost/hana/core/to.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/concepts.hpp> #include <boost/hana/detail/has_common_embedding.hpp> #include <boost/hana/detail/nested_to.hpp> // required by fwd decl #include <boost/hana/first.hpp> #include <boost/hana/if.hpp> #include <boost/hana/length.hpp> #include <boost/hana/second.hpp> #include <boost/hana/value.hpp> #include <cstddef> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename X, typename Y> constexpr auto equal_t::operator()(X&& x, Y&& y) const { using T = typename hana::tag_of<X>::type; using U = typename hana::tag_of<Y>::type; using Equal = equal_impl<T, U>; return Equal::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); } //! @endcond template <typename T, typename U, bool condition> struct equal_impl<T, U, when<condition>> : default_ { template <typename X, typename Y> static constexpr auto apply(X const&, Y const&) { // Delay the static_assert by ensuring T_ is dependent. using T_ = typename hana::tag_of<X>::type; static_assert(!hana::is_convertible<T_, U>::value && !hana::is_convertible<U, T_>::value, "No default implementation of hana::equal is provided for related " "types that can't be safely embedded into a common type, because " "those are most likely programming errors. If this is really what " "you want, you can manually convert both objects to a common " "Comparable type before performing the comparison. If you think " "you have made your types Comparable but you see this, perhaps you " "forgot to define some of the necessary methods for an automatic " "model of Comparable to kick in. A possible culprit is defining " "'operator==' but not 'operator!='."); return hana::false_c; } }; // Cross-type overload template <typename T, typename U> struct equal_impl<T, U, when< detail::has_nontrivial_common_embedding<Comparable, T, U>::value && !detail::EqualityComparable<T, U>::value >> { using C = typename hana::common<T, U>::type; template <typename X, typename Y> static constexpr auto apply(X&& x, Y&& y) { return hana::equal(hana::to<C>(static_cast<X&&>(x)), hana::to<C>(static_cast<Y&&>(y))); } }; ////////////////////////////////////////////////////////////////////////// // Model for EqualityComparable data types ////////////////////////////////////////////////////////////////////////// template <typename T, typename U> struct equal_impl<T, U, when<detail::EqualityComparable<T, U>::value>> { template <typename X, typename Y> static constexpr auto apply(X&& x, Y&& y) { return static_cast<X&&>(x) == static_cast<Y&&>(y); } }; ////////////////////////////////////////////////////////////////////////// // Model for Constants wrapping a Comparable ////////////////////////////////////////////////////////////////////////// template <typename C> struct equal_impl<C, C, when< hana::Constant<C>::value && Comparable<typename C::value_type>::value >> { template <typename X, typename Y> static constexpr auto apply(X const&, Y const&) { constexpr auto eq = hana::equal(hana::value<X>(), hana::value<Y>()); constexpr bool truth_value = hana::if_(eq, true, false); return hana::bool_<truth_value>{}; } }; ////////////////////////////////////////////////////////////////////////// // Comparable for Products ////////////////////////////////////////////////////////////////////////// template <typename T, typename U> struct equal_impl<T, U, when<hana::Product<T>::value && hana::Product<U>::value>> { template <typename X, typename Y> static constexpr auto apply(X const& x, Y const& y) { return hana::and_( hana::equal(hana::first(x), hana::first(y)), hana::equal(hana::second(x), hana::second(y)) ); } }; ////////////////////////////////////////////////////////////////////////// // Comparable for Sequences ////////////////////////////////////////////////////////////////////////// namespace detail { template <typename Xs, typename Ys, std::size_t Length> struct compare_finite_sequences { Xs const& xs; Ys const& ys; template <std::size_t i> constexpr auto apply(hana::false_, hana::true_) const { return compare_finite_sequences::apply<i+1>( hana::bool_<i+1 == Length>{}, hana::if_(hana::equal(hana::at_c<i>(xs), hana::at_c<i>(ys)), hana::true_c, hana::false_c) ); } template <std::size_t i> constexpr auto apply(hana::false_, hana::false_) const { return hana::false_c; } template <std::size_t i, typename Result> constexpr auto apply(hana::true_, Result r) const { return r; } template <std::size_t i> constexpr bool apply(hana::false_, bool b) const { return b && compare_finite_sequences::apply<i+1>( hana::bool_<i+1 == Length>{}, hana::if_(hana::equal(hana::at_c<i>(xs), hana::at_c<i>(ys)), hana::true_c, hana::false_c) ); } }; } template <typename T, typename U> struct equal_impl<T, U, when<Sequence<T>::value && hana::Sequence<U>::value>> { template <typename Xs, typename Ys> static constexpr auto apply(Xs const& xs, Ys const& ys) { constexpr std::size_t xs_size = decltype(hana::length(xs))::value; constexpr std::size_t ys_size = decltype(hana::length(ys))::value; detail::compare_finite_sequences<Xs, Ys, xs_size> comp{xs, ys}; return comp.template apply<0>(hana::bool_<xs_size == 0>{}, hana::bool_<xs_size == ys_size>{}); } }; namespace detail { template <typename X, typename Y> struct compare_struct_members { X const& x; Y const& y; template <typename Member> constexpr auto operator()(Member&& member) const { auto accessor = hana::second(static_cast<Member&&>(member)); return hana::equal(accessor(x), accessor(y)); } }; } template <typename S> struct equal_impl<S, S, when< hana::Struct<S>::value && !detail::EqualityComparable<S, S>::value >> { template <typename X, typename Y> static constexpr auto apply(X const& x, Y const& y) { return hana::all_of(hana::accessors<S>(), detail::compare_struct_members<X, Y>{x, y}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_EQUAL_HPP PK �\�[!:� f f ext/boost.hppnu �[��� /*! @file Includes all the adaptors for external Boost libraries. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EXT_BOOST_HPP #define BOOST_HANA_EXT_BOOST_HPP //! @ingroup group-ext //! @defgroup group-ext-boost Other Boost adapters //! Adapters for miscellaneous heterogeneous containers in Boost. #include <boost/hana/ext/boost/fusion.hpp> #include <boost/hana/ext/boost/mpl.hpp> #include <boost/hana/ext/boost/tuple.hpp> #endif // !BOOST_HANA_EXT_BOOST_HPP PK �\�[~�7�I I ext/boost/mpl/list.hppnu �[��� /*! @file Adapts `boost::mpl::list` for use with Hana. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EXT_BOOST_MPL_LIST_HPP #define BOOST_HANA_EXT_BOOST_MPL_LIST_HPP #include <boost/hana/concept/foldable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/ext/boost/mpl/integral_c.hpp> #include <boost/hana/fwd/at.hpp> #include <boost/hana/fwd/core/to.hpp> #include <boost/hana/fwd/core/tag_of.hpp> #include <boost/hana/fwd/drop_front.hpp> #include <boost/hana/fwd/equal.hpp> #include <boost/hana/fwd/is_empty.hpp> #include <boost/hana/fwd/less.hpp> #include <boost/hana/integral_constant.hpp> #include <boost/hana/length.hpp> #include <boost/hana/type.hpp> #include <boost/hana/unpack.hpp> #include <boost/mpl/at.hpp> #include <boost/mpl/empty.hpp> #include <boost/mpl/equal.hpp> #include <boost/mpl/list.hpp> #include <boost/mpl/sequence_tag.hpp> #include <boost/mpl/size.hpp> #include <cstddef> #include <type_traits> #include <utility> #ifdef BOOST_HANA_DOXYGEN_INVOKED namespace boost { namespace mpl { //! @ingroup group-ext-mpl //! Adapter for Boost.MPL lists. //! //! //! Modeled concepts //! ---------------- //! It is possible for MPL lists to model a couple of concepts. //! However, because they are only able to hold types, they lack //! the generality required to model concepts like `Functor`, //! `Sequence` and other related concepts. //! //! 1. `Comparable`\n //! Two MPL lists are equal if and only if they contain the same //! number of types, and if all those types are equal. //! @include example/ext/boost/mpl/list/comparable.cpp //! //! 2. `Foldable`\n //! Folding a MPL list is equivalent to folding it as a `Sequence`. //! @include example/ext/boost/mpl/list/foldable.cpp //! //! 3. `Iterable`\n //! Iterating over a MPL list is just iterating over each of the //! types it contains, as if it were a `Sequence`. //! @include example/ext/boost/mpl/list/iterable.cpp //! //! 4. `Searchable`\n //! A MPL list can be searched as if it were a tuple containing //! `hana::type`s. //! @include example/ext/boost/mpl/list/searchable.cpp //! //! //! Conversion from any `Foldable` //! ------------------------------ //! A MPL list can be created from any `Foldable`. More precisely, //! for a `Foldable` `xs` whose linearization is `[x1, ..., xn]`, //! @code //! to<ext::boost::mpl::list_tag>(xs) == mpl::list<t1, ..., tn>{} //! @endcode //! where `tk` is the type of `xk`, or the type contained in `xk` if //! `xk` is a `hana::type`. //! @warning //! The limitations on the size of `mpl::list`s are inherited by //! this conversion utility, and hence trying to convert a `Foldable` //! containing more than [BOOST_MPL_LIMIT_LIST_SIZE][1] elements is //! an error. //! @include example/ext/boost/mpl/list/conversion.cpp //! //! [1]: http://www.boost.org/doc/libs/release/libs/mpl/doc/refmanual/limit-list-size.html template <typename ...T> struct list { }; }} #endif BOOST_HANA_NAMESPACE_BEGIN namespace ext { namespace boost { namespace mpl { using list_tag = ::boost::mpl::sequence_tag< ::boost::mpl::list<>>::type; }}} template <typename T> struct tag_of<T, when< std::is_same< typename ::boost::mpl::sequence_tag<T>::type, ::boost::mpl::sequence_tag< ::boost::mpl::list<>>::type >::value >> { using type = ext::boost::mpl::list_tag; }; ////////////////////////////////////////////////////////////////////////// // Comparable ////////////////////////////////////////////////////////////////////////// template <> struct equal_impl<ext::boost::mpl::list_tag, ext::boost::mpl::list_tag> { template <typename Xs, typename Ys> static constexpr auto apply(Xs const&, Ys const&) { return typename ::boost::mpl::equal<Xs, Ys>::type{}; } }; ////////////////////////////////////////////////////////////////////////// // Foldable ////////////////////////////////////////////////////////////////////////// template <> struct length_impl<ext::boost::mpl::list_tag> { template <typename Xs> static constexpr auto apply(Xs const&) { return hana::size_c< ::boost::mpl::size<Xs>::type::value>; } }; ////////////////////////////////////////////////////////////////////////// // Iterable ////////////////////////////////////////////////////////////////////////// template <> struct at_impl<ext::boost::mpl::list_tag> { template <typename Ts, typename N> static constexpr auto apply(Ts const&, N const&) { constexpr std::size_t n = N::value; using T = typename ::boost::mpl::at_c<Ts, n>::type; return hana::type_c<T>; } }; template <> struct drop_front_impl<ext::boost::mpl::list_tag> { template <std::size_t n, typename Xs, std::size_t ...i> static constexpr auto drop_front_helper(Xs const&, std::index_sequence<i...>) { return boost::mpl::list< typename boost::mpl::at_c<Xs, n + i>::type... >{}; } template <typename Xs, typename N> static constexpr auto apply(Xs const& xs, N const&) { constexpr std::size_t n = N::value; constexpr std::size_t len = decltype(hana::length(xs))::value; return drop_front_helper<n>(xs, std::make_index_sequence<(n < len ? len - n : 0)>{}); } }; template <> struct is_empty_impl<ext::boost::mpl::list_tag> { template <typename Xs> static constexpr auto apply(Xs const&) { return typename ::boost::mpl::empty<Xs>::type{}; } }; ////////////////////////////////////////////////////////////////////////// // Conversion from a Foldable ////////////////////////////////////////////////////////////////////////// template <typename F> struct to_impl<ext::boost::mpl::list_tag, F, when<hana::Foldable<F>::value>> { template <typename Xs> static constexpr decltype(auto) apply(Xs&& xs) { auto list_type = hana::unpack(static_cast<Xs&&>(xs), hana::template_<::boost::mpl::list>); return typename decltype(list_type)::type{}; } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_EXT_BOOST_MPL_LIST_HPP PK �\�[� ext/boost/mpl/integral_c.hppnu �[��� /*! @file Adapts Boost.MPL IntegralConstants for use with Hana. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EXT_BOOST_MPL_INTEGRAL_C_HPP #define BOOST_HANA_EXT_BOOST_MPL_INTEGRAL_C_HPP #include <boost/hana/concept/integral_constant.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/fwd/core/to.hpp> #include <boost/mpl/integral_c.hpp> #include <boost/mpl/integral_c_tag.hpp> #include <type_traits> #ifdef BOOST_HANA_DOXYGEN_INVOKED namespace boost { namespace mpl { //! @ingroup group-ext-mpl //! Adapter for IntegralConstants from the Boost.MPL. //! //! Provided models //! --------------- //! 1. `Constant` and `IntegralConstant`\n //! A Boost.MPL IntegralConstant is a model of the `IntegralConstant` //! and `Constant` concepts just like `hana::integral_constant`s are. //! As a consequence, they are also implicitly a model of the concepts //! provided for all models of `Constant`. //! @include example/ext/boost/mpl/integral_c/integral_constant.cpp template <typename T, T v> struct integral_c { }; }} #endif BOOST_HANA_NAMESPACE_BEGIN namespace ext { namespace boost { namespace mpl { template <typename T> struct integral_c_tag { using value_type = T; }; }}} template <typename T> struct tag_of<T, when< std::is_same< typename T::tag, ::boost::mpl::integral_c_tag >::value >> { using type = ext::boost::mpl::integral_c_tag< typename hana::tag_of<typename T::value_type>::type >; }; ////////////////////////////////////////////////////////////////////////// // IntegralConstant/Constant ////////////////////////////////////////////////////////////////////////// template <typename T> struct IntegralConstant<ext::boost::mpl::integral_c_tag<T>> { static constexpr bool value = true; }; template <typename T, typename C> struct to_impl<ext::boost::mpl::integral_c_tag<T>, C, when<hana::IntegralConstant<C>::value> > : embedding<is_embedded<typename C::value_type, T>::value> { template <typename N> static constexpr auto apply(N const&) { return ::boost::mpl::integral_c<T, N::value>{}; } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_EXT_BOOST_MPL_INTEGRAL_C_HPP PK �\�[b�T ext/boost/mpl/vector.hppnu �[��� /*! @file Adapts `boost::mpl::vector` for use with Hana. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EXT_BOOST_MPL_VECTOR_HPP #define BOOST_HANA_EXT_BOOST_MPL_VECTOR_HPP #include <boost/hana/concept/foldable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/ext/boost/mpl/integral_c.hpp> #include <boost/hana/fwd/at.hpp> #include <boost/hana/fwd/core/to.hpp> #include <boost/hana/fwd/core/tag_of.hpp> #include <boost/hana/fwd/drop_front.hpp> #include <boost/hana/fwd/equal.hpp> #include <boost/hana/fwd/is_empty.hpp> #include <boost/hana/fwd/less.hpp> #include <boost/hana/integral_constant.hpp> #include <boost/hana/length.hpp> #include <boost/hana/type.hpp> #include <boost/hana/unpack.hpp> #include <boost/mpl/at.hpp> #include <boost/mpl/empty.hpp> #include <boost/mpl/equal.hpp> #include <boost/mpl/sequence_tag.hpp> #include <boost/mpl/size.hpp> #include <boost/mpl/vector.hpp> #include <cstddef> #include <type_traits> #include <utility> #ifdef BOOST_HANA_DOXYGEN_INVOKED namespace boost { namespace mpl { //! @ingroup group-ext-mpl //! Adapter for Boost.MPL vectors. //! //! //! Modeled concepts //! ---------------- //! It is possible for MPL vectors to model a couple of concepts. //! However, because they are only able to hold types, they lack //! the generality required to model concepts like `Functor`, //! `Sequence` and other related concepts. //! //! 1. `Comparable`\n //! Two MPL vectors are equal if and only if they contain the same //! number of types, and if all those types are equal. //! @include example/ext/boost/mpl/vector/comparable.cpp //! //! 2. `Foldable`\n //! Folding a MPL vector is equivalent to folding it as a `Sequence`. //! @include example/ext/boost/mpl/vector/foldable.cpp //! //! 3. `Iterable`\n //! Iterating over a MPL vector is just iterating over each of the //! types it contains, as if it were a `Sequence`. //! @include example/ext/boost/mpl/vector/iterable.cpp //! //! 4. `Searchable`\n //! A MPL vector can be searched as if it were a tuple containing //! `hana::type`s. //! @include example/ext/boost/mpl/vector/searchable.cpp //! //! //! Conversion from any `Foldable` //! ------------------------------ //! A MPL vector can be created from any `Foldable`. More precisely, //! for a `Foldable` `xs` whose linearization is `[x1, ..., xn]`, //! @code //! to<ext::boost::mpl::vector_tag>(xs) == mpl::vector<t1, ..., tn> //! @endcode //! where `tk` is the type of `xk`, or the type contained in `xk` if //! `xk` is a `hana::type`. //! @warning //! The limitations on the size of `mpl::vector`s are inherited by //! this conversion utility, and hence trying to convert a `Foldable` //! containing more than [BOOST_MPL_LIMIT_VECTOR_SIZE][1] elements //! is an error. //! @include example/ext/boost/mpl/vector/conversion.cpp //! //! [1]: http://www.boost.org/doc/libs/release/libs/mpl/doc/refmanual/limit-vector-size.html template <typename ...T> struct vector { }; }} #endif BOOST_HANA_NAMESPACE_BEGIN namespace ext { namespace boost { namespace mpl { using vector_tag = ::boost::mpl::sequence_tag< ::boost::mpl::vector<>>::type; }}} namespace mpl_detail { // When `BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES` is not defined (e.g. on // MSVC), different MPL sequences (like vector0 and vector1) have different // tags, so we need to take that into account when we compare them. #ifndef BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES template <typename T1, typename T2> struct is_same_mpl_vector_tag : std::false_type { }; template <template <long> class Tag, long x, long y> struct is_same_mpl_vector_tag<Tag<x>, Tag<y>> : std::true_type { }; #else template <typename T1, typename T2> struct is_same_mpl_vector_tag : std::is_same<T1, T2> { }; #endif } template <typename T> struct tag_of<T, when< mpl_detail::is_same_mpl_vector_tag< typename ::boost::mpl::sequence_tag<T>::type, ::boost::mpl::sequence_tag< ::boost::mpl::vector<>>::type >::value >> { using type = ext::boost::mpl::vector_tag; }; ////////////////////////////////////////////////////////////////////////// // Comparable ////////////////////////////////////////////////////////////////////////// template <> struct equal_impl<ext::boost::mpl::vector_tag, ext::boost::mpl::vector_tag> { template <typename Xs, typename Ys> static constexpr auto apply(Xs const&, Ys const&) { return typename ::boost::mpl::equal<Xs, Ys>::type{}; } }; ////////////////////////////////////////////////////////////////////////// // Foldable ////////////////////////////////////////////////////////////////////////// template <> struct length_impl<ext::boost::mpl::vector_tag> { template <typename Xs> static constexpr auto apply(Xs const&) { return hana::size_c< ::boost::mpl::size<Xs>::type::value>; } }; ////////////////////////////////////////////////////////////////////////// // Iterable ////////////////////////////////////////////////////////////////////////// template <> struct at_impl<ext::boost::mpl::vector_tag> { template <typename Ts, typename N> static constexpr auto apply(Ts const&, N const&) { constexpr std::size_t n = N::value; using T = typename ::boost::mpl::at_c<Ts, n>::type; return hana::type_c<T>; } }; template <> struct drop_front_impl<ext::boost::mpl::vector_tag> { template <std::size_t n, typename Xs, std::size_t ...i> static constexpr auto drop_front_helper(Xs const&, std::index_sequence<i...>) { return boost::mpl::vector< typename boost::mpl::at_c<Xs, n + i>::type... >{}; } template <typename Xs, typename N> static constexpr auto apply(Xs const& xs, N const&) { constexpr std::size_t n = N::value; constexpr std::size_t len = decltype(hana::length(xs))::value; return drop_front_helper<n>(xs, std::make_index_sequence<(n < len ? len - n : 0)>{}); } }; template <> struct is_empty_impl<ext::boost::mpl::vector_tag> { template <typename xs> static constexpr auto apply(xs) { return typename ::boost::mpl::empty<xs>::type{}; } }; ////////////////////////////////////////////////////////////////////////// // Conversion from a Foldable ////////////////////////////////////////////////////////////////////////// template <typename F> struct to_impl<ext::boost::mpl::vector_tag, F, when<hana::Foldable<F>::value>> { template <typename Xs> static constexpr auto apply(Xs const& xs) { auto vector_type = hana::unpack(xs, hana::template_<boost::mpl::vector>); return typename decltype(vector_type)::type{}; } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_EXT_BOOST_MPL_VECTOR_HPP PK �\�[s��ټ � ext/boost/fusion/deque.hppnu �[��� /*! @file Adapts `boost::fusion::deque` for use with Hana. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EXT_BOOST_FUSION_DEQUE_HPP #define BOOST_HANA_EXT_BOOST_FUSION_DEQUE_HPP #include <boost/hana/at.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/config.hpp> #include <boost/hana/ext/boost/fusion/detail/common.hpp> #include <boost/hana/fwd/core/make.hpp> #include <boost/hana/fwd/core/tag_of.hpp> #include <boost/hana/fwd/drop_front.hpp> #include <boost/hana/length.hpp> #include <boost/fusion/container/deque.hpp> #include <boost/fusion/container/generation/make_deque.hpp> #include <boost/fusion/support/tag_of.hpp> #include <cstddef> #include <type_traits> #include <utility> #ifdef BOOST_HANA_DOXYGEN_INVOKED namespace boost { namespace fusion { //! @ingroup group-ext-fusion //! Adapter for Boost.Fusion deques. //! //! //! Modeled concepts //! ---------------- //! A Fusion deque is a model of the `Sequence` concept, and all the //! concepts it refines. That makes it essentially the same as a Hana //! tuple, although the complexity of some operations might differ from //! that of a tuple. //! //! @include example/ext/boost/fusion/deque.cpp template <typename ...T> struct deque { }; }} #endif BOOST_HANA_NAMESPACE_BEGIN namespace ext { namespace boost { namespace fusion { struct deque_tag; }}} template <typename T> struct tag_of<T, when< std::is_same< typename ::boost::fusion::traits::tag_of<T>::type, ::boost::fusion::traits::tag_of< ::boost::fusion::deque<> >::type >::value >> { using type = ext::boost::fusion::deque_tag; }; namespace detail { template <> struct is_fusion_sequence<ext::boost::fusion::deque_tag> { static constexpr bool value = true; }; } ////////////////////////////////////////////////////////////////////////// // Iterable (the rest is in detail/common.hpp) ////////////////////////////////////////////////////////////////////////// template <> struct drop_front_impl<ext::boost::fusion::deque_tag> { template <std::size_t n, typename Xs, std::size_t ...i> static constexpr auto drop_front_helper(Xs&& xs, std::index_sequence<i...>) { return hana::make<ext::boost::fusion::deque_tag>( hana::at_c<n + i>(static_cast<Xs&&>(xs))... ); } template <typename Xs, typename N> static constexpr auto apply(Xs&& xs, N const&) { constexpr std::size_t n = N::value; constexpr std::size_t len = decltype(hana::length(xs))::value; return drop_front_helper<n>(static_cast<Xs&&>(xs), std::make_index_sequence<(n < len ? len - n : 0)>{}); } }; ////////////////////////////////////////////////////////////////////////// // Sequence ////////////////////////////////////////////////////////////////////////// template <> struct make_impl<ext::boost::fusion::deque_tag> { template <typename ...Xs> static constexpr auto apply(Xs&& ...xs) { return ::boost::fusion::make_deque(static_cast<Xs&&>(xs)...); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_EXT_BOOST_FUSION_DEQUE_HPP PK �\�[%U/gA A ext/boost/fusion/list.hppnu �[��� /*! @file Adapts `boost::fusion::list` for use with Hana. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EXT_BOOST_FUSION_LIST_HPP #define BOOST_HANA_EXT_BOOST_FUSION_LIST_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/ext/boost/fusion/detail/common.hpp> #include <boost/hana/fwd/at.hpp> #include <boost/hana/fwd/core/make.hpp> #include <boost/hana/fwd/core/tag_of.hpp> #include <boost/hana/fwd/drop_front.hpp> #include <boost/hana/fwd/length.hpp> #include <boost/fusion/algorithm/transformation/pop_front.hpp> #include <boost/fusion/container/generation/make_list.hpp> #include <boost/fusion/container/list.hpp> #include <boost/fusion/container/list/convert.hpp> #include <boost/fusion/support/tag_of.hpp> #include <boost/version.hpp> #include <cstddef> #include <type_traits> #include <utility> #ifdef BOOST_HANA_DOXYGEN_INVOKED namespace boost { namespace fusion { //! @ingroup group-ext-fusion //! Adapter for Boost.Fusion lists. //! //! //! Modeled concepts //! ---------------- //! A Fusion list is a model of the `Sequence` concept, and all the //! concepts it refines. That makes it essentially the same as a Hana //! tuple, although the complexity of some operations might differ from //! that of a tuple. //! //! @include example/ext/boost/fusion/list.cpp template <typename ...T> struct list { }; }} #endif BOOST_HANA_NAMESPACE_BEGIN namespace ext { namespace boost { namespace fusion { struct list_tag; }}} template <typename T> struct tag_of<T, when< std::is_same< typename ::boost::fusion::traits::tag_of<T>::type, ::boost::fusion::traits::tag_of< ::boost::fusion::list<> >::type >::value >> { using type = ext::boost::fusion::list_tag; }; namespace detail { template <> struct is_fusion_sequence<ext::boost::fusion::list_tag> { static constexpr bool value = true; }; } ////////////////////////////////////////////////////////////////////////// // Iterable (the rest is in detail/common.hpp) ////////////////////////////////////////////////////////////////////////// template <> struct drop_front_impl<ext::boost::fusion::list_tag> { template <std::size_t n, typename Xs, std::size_t ...i> static constexpr auto drop_front_helper(Xs&& xs, std::index_sequence<i...>) { return hana::make<ext::boost::fusion::list_tag>( hana::at_c<n + i>(static_cast<Xs&&>(xs))... ); } template <typename Xs, typename N> static constexpr auto apply(Xs&& xs, N const&) { constexpr std::size_t n = N::value; constexpr std::size_t len = decltype(hana::length(xs))::value; return drop_front_helper<n>(static_cast<Xs&&>(xs), std::make_index_sequence<(n < len ? len - n : 0)>{}); } }; ////////////////////////////////////////////////////////////////////////// // Sequence ////////////////////////////////////////////////////////////////////////// template <> struct make_impl<ext::boost::fusion::list_tag> { template <typename ...Xs> static constexpr auto apply(Xs&& ...xs) { return ::boost::fusion::make_list(static_cast<Xs&&>(xs)...); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_EXT_BOOST_FUSION_LIST_HPP PK �\�[�ոMJ J ext/boost/fusion/vector.hppnu �[��� /*! @file Adapts `boost::fusion::vector` for use with Hana. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EXT_BOOST_FUSION_VECTOR_HPP #define BOOST_HANA_EXT_BOOST_FUSION_VECTOR_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/ext/boost/fusion/detail/common.hpp> #include <boost/hana/fwd/at.hpp> #include <boost/hana/fwd/core/make.hpp> #include <boost/hana/fwd/core/tag_of.hpp> #include <boost/hana/fwd/drop_front.hpp> #include <boost/hana/fwd/length.hpp> #include <boost/fusion/algorithm/transformation/pop_front.hpp> #include <boost/fusion/container/generation/make_vector.hpp> #include <boost/fusion/container/vector.hpp> #include <boost/fusion/container/vector/convert.hpp> #include <boost/fusion/support/tag_of.hpp> #include <cstddef> #include <type_traits> #include <utility> #ifdef BOOST_HANA_DOXYGEN_INVOKED namespace boost { namespace fusion { //! @ingroup group-ext-fusion //! Adapter for Boost.Fusion vectors. //! //! //! Modeled concepts //! ---------------- //! A Fusion vector is a model of the `Sequence` concept, and all the //! concepts it refines. That makes it essentially the same as a Hana //! tuple, although the complexity of some operations might differ from //! that of a tuple. //! //! @include example/ext/boost/fusion/vector.cpp template <typename ...T> struct vector { }; }} #endif BOOST_HANA_NAMESPACE_BEGIN namespace ext { namespace boost { namespace fusion { struct vector_tag; }}} template <typename T> struct tag_of<T, when< std::is_same< typename ::boost::fusion::traits::tag_of<T>::type, ::boost::fusion::traits::tag_of< ::boost::fusion::vector<> >::type >::value >> { using type = ext::boost::fusion::vector_tag; }; namespace detail { template <> struct is_fusion_sequence<ext::boost::fusion::vector_tag> { static constexpr bool value = true; }; } ////////////////////////////////////////////////////////////////////////// // Iterable (the rest is in detail/common.hpp) ////////////////////////////////////////////////////////////////////////// template <> struct drop_front_impl<ext::boost::fusion::vector_tag> { template <std::size_t n, typename Xs, std::size_t ...i> static constexpr auto drop_front_helper(Xs&& xs, std::index_sequence<i...>) { return hana::make<ext::boost::fusion::vector_tag>( hana::at_c<n + i>(static_cast<Xs&&>(xs))... ); } template <typename Xs, typename N> static constexpr auto apply(Xs&& xs, N const&) { constexpr std::size_t n = N::value; constexpr std::size_t len = decltype(hana::length(xs))::value; return drop_front_helper<n>(static_cast<Xs&&>(xs), std::make_index_sequence<(n < len ? len - n : 0)>{}); } }; ////////////////////////////////////////////////////////////////////////// // Sequence ////////////////////////////////////////////////////////////////////////// template <> struct make_impl<ext::boost::fusion::vector_tag> { template <typename ...Xs> static constexpr auto apply(Xs&& ...xs) { return ::boost::fusion::make_vector(static_cast<Xs&&>(xs)...); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_EXT_BOOST_FUSION_VECTOR_HPP PK �\�[Y;�j� � " ext/boost/fusion/detail/common.hppnu �[��� /*! @file Defines common methods for all Boost.Fusion sequences. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EXT_BOOST_FUSION_DETAIL_COMMON_HPP #define BOOST_HANA_EXT_BOOST_FUSION_DETAIL_COMMON_HPP #include <boost/hana/bool.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/fwd/at.hpp> #include <boost/hana/fwd/concept/sequence.hpp> #include <boost/hana/fwd/is_empty.hpp> #include <boost/hana/fwd/length.hpp> #include <boost/hana/integral_constant.hpp> #include <boost/fusion/sequence/intrinsic/at.hpp> #include <boost/fusion/sequence/intrinsic/empty.hpp> #include <boost/fusion/sequence/intrinsic/size.hpp> #include <cstddef> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <typename T> struct is_fusion_sequence { static constexpr bool value = false; }; } ////////////////////////////////////////////////////////////////////////// // Iterable ////////////////////////////////////////////////////////////////////////// template <typename S> struct at_impl<S, when<detail::is_fusion_sequence<S>::value>> { template <typename Xs, typename N> static constexpr decltype(auto) apply(Xs&& xs, N const&) { constexpr std::size_t n = N::value; return boost::fusion::at_c<n>(static_cast<Xs&&>(xs)); } }; template <typename S> struct is_empty_impl<S, when<detail::is_fusion_sequence<S>::value>> { template <typename Xs> static constexpr auto apply(Xs&& xs) { using Empty = decltype(boost::fusion::empty(xs)); return hana::bool_c<Empty::value>; } }; ////////////////////////////////////////////////////////////////////////// // Foldable ////////////////////////////////////////////////////////////////////////// template <typename S> struct length_impl<S, when<detail::is_fusion_sequence<S>::value>> { template <typename Xs> static constexpr auto apply(Xs const&) { using Size = typename boost::fusion::result_of::size<Xs>::type; return hana::size_c<Size::value>; } }; ////////////////////////////////////////////////////////////////////////// // Sequence ////////////////////////////////////////////////////////////////////////// template <typename S> struct Sequence<S, when<detail::is_fusion_sequence<S>::value>> { static constexpr bool value = true; }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_EXT_BOOST_FUSION_DETAIL_COMMON_HPP PK �\�[ì� � ext/boost/fusion/tuple.hppnu �[��� /*! @file Adapts `boost::fusion::tuple` for use with Hana. In the current version of Boost.Fusion, `boost::fusion::tuple` is basically an alias to `boost::fusion::vector`, so both data types share the same implementation in Hana. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EXT_BOOST_FUSION_TUPLE_HPP #define BOOST_HANA_EXT_BOOST_FUSION_TUPLE_HPP #include <boost/hana/config.hpp> #include <boost/hana/ext/boost/fusion/vector.hpp> #ifdef BOOST_HANA_DOXYGEN_INVOKED namespace boost { namespace fusion { //! @ingroup group-ext-fusion //! Adapter for Boost.Fusion tuples. //! //! //! Modeled concepts //! ---------------- //! A Fusion tuple is a model of the `Sequence` concept, and all the //! concepts it refines. That makes it essentially the same as a Hana //! tuple, although the complexity of some operations might differ from //! that of a tuple. //! //! @include example/ext/boost/fusion/tuple.cpp template <typename ...T> struct tuple { }; }} #endif BOOST_HANA_NAMESPACE_BEGIN namespace ext { namespace boost { namespace fusion { // In the current version of Boost.Fusion, `boost::fusion::tuple` is // basically an alias to `boost::fusion::vector`, hence the alias. using tuple_tag = vector_tag; }}} BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_EXT_BOOST_FUSION_TUPLE_HPP PK �\�[C�� � ext/boost/fusion.hppnu �[��� /*! @file Includes all the adaptors for the Boost.Fusion library. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EXT_BOOST_FUSION_HPP #define BOOST_HANA_EXT_BOOST_FUSION_HPP //! @ingroup group-ext //! @defgroup group-ext-fusion Boost.Fusion adapters //! Adapters for Boost.Fusion containers. #include <boost/hana/ext/boost/fusion/deque.hpp> #include <boost/hana/ext/boost/fusion/list.hpp> #include <boost/hana/ext/boost/fusion/tuple.hpp> #include <boost/hana/ext/boost/fusion/vector.hpp> #endif // !BOOST_HANA_EXT_BOOST_FUSION_HPP PK �\�[ ��� ext/boost/tuple.hppnu �[��� /*! @file Adapts `boost::tuple` for use with Hana. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EXT_BOOST_TUPLE_HPP #define BOOST_HANA_EXT_BOOST_TUPLE_HPP #include <boost/hana/bool.hpp> #include <boost/hana/config.hpp> #include <boost/hana/detail/decay.hpp> #include <boost/hana/fwd/at.hpp> #include <boost/hana/fwd/core/make.hpp> #include <boost/hana/fwd/core/tag_of.hpp> #include <boost/hana/fwd/drop_front.hpp> #include <boost/hana/fwd/is_empty.hpp> #include <boost/hana/fwd/length.hpp> #include <boost/hana/integral_constant.hpp> #include <boost/tuple/tuple.hpp> #include <cstddef> #include <utility> #ifdef BOOST_HANA_DOXYGEN_INVOKED namespace boost { //! @ingroup group-ext-boost //! Adapter for `boost::tuple`s. //! //! //! Modeled concepts //! ---------------- //! A `boost::tuple` is a model of the `Sequence` concept, and all the //! concepts it refines. That makes it essentially the same as a Hana //! tuple, although the complexity of some operations might differ from //! that of Hana's tuple. //! //! @include example/ext/boost/tuple.cpp template <typename ...T> struct tuple { }; } #endif BOOST_HANA_NAMESPACE_BEGIN namespace ext { namespace boost { struct tuple_tag; }} template <typename ...Xs> struct tag_of<boost::tuple<Xs...>> { using type = ext::boost::tuple_tag; }; template <typename H, typename T> struct tag_of<boost::tuples::cons<H, T>> { using type = ext::boost::tuple_tag; }; template <> struct tag_of<boost::tuples::null_type> { using type = ext::boost::tuple_tag; }; ////////////////////////////////////////////////////////////////////////// // Iterable ////////////////////////////////////////////////////////////////////////// template <> struct at_impl<ext::boost::tuple_tag> { template <typename Xs, typename N> static constexpr decltype(auto) apply(Xs&& xs, N const&) { constexpr std::size_t n = N::value; return static_cast<Xs&&>(xs).template get<n>(); } }; template <> struct drop_front_impl<ext::boost::tuple_tag> { template <std::size_t n, typename Xs, std::size_t ...i> static constexpr auto drop_front_helper(Xs&& xs, std::index_sequence<i...>) { return hana::make<ext::boost::tuple_tag>( hana::at_c<n + i>(static_cast<Xs&&>(xs))... ); } template <typename Xs, typename N> static constexpr auto apply(Xs&& xs, N const&) { constexpr std::size_t n = N::value; constexpr std::size_t len = decltype(hana::length(xs))::value; return drop_front_helper<n>(static_cast<Xs&&>(xs), std::make_index_sequence<(n < len ? len - n : 0)>{}); } }; template <> struct is_empty_impl<ext::boost::tuple_tag> { static constexpr auto apply(boost::tuples::null_type const&) { return hana::true_c; } template <typename H, typename T> static constexpr auto apply(boost::tuples::cons<H, T> const&) { return hana::false_c; } }; ////////////////////////////////////////////////////////////////////////// // Foldable ////////////////////////////////////////////////////////////////////////// template <> struct length_impl<ext::boost::tuple_tag> { template <typename Xs> static constexpr auto apply(Xs const&) { return hana::size_c<boost::tuples::length<Xs>::value>; } }; ////////////////////////////////////////////////////////////////////////// // Sequence ////////////////////////////////////////////////////////////////////////// template <> struct Sequence<ext::boost::tuple_tag> { static constexpr bool value = true; }; template <> struct make_impl<ext::boost::tuple_tag> { template <typename ...Xs> static constexpr auto apply(Xs&& ...xs) { return boost::tuples::tuple< typename detail::decay<Xs>::type... >{static_cast<Xs&&>(xs)...}; } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_EXT_BOOST_TUPLE_HPP PK �\�[A��@b b ext/boost/mpl.hppnu �[��� /*! @file Includes all the adaptors for the Boost.MPL library. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EXT_BOOST_MPL_HPP #define BOOST_HANA_EXT_BOOST_MPL_HPP //! @ingroup group-ext //! @defgroup group-ext-mpl Boost.MPL adapters //! Adapters for Boost.MPL containers. #include <boost/hana/ext/boost/mpl/integral_c.hpp> #include <boost/hana/ext/boost/mpl/list.hpp> #include <boost/hana/ext/boost/mpl/vector.hpp> #endif // !BOOST_HANA_EXT_BOOST_MPL_HPP PK �\�[�2��� � ext/std/integral_constant.hppnu �[��� /*! @file Adapts `std::integral_constant` for use with Hana. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EXT_STD_INTEGRAL_CONSTANT_HPP #define BOOST_HANA_EXT_STD_INTEGRAL_CONSTANT_HPP #include <boost/hana/concept/integral_constant.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/fwd/core/to.hpp> #include <boost/hana/fwd/core/tag_of.hpp> #include <boost/hana/fwd/integral_constant.hpp> #include <type_traits> #ifdef BOOST_HANA_DOXYGEN_INVOKED namespace std { //! @ingroup group-ext-std //! Adapter for `std::integral_constant`s. //! //! Provided models //! --------------- //! 1. `Constant` and `IntegralConstant`\n //! A `std::integral_constant` is a model of the `IntegralConstant` and //! `Constant` concepts, just like `hana::integral_constant`s are. As a //! consequence, they are also implicitly a model of the concepts provided //! for all models of `Constant`. //! @include example/ext/std/integral_constant.cpp template <typename T, T v> struct integral_constant { }; } #endif BOOST_HANA_NAMESPACE_BEGIN namespace ext { namespace std { template <typename T> struct integral_constant_tag { using value_type = T; }; }} namespace detail { template <typename T, T v> constexpr bool is_std_integral_constant(std::integral_constant<T, v>*) { return true; } constexpr bool is_std_integral_constant(...) { return false; } template <typename T, T v> constexpr bool is_hana_integral_constant(hana::integral_constant<T, v>*) { return true; } constexpr bool is_hana_integral_constant(...) { return false; } } template <typename T> struct tag_of<T, when< detail::is_std_integral_constant((T*)0) && !detail::is_hana_integral_constant((T*)0) >> { using type = ext::std::integral_constant_tag< typename hana::tag_of<typename T::value_type>::type >; }; ////////////////////////////////////////////////////////////////////////// // Constant/IntegralConstant ////////////////////////////////////////////////////////////////////////// template <typename T> struct IntegralConstant<ext::std::integral_constant_tag<T>> { static constexpr bool value = true; }; template <typename T, typename C> struct to_impl<ext::std::integral_constant_tag<T>, C, when< hana::IntegralConstant<C>::value >> : embedding<is_embedded<typename C::value_type, T>::value> { template <typename N> static constexpr auto apply(N const&) { return std::integral_constant<T, N::value>{}; } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_EXT_STD_INTEGRAL_CONSTANT_HPP PK �\�[J^Lج � ext/std/integer_sequence.hppnu �[��� /*! @file Adapts `std::integer_sequence` for use with Hana. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EXT_STD_INTEGER_SEQUENCE_HPP #define BOOST_HANA_EXT_STD_INTEGER_SEQUENCE_HPP #include <boost/hana/bool.hpp> #include <boost/hana/config.hpp> #include <boost/hana/detail/fast_and.hpp> #include <boost/hana/ext/std/integral_constant.hpp> #include <boost/hana/fwd/at.hpp> #include <boost/hana/fwd/core/tag_of.hpp> #include <boost/hana/fwd/drop_front.hpp> #include <boost/hana/fwd/equal.hpp> #include <boost/hana/fwd/is_empty.hpp> #include <boost/hana/fwd/unpack.hpp> #include <cstddef> #include <type_traits> #include <utility> #ifdef BOOST_HANA_DOXYGEN_INVOKED namespace std { //! @ingroup group-ext-std //! Adaptation of `std::integer_sequence` for Hana. //! //! //! //! Modeled concepts //! ---------------- //! 1. `Comparable`\n //! Two `std::integer_sequence`s are equal if and only if they have the //! same number of elements, and if corresponding elements compare equal. //! The types of the elements held in both `integer_sequence`s may be //! different, as long as they can be compared. //! @include example/ext/std/integer_sequence/comparable.cpp //! //! 2. `Foldable`\n //! Folding an `integer_sequence` is equivalent to folding a sequence of //! `std::integral_constant`s with the corresponding types. //! @include example/ext/std/integer_sequence/foldable.cpp //! //! 3. `Iterable`\n //! Iterating over an `integer_sequence` is equivalent to iterating over //! a sequence of the corresponding `std::integral_constant`s. //! @include example/ext/std/integer_sequence/iterable.cpp //! //! 4. `Searchable`\n //! Searching through an `integer_sequence` is equivalent to searching //! through the corresponding sequence of `std::integral_constant`s. //! @include example/ext/std/integer_sequence/searchable.cpp template <typename T, T ...v> struct integer_sequence { }; } #endif BOOST_HANA_NAMESPACE_BEGIN namespace ext { namespace std { struct integer_sequence_tag; }} template <typename T, T ...v> struct tag_of<std::integer_sequence<T, v...>> { using type = ext::std::integer_sequence_tag; }; ////////////////////////////////////////////////////////////////////////// // Comparable ////////////////////////////////////////////////////////////////////////// template <> struct equal_impl<ext::std::integer_sequence_tag, ext::std::integer_sequence_tag> { template <typename X, X ...xs, typename Y, Y ...ys> static constexpr hana::bool_<detail::fast_and<(xs == ys)...>::value> apply(std::integer_sequence<X, xs...> const&, std::integer_sequence<Y, ys...> const&) { return {}; } template <typename Xs, typename Ys> static constexpr hana::false_ apply(Xs const&, Ys const&, ...) { return {}; } }; ////////////////////////////////////////////////////////////////////////// // Foldable ////////////////////////////////////////////////////////////////////////// template <> struct unpack_impl<ext::std::integer_sequence_tag> { template <typename T, T ...v, typename F> static constexpr decltype(auto) apply(std::integer_sequence<T, v...> const&, F&& f) { return static_cast<F&&>(f)(std::integral_constant<T, v>{}...); } }; ////////////////////////////////////////////////////////////////////////// // Iterable ////////////////////////////////////////////////////////////////////////// template <> struct at_impl<ext::std::integer_sequence_tag> { template <typename T, T ...v, typename N> static constexpr auto apply(std::integer_sequence<T, v...> const&, N const&) { constexpr std::size_t n = N::value; constexpr T values_[] = {v...}; return std::integral_constant<T, values_[n]>{}; } }; template <> struct drop_front_impl<ext::std::integer_sequence_tag> { template <std::size_t n, typename T, T ...t, std::size_t ...i> static constexpr auto drop_front_helper(std::integer_sequence<T, t...>, std::index_sequence<i...>) { constexpr T ts[sizeof...(t)+1] = {t...}; // avoid 0-sized array return std::integer_sequence<T, ts[n + i]...>{}; } template <typename T, T ...t, typename N> static constexpr auto apply(std::integer_sequence<T, t...> ts, N const&) { constexpr std::size_t n = N::value; constexpr std::size_t len = sizeof...(t); return drop_front_helper<n>(ts, std::make_index_sequence<(n < len ? len - n : 0)>{}); } }; template <> struct is_empty_impl<ext::std::integer_sequence_tag> { template <typename T, T ...xs> static constexpr auto apply(std::integer_sequence<T, xs...> const&) { return hana::bool_c<sizeof...(xs) == 0>; } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_EXT_STD_INTEGER_SEQUENCE_HPP PK �\�[� �¢ � ext/std/array.hppnu �[��� /*! @file Adapts `std::array` for use with Hana. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EXT_STD_ARRAY_HPP #define BOOST_HANA_EXT_STD_ARRAY_HPP #include <boost/hana/bool.hpp> #include <boost/hana/config.hpp> #include <boost/hana/detail/algorithm.hpp> #include <boost/hana/fwd/at.hpp> #include <boost/hana/fwd/core/tag_of.hpp> #include <boost/hana/fwd/drop_front.hpp> #include <boost/hana/fwd/equal.hpp> #include <boost/hana/fwd/is_empty.hpp> #include <boost/hana/fwd/length.hpp> #include <boost/hana/fwd/less.hpp> #include <boost/hana/integral_constant.hpp> #include <array> #include <cstddef> #include <type_traits> #include <utility> #ifdef BOOST_HANA_DOXYGEN_INVOKED namespace std { //! @ingroup group-ext-std //! Adaptation of `std::array` for Hana. //! //! //! //! Modeled concepts //! ---------------- //! 1. `Comparable`\n //! `std::array`s are compared as per `std::equal`, except that two arrays //! with different sizes compare unequal instead of triggering an error //! and the result of the comparison is `constexpr` if both arrays are //! `constexpr`. //! @include example/ext/std/array/comparable.cpp //! //! 2. `Orderable`\n //! `std::array`s are ordered with the usual lexicographical ordering, //! except that two arrays with different size can be ordered instead //! of triggering an error and the result of the comparison is `constexpr` //! if both arrays are `constexpr`. //! @include example/ext/std/array/orderable.cpp //! //! 3. `Foldable`\n //! Folding an array from the left is equivalent to calling //! `std::accumulate` on it, except it can be `constexpr`. //! @include example/ext/std/array/foldable.cpp //! //! 4. `Iterable`\n //! Iterating over a `std::array` is equivalent to iterating over it with //! a normal `for` loop. //! @include example/ext/std/array/iterable.cpp template <typename T, std::size_t N> struct array { }; } #endif BOOST_HANA_NAMESPACE_BEGIN namespace ext { namespace std { struct array_tag; }} template <typename T, std::size_t N> struct tag_of<std::array<T, N>> { using type = ext::std::array_tag; }; ////////////////////////////////////////////////////////////////////////// // Foldable ////////////////////////////////////////////////////////////////////////// template <> struct length_impl<ext::std::array_tag> { template <typename Xs> static constexpr auto apply(Xs const&) { return hana::size_c<std::tuple_size<Xs>::type::value>; } }; ////////////////////////////////////////////////////////////////////////// // Iterable ////////////////////////////////////////////////////////////////////////// template <> struct at_impl<ext::std::array_tag> { template <typename Xs, typename N> static constexpr decltype(auto) apply(Xs&& xs, N const&) { constexpr std::size_t n = N::value; return std::get<n>(static_cast<Xs&&>(xs)); } }; template <> struct drop_front_impl<ext::std::array_tag> { template <std::size_t n, typename Xs, std::size_t ...i> static constexpr auto drop_front_helper(Xs&& xs, std::index_sequence<i...>) { using T = typename std::remove_reference<Xs>::type::value_type; return std::array<T, sizeof...(i)>{{static_cast<Xs&&>(xs)[n + i]...}}; } template <typename Xs, typename N> static constexpr auto apply(Xs&& xs, N const&) { constexpr std::size_t n = N::value; constexpr std::size_t len = std::tuple_size< typename std::remove_cv< typename std::remove_reference<Xs>::type >::type >::value; return drop_front_helper<n>(static_cast<Xs&&>(xs), std::make_index_sequence<(n < len ? len - n : 0)>{}); } }; template <> struct is_empty_impl<ext::std::array_tag> { template <typename T, std::size_t N> static constexpr auto apply(std::array<T, N> const&) { return hana::bool_c<N == 0>; } }; ////////////////////////////////////////////////////////////////////////// // Comparable ////////////////////////////////////////////////////////////////////////// template <> struct equal_impl<ext::std::array_tag, ext::std::array_tag> { template <typename T, std::size_t n, typename U> static constexpr bool apply(std::array<T, n> const& xs, std::array<U, n> const& ys) { return detail::equal(&xs[0], &xs[0] + n, &ys[0], &ys[0] + n); } template <typename T, typename U> static constexpr auto apply(std::array<T, 0> const&, std::array<U, 0> const&) { return hana::true_c; } template <typename T, std::size_t n, typename U, std::size_t m> static constexpr auto apply(std::array<T, n> const&, std::array<U, m> const&) { return hana::false_c; } }; ////////////////////////////////////////////////////////////////////////// // Orderable ////////////////////////////////////////////////////////////////////////// template <> struct less_impl<ext::std::array_tag, ext::std::array_tag> { template <typename T, std::size_t n, typename U, std::size_t m> static constexpr auto apply(std::array<T, n> const& xs, std::array<U, m> const& ys) { // This logic is more complex than it needs to be because we can't // use `.begin()` and `.end()`, which are not constexpr in C++14, // and because `&arr[0]` is UB when the array is empty. if (xs.empty()) { return !ys.empty(); } else { if (ys.empty()) { return false; } else { return detail::lexicographical_compare(&xs[0], &xs[0] + n, &ys[0], &ys[0] + m); } } } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_EXT_STD_ARRAY_HPP PK �\�[��C C ext/std/vector.hppnu �[��� /*! @file Adapts `std::vector` for use with Hana. @copyright Louis Dionne 2013-2017 @copyright Gonzalo Brito Gadeschi 2015 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EXT_STD_VECTOR_HPP #define BOOST_HANA_EXT_STD_VECTOR_HPP #include <boost/hana/config.hpp> #include <boost/hana/equal.hpp> #include <boost/hana/fwd/core/tag_of.hpp> #include <boost/hana/less.hpp> #include <algorithm> #include <iterator> #include <memory> #include <type_traits> #include <utility> #include <vector> BOOST_HANA_NAMESPACE_BEGIN namespace ext { namespace std { struct vector_tag; }} template <typename T, typename Allocator> struct tag_of<std::vector<T, Allocator>> { using type = ext::std::vector_tag; }; ////////////////////////////////////////////////////////////////////////// // Comparable ////////////////////////////////////////////////////////////////////////// template <> struct equal_impl<ext::std::vector_tag, ext::std::vector_tag> { template <typename T1, typename A1, typename T2, typename A2> static bool apply(std::vector<T1, A1> const& v1, std::vector<T2, A2> const& v2) { return std::equal(begin(v1), end(v1), begin(v2), end(v2), hana::equal); } }; ////////////////////////////////////////////////////////////////////////// // Orderable ////////////////////////////////////////////////////////////////////////// template <> struct less_impl<ext::std::vector_tag, ext::std::vector_tag> { template <typename T1, typename A1, typename T2, typename A2> static bool apply(std::vector<T1, A1> const& v1, std::vector<T2, A2> const& v2) { return std::lexicographical_compare(begin(v1), end(v1), begin(v2), end(v2), hana::less); } }; #if 0 ////////////////////////////////////////////////////////////////////////// // Functor ////////////////////////////////////////////////////////////////////////// template <> struct transform_impl<ext::std::vector_tag> { template <typename V, typename F> static auto apply(V&& v, F&& f) { using U = std::remove_cv_t<std::remove_reference_t< decltype(f(*v.begin())) >>; using Alloc = typename std::remove_reference_t<V>::allocator_type; using NewAlloc = typename std::allocator_traits<Alloc>:: template rebind_alloc<U>; std::vector<U, NewAlloc> result; result.reserve(v.size()); std::transform(begin(v), end(v), std::back_inserter(result), std::forward<F>(f)); return result; } template <typename T, typename Alloc, typename F> static auto apply(std::vector<T, Alloc>&& v, F&& f) -> std::enable_if_t< std::is_same< T, std::remove_cv_t<std::remove_reference_t< decltype(f(*v.begin())) >> >{} , std::vector<T, Alloc> > { // If we receive a rvalue and the function returns elements of // the same type, we modify the vector in-place instead of // returning a new one. std::transform(std::make_move_iterator(begin(v)), std::make_move_iterator(end(v)), begin(v), std::forward<F>(f)); return std::move(v); } }; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_EXT_STD_VECTOR_HPP PK �\�[�1�h h ext/std/ratio.hppnu �[��� /*! @file Adapts `std::ratio` for use with Hana. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EXT_STD_RATIO_HPP #define BOOST_HANA_EXT_STD_RATIO_HPP #include <boost/hana/bool.hpp> #include <boost/hana/concept/integral_constant.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/fwd/core/to.hpp> #include <boost/hana/fwd/core/tag_of.hpp> #include <boost/hana/fwd/div.hpp> #include <boost/hana/fwd/equal.hpp> #include <boost/hana/fwd/less.hpp> #include <boost/hana/fwd/minus.hpp> #include <boost/hana/fwd/mod.hpp> #include <boost/hana/fwd/mult.hpp> #include <boost/hana/fwd/one.hpp> #include <boost/hana/fwd/plus.hpp> #include <boost/hana/fwd/zero.hpp> #include <cstdint> #include <ratio> #include <type_traits> #ifdef BOOST_HANA_DOXYGEN_INVOKED namespace std { //! @ingroup group-ext-std //! Adaptation of `std::ratio` for Hana. //! //! //! Modeled concepts //! ---------------- //! 1. `Comparable`\n //! `std::ratio`s are compared for equality using `std::ratio_equal`. //! @include example/ext/std/ratio/comparable.cpp //! //! 2. `Orderable`\n //! `std::ratio`s are ordered using `std::ratio_less`. //! @include example/ext/std/ratio/orderable.cpp //! //! 3. `Monoid`, `Group`, `Ring`, and `EuclideanRing`\n //! `std::ratio`s are added, subtracted, multiplied and divided using //! `std::ratio_add`, `std::ratio_subtract`, `std::ratio_multiply` and //! `std::ratio_divide`, respectively. Furthermore, the neutral element //! for the additive operation is `std::ratio<0, 1>{}`, and the neutral //! element for the multiplicative operation is `std::ratio<1, 1>{}`. //! @include example/ext/std/ratio/arithmetic.cpp template <std::intmax_t Num, std::intmax_t Denom> class ratio { }; } #endif BOOST_HANA_NAMESPACE_BEGIN namespace ext { namespace std { struct ratio_tag; }} template <std::intmax_t num, std::intmax_t den> struct tag_of<std::ratio<num, den>> { using type = ext::std::ratio_tag; }; ////////////////////////////////////////////////////////////////////////// // Conversion from IntegralConstants ////////////////////////////////////////////////////////////////////////// template <typename C> struct to_impl<ext::std::ratio_tag, C, when< hana::IntegralConstant<C>::value >> { template <typename N> static constexpr auto apply(N const&) { return std::ratio<N::value>{}; } }; ////////////////////////////////////////////////////////////////////////// // Comparable ////////////////////////////////////////////////////////////////////////// template <> struct equal_impl<ext::std::ratio_tag, ext::std::ratio_tag> { template <typename R1, typename R2> static constexpr auto apply(R1 const&, R2 const&) { return hana::bool_c<std::ratio_equal<R1, R2>::value>; } }; ////////////////////////////////////////////////////////////////////////// // Orderable ////////////////////////////////////////////////////////////////////////// template <> struct less_impl<ext::std::ratio_tag, ext::std::ratio_tag> { template <typename R1, typename R2> static constexpr auto apply(R1 const&, R2 const&) { return hana::bool_c<std::ratio_less<R1, R2>::value>; } }; ////////////////////////////////////////////////////////////////////////// // Monoid ////////////////////////////////////////////////////////////////////////// template <> struct plus_impl<ext::std::ratio_tag, ext::std::ratio_tag> { template <typename R1, typename R2> static constexpr std::ratio_add<R1, R2> apply(R1 const&, R2 const&) { return {}; } }; template <> struct zero_impl<ext::std::ratio_tag> { static constexpr std::ratio<0> apply() { return {}; } }; ////////////////////////////////////////////////////////////////////////// // Group ////////////////////////////////////////////////////////////////////////// template <> struct minus_impl<ext::std::ratio_tag, ext::std::ratio_tag> { template <typename R1, typename R2> static constexpr std::ratio_subtract<R1, R2> apply(R1 const&, R2 const&) { return {}; } }; ////////////////////////////////////////////////////////////////////////// // Ring ////////////////////////////////////////////////////////////////////////// template <> struct mult_impl<ext::std::ratio_tag, ext::std::ratio_tag> { template <typename R1, typename R2> static constexpr std::ratio_multiply<R1, R2> apply(R1 const&, R2 const&) { return {}; } }; template <> struct one_impl<ext::std::ratio_tag> { static constexpr std::ratio<1> apply() { return {}; } }; ////////////////////////////////////////////////////////////////////////// // EuclideanRing ////////////////////////////////////////////////////////////////////////// template <> struct div_impl<ext::std::ratio_tag, ext::std::ratio_tag> { template <typename R1, typename R2> static constexpr std::ratio_divide<R1, R2> apply(R1 const&, R2 const&) { return {}; } }; template <> struct mod_impl<ext::std::ratio_tag, ext::std::ratio_tag> { template <typename R1, typename R2> static constexpr std::ratio<0> apply(R1 const&, R2 const&) { return {}; } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_EXT_STD_RATIO_HPP PK �\�[A�7 ext/std/pair.hppnu �[��� /*! @file Adapts `std::pair` for use with Hana. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EXT_STD_PAIR_HPP #define BOOST_HANA_EXT_STD_PAIR_HPP #include <boost/hana/config.hpp> #include <boost/hana/fwd/core/make.hpp> #include <boost/hana/fwd/core/tag_of.hpp> #include <boost/hana/fwd/first.hpp> #include <boost/hana/fwd/second.hpp> #include <utility> #ifdef BOOST_HANA_DOXYGEN_INVOKED namespace std { //! @ingroup group-ext-std //! Adaptation of `std::pair` for Hana. //! //! //! Modeled concepts //! ---------------- //! A `std::pair` models exactly the same concepts as a `hana::pair`. //! Please refer to the documentation of `hana::pair` for details. //! //! @include example/ext/std/pair.cpp template <typename First, typename Second> struct pair { }; } #endif BOOST_HANA_NAMESPACE_BEGIN namespace ext { namespace std { struct pair_tag; }} template <typename First, typename Second> struct tag_of<std::pair<First, Second>> { using type = ext::std::pair_tag; }; ////////////////////////////////////////////////////////////////////////// // Product ////////////////////////////////////////////////////////////////////////// template <> struct make_impl<ext::std::pair_tag> { template <typename X, typename Y> static constexpr decltype(auto) apply(X&& x, Y&& y) { return std::make_pair(static_cast<X&&>(x), static_cast<Y&&>(y)); } }; template <> struct first_impl<ext::std::pair_tag> { template <typename T, typename U> static constexpr T const& apply(std::pair<T, U> const& p) { return p.first; } template <typename T, typename U> static constexpr T& apply(std::pair<T, U>& p) { return p.first; } template <typename T, typename U> static constexpr T&& apply(std::pair<T, U>&& p) { return static_cast<T&&>(p.first); } }; template <> struct second_impl<ext::std::pair_tag> { template <typename T, typename U> static constexpr U const& apply(std::pair<T, U> const& p) { return p.second; } template <typename T, typename U> static constexpr U& apply(std::pair<T, U>& p) { return p.second; } template <typename T, typename U> static constexpr U&& apply(std::pair<T, U>&& p) { return static_cast<U&&>(p.second); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_EXT_STD_PAIR_HPP PK �\�[�o��� � ext/std/tuple.hppnu �[��� /*! @file Adapts `std::tuple` for use with Hana. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EXT_STD_TUPLE_HPP #define BOOST_HANA_EXT_STD_TUPLE_HPP #include <boost/hana/bool.hpp> #include <boost/hana/config.hpp> #include <boost/hana/detail/decay.hpp> #include <boost/hana/fwd/at.hpp> #include <boost/hana/fwd/core/make.hpp> #include <boost/hana/fwd/core/tag_of.hpp> #include <boost/hana/fwd/drop_front.hpp> #include <boost/hana/fwd/empty.hpp> #include <boost/hana/fwd/flatten.hpp> #include <boost/hana/fwd/front.hpp> #include <boost/hana/fwd/is_empty.hpp> #include <boost/hana/fwd/length.hpp> #include <boost/hana/fwd/lift.hpp> #include <boost/hana/integral_constant.hpp> #include <cstddef> #include <tuple> #include <type_traits> #include <utility> #ifdef BOOST_HANA_DOXYGEN_INVOKED namespace std { //! @ingroup group-ext-std //! Adapter for `std::tuple`s. //! //! //! Modeled concepts //! ---------------- //! A `std::tuple` is a model of the `Sequence` concept, and all the //! concepts it refines. That makes it essentially the same as a Hana //! tuple, although the complexity of some operations might differ from //! that of Hana's tuple. //! //! @include example/ext/std/tuple.cpp template <typename ...T> struct tuple { }; } #endif BOOST_HANA_NAMESPACE_BEGIN namespace ext { namespace std { struct tuple_tag; }} template <typename ...Xs> struct tag_of<std::tuple<Xs...>> { using type = ext::std::tuple_tag; }; ////////////////////////////////////////////////////////////////////////// // make ////////////////////////////////////////////////////////////////////////// template <> struct make_impl<ext::std::tuple_tag> { template <typename ...Xs> static constexpr decltype(auto) apply(Xs&& ...xs) { return std::make_tuple(static_cast<Xs&&>(xs)...); } }; ////////////////////////////////////////////////////////////////////////// // Applicative ////////////////////////////////////////////////////////////////////////// template <> struct lift_impl<ext::std::tuple_tag> { template <typename X> static constexpr auto apply(X&& x) { return std::tuple<typename detail::decay<X>::type>{ static_cast<X&&>(x)}; } }; ////////////////////////////////////////////////////////////////////////// // Monad ////////////////////////////////////////////////////////////////////////// template <> struct flatten_impl<ext::std::tuple_tag> { template <typename Xs, std::size_t ...i> static constexpr decltype(auto) flatten_helper(Xs&& xs, std::index_sequence<i...>) { return std::tuple_cat(std::get<i>(static_cast<Xs&&>(xs))...); } template <typename Xs> static constexpr decltype(auto) apply(Xs&& xs) { using Raw = typename std::remove_reference<Xs>::type; constexpr std::size_t Length = std::tuple_size<Raw>::value; return flatten_helper(static_cast<Xs&&>(xs), std::make_index_sequence<Length>{}); } }; ////////////////////////////////////////////////////////////////////////// // MonadPlus ////////////////////////////////////////////////////////////////////////// template <> struct empty_impl<ext::std::tuple_tag> { static constexpr auto apply() { return std::tuple<>{}; } }; ////////////////////////////////////////////////////////////////////////// // Iterable ////////////////////////////////////////////////////////////////////////// template <> struct front_impl<ext::std::tuple_tag> { template <typename Xs> static constexpr decltype(auto) apply(Xs&& xs) { return std::get<0>(static_cast<Xs&&>(xs)); } }; template <> struct drop_front_impl<ext::std::tuple_tag> { template <std::size_t n, typename Xs, std::size_t ...i> static constexpr auto drop_front_helper(Xs&& xs, std::index_sequence<i...>) { return std::make_tuple( hana::at_c<n + i>(static_cast<Xs&&>(xs))... ); } template <typename Xs, typename N> static constexpr auto apply(Xs&& xs, N const&) { using Raw = typename std::remove_reference<Xs>::type; constexpr std::size_t n = N::value; constexpr auto len = std::tuple_size<Raw>::value; return drop_front_helper<n>(static_cast<Xs&&>(xs), std::make_index_sequence<(n < len ? len - n : 0)>{}); } }; template <> struct is_empty_impl<ext::std::tuple_tag> { template <typename ...Xs> static constexpr auto apply(std::tuple<Xs...> const&) { return hana::bool_c<sizeof...(Xs) == 0>; } }; template <> struct at_impl<ext::std::tuple_tag> { template <typename Xs, typename N> static constexpr decltype(auto) apply(Xs&& xs, N const&) { constexpr std::size_t index = N::value; return std::get<index>(static_cast<Xs&&>(xs)); } }; ////////////////////////////////////////////////////////////////////////// // Foldable ////////////////////////////////////////////////////////////////////////// template <> struct length_impl<ext::std::tuple_tag> { template <typename ...Xs> static constexpr auto apply(std::tuple<Xs...> const&) { return hana::size_c<sizeof...(Xs)>; } }; ////////////////////////////////////////////////////////////////////////// // Sequence ////////////////////////////////////////////////////////////////////////// template <> struct Sequence<ext::std::tuple_tag> { static constexpr bool value = true; }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_EXT_STD_TUPLE_HPP PK �\�[a�D� ext/std.hppnu �[��� /*! @file Includes all the adaptors for the standard library. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EXT_STD_HPP #define BOOST_HANA_EXT_STD_HPP //! @ingroup group-ext //! @defgroup group-ext-std Standard library adapters //! Adapters for components in the standard library. #include <boost/hana/ext/std/array.hpp> #include <boost/hana/ext/std/integer_sequence.hpp> #include <boost/hana/ext/std/integral_constant.hpp> #include <boost/hana/ext/std/pair.hpp> #include <boost/hana/ext/std/ratio.hpp> #include <boost/hana/ext/std/tuple.hpp> #include <boost/hana/ext/std/vector.hpp> #endif // !BOOST_HANA_EXT_STD_HPP PK �\�[��유' �' traits.hppnu �[��� /*! @file Defines function-like equivalents to the standard `<type_traits>`, and also to some utilities like `std::declval`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_TRAITS_HPP #define BOOST_HANA_TRAITS_HPP #include <boost/hana/config.hpp> #include <boost/hana/integral_constant.hpp> #include <boost/hana/type.hpp> #include <cstddef> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN namespace traits { namespace detail { // We use this instead of hana::integral because we want to return // hana::integral_constants instead of std::integral_constants. template <template <typename ...> class F> struct hana_trait { template <typename ...T> constexpr auto operator()(T const& ...) const { using Result = typename F<typename T::type...>::type; return hana::integral_c<typename Result::value_type, Result::value>; } }; } /////////////////////// // Type properties /////////////////////// // Primary type categories constexpr auto is_void = detail::hana_trait<std::is_void>{}; constexpr auto is_null_pointer = detail::hana_trait<std::is_null_pointer>{}; constexpr auto is_integral = detail::hana_trait<std::is_integral>{}; constexpr auto is_floating_point = detail::hana_trait<std::is_floating_point>{}; constexpr auto is_array = detail::hana_trait<std::is_array>{}; constexpr auto is_enum = detail::hana_trait<std::is_enum>{}; constexpr auto is_union = detail::hana_trait<std::is_union>{}; constexpr auto is_class = detail::hana_trait<std::is_class>{}; constexpr auto is_function = detail::hana_trait<std::is_function>{}; constexpr auto is_pointer = detail::hana_trait<std::is_pointer>{}; constexpr auto is_lvalue_reference = detail::hana_trait<std::is_lvalue_reference>{}; constexpr auto is_rvalue_reference = detail::hana_trait<std::is_rvalue_reference>{}; constexpr auto is_member_object_pointer = detail::hana_trait<std::is_member_object_pointer>{}; constexpr auto is_member_function_pointer = detail::hana_trait<std::is_member_function_pointer>{}; // Composite type categories constexpr auto is_fundamental = detail::hana_trait<std::is_fundamental>{}; constexpr auto is_arithmetic = detail::hana_trait<std::is_arithmetic>{}; constexpr auto is_scalar = detail::hana_trait<std::is_scalar>{}; constexpr auto is_object = detail::hana_trait<std::is_object>{}; constexpr auto is_compound = detail::hana_trait<std::is_compound>{}; constexpr auto is_reference = detail::hana_trait<std::is_reference>{}; constexpr auto is_member_pointer = detail::hana_trait<std::is_member_pointer>{}; // Type properties constexpr auto is_const = detail::hana_trait<std::is_const>{}; constexpr auto is_volatile = detail::hana_trait<std::is_volatile>{}; constexpr auto is_trivial = detail::hana_trait<std::is_trivial>{}; constexpr auto is_trivially_copyable = detail::hana_trait<std::is_trivially_copyable>{}; constexpr auto is_standard_layout = detail::hana_trait<std::is_standard_layout>{}; #if __cplusplus < 202002L constexpr auto is_pod = detail::hana_trait<std::is_pod>{}; #endif constexpr auto is_literal_type = detail::hana_trait<std::is_literal_type>{}; constexpr auto is_empty = detail::hana_trait<std::is_empty>{}; constexpr auto is_polymorphic = detail::hana_trait<std::is_polymorphic>{}; constexpr auto is_abstract = detail::hana_trait<std::is_abstract>{}; constexpr auto is_signed = detail::hana_trait<std::is_signed>{}; constexpr auto is_unsigned = detail::hana_trait<std::is_unsigned>{}; // Supported operations constexpr auto is_constructible = detail::hana_trait<std::is_constructible>{}; constexpr auto is_trivially_constructible = detail::hana_trait<std::is_trivially_constructible>{}; constexpr auto is_nothrow_constructible = detail::hana_trait<std::is_nothrow_constructible>{}; constexpr auto is_default_constructible = detail::hana_trait<std::is_default_constructible>{}; constexpr auto is_trivially_default_constructible = detail::hana_trait<std::is_trivially_default_constructible>{}; constexpr auto is_nothrow_default_constructible = detail::hana_trait<std::is_nothrow_default_constructible>{}; constexpr auto is_copy_constructible = detail::hana_trait<std::is_copy_constructible>{}; constexpr auto is_trivially_copy_constructible = detail::hana_trait<std::is_trivially_copy_constructible>{}; constexpr auto is_nothrow_copy_constructible = detail::hana_trait<std::is_nothrow_copy_constructible>{}; constexpr auto is_move_constructible = detail::hana_trait<std::is_move_constructible>{}; constexpr auto is_trivially_move_constructible = detail::hana_trait<std::is_trivially_move_constructible>{}; constexpr auto is_nothrow_move_constructible = detail::hana_trait<std::is_nothrow_move_constructible>{}; constexpr auto is_assignable = detail::hana_trait<std::is_assignable>{}; constexpr auto is_trivially_assignable = detail::hana_trait<std::is_trivially_assignable>{}; constexpr auto is_nothrow_assignable = detail::hana_trait<std::is_nothrow_assignable>{}; constexpr auto is_copy_assignable = detail::hana_trait<std::is_copy_assignable>{}; constexpr auto is_trivially_copy_assignable = detail::hana_trait<std::is_trivially_copy_assignable>{}; constexpr auto is_nothrow_copy_assignable = detail::hana_trait<std::is_nothrow_copy_assignable>{}; constexpr auto is_move_assignable = detail::hana_trait<std::is_move_assignable>{}; constexpr auto is_trivially_move_assignable = detail::hana_trait<std::is_trivially_move_assignable>{}; constexpr auto is_nothrow_move_assignable = detail::hana_trait<std::is_nothrow_move_assignable>{}; constexpr auto is_destructible = detail::hana_trait<std::is_destructible>{}; constexpr auto is_trivially_destructible = detail::hana_trait<std::is_trivially_destructible>{}; constexpr auto is_nothrow_destructible = detail::hana_trait<std::is_nothrow_destructible>{}; constexpr auto has_virtual_destructor = detail::hana_trait<std::has_virtual_destructor>{}; // Property queries constexpr auto alignment_of = detail::hana_trait<std::alignment_of>{}; constexpr auto rank = detail::hana_trait<std::rank>{}; constexpr struct extent_t { template <typename T, typename N> constexpr auto operator()(T const&, N const&) const { constexpr unsigned n = N::value; using Result = typename std::extent<typename T::type, n>::type; return hana::integral_c<typename Result::value_type, Result::value>; } template <typename T> constexpr auto operator()(T const& t) const { return (*this)(t, hana::uint_c<0>); } } extent{}; // Type relationships constexpr auto is_same = detail::hana_trait<std::is_same>{}; constexpr auto is_base_of = detail::hana_trait<std::is_base_of>{}; constexpr auto is_convertible = detail::hana_trait<std::is_convertible>{}; /////////////////////// // Type modifications /////////////////////// // Const-volatility specifiers constexpr auto remove_cv = metafunction<std::remove_cv>; constexpr auto remove_const = metafunction<std::remove_const>; constexpr auto remove_volatile = metafunction<std::remove_volatile>; constexpr auto add_cv = metafunction<std::add_cv>; constexpr auto add_const = metafunction<std::add_const>; constexpr auto add_volatile = metafunction<std::add_volatile>; // References constexpr auto remove_reference = metafunction<std::remove_reference>; constexpr auto add_lvalue_reference = metafunction<std::add_lvalue_reference>; constexpr auto add_rvalue_reference = metafunction<std::add_rvalue_reference>; // Pointers constexpr auto remove_pointer = metafunction<std::remove_pointer>; constexpr auto add_pointer = metafunction<std::add_pointer>; // Sign modifiers constexpr auto make_signed = metafunction<std::make_signed>; constexpr auto make_unsigned = metafunction<std::make_unsigned>; // Arrays constexpr auto remove_extent = metafunction<std::remove_extent>; constexpr auto remove_all_extents = metafunction<std::remove_all_extents>; // Miscellaneous transformations constexpr struct aligned_storage_t { template <typename Len, typename Align> constexpr auto operator()(Len const&, Align const&) const { constexpr std::size_t len = Len::value; constexpr std::size_t align = Align::value; using Result = typename std::aligned_storage<len, align>::type; return hana::type_c<Result>; } template <typename Len> constexpr auto operator()(Len const&) const { constexpr std::size_t len = Len::value; using Result = typename std::aligned_storage<len>::type; return hana::type_c<Result>; } } aligned_storage{}; constexpr struct aligned_union_t { template <typename Len, typename ...T> constexpr auto operator()(Len const&, T const&...) const { constexpr std::size_t len = Len::value; using Result = typename std::aligned_union<len, typename T::type...>::type; return hana::type_c<Result>; } } aligned_union{}; constexpr auto decay = metafunction<std::decay>; // enable_if // disable_if // conditional constexpr auto common_type = metafunction<std::common_type>; constexpr auto underlying_type = metafunction<std::underlying_type>; /////////////////////// // Utilities /////////////////////// struct declval_t { template <typename T> typename std::add_rvalue_reference< typename T::type >::type operator()(T const&) const; }; constexpr declval_t declval{}; } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_TRAITS_HPP PK �\�[�@ �� � not.hppnu �[��� /*! @file Defines `boost::hana::not_`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_NOT_HPP #define BOOST_HANA_NOT_HPP #include <boost/hana/fwd/not.hpp> #include <boost/hana/concept/constant.hpp> #include <boost/hana/concept/logical.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/to.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/canonical_constant.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename X> constexpr decltype(auto) not_t::operator()(X&& x) const { using Bool = typename hana::tag_of<X>::type; using Not = BOOST_HANA_DISPATCH_IF(hana::not_impl<Bool>, hana::Logical<Bool>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Logical<Bool>::value, "hana::not_(cond) requires 'cond' to be a Logical"); #endif return Not::apply(static_cast<X&&>(x)); } //! @endcond template <typename L, bool condition> struct not_impl<L, when<condition>> : hana::default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; template <typename L> struct not_impl<L, hana::when<std::is_arithmetic<L>::value>> { template <typename Cond> static constexpr Cond apply(Cond const& cond) { return static_cast<Cond>(cond ? false : true); } }; namespace detail { template <typename C, typename X> struct constant_from_not { static constexpr auto value = hana::not_(hana::value<X>()); using hana_tag = detail::CanonicalConstant<typename C::value_type>; }; } template <typename C> struct not_impl<C, hana::when< hana::Constant<C>::value && hana::Logical<typename C::value_type>::value >> { template <typename Cond> static constexpr auto apply(Cond const&) { return hana::to<C>(detail::constant_from_not<C, Cond>{}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_NOT_HPP PK �\�[+��� � none_of.hppnu �[��� /*! @file Defines `boost::hana::none_of`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_NONE_OF_HPP #define BOOST_HANA_NONE_OF_HPP #include <boost/hana/fwd/none_of.hpp> #include <boost/hana/any_of.hpp> #include <boost/hana/concept/searchable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/not.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Pred> constexpr auto none_of_t::operator()(Xs&& xs, Pred&& pred) const { using S = typename hana::tag_of<Xs>::type; using NoneOf = BOOST_HANA_DISPATCH_IF(none_of_impl<S>, hana::Searchable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Searchable<S>::value, "hana::none_of(xs, pred) requires 'xs' to be a Searchable"); #endif return NoneOf::apply(static_cast<Xs&&>(xs), static_cast<Pred&&>(pred)); } //! @endcond template <typename S, bool condition> struct none_of_impl<S, when<condition>> : default_ { template <typename Xs, typename Pred> static constexpr auto apply(Xs&& xs, Pred&& pred) { return hana::not_(hana::any_of(static_cast<Xs&&>(xs), static_cast<Pred&&>(pred))); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_NONE_OF_HPP PK �\�[���ȥ � product.hppnu �[��� /*! @file Defines `boost::hana::product`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_PRODUCT_HPP #define BOOST_HANA_PRODUCT_HPP #include <boost/hana/fwd/product.hpp> #include <boost/hana/concept/foldable.hpp> #include <boost/hana/concept/ring.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/fold_left.hpp> #include <boost/hana/integral_constant.hpp> // required by fwd decl #include <boost/hana/mult.hpp> #include <boost/hana/one.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename R> template <typename Xs> constexpr decltype(auto) product_t<R>::operator()(Xs&& xs) const { using S = typename hana::tag_of<Xs>::type; using Product = BOOST_HANA_DISPATCH_IF(product_impl<S>, hana::Foldable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Ring<R>::value, "hana::product<R> requires 'R' to be a Ring"); static_assert(hana::Foldable<S>::value, "hana::product<R>(xs) requires 'xs' to be Foldable"); #endif return Product::template apply<R>(static_cast<Xs&&>(xs)); } //! @endcond template <typename T, bool condition> struct product_impl<T, when<condition>> : default_ { template <typename R, typename Xs> static constexpr decltype(auto) apply(Xs&& xs) { return hana::fold_left(static_cast<Xs&&>(xs), hana::one<R>(), hana::mult); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_PRODUCT_HPP PK �\�[�F�� intersperse.hppnu �[��� /*! @file Defines `boost::hana::intersperse`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_INTERSPERSE_HPP #define BOOST_HANA_INTERSPERSE_HPP #include <boost/hana/fwd/intersperse.hpp> #include <boost/hana/at.hpp> #include <boost/hana/bool.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/length.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Z> constexpr auto intersperse_t::operator()(Xs&& xs, Z&& z) const { using S = typename hana::tag_of<Xs>::type; using Intersperse = BOOST_HANA_DISPATCH_IF(intersperse_impl<S>, hana::Sequence<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Sequence<S>::value, "hana::intersperse(xs, z) requires 'xs' to be a Sequence"); #endif return Intersperse::apply(static_cast<Xs&&>(xs), static_cast<Z&&>(z)); } //! @endcond template <typename S, bool condition> struct intersperse_impl<S, when<condition>> : default_ { template <std::size_t i, typename Xs, typename Z> static constexpr decltype(auto) pick(Xs&&, Z&& z, hana::false_ /* odd index */) { return static_cast<Z&&>(z); } template <std::size_t i, typename Xs, typename Z> static constexpr decltype(auto) pick(Xs&& xs, Z&&, hana::true_ /* even index */) { return hana::at_c<(i + 1) / 2>(static_cast<Xs&&>(xs)); } template <typename Xs, typename Z, std::size_t ...i> static constexpr auto intersperse_helper(Xs&& xs, Z&& z, std::index_sequence<i...>) { return hana::make<S>( pick<i>(static_cast<Xs&&>(xs), static_cast<Z&&>(z), hana::bool_c<(i % 2 == 0)>)... ); } template <typename Xs, typename Z> static constexpr auto apply(Xs&& xs, Z&& z) { constexpr std::size_t size = decltype(hana::length(xs))::value; constexpr std::size_t new_size = size == 0 ? 0 : (size * 2) - 1; return intersperse_helper(static_cast<Xs&&>(xs), static_cast<Z&&>(z), std::make_index_sequence<new_size>{}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_INTERSPERSE_HPP PK �\�[�M��9 9 unique.hppnu �[��� /*! @file Defines `boost::hana::unique`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_UNIQUE_HPP #define BOOST_HANA_UNIQUE_HPP #include <boost/hana/fwd/unique.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/nested_by.hpp> // required by fwd decl #include <boost/hana/equal.hpp> #include <boost/hana/front.hpp> #include <boost/hana/group.hpp> #include <boost/hana/transform.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs> constexpr auto unique_t::operator()(Xs&& xs) const { using S = typename hana::tag_of<Xs>::type; using Unique = BOOST_HANA_DISPATCH_IF(unique_impl<S>, hana::Sequence<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Sequence<S>::value, "hana::unique(xs) requires 'xs' to be a Sequence"); #endif return Unique::apply(static_cast<Xs&&>(xs)); } template <typename Xs, typename Predicate> constexpr auto unique_t::operator()(Xs&& xs, Predicate&& predicate) const { using S = typename hana::tag_of<Xs>::type; using Unique = BOOST_HANA_DISPATCH_IF(unique_impl<S>, hana::Sequence<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Sequence<S>::value, "hana::unique(xs, predicate) requires 'xs' to be a Sequence"); #endif return Unique::apply(static_cast<Xs&&>(xs), static_cast<Predicate&&>(predicate)); } //! @endcond template <typename S, bool condition> struct unique_impl<S, when<condition>> : default_ { template <typename Xs, typename Pred> static constexpr auto apply(Xs&& xs, Pred&& pred) { return hana::transform( hana::group(static_cast<Xs&&>(xs), static_cast<Pred&&>(pred)), hana::front ); } template <typename Xs> static constexpr auto apply(Xs&& xs) { return unique_impl::apply(static_cast<Xs&&>(xs), hana::equal); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_UNIQUE_HPP PK �\�[��� keys.hppnu �[��� /*! @file Defines `boost::hana::keys`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_KEYS_HPP #define BOOST_HANA_KEYS_HPP #include <boost/hana/fwd/keys.hpp> #include <boost/hana/accessors.hpp> #include <boost/hana/concept/struct.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/first.hpp> #include <boost/hana/transform.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Map> constexpr auto keys_t::operator()(Map&& map) const { return keys_impl<typename hana::tag_of<Map>::type>::apply( static_cast<Map&&>(map) ); } //! @endcond template <typename T, bool condition> struct keys_impl<T, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; template <typename S> struct keys_impl<S, when<hana::Struct<S>::value>> { template <typename Object> static constexpr auto apply(Object const&) { return hana::transform(hana::accessors<S>(), hana::first); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_KEYS_HPP PK �\�[�!��p p duplicate.hppnu �[��� /*! @file Defines `boost::hana::duplicate`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DUPLICATE_HPP #define BOOST_HANA_DUPLICATE_HPP #include <boost/hana/fwd/duplicate.hpp> #include <boost/hana/concept/comonad.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/extend.hpp> #include <boost/hana/functional/id.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename W_> constexpr decltype(auto) duplicate_t::operator()(W_&& w) const { using W = typename hana::tag_of<W_>::type; using Duplicate = BOOST_HANA_DISPATCH_IF(duplicate_impl<W>, hana::Comonad<W>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Comonad<W>::value, "hana::duplicate(w) requires 'w' to be a Comonad"); #endif return Duplicate::apply(static_cast<W_&&>(w)); } //! @endcond template <typename W, bool condition> struct duplicate_impl<W, when<condition>> : default_ { template <typename X> static constexpr decltype(auto) apply(X&& x) { return hana::extend(static_cast<X&&>(x), hana::id); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DUPLICATE_HPP PK �\�[LU�" �" sort.hppnu �[��� /*! @file Defines `boost::hana::sort`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_SORT_HPP #define BOOST_HANA_SORT_HPP #include <boost/hana/fwd/sort.hpp> #include <boost/hana/at.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/detail/nested_by.hpp> // required by fwd decl #include <boost/hana/length.hpp> #include <boost/hana/less.hpp> #include <utility> // std::declval, std::index_sequence BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Predicate> constexpr auto sort_t::operator()(Xs&& xs, Predicate&& pred) const { using S = typename hana::tag_of<Xs>::type; using Sort = BOOST_HANA_DISPATCH_IF(sort_impl<S>, hana::Sequence<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Sequence<S>::value, "hana::sort(xs, predicate) requires 'xs' to be a Sequence"); #endif return Sort::apply(static_cast<Xs&&>(xs), static_cast<Predicate&&>(pred)); } template <typename Xs> constexpr auto sort_t::operator()(Xs&& xs) const { using S = typename hana::tag_of<Xs>::type; using Sort = BOOST_HANA_DISPATCH_IF(sort_impl<S>, hana::Sequence<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Sequence<S>::value, "hana::sort(xs) requires 'xs' to be a Sequence"); #endif return Sort::apply(static_cast<Xs&&>(xs)); } //! @endcond namespace detail { template <typename Xs, typename Pred> struct sort_predicate { template <std::size_t I, std::size_t J> using apply = decltype(std::declval<Pred>()( hana::at_c<I>(std::declval<Xs>()), hana::at_c<J>(std::declval<Xs>()) )); }; template <typename Left, typename Right> struct concat; template <std::size_t ...l, std::size_t ...r> struct concat<std::index_sequence<l...>, std::index_sequence<r...>> { using type = std::index_sequence<l..., r...>; }; template <typename Pred, bool PickRight, typename Left, typename Right> struct merge; template < typename Pred, std::size_t l0, std::size_t l1, std::size_t ...l, std::size_t r0, std::size_t ...r> struct merge< Pred, false, std::index_sequence<l0, l1, l...>, std::index_sequence<r0, r...> > { using type = typename concat< std::index_sequence<l0>, typename merge< Pred, (bool)Pred::template apply<r0, l1>::value, std::index_sequence<l1, l...>, std::index_sequence<r0, r...> >::type >::type; }; template < typename Pred, std::size_t l0, std::size_t r0, std::size_t ...r> struct merge< Pred, false, std::index_sequence<l0>, std::index_sequence<r0, r...> > { using type = std::index_sequence<l0, r0, r...>; }; template < typename Pred, std::size_t l0, std::size_t ...l, std::size_t r0, std::size_t r1, std::size_t ...r> struct merge< Pred, true, std::index_sequence<l0, l...>, std::index_sequence<r0, r1, r...> > { using type = typename concat< std::index_sequence<r0>, typename merge< Pred, (bool)Pred::template apply<r1, l0>::value, std::index_sequence<l0, l...>, std::index_sequence<r1, r...> >::type >::type; }; template < typename Pred, std::size_t l0, std::size_t ...l, std::size_t r0> struct merge< Pred, true, std::index_sequence<l0, l...>, std::index_sequence<r0> > { using type = std::index_sequence<r0, l0, l...>; }; template <typename Pred, typename Left, typename Right> struct merge_helper; template < typename Pred, std::size_t l0, std::size_t ...l, std::size_t r0, std::size_t ...r> struct merge_helper< Pred, std::index_sequence<l0, l...>, std::index_sequence<r0, r...> > { using type = typename merge< Pred, (bool)Pred::template apply<r0, l0>::value, std::index_sequence<l0, l...>, std::index_sequence<r0, r...> >::type; }; // split templated structure, Nr represents the number of elements // from Right to move to Left // There are two specializations: // The first handles the generic case (Nr > 0) // The second handles the stop condition (Nr == 0) // These two specializations are not strictly ordered as // the first cannot match Nr==0 && empty Right // the second cannot match Nr!=0 // std::enable_if<Nr!=0> is therefore required to make sure these two // specializations will never both be candidates during an overload // resolution (otherwise ambiguity occurs for Nr==0 and non-empty Right) template <std::size_t Nr, typename Left, typename Right, typename=void> struct split; template < std::size_t Nr, std::size_t ...l, std::size_t ...r, std::size_t r0> struct split< Nr, std::index_sequence<l...>, std::index_sequence<r0, r...>, typename std::enable_if<Nr!=0>::type > { using sp = split< Nr-1, std::index_sequence<l..., r0>, std::index_sequence<r...> >; using left = typename sp::left; using right = typename sp::right; }; template <std::size_t ...l, std::size_t ...r> struct split<0, std::index_sequence<l...>, std::index_sequence<r...>> { using left = std::index_sequence<l...>; using right = std::index_sequence<r...>; }; template <typename Pred, typename Sequence> struct merge_sort_impl; template <typename Pred, std::size_t ...seq> struct merge_sort_impl<Pred, std::index_sequence<seq...>> { using sequence = std::index_sequence<seq...>; using sp = split< sequence::size() / 2, std::index_sequence<>, sequence >; using type = typename merge_helper< Pred, typename merge_sort_impl<Pred, typename sp::left>::type, typename merge_sort_impl<Pred, typename sp::right>::type >::type; }; template <typename Pred, std::size_t x> struct merge_sort_impl<Pred, std::index_sequence<x>> { using type = std::index_sequence<x>; }; template <typename Pred> struct merge_sort_impl<Pred, std::index_sequence<>> { using type = std::index_sequence<>; }; } // end namespace detail template <typename S, bool condition> struct sort_impl<S, when<condition>> : default_ { template <typename Xs, std::size_t ...i> static constexpr auto apply_impl(Xs&& xs, std::index_sequence<i...>) { return hana::make<S>(hana::at_c<i>(static_cast<Xs&&>(xs))...); } template <typename Xs, typename Pred> static constexpr auto apply(Xs&& xs, Pred const&) { constexpr std::size_t Len = decltype(hana::length(xs))::value; using Indices = typename detail::merge_sort_impl< detail::sort_predicate<Xs&&, Pred>, std::make_index_sequence<Len> >::type; return apply_impl(static_cast<Xs&&>(xs), Indices{}); } template <typename Xs> static constexpr auto apply(Xs&& xs) { return sort_impl::apply(static_cast<Xs&&>(xs), hana::less); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_SORT_HPP PK �\�[�;�� � take_back.hppnu �[��� /*! @file Defines `boost::hana::take_back`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_TAKE_BACK_HPP #define BOOST_HANA_TAKE_BACK_HPP #include <boost/hana/fwd/take_back.hpp> #include <boost/hana/at.hpp> #include <boost/hana/concept/integral_constant.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/integral_constant.hpp> #include <boost/hana/length.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename N> constexpr auto take_back_t::operator()(Xs&& xs, N const& n) const { using S = typename hana::tag_of<Xs>::type; using TakeBack = BOOST_HANA_DISPATCH_IF(take_back_impl<S>, hana::Sequence<S>::value && hana::IntegralConstant<N>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Sequence<S>::value, "hana::take_back(xs, n) requires 'xs' to be a Sequence"); static_assert(hana::IntegralConstant<N>::value, "hana::take_back(xs, n) requires 'n' to be an IntegralConstant"); #endif return TakeBack::apply(static_cast<Xs&&>(xs), n); } //! @endcond template <typename S, bool condition> struct take_back_impl<S, when<condition>> : default_ { template <std::size_t start, typename Xs, std::size_t ...n> static constexpr auto take_back_helper(Xs&& xs, std::index_sequence<n...>) { return hana::make<S>(hana::at_c<start + n>(static_cast<Xs&&>(xs))...); } template <typename Xs, typename N> static constexpr auto apply(Xs&& xs, N const&) { constexpr std::size_t n = N::value; constexpr std::size_t len = decltype(hana::length(xs))::value; constexpr std::size_t start = n < len ? len - n : 0; return take_back_helper<start>(static_cast<Xs&&>(xs), std::make_index_sequence<(n < len ? n : len)>{}); } }; template <std::size_t n> struct take_back_c_t { template <typename Xs> constexpr auto operator()(Xs&& xs) const { return hana::take_back(static_cast<Xs&&>(xs), hana::size_c<n>); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_TAKE_BACK_HPP PK �\�[���x x reverse_fold.hppnu �[��� /*! @file Defines `boost::hana::reverse_fold`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_REVERSE_FOLD_HPP #define BOOST_HANA_REVERSE_FOLD_HPP #include <boost/hana/fwd/reverse_fold.hpp> #include <boost/hana/config.hpp> #include <boost/hana/fold_right.hpp> #include <boost/hana/functional/flip.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename S, typename F> constexpr decltype(auto) reverse_fold_t::operator()(Xs&& xs, S&& s, F&& f) const { return hana::fold_right(static_cast<Xs&&>(xs), static_cast<S&&>(s), hana::flip(static_cast<F&&>(f))); } template <typename Xs, typename F> constexpr decltype(auto) reverse_fold_t::operator()(Xs&& xs, F&& f) const { return hana::fold_right(static_cast<Xs&&>(xs), hana::flip(static_cast<F&&>(f))); } //! @endcond BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_REVERSE_FOLD_HPP PK �\�[u�T� � less.hppnu �[��� /*! @file Defines `boost::hana::less`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_LESS_HPP #define BOOST_HANA_LESS_HPP #include <boost/hana/fwd/less.hpp> #include <boost/hana/and.hpp> #include <boost/hana/bool.hpp> #include <boost/hana/concept/constant.hpp> #include <boost/hana/concept/orderable.hpp> #include <boost/hana/concept/product.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/common.hpp> #include <boost/hana/core/to.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/concepts.hpp> #include <boost/hana/detail/has_common_embedding.hpp> #include <boost/hana/detail/nested_than.hpp> // required by fwd decl #include <boost/hana/equal.hpp> #include <boost/hana/first.hpp> #include <boost/hana/if.hpp> #include <boost/hana/less_equal.hpp> #include <boost/hana/lexicographical_compare.hpp> #include <boost/hana/or.hpp> #include <boost/hana/second.hpp> #include <boost/hana/value.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename X, typename Y> constexpr auto less_t::operator()(X&& x, Y&& y) const { using T = typename hana::tag_of<X>::type; using U = typename hana::tag_of<Y>::type; using Less = BOOST_HANA_DISPATCH_IF(decltype(less_impl<T, U>{}), hana::Orderable<T>::value && hana::Orderable<U>::value && !is_default<less_impl<T, U>>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Orderable<T>::value, "hana::less(x, y) requires 'x' to be Orderable"); static_assert(hana::Orderable<U>::value, "hana::less(x, y) requires 'y' to be Orderable"); static_assert(!is_default<less_impl<T, U>>::value, "hana::less(x, y) requires 'x' and 'y' to be embeddable " "in a common Orderable"); #endif return Less::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); } //! @endcond template <typename T, typename U, bool condition> struct less_impl<T, U, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; // Cross-type overload template <typename T, typename U> struct less_impl<T, U, when< detail::has_nontrivial_common_embedding<Orderable, T, U>::value && !detail::LessThanComparable<T, U>::value >> { using C = typename hana::common<T, U>::type; template <typename X, typename Y> static constexpr decltype(auto) apply(X&& x, Y&& y) { return hana::less(hana::to<C>(static_cast<X&&>(x)), hana::to<C>(static_cast<Y&&>(y))); } }; ////////////////////////////////////////////////////////////////////////// // Model for LessThanComparable data types ////////////////////////////////////////////////////////////////////////// template <typename T, typename U> struct less_impl<T, U, when<detail::LessThanComparable<T, U>::value>> { template <typename X, typename Y> static constexpr decltype(auto) apply(X&& x, Y&& y) { return static_cast<X&&>(x) < static_cast<Y&&>(y); } }; ////////////////////////////////////////////////////////////////////////// // Model for Constants wrapping an Orderable ////////////////////////////////////////////////////////////////////////// template <typename C> struct less_impl<C, C, when< hana::Constant<C>::value && Orderable<typename C::value_type>::value >> { template <typename X, typename Y> static constexpr auto apply(X const&, Y const&) { constexpr auto is_less = hana::less(hana::value<X>(), hana::value<Y>()); constexpr bool truth_value = hana::if_(is_less, true, false); return hana::bool_c<truth_value>; } }; ////////////////////////////////////////////////////////////////////////// // Model for Products ////////////////////////////////////////////////////////////////////////// template <typename T, typename U> struct less_impl<T, U, when<hana::Product<T>::value && hana::Product<U>::value>> { template <typename X, typename Y> static constexpr decltype(auto) apply(X const& x, Y const& y) { return hana::or_( hana::less(hana::first(x), hana::first(y)), hana::and_( hana::less_equal(hana::first(x), hana::first(y)), hana::less(hana::second(x), hana::second(y)) ) ); } }; ////////////////////////////////////////////////////////////////////////// // Model for Sequences ////////////////////////////////////////////////////////////////////////// template <typename T, typename U> struct less_impl<T, U, when< hana::Sequence<T>::value && hana::Sequence<U>::value >> { template <typename Xs, typename Ys> static constexpr auto apply(Xs const& xs, Ys const& ys) { return hana::lexicographical_compare(xs, ys); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_LESS_HPP PK �\�[�� �P P tap.hppnu �[��� /*! @file Defines `boost::hana::tap`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_TAP_HPP #define BOOST_HANA_TAP_HPP #include <boost/hana/fwd/tap.hpp> #include <boost/hana/concept/monad.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/functional/partial.hpp> #include <boost/hana/lift.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename M> template <typename F> constexpr auto tap_t<M>::operator()(F&& f) const { #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Monad<M>::value, "hana::tap<M> requires 'M' to be a Monad"); #endif using Tap = BOOST_HANA_DISPATCH_IF(tap_impl<M>, hana::Monad<M>::value ); return Tap::apply(static_cast<F&&>(f)); } //! @endcond namespace detail { template <typename M> struct tap_helper { template <typename F, typename X> constexpr auto operator()(F&& f, X&& x) const { (void)static_cast<F&&>(f)(x); return hana::lift<M>(static_cast<X&&>(x)); } }; } template <typename M, bool condition> struct tap_impl<M, when<condition>> : default_ { template <typename F> static constexpr auto apply(F&& f) { return hana::partial(detail::tap_helper<M>{}, static_cast<F&&>(f)); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_TAP_HPP PK �\�[ x1- - remove_range.hppnu �[��� /*! @file Defines `boost::hana::remove_range` and `boost::hana::remove_range_c`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_REMOVE_RANGE_HPP #define BOOST_HANA_REMOVE_RANGE_HPP #include <boost/hana/fwd/remove_range.hpp> #include <boost/hana/at.hpp> #include <boost/hana/concept/integral_constant.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/integral_constant.hpp> #include <boost/hana/length.hpp> #include <cstddef> #include <utility> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename From, typename To> constexpr auto remove_range_t::operator()(Xs&& xs, From const& from, To const& to) const { using S = typename hana::tag_of<Xs>::type; using RemoveRange = BOOST_HANA_DISPATCH_IF(remove_range_impl<S>, hana::Sequence<S>::value && hana::IntegralConstant<From>::value && hana::IntegralConstant<To>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Sequence<S>::value, "hana::remove_range(xs, from, to) requires 'xs' to be a Sequence"); static_assert(hana::IntegralConstant<From>::value, "hana::remove_range(xs, from, to) requires 'from' to be an IntegralConstant"); static_assert(hana::IntegralConstant<To>::value, "hana::remove_range(xs, from, to) requires 'to' to be an IntegralConstant"); #endif return RemoveRange::apply(static_cast<Xs&&>(xs), from, to); } //! @endcond template <typename S, bool condition> struct remove_range_impl<S, when<condition>> : default_ { template <std::size_t offset, typename Xs, std::size_t ...before, std::size_t ...after> static constexpr auto remove_range_helper(Xs&& xs, std::index_sequence<before...>, std::index_sequence<after...>) { return hana::make<S>( hana::at_c<before>(static_cast<Xs&&>(xs))..., hana::at_c<offset + after>(static_cast<Xs&&>(xs))... ); } template <typename Xs, typename From, typename To> static constexpr auto apply(Xs&& xs, From const&, To const&) { constexpr std::size_t from = From::value; constexpr std::size_t to = To::value; constexpr std::size_t len = decltype(hana::length(xs))::value; constexpr std::size_t before = from == to ? len : from; constexpr std::size_t after = from == to ? 0 : len - to; static_assert(from <= to, "hana::remove_range(xs, from, to) requires '[from, to)' to be a " "valid interval, meaning that 'from <= to'"); static_assert(from == to || from >= 0, "hana::remove_range(xs, from, to) requires 'from' to be non-negative"); static_assert(from == to || to <= len, "hana::remove_range(xs, from, to) requires 'to <= length(xs)'"); return remove_range_helper<to>(static_cast<Xs&&>(xs), std::make_index_sequence<before>{}, std::make_index_sequence<after>{}); } }; template <std::size_t from, std::size_t to> struct remove_range_c_t { template <typename Xs> constexpr decltype(auto) operator()(Xs&& xs) const { return hana::remove_range(static_cast<Xs&&>(xs), hana::size_c<from>, hana::size_c<to>); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_REMOVE_RANGE_HPP PK �\�[� 5� contains.hppnu �[��� /*! @file Defines `boost::hana::contains` and `boost::hana::in`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CONTAINS_HPP #define BOOST_HANA_CONTAINS_HPP #include <boost/hana/fwd/contains.hpp> #include <boost/hana/any_of.hpp> #include <boost/hana/concept/searchable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/equal.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Key> constexpr auto contains_t::operator()(Xs&& xs, Key&& key) const { using S = typename hana::tag_of<Xs>::type; using Contains = BOOST_HANA_DISPATCH_IF(contains_impl<S>, hana::Searchable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Searchable<S>::value, "hana::contains(xs, key) requires 'xs' to be a Searchable"); #endif return Contains::apply(static_cast<Xs&&>(xs), static_cast<Key&&>(key)); } //! @endcond template <typename S, bool condition> struct contains_impl<S, when<condition>> : default_ { template <typename Xs, typename X> static constexpr auto apply(Xs&& xs, X&& x) { return hana::any_of(static_cast<Xs&&>(xs), hana::equal.to(static_cast<X&&>(x))); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CONTAINS_HPP PK �\�[�Ya� � concept/group.hppnu �[��� /*! @file Defines `boost::hana::Group`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CONCEPT_GROUP_HPP #define BOOST_HANA_CONCEPT_GROUP_HPP #include <boost/hana/fwd/concept/group.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/default.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/detail/integral_constant.hpp> #include <boost/hana/minus.hpp> #include <boost/hana/negate.hpp> BOOST_HANA_NAMESPACE_BEGIN template <typename G> struct Group : hana::integral_constant<bool, !is_default<negate_impl<typename tag_of<G>::type>>::value || !is_default<minus_impl<typename tag_of<G>::type, typename tag_of<G>::type>>::value > { }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CONCEPT_GROUP_HPP PK �\�[2d1� � concept/integral_constant.hppnu �[��� /*! @file Defines `boost::hana::IntegralConstant`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CONCEPT_INTEGRAL_CONSTANT_HPP #define BOOST_HANA_CONCEPT_INTEGRAL_CONSTANT_HPP #include <boost/hana/fwd/concept/integral_constant.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/detail/integral_constant.hpp> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <typename C, typename Tag = typename tag_of<C>::type> struct integral_constant_dispatch : hana::integral_constant<bool, hana::IntegralConstant<Tag>::value > { }; template <typename C> struct integral_constant_dispatch<C, C> : hana::integral_constant<bool, false> { }; } //! @cond template <typename C> struct IntegralConstant : detail::integral_constant_dispatch<C> { }; //! @endcond BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CONCEPT_INTEGRAL_CONSTANT_HPP PK �\�[ 8+� � concept/foldable.hppnu �[��� /*! @file Defines `boost::hana::Foldable`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CONCEPT_FOLDABLE_HPP #define BOOST_HANA_CONCEPT_FOLDABLE_HPP #include <boost/hana/fwd/concept/foldable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/default.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/detail/integral_constant.hpp> #include <boost/hana/fold_left.hpp> #include <boost/hana/unpack.hpp> BOOST_HANA_NAMESPACE_BEGIN template <typename T> struct Foldable : hana::integral_constant<bool, !is_default<fold_left_impl<typename tag_of<T>::type>>::value || !is_default<unpack_impl<typename tag_of<T>::type>>::value > { }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CONCEPT_FOLDABLE_HPP PK �\�[$��2� � concept/logical.hppnu �[��� /*! @file Defines `boost::hana::Logical`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CONCEPT_LOGICAL_HPP #define BOOST_HANA_CONCEPT_LOGICAL_HPP #include <boost/hana/fwd/concept/logical.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/default.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/detail/integral_constant.hpp> #include <boost/hana/eval_if.hpp> #include <boost/hana/not.hpp> #include <boost/hana/while.hpp> BOOST_HANA_NAMESPACE_BEGIN template <typename L> struct Logical : hana::integral_constant<bool, !is_default<eval_if_impl<typename tag_of<L>::type>>::value && !is_default<not_impl<typename tag_of<L>::type>>::value && !is_default<while_impl<typename tag_of<L>::type>>::value > { }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CONCEPT_LOGICAL_HPP PK �\�[�16{� � concept/searchable.hppnu �[��� /*! @file Defines `boost::hana::Searchable`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CONCEPT_SEARCHABLE_HPP #define BOOST_HANA_CONCEPT_SEARCHABLE_HPP #include <boost/hana/fwd/concept/searchable.hpp> #include <boost/hana/any_of.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/default.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/detail/integral_constant.hpp> #include <boost/hana/find_if.hpp> BOOST_HANA_NAMESPACE_BEGIN template <typename S> struct Searchable : hana::integral_constant<bool, !is_default<any_of_impl<typename tag_of<S>::type>>::value && !is_default<find_if_impl<typename tag_of<S>::type>>::value > { }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CONCEPT_SEARCHABLE_HPP PK �\�[�mxe concept/comonad.hppnu �[��� /*! @file Defines `boost::hana::Comonad`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CONCEPT_COMONAD_HPP #define BOOST_HANA_CONCEPT_COMONAD_HPP #include <boost/hana/fwd/concept/comonad.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/default.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/detail/integral_constant.hpp> #include <boost/hana/duplicate.hpp> #include <boost/hana/extend.hpp> #include <boost/hana/extract.hpp> BOOST_HANA_NAMESPACE_BEGIN template <typename W> struct Comonad : hana::integral_constant<bool, !is_default<extract_impl<typename tag_of<W>::type>>::value && (!is_default<duplicate_impl<typename tag_of<W>::type>>::value || !is_default<extend_impl<typename tag_of<W>::type>>::value) > { }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CONCEPT_COMONAD_HPP PK �\�[�ź�C C concept/hashable.hppnu �[��� /*! @file Defines `boost::hana::Hashable`. @copyright Louis Dionne 2016 @copyright Jason Rice 2016 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CONCEPT_HASHABLE_HPP #define BOOST_HANA_CONCEPT_HASHABLE_HPP #include <boost/hana/fwd/concept/hashable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/default.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/detail/integral_constant.hpp> #include <boost/hana/hash.hpp> BOOST_HANA_NAMESPACE_BEGIN template <typename T> struct Hashable : hana::integral_constant<bool, !is_default<hash_impl<typename tag_of<T>::type>>::value > { }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CONCEPT_HASHABLE_HPP PK �\�[ *J � � concept/monad.hppnu �[��� /*! @file Defines `boost::hana::Monad`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CONCEPT_MONAD_HPP #define BOOST_HANA_CONCEPT_MONAD_HPP #include <boost/hana/fwd/concept/monad.hpp> #include <boost/hana/chain.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/default.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/detail/integral_constant.hpp> #include <boost/hana/flatten.hpp> BOOST_HANA_NAMESPACE_BEGIN template <typename M> struct Monad : hana::integral_constant<bool, !is_default<flatten_impl<typename tag_of<M>::type>>::value || !is_default<chain_impl<typename tag_of<M>::type>>::value > { }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CONCEPT_MONAD_HPP PK �\�[�.�K concept/iterable.hppnu �[��� /*! @file Defines `boost::hana::Iterable`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CONCEPT_ITERABLE_HPP #define BOOST_HANA_CONCEPT_ITERABLE_HPP #include <boost/hana/fwd/concept/iterable.hpp> #include <boost/hana/at.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/default.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/detail/integral_constant.hpp> #include <boost/hana/drop_front.hpp> #include <boost/hana/is_empty.hpp> BOOST_HANA_NAMESPACE_BEGIN template <typename It> struct Iterable : hana::integral_constant<bool, !is_default<at_impl<typename tag_of<It>::type>>::value && !is_default<drop_front_impl<typename tag_of<It>::type>>::value && !is_default<is_empty_impl<typename tag_of<It>::type>>::value > { }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CONCEPT_ITERABLE_HPP PK �\�[C�/ / concept/constant.hppnu �[��� /*! @file Defines `boost::hana::Constant`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CONCEPT_CONSTANT_HPP #define BOOST_HANA_CONCEPT_CONSTANT_HPP #include <boost/hana/fwd/concept/constant.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/default.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/detail/integral_constant.hpp> #include <boost/hana/value.hpp> BOOST_HANA_NAMESPACE_BEGIN template <typename C> struct Constant : hana::integral_constant<bool, !is_default<value_impl<typename tag_of<C>::type>>::value > { }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CONCEPT_CONSTANT_HPP PK �\�[�U� � � concept/sequence.hppnu �[��� /*! @file Defines `boost::hana::Sequence`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CONCEPT_SEQUENCE_HPP #define BOOST_HANA_CONCEPT_SEQUENCE_HPP #include <boost/hana/fwd/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/integral_constant.hpp> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <typename S, typename Tag = typename hana::tag_of<S>::type> struct sequence_dispatch : hana::integral_constant<bool, hana::Sequence<Tag>::value > { }; template <typename S> struct sequence_dispatch<S, S> : hana::integral_constant<bool, false> { }; } //! @cond template <typename S, bool condition> struct Sequence<S, when<condition>> : detail::sequence_dispatch<S> { }; //! @endcond BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CONCEPT_SEQUENCE_HPP PK �\�[��ˡ � concept/applicative.hppnu �[��� /*! @file Defines `boost::hana::Applicative`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CONCEPT_APPLICATIVE_HPP #define BOOST_HANA_CONCEPT_APPLICATIVE_HPP #include <boost/hana/fwd/concept/applicative.hpp> #include <boost/hana/ap.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/default.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/detail/integral_constant.hpp> #include <boost/hana/lift.hpp> BOOST_HANA_NAMESPACE_BEGIN template <typename A> struct Applicative : hana::integral_constant<bool, !is_default<ap_impl<typename tag_of<A>::type>>::value && !is_default<lift_impl<typename tag_of<A>::type>>::value > { }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CONCEPT_APPLICATIVE_HPP PK �\�[���� � concept/functor.hppnu �[��� /*! @file Defines `boost::hana::Functor`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CONCEPT_FUNCTOR_HPP #define BOOST_HANA_CONCEPT_FUNCTOR_HPP #include <boost/hana/fwd/concept/functor.hpp> #include <boost/hana/adjust_if.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/default.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/detail/integral_constant.hpp> #include <boost/hana/transform.hpp> BOOST_HANA_NAMESPACE_BEGIN template <typename F> struct Functor : hana::integral_constant<bool, !is_default<transform_impl<typename tag_of<F>::type>>::value || !is_default<adjust_if_impl<typename tag_of<F>::type>>::value > { }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CONCEPT_FUNCTOR_HPP PK �\�[ ���+ + concept/struct.hppnu �[��� /*! @file Defines `boost::hana::Struct`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CONCEPT_STRUCT_HPP #define BOOST_HANA_CONCEPT_STRUCT_HPP #include <boost/hana/fwd/concept/struct.hpp> #include <boost/hana/accessors.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/default.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/detail/integral_constant.hpp> BOOST_HANA_NAMESPACE_BEGIN template <typename S> struct Struct : hana::integral_constant<bool, !is_default<accessors_impl<typename tag_of<S>::type>>::value > { }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CONCEPT_STRUCT_HPP PK �\�[�2;x x concept/comparable.hppnu �[��� /*! @file Defines `boost::hana::Comparable`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CONCEPT_COMPARABLE_HPP #define BOOST_HANA_CONCEPT_COMPARABLE_HPP #include <boost/hana/fwd/concept/comparable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/default.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/detail/integral_constant.hpp> #include <boost/hana/equal.hpp> BOOST_HANA_NAMESPACE_BEGIN template <typename T> struct Comparable : hana::integral_constant<bool, !is_default<equal_impl<typename tag_of<T>::type, typename tag_of<T>::type>>::value > { }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CONCEPT_COMPARABLE_HPP PK �\�[a~n�' ' concept/euclidean_ring.hppnu �[��� /*! @file Defines `boost::hana::EuclideanRing`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CONCEPT_EUCLIDEAN_RING_HPP #define BOOST_HANA_CONCEPT_EUCLIDEAN_RING_HPP #include <boost/hana/fwd/concept/euclidean_ring.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/default.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/detail/integral_constant.hpp> #include <boost/hana/div.hpp> #include <boost/hana/mod.hpp> BOOST_HANA_NAMESPACE_BEGIN template <typename R> struct EuclideanRing : hana::integral_constant<bool, !is_default<mod_impl<typename tag_of<R>::type, typename tag_of<R>::type>>::value && !is_default<div_impl<typename tag_of<R>::type, typename tag_of<R>::type>>::value > { }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CONCEPT_EUCLIDEAN_RING_HPP PK �\�[��ߝ8 8 concept/metafunction.hppnu �[��� /*! @file Defines `boost::hana::Metafunction`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CONCEPT_METAFUNCTION_HPP #define BOOST_HANA_CONCEPT_METAFUNCTION_HPP #include <boost/hana/fwd/concept/metafunction.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/detail/integral_constant.hpp> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <typename F, typename Tag = typename tag_of<F>::type> struct metafunction_dispatch : hana::integral_constant<bool, Metafunction<Tag>::value > { }; template <typename F> struct metafunction_dispatch<F, F> : hana::integral_constant<bool, false> { }; } template <typename F> struct Metafunction : detail::metafunction_dispatch<F> { }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CONCEPT_METAFUNCTION_HPP PK �\�[Ғ�� � concept/monoid.hppnu �[��� /*! @file Defines `boost::hana::Monoid`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CONCEPT_MONOID_HPP #define BOOST_HANA_CONCEPT_MONOID_HPP #include <boost/hana/fwd/concept/monoid.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/default.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/detail/integral_constant.hpp> #include <boost/hana/plus.hpp> #include <boost/hana/zero.hpp> BOOST_HANA_NAMESPACE_BEGIN template <typename M> struct Monoid : hana::integral_constant<bool, !is_default<zero_impl<typename tag_of<M>::type>>::value && !is_default<plus_impl<typename tag_of<M>::type, typename tag_of<M>::type>>::value > { }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CONCEPT_MONOID_HPP PK �\�[ω��u u concept/orderable.hppnu �[��� /*! @file Defines `boost::hana::Orderable`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CONCEPT_ORDERABLE_HPP #define BOOST_HANA_CONCEPT_ORDERABLE_HPP #include <boost/hana/fwd/concept/orderable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/default.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/detail/integral_constant.hpp> #include <boost/hana/less.hpp> BOOST_HANA_NAMESPACE_BEGIN template <typename Ord> struct Orderable : hana::integral_constant<bool, !is_default<less_impl<typename tag_of<Ord>::type, typename tag_of<Ord>::type>>::value > { }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CONCEPT_ORDERABLE_HPP PK �\�[���� � concept/product.hppnu �[��� /*! @file Defines `boost::hana::Product`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CONCEPT_PRODUCT_HPP #define BOOST_HANA_CONCEPT_PRODUCT_HPP #include <boost/hana/fwd/concept/product.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/default.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/detail/integral_constant.hpp> #include <boost/hana/first.hpp> #include <boost/hana/second.hpp> BOOST_HANA_NAMESPACE_BEGIN template <typename P> struct Product : hana::integral_constant<bool, !is_default<first_impl<typename tag_of<P>::type>>::value && !is_default<second_impl<typename tag_of<P>::type>>::value > { }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CONCEPT_PRODUCT_HPP PK �\�[I�Z�� � concept/ring.hppnu �[��� /*! @file Defines `boost::hana::Ring`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CONCEPT_RING_HPP #define BOOST_HANA_CONCEPT_RING_HPP #include <boost/hana/fwd/concept/ring.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/default.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/detail/integral_constant.hpp> #include <boost/hana/mult.hpp> #include <boost/hana/one.hpp> BOOST_HANA_NAMESPACE_BEGIN template <typename R> struct Ring : hana::integral_constant<bool, !is_default<one_impl<typename tag_of<R>::type>>::value && !is_default<mult_impl<typename tag_of<R>::type, typename tag_of<R>::type>>::value > { }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CONCEPT_RING_HPP PK �\�[�w�^� � concept/monad_plus.hppnu �[��� /*! @file Defines `boost::hana::MonadPlus`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CONCEPT_MONAD_PLUS_HPP #define BOOST_HANA_CONCEPT_MONAD_PLUS_HPP #include <boost/hana/fwd/concept/monad_plus.hpp> #include <boost/hana/concat.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/default.hpp> #include <boost/hana/core/tag_of.hpp> #include <boost/hana/detail/integral_constant.hpp> #include <boost/hana/empty.hpp> BOOST_HANA_NAMESPACE_BEGIN template <typename M> struct MonadPlus : hana::integral_constant<bool, !is_default<concat_impl<typename tag_of<M>::type>>::value && !is_default<empty_impl<typename tag_of<M>::type>>::value > { }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CONCEPT_MONAD_PLUS_HPP PK �\�[,� union.hppnu �[��� /*! @file Defines `boost::hana::union`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_UNION_HPP #define BOOST_HANA_UNION_HPP #include <boost/hana/fwd/union.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Ys> constexpr auto union_t::operator()(Xs&& xs, Ys&& ys) const { using S = typename hana::tag_of<Xs>::type; using Union = BOOST_HANA_DISPATCH_IF(union_impl<S>, true ); return Union::apply(static_cast<Xs&&>(xs), static_cast<Ys&&>(ys)); } //! @endcond template <typename S, bool condition> struct union_impl<S, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_UNION_HPP PK �\�[�K�� � ap.hppnu �[��� /*! @file Defines `boost::hana::ap`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_AP_HPP #define BOOST_HANA_AP_HPP #include <boost/hana/fwd/ap.hpp> #include <boost/hana/chain.hpp> #include <boost/hana/concept/applicative.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/variadic/foldl1.hpp> #include <boost/hana/functional/curry.hpp> #include <boost/hana/functional/partial.hpp> #include <boost/hana/transform.hpp> BOOST_HANA_NAMESPACE_BEGIN template <typename A, bool condition> struct ap_impl<A, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...args) = delete; }; //! @cond template <typename F, typename X> constexpr decltype(auto) ap_t::operator()(F&& f, X&& x) const { using Function = typename hana::tag_of<F>::type; using Value = typename hana::tag_of<X>::type; using Ap = BOOST_HANA_DISPATCH_IF(ap_impl<Function>, hana::Applicative<Function>::value && hana::Applicative<Value>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Applicative<Function>::value, "hana::ap(f, x) requires 'f' to be an Applicative"); static_assert(hana::Applicative<Value>::value, "hana::ap(f, x) requires 'x' to be an Applicative"); #endif return Ap::apply(static_cast<F&&>(f), static_cast<X&&>(x)); } template <typename F, typename ...Xs> constexpr decltype(auto) ap_t::operator()(F&& f, Xs&& ...xs) const { static_assert(sizeof...(xs) >= 1, "hana::ap must be called with at least two arguments"); return detail::variadic::foldl1( *this, hana::transform(static_cast<F&&>(f), hana::curry<sizeof...(xs)>), static_cast<Xs&&>(xs)... ); } //! @endcond template <typename S> struct ap_impl<S, when<Sequence<S>::value>> { template <typename F, typename X> static constexpr decltype(auto) apply(F&& f, X&& x) { return hana::chain( static_cast<F&&>(f), hana::partial(hana::transform, static_cast<X&&>(x)) ); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_AP_HPP PK �\�[}�'j� � less_equal.hppnu �[��� /*! @file Defines `boost::hana::less_equal`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_LESS_EQUAL_HPP #define BOOST_HANA_LESS_EQUAL_HPP #include <boost/hana/fwd/less_equal.hpp> #include <boost/hana/concept/orderable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/common.hpp> #include <boost/hana/core/to.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/has_common_embedding.hpp> #include <boost/hana/detail/nested_than.hpp> // required by fwd decl #include <boost/hana/less.hpp> #include <boost/hana/not.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename X, typename Y> constexpr auto less_equal_t::operator()(X&& x, Y&& y) const { using T = typename hana::tag_of<X>::type; using U = typename hana::tag_of<Y>::type; using LessEqual = BOOST_HANA_DISPATCH_IF( decltype(less_equal_impl<T, U>{}), hana::Orderable<T>::value && hana::Orderable<U>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Orderable<T>::value, "hana::less_equal(x, y) requires 'x' to be Orderable"); static_assert(hana::Orderable<U>::value, "hana::less_equal(x, y) requires 'y' to be Orderable"); #endif return LessEqual::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); } //! @endcond template <typename T, typename U, bool condition> struct less_equal_impl<T, U, when<condition>> : default_ { template <typename X, typename Y> static constexpr decltype(auto) apply(X&& x, Y&& y) { return hana::not_(hana::less(static_cast<Y&&>(y), static_cast<X&&>(x))); } }; // Cross-type overload template <typename T, typename U> struct less_equal_impl<T, U, when< detail::has_nontrivial_common_embedding<Orderable, T, U>::value >> { using C = typename hana::common<T, U>::type; template <typename X, typename Y> static constexpr decltype(auto) apply(X&& x, Y&& y) { return hana::less_equal(hana::to<C>(static_cast<X&&>(x)), hana::to<C>(static_cast<Y&&>(y))); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_LESS_EQUAL_HPP PK �\�['K�F F core/make.hppnu �[��� /*! @file Defines `boost::hana::make`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CORE_MAKE_HPP #define BOOST_HANA_CORE_MAKE_HPP #include <boost/hana/fwd/core/make.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/default.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Datatype, typename> struct make_impl : make_impl<Datatype, when<true>> { }; //! @endcond template <typename Datatype, bool condition> struct make_impl<Datatype, when<condition>> : default_ { template <typename ...X> static constexpr auto make_helper(int, X&& ...x) -> decltype(Datatype(static_cast<X&&>(x)...)) { return Datatype(static_cast<X&&>(x)...); } template <typename ...X> static constexpr auto make_helper(long, X&& ...) { static_assert((sizeof...(X), false), "there exists no constructor for the given data type"); } template <typename ...X> static constexpr decltype(auto) apply(X&& ...x) { return make_helper(int{}, static_cast<X&&>(x)...); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CORE_MAKE_HPP PK �\�[�{�{� � core/when.hppnu �[��� /*! @file Defines `boost::hana::when` and `boost::hana::when_valid`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CORE_WHEN_HPP #define BOOST_HANA_CORE_WHEN_HPP #include <boost/hana/fwd/core/when.hpp> #endif // !BOOST_HANA_CORE_WHEN_HPP PK �\�[4,>o o core/is_a.hppnu �[��� /*! @file Defines `boost::hana::is_a` and `boost::hana::is_an`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CORE_IS_A_HPP #define BOOST_HANA_CORE_IS_A_HPP #include <boost/hana/fwd/core/is_a.hpp> #include <boost/hana/bool.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/tag_of.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN ////////////////////////////////////////////////////////////////////////// // is_a ////////////////////////////////////////////////////////////////////////// template <typename DataType, typename T> struct is_a_t<DataType, T> : integral_constant<bool, std::is_same<DataType, typename hana::tag_of<T>::type>::value > { }; template <typename DataType> struct is_a_t<DataType> { template <typename T> constexpr auto operator()(T const&) const { return hana::is_a<DataType, T>; } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CORE_IS_A_HPP PK �\�[`��� � core/default.hppnu �[��� /*! @file Defines `boost::hana::default_` and `boost::hana::is_default`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CORE_DEFAULT_HPP #define BOOST_HANA_CORE_DEFAULT_HPP #include <boost/hana/fwd/core/default.hpp> #include <boost/hana/config.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN template <typename Method, typename> struct is_default : std::false_type { }; template <typename Method> struct is_default<Method, decltype((void) static_cast<default_>(*(Method*)0) )> : std::true_type { }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CORE_DEFAULT_HPP PK �\�[�E��j j core/tag_of.hppnu �[��� /*! @file Defines `boost::hana::tag_of` and `boost::hana::tag_of_t`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CORE_TAG_OF_HPP #define BOOST_HANA_CORE_TAG_OF_HPP #include <boost/hana/fwd/core/tag_of.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename T, typename> struct tag_of : tag_of<T, when<true>> { }; //! @endcond namespace core_detail { template <typename ...> struct is_valid { static constexpr bool value = true; }; } template <typename T, bool condition> struct tag_of<T, when<condition>> { using type = T; }; template <typename T> struct tag_of<T, when< core_detail::is_valid<typename T::hana_tag>::value >> { using type = typename T::hana_tag; }; template <typename T> struct tag_of<T const> : tag_of<T> { }; template <typename T> struct tag_of<T volatile> : tag_of<T> { }; template <typename T> struct tag_of<T const volatile> : tag_of<T> { }; template <typename T> struct tag_of<T&> : tag_of<T> { }; template <typename T> struct tag_of<T&&> : tag_of<T> { }; namespace detail { template <typename T> struct has_idempotent_tag : std::is_same<hana::tag_of_t<T>, std::remove_const_t<std::remove_reference_t<T>>> { }; } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CORE_TAG_OF_HPP PK �\�[�s�:� � core/to.hppnu �[��� /*! @file Defines `boost::hana::to` and related utilities. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CORE_TO_HPP #define BOOST_HANA_CORE_TO_HPP #include <boost/hana/fwd/core/to.hpp> #include <boost/hana/concept/constant.hpp> #include <boost/hana/concept/foldable.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/common.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> #include <boost/hana/detail/wrong.hpp> #include <boost/hana/unpack.hpp> #include <boost/hana/value.hpp> #include <type_traits> #include <utility> BOOST_HANA_NAMESPACE_BEGIN ////////////////////////////////////////////////////////////////////////// // to ////////////////////////////////////////////////////////////////////////// //! @cond template <typename To, typename From, typename> struct to_impl : to_impl<To, From, when<true>> { }; //! @endcond namespace convert_detail { struct no_conversion { }; template <typename To, typename From, typename = void> struct maybe_static_cast : no_conversion { template <typename X> static constexpr auto apply(X const&) { static_assert(detail::wrong<to_impl<To, From>, X>{}, "no conversion is available between the provided types"); } }; template <typename To, typename From> struct maybe_static_cast<To, From, decltype((void) static_cast<To>(std::declval<From>()) )> { template <typename X> static constexpr To apply(X&& x) { return static_cast<To>(static_cast<X&&>(x)); } }; } // end namespace convert_detail template <typename To, typename From, bool condition> struct to_impl<To, From, when<condition>> : convert_detail::maybe_static_cast<To, From> { }; template <typename To> struct to_impl<To, To> : embedding<> { template <typename X> static constexpr X apply(X&& x) { return static_cast<X&&>(x); } }; //! @cond template <typename To> template <typename X> constexpr decltype(auto) to_t<To>::operator()(X&& x) const { using From = typename hana::tag_of<X>::type; return to_impl<To, From>::apply(static_cast<X&&>(x)); } //! @endcond #define BOOST_HANA_DEFINE_EMBEDDING_IMPL(TO, FROM) \ template <> \ struct to_impl<TO, FROM> : embedding<> \ { static constexpr TO apply(FROM x) { return x; } } \ /**/ BOOST_HANA_DEFINE_EMBEDDING_IMPL(long double, double); BOOST_HANA_DEFINE_EMBEDDING_IMPL(long double, float); BOOST_HANA_DEFINE_EMBEDDING_IMPL(double , float); BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long long, signed long); BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long long, signed int); BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long long, signed short); BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long long, signed char); BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long , signed int); BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long , signed short); BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long , signed char); BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed int , signed short); BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed int , signed char); BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed short , signed char); BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long long, unsigned long); BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long long, unsigned int); BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long long, unsigned short); BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long long, unsigned char); BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long , unsigned int); BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long , unsigned short); BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long , unsigned char); BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned int , unsigned short); BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned int , unsigned char); BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned short , unsigned char); #undef BOOST_HANA_DEFINE_EMBEDDING_IMPL namespace detail { template <typename T> struct copy_char_signedness { using type = typename std::conditional<std::is_signed<char>::value, std::make_signed<T>, std::make_unsigned<T> >::type::type; }; } // If `char` is signed, we define an embedding from `char` to any signed // integral type. Otherwise, we define one from `char` to any unsigned // integral type. #define BOOST_HANA_DEFINE_CHAR_EMBEDDING_IMPL(TO) \ template <> \ struct to_impl<detail::copy_char_signedness<TO>::type, char> \ : embedding<> \ { \ static constexpr detail::copy_char_signedness<TO>::type \ apply(char x) \ { return x; } \ } \ /**/ BOOST_HANA_DEFINE_CHAR_EMBEDDING_IMPL(long long); BOOST_HANA_DEFINE_CHAR_EMBEDDING_IMPL(long); BOOST_HANA_DEFINE_CHAR_EMBEDDING_IMPL(int); BOOST_HANA_DEFINE_CHAR_EMBEDDING_IMPL(short); #undef BOOST_HANA_DEFINE_CHAR_EMBEDDING_IMPL template <typename T> struct to_impl<T*, decltype(nullptr)> : embedding<> { static constexpr T* apply(decltype(nullptr)) { return nullptr; } }; ////////////////////////////////////////////////////////////////////////// // is_convertible ////////////////////////////////////////////////////////////////////////// template <typename From, typename To, typename> struct is_convertible : std::true_type { }; template <typename From, typename To> struct is_convertible<From, To, decltype((void) static_cast<convert_detail::no_conversion>(*(to_impl<To, From>*)0) )> : std::false_type { }; ////////////////////////////////////////////////////////////////////////// // is_embedded ////////////////////////////////////////////////////////////////////////// template <typename From, typename To, typename> struct is_embedded : std::false_type { }; template <typename From, typename To> struct is_embedded<From, To, decltype((void) static_cast<embedding<true>>(*(to_impl<To, From>*)0) )> : std::true_type { }; ////////////////////////////////////////////////////////////////////////// // Conversion for Constants ////////////////////////////////////////////////////////////////////////// template <typename To, typename From> struct to_impl<To, From, when< hana::Constant<From>::value && is_convertible<typename From::value_type, To>::value >> : embedding<is_embedded<typename From::value_type, To>::value> { template <typename X> static constexpr decltype(auto) apply(X const&) { return hana::to<To>(hana::value<X>()); } }; ////////////////////////////////////////////////////////////////////////// // Foldable -> Sequence ////////////////////////////////////////////////////////////////////////// template <typename S, typename F> struct to_impl<S, F, when< hana::Sequence<S>::value && hana::Foldable<F>::value >> : embedding<Sequence<F>::value> { template <typename Xs> static constexpr decltype(auto) apply(Xs&& xs) { return hana::unpack(static_cast<Xs&&>(xs), hana::make<S>); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CORE_TO_HPP PK �\�[8� core/dispatch.hppnu �[��� /*! @file Includes all the headers needed to setup tag-dispatching. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CORE_DISPATCH_HPP #define BOOST_HANA_CORE_DISPATCH_HPP #include <boost/hana/core/tag_of.hpp> #include <boost/hana/detail/dispatch_if.hpp> #include <boost/hana/core/default.hpp> #include <boost/hana/core/when.hpp> #endif // !BOOST_HANA_CORE_DISPATCH_HPP PK �\�[�l�� � core/common.hppnu �[��� /*! @file Defines `boost::hana::common` and `boost::hana::common_t`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CORE_COMMON_HPP #define BOOST_HANA_CORE_COMMON_HPP #include <boost/hana/fwd/core/common.hpp> #include <boost/hana/concept/constant.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/canonical_constant.hpp> #include <boost/hana/detail/std_common_type.hpp> #include <boost/hana/detail/void_t.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN ////////////////////////////////////////////////////////////////////////// // common ////////////////////////////////////////////////////////////////////////// //! @cond template <typename T, typename U, typename> struct common : common<T, U, when<true>> { }; //! @endcond template <typename T, typename U, bool condition> struct common<T, U, when<condition>> : detail::std_common_type<T, U> { }; template <typename T> struct common<T, T> { using type = T; }; ////////////////////////////////////////////////////////////////////////// // has_common ////////////////////////////////////////////////////////////////////////// template <typename T, typename U, typename> struct has_common : std::false_type { }; template <typename T, typename U> struct has_common<T, U, detail::void_t<typename common<T, U>::type>> : std::true_type { }; ////////////////////////////////////////////////////////////////////////// // Provided common data types for Constants ////////////////////////////////////////////////////////////////////////// namespace constant_detail { //! @todo //! This is an awful hack to avoid having //! @code //! common<integral_constant_tag<int>, integral_constant_tag<long>> //! == //! CanonicalConstant<long> //! @endcode template <typename A, typename B, typename C> struct which { using type = detail::CanonicalConstant<C>; }; template <template <typename ...> class A, typename T, typename U, typename C> struct which<A<T>, A<U>, C> { using type = A<C>; }; } template <typename A, typename B> struct common<A, B, when< hana::Constant<A>::value && hana::Constant<B>::value && has_common<typename A::value_type, typename B::value_type>::value >> { using type = typename constant_detail::which< A, B, typename common<typename A::value_type, typename B::value_type>::type >::type; }; template <typename A, typename B> struct common<A, B, when< hana::Constant<A>::value && !hana::Constant<B>::value && has_common<typename A::value_type, B>::value >> { using type = typename common<typename A::value_type, B>::type; }; template <typename A, typename B> struct common<A, B, when< !hana::Constant<A>::value && hana::Constant<B>::value && has_common<A, typename B::value_type>::value >> { using type = typename common<A, typename B::value_type>::type; }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CORE_COMMON_HPP PK �\�[Nr�o� � replace_if.hppnu �[��� /*! @file Defines `boost::hana::replace_if`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_REPLACE_IF_HPP #define BOOST_HANA_REPLACE_IF_HPP #include <boost/hana/fwd/replace_if.hpp> #include <boost/hana/adjust_if.hpp> #include <boost/hana/concept/functor.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/functional/always.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Pred, typename Value> constexpr auto replace_if_t::operator()(Xs&& xs, Pred&& pred, Value&& value) const { using S = typename hana::tag_of<Xs>::type; using ReplaceIf = BOOST_HANA_DISPATCH_IF(replace_if_impl<S>, hana::Functor<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Functor<S>::value, "hana::replace_if(xs, pred, value) requires 'xs' to be a Functor"); #endif return ReplaceIf::apply(static_cast<Xs&&>(xs), static_cast<Pred&&>(pred), static_cast<Value&&>(value)); } //! @endcond template <typename Fun, bool condition> struct replace_if_impl<Fun, when<condition>> : default_ { template <typename Xs, typename Pred, typename Value> static constexpr auto apply(Xs&& xs, Pred&& pred, Value&& v) { return hana::adjust_if(static_cast<Xs&&>(xs), static_cast<Pred&&>(pred), hana::always(static_cast<Value&&>(v)) ); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_REPLACE_IF_HPP PK �\�[Bl�� � comparing.hppnu �[��� /*! @file Defines `boost::hana::comparing`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_COMPARING_HPP #define BOOST_HANA_COMPARING_HPP #include <boost/hana/fwd/comparing.hpp> #include <boost/hana/config.hpp> #include <boost/hana/detail/decay.hpp> #include <boost/hana/equal.hpp> BOOST_HANA_NAMESPACE_BEGIN namespace detail { template <typename F> struct equal_by { F f; template <typename X, typename Y> constexpr auto operator()(X&& x, Y&& y) const& { return hana::equal(f(static_cast<X&&>(x)), f(static_cast<Y&&>(y))); } template <typename X, typename Y> constexpr auto operator()(X&& x, Y&& y) & { return hana::equal(f(static_cast<X&&>(x)), f(static_cast<Y&&>(y))); } }; } //! @cond template <typename F> constexpr auto comparing_t::operator()(F&& f) const { return detail::equal_by<typename detail::decay<F>::type>{static_cast<F&&>(f)}; } //! @endcond BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_COMPARING_HPP PK �\�[Ӽ��5 5 eval_if.hppnu �[��� /*! @file Defines `boost::hana::eval_if`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_EVAL_IF_HPP #define BOOST_HANA_EVAL_IF_HPP #include <boost/hana/fwd/eval_if.hpp> #include <boost/hana/bool.hpp> #include <boost/hana/concept/constant.hpp> #include <boost/hana/concept/logical.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/eval.hpp> #include <boost/hana/if.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Cond, typename Then, typename Else> constexpr decltype(auto) eval_if_t::operator()(Cond&& cond, Then&& then_, Else&& else_) const { using Bool = typename hana::tag_of<Cond>::type; using EvalIf = BOOST_HANA_DISPATCH_IF(eval_if_impl<Bool>, hana::Logical<Bool>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Logical<Bool>::value, "hana::eval_if(cond, then, else) requires 'cond' to be a Logical"); #endif return EvalIf::apply(static_cast<Cond&&>(cond), static_cast<Then&&>(then_), static_cast<Else&&>(else_)); } //! @endcond template <typename L, bool condition> struct eval_if_impl<L, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; ////////////////////////////////////////////////////////////////////////// // Model for arithmetic data types ////////////////////////////////////////////////////////////////////////// template <typename L> struct eval_if_impl<L, when<std::is_arithmetic<L>::value>> { template <typename Cond, typename T, typename E> static constexpr auto apply(Cond const& cond, T&& t, E&& e) { return cond ? hana::eval(static_cast<T&&>(t)) : hana::eval(static_cast<E&&>(e)); } }; ////////////////////////////////////////////////////////////////////////// // Model for Constants over a Logical ////////////////////////////////////////////////////////////////////////// template <typename C> struct eval_if_impl<C, when< hana::Constant<C>::value && Logical<typename C::value_type>::value >> { template <typename Then, typename Else> static constexpr decltype(auto) eval_if_helper(hana::true_, Then&& t, Else&&) { return hana::eval(static_cast<Then&&>(t)); } template <typename Then, typename Else> static constexpr decltype(auto) eval_if_helper(hana::false_, Then&&, Else&& e) { return hana::eval(static_cast<Else&&>(e)); } template <typename Cond, typename Then, typename Else> static constexpr decltype(auto) apply(Cond const&, Then&& t, Else&& e) { constexpr auto cond = hana::value<Cond>(); constexpr bool truth_value = hana::if_(cond, true, false); return eval_if_helper(hana::bool_<truth_value>{}, static_cast<Then&&>(t), static_cast<Else&&>(e)); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_EVAL_IF_HPP PK �\�[� �\ \ difference.hppnu �[��� /*! @file Defines `boost::hana::difference`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_DIFFERENCE_HPP #define BOOST_HANA_DIFFERENCE_HPP #include <boost/hana/fwd/difference.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/erase_key.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs, typename Ys> constexpr auto difference_t::operator()(Xs&& xs, Ys&& ys) const { using S = typename hana::tag_of<Xs>::type; using Difference = BOOST_HANA_DISPATCH_IF(difference_impl<S>, true ); return Difference::apply(static_cast<Xs&&>(xs), static_cast<Ys&&>(ys)); } //! @endcond template <typename S, bool condition> struct difference_impl<S, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_DIFFERENCE_HPP PK �\�[Z�5�� � lift.hppnu �[��� /*! @file Defines `boost::hana::lift`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_LIFT_HPP #define BOOST_HANA_LIFT_HPP #include <boost/hana/fwd/lift.hpp> #include <boost/hana/concept/applicative.hpp> #include <boost/hana/concept/sequence.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/core/make.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename A> template <typename X> constexpr auto lift_t<A>::operator()(X&& x) const { #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Applicative<A>::value, "hana::lift<A> requires 'A' to be an Applicative"); #endif using Lift = BOOST_HANA_DISPATCH_IF(lift_impl<A>, hana::Applicative<A>::value ); return Lift::apply(static_cast<X&&>(x)); } //! @endcond template <typename A, bool condition> struct lift_impl<A, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...args) = delete; }; template <typename S> struct lift_impl<S, when<Sequence<S>::value>> { template <typename X> static constexpr decltype(auto) apply(X&& x) { return hana::make<S>(static_cast<X&&>(x)); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_LIFT_HPP PK �\�[�IV� � then.hppnu �[��� /*! @file Defines `boost::hana::then`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_THEN_HPP #define BOOST_HANA_THEN_HPP #include <boost/hana/fwd/then.hpp> #include <boost/hana/chain.hpp> #include <boost/hana/concept/monad.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/functional/always.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Before, typename Xs> constexpr decltype(auto) then_t::operator()(Before&& before, Xs&& xs) const { using M = typename hana::tag_of<Before>::type; using Then = BOOST_HANA_DISPATCH_IF(then_impl<M>, hana::Monad<M>::value && hana::Monad<Xs>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Monad<M>::value, "hana::then(before, xs) requires 'before' to be a Monad"); static_assert(hana::Monad<Xs>::value, "hana::then(before, xs) requires 'xs' to be a Monad"); #endif return Then::apply(static_cast<Before&&>(before), static_cast<Xs&&>(xs)); } //! @endcond template <typename M, bool condition> struct then_impl<M, when<condition>> : default_ { template <typename Xs, typename Ys> static constexpr decltype(auto) apply(Xs&& xs, Ys&& ys) { return hana::chain(static_cast<Xs&&>(xs), hana::always(static_cast<Ys&&>(ys))); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_THEN_HPP PK �\�[� �� � plus.hppnu �[��� /*! @file Defines `boost::hana::plus`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_PLUS_HPP #define BOOST_HANA_PLUS_HPP #include <boost/hana/fwd/plus.hpp> #include <boost/hana/concept/constant.hpp> #include <boost/hana/concept/monoid.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/common.hpp> #include <boost/hana/core/to.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/detail/canonical_constant.hpp> #include <boost/hana/detail/has_common_embedding.hpp> #include <type_traits> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename X, typename Y> constexpr decltype(auto) plus_t::operator()(X&& x, Y&& y) const { using T = typename hana::tag_of<X>::type; using U = typename hana::tag_of<Y>::type; using Plus = BOOST_HANA_DISPATCH_IF(decltype(plus_impl<T, U>{}), hana::Monoid<T>::value && hana::Monoid<U>::value && !is_default<plus_impl<T, U>>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Monoid<T>::value, "hana::plus(x, y) requires 'x' to be a Monoid"); static_assert(hana::Monoid<U>::value, "hana::plus(x, y) requires 'y' to be a Monoid"); static_assert(!is_default<plus_impl<T, U>>::value, "hana::plus(x, y) requires 'x' and 'y' to be embeddable " "in a common Monoid"); #endif return Plus::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); } //! @endcond template <typename T, typename U, bool condition> struct plus_impl<T, U, when<condition>> : default_ { template <typename ...Args> static constexpr auto apply(Args&& ...) = delete; }; // Cross-type overload template <typename T, typename U> struct plus_impl<T, U, when< detail::has_nontrivial_common_embedding<Monoid, T, U>::value >> { using C = typename common<T, U>::type; template <typename X, typename Y> static constexpr decltype(auto) apply(X&& x, Y&& y) { return hana::plus(hana::to<C>(static_cast<X&&>(x)), hana::to<C>(static_cast<Y&&>(y))); } }; ////////////////////////////////////////////////////////////////////////// // Model for non-boolean arithmetic data types ////////////////////////////////////////////////////////////////////////// template <typename T> struct plus_impl<T, T, when< std::is_arithmetic<T>::value && !std::is_same<T, bool>::value >> { template <typename X, typename Y> static constexpr decltype(auto) apply(X&& x, Y&& y) { return static_cast<X&&>(x) + static_cast<Y&&>(y); } }; ////////////////////////////////////////////////////////////////////////// // Model for Constants over a Monoid ////////////////////////////////////////////////////////////////////////// namespace detail { template <typename C, typename X, typename Y> struct constant_from_plus { static constexpr auto value = hana::plus(hana::value<X>(), hana::value<Y>()); using hana_tag = detail::CanonicalConstant<typename C::value_type>; }; } template <typename C> struct plus_impl<C, C, when< hana::Constant<C>::value && Monoid<typename C::value_type>::value >> { template <typename X, typename Y> static constexpr decltype(auto) apply(X const&, Y const&) { return hana::to<C>(detail::constant_from_plus<C, X, Y>{}); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_PLUS_HPP PK �\�[����? �? assert.hppnu �[��� /*! @file Defines macros to perform different kinds of assertions. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_ASSERT_HPP #define BOOST_HANA_ASSERT_HPP #include <boost/hana/concept/constant.hpp> #include <boost/hana/config.hpp> #include <boost/hana/detail/preprocessor.hpp> #include <boost/hana/if.hpp> #include <boost/hana/value.hpp> #include <cstdio> #include <cstdlib> #if defined(BOOST_HANA_DOXYGEN_INVOKED) //! @ingroup group-assertions //! Expands to a runtime assertion. //! //! Given a condition known at runtime, this macro expands to a runtime //! assertion similar to the `assert` macro. The provided condition must //! be explicitly convertible to a `bool`, and it must not be a model of //! the `Constant` concept. If the condition is a `Constant`, a static //! assertion will be triggered, asking you to use the //! `BOOST_HANA_CONSTANT_ASSERT` macro instead. //! //! @note //! This macro may only be used at function scope. # define BOOST_HANA_RUNTIME_ASSERT(condition) unspecified //! @ingroup group-assertions //! Equivalent to `BOOST_HANA_RUNTIME_ASSERT`, but allows providing a //! custom failure message. //! //! @warning //! Conditions that contain multiple comma-separated elements should be //! parenthesized. # define BOOST_HANA_RUNTIME_ASSERT_MSG(condition, message) unspecified //! @ingroup group-assertions //! Compile-time assertion for `Constant`s. //! //! Given a condition known at compile-time in the form of a `Constant`, //! this macro expands to a compile-time assertion similar to a `static_assert`. //! The provided condition must be a model of the `Constant` concept, in //! which case its value is retrieved using `hana::value` and then converted //! to a `bool`. If the condition is not a `Constant`, a static assertion //! will be triggered, asking you to use the `BOOST_HANA_RUNTIME_ASSERT` //! macro instead. //! //! This macro may be used at global/namespace scope and function scope //! only; it may not be used at class scope. Note that the condition may //! never be evaluated at runtime. Hence, any side effect may not take //! place (but you shouldn't rely on side effects inside assertions anyway). # define BOOST_HANA_CONSTANT_ASSERT(condition) unspecified //! @ingroup group-assertions //! Equivalent to `BOOST_HANA_CONSTANT_ASSERT`, but allows providing a //! custom failure message. //! //! @warning //! Conditions that contain multiple comma-separated elements should be //! parenthesized. # define BOOST_HANA_CONSTANT_ASSERT_MSG(condition, message) unspecified //! @ingroup group-assertions //! Expands to the strongest form of assertion possible for the given //! condition. //! //! Given a condition, `BOOST_HANA_ASSERT` expands either to a compile-time //! or to a runtime assertion, depending on whether the value of the //! condition is known at compile-time or at runtime. Compile-time //! assertions are always preferred over runtime assertions. If the //! condition is a model of the `Constant` concept, its value (retrievable //! with `hana::value`) is assumed to be explicitly convertible to `bool`, //! and a compile-time assertion is performed on it. Otherwise, the //! condition itself is assumed to be explicitly convertible to `bool`, //! and a runtime assertion is performed on it. //! //! If the assertion can be carried out at compile-time, the condition //! is not guaranteed to be evaluated at runtime at all (but it may). //! Hence, in general, you shouldn't rely on side effects that take place //! inside an assertion. //! //! @note //! This macro may only be used at function scope. # define BOOST_HANA_ASSERT(condition) unspecified //! @ingroup group-assertions //! Equivalent to `BOOST_HANA_ASSERT`, but allows providing a custom //! failure message. //! //! @warning //! Conditions that contain multiple comma-separated elements should be //! parenthesized. # define BOOST_HANA_ASSERT_MSG(condition, message) unspecified //! @ingroup group-assertions //! Expands to a static assertion or a runtime assertion, depending on //! whether `constexpr` lambdas are supported. //! //! This macro is used to assert on a condition that would be a constant //! expression if constexpr lambdas were supported. Right now, constexpr //! lambdas are not supported, and this is always a runtime assertion. //! Specifically, this is equivalent to `BOOST_HANA_RUNTIME_ASSERT`. # define BOOST_HANA_CONSTEXPR_ASSERT(condition) unspecified //! @ingroup group-assertions //! Equivalent to `BOOST_HANA_CONSTEXPR_ASSERT`, but allows providing a //! custom failure message. # define BOOST_HANA_CONSTEXPR_ASSERT_MSG(condition, message) unspecified #elif defined(BOOST_HANA_CONFIG_DISABLE_ASSERTIONS) # define BOOST_HANA_CONSTANT_ASSERT(...) /* nothing */ # define BOOST_HANA_CONSTANT_ASSERT_MSG(condition, message) /* nothing */ # define BOOST_HANA_RUNTIME_ASSERT(...) /* nothing */ # define BOOST_HANA_RUNTIME_ASSERT_MSG(condition, message) /* nothing */ # define BOOST_HANA_ASSERT(...) /* nothing */ # define BOOST_HANA_ASSERT_MSG(condition, message) /* nothing */ # define BOOST_HANA_CONSTEXPR_ASSERT(...) /* nothing */ # define BOOST_HANA_CONSTEXPR_ASSERT_MSG(condition, message) /* nothing */ #else ////////////////////////////////////////////////////////////////////////////// // BOOST_HANA_RUNTIME_ASSERT and BOOST_HANA_RUNTIME_ASSERT_MSG ////////////////////////////////////////////////////////////////////////////// # define BOOST_HANA_RUNTIME_ASSERT_MSG(condition, message) \ BOOST_HANA_RUNTIME_CHECK_MSG(condition, message) \ /**/ # define BOOST_HANA_RUNTIME_ASSERT(...) \ BOOST_HANA_RUNTIME_CHECK(__VA_ARGS__) \ /**/ ////////////////////////////////////////////////////////////////////////////// // BOOST_HANA_CONSTANT_ASSERT and BOOST_HANA_CONSTANT_ASSERT_MSG ////////////////////////////////////////////////////////////////////////////// # define BOOST_HANA_CONSTANT_ASSERT_MSG(condition, message) \ BOOST_HANA_CONSTANT_CHECK_MSG(condition, message) \ /**/ # define BOOST_HANA_CONSTANT_ASSERT(...) \ BOOST_HANA_CONSTANT_CHECK(__VA_ARGS__) \ /**/ ////////////////////////////////////////////////////////////////////////////// // BOOST_HANA_ASSERT and BOOST_HANA_ASSERT_MSG ////////////////////////////////////////////////////////////////////////////// # define BOOST_HANA_ASSERT_MSG(condition, message) \ BOOST_HANA_CHECK_MSG(condition, message) \ /**/ # define BOOST_HANA_ASSERT(...) \ BOOST_HANA_CHECK(__VA_ARGS__) \ /**/ ////////////////////////////////////////////////////////////////////////////// // BOOST_HANA_CONSTEXPR_ASSERT and BOOST_HANA_CONSTEXPR_ASSERT_MSG ////////////////////////////////////////////////////////////////////////////// # define BOOST_HANA_CONSTEXPR_ASSERT_MSG(condition, message) \ BOOST_HANA_CONSTEXPR_CHECK_MSG(condition, message) \ /**/ # define BOOST_HANA_CONSTEXPR_ASSERT(...) \ BOOST_HANA_CONSTEXPR_CHECK(__VA_ARGS__) \ /**/ #endif ////////////////////////////////////////////////////////////////////////////// // BOOST_HANA_RUNTIME_CHECK and BOOST_HANA_RUNTIME_CHECK_MSG ////////////////////////////////////////////////////////////////////////////// //! @ingroup group-assertions //! Equivalent to `BOOST_HANA_RUNTIME_ASSERT_MSG`, but not influenced by the //! `BOOST_HANA_CONFIG_DISABLE_ASSERTIONS` config macro. For internal use only. # define BOOST_HANA_RUNTIME_CHECK_MSG(condition, message) \ do { \ auto __hana_tmp = condition; \ static_assert(!::boost::hana::Constant<decltype(__hana_tmp)>::value,\ "the expression (" # condition ") yields a Constant; " \ "use BOOST_HANA_CONSTANT_ASSERT instead"); \ \ if (!static_cast<bool>(__hana_tmp)) { \ ::std::fprintf(stderr, "Assertion failed: " \ "(%s), function %s, file %s, line %i.\n", \ message, __func__, __FILE__, __LINE__); \ ::std::abort(); \ } \ } while (false); \ static_assert(true, "force trailing semicolon") \ /**/ //! @ingroup group-assertions //! Equivalent to `BOOST_HANA_RUNTIME_ASSERT`, but not influenced by the //! `BOOST_HANA_CONFIG_DISABLE_ASSERTIONS` config macro. For internal use only. # define BOOST_HANA_RUNTIME_CHECK(...) \ BOOST_HANA_RUNTIME_CHECK_MSG( \ (__VA_ARGS__), \ BOOST_HANA_PP_STRINGIZE(__VA_ARGS__) \ ) \ /**/ ////////////////////////////////////////////////////////////////////////////// // BOOST_HANA_CONSTANT_CHECK and BOOST_HANA_CONSTANT_CHECK_MSG ////////////////////////////////////////////////////////////////////////////// //! @ingroup group-assertions //! Equivalent to `BOOST_HANA_CONSTANT_ASSERT_MSG`, but not influenced by the //! `BOOST_HANA_CONFIG_DISABLE_ASSERTIONS` config macro. For internal use only. # define BOOST_HANA_CONSTANT_CHECK_MSG(condition, message) \ auto BOOST_HANA_PP_CONCAT(__hana_tmp_, __LINE__) = condition; \ static_assert(::boost::hana::Constant< \ decltype(BOOST_HANA_PP_CONCAT(__hana_tmp_, __LINE__)) \ >::value, \ "the expression " # condition " does not yield a Constant; " \ "use BOOST_HANA_RUNTIME_ASSERT instead"); \ static_assert(::boost::hana::value< \ decltype(BOOST_HANA_PP_CONCAT(__hana_tmp_, __LINE__)) \ >(), message); \ static_assert(true, "force trailing semicolon") \ /**/ //! @ingroup group-assertions //! Equivalent to `BOOST_HANA_CONSTANT_ASSERT`, but not influenced by the //! `BOOST_HANA_CONFIG_DISABLE_ASSERTIONS` config macro. For internal use only. # define BOOST_HANA_CONSTANT_CHECK(...) \ BOOST_HANA_CONSTANT_CHECK_MSG( \ (__VA_ARGS__), \ BOOST_HANA_PP_STRINGIZE(__VA_ARGS__) \ ) \ /**/ ////////////////////////////////////////////////////////////////////////////// // BOOST_HANA_CHECK and BOOST_HANA_CHECK_MSG ////////////////////////////////////////////////////////////////////////////// //! @ingroup group-assertions //! Equivalent to `BOOST_HANA_ASSERT_MSG`, but not influenced by the //! `BOOST_HANA_CONFIG_DISABLE_ASSERTIONS` config macro. For internal use only. # define BOOST_HANA_CHECK_MSG(condition, message) \ do { \ auto __hana_tmp = condition; \ ::boost::hana::if_(::boost::hana::bool_c< \ ::boost::hana::Constant<decltype(__hana_tmp)>::value>, \ [](auto expr) { \ static_assert(::boost::hana::value<decltype(expr)>(), \ message); \ }, \ [](auto expr) { \ if (!static_cast<bool>(expr)) { \ ::std::fprintf(stderr, "Assertion failed: " \ "(%s), function %s, file %s, line %i.\n", \ message, __func__, __FILE__, __LINE__); \ ::std::abort(); \ } \ } \ )(__hana_tmp); \ } while (false); \ static_assert(true, "force trailing semicolon") \ /**/ //! @ingroup group-assertions //! Equivalent to `BOOST_HANA__ASSERT`, but not influenced by the //! `BOOST_HANA_CONFIG_DISABLE_ASSERTIONS` config macro. For internal use only. # define BOOST_HANA_CHECK(...) \ BOOST_HANA_CHECK_MSG( \ (__VA_ARGS__), \ BOOST_HANA_PP_STRINGIZE(__VA_ARGS__) \ ) \ /**/ ////////////////////////////////////////////////////////////////////////////// // BOOST_HANA_CONSTEXPR_CHECK and BOOST_HANA_CONSTEXPR_CHECK_MSG ////////////////////////////////////////////////////////////////////////////// #if defined(BOOST_HANA_DOXYGEN_INVOKED) //! @ingroup group-assertions //! Equivalent to `BOOST_HANA_CONSTEXPR_ASSERT_MSG`, but not influenced by //! the `BOOST_HANA_CONFIG_DISABLE_ASSERTIONS` config macro. //! For internal use only. # define BOOST_HANA_CONSTEXPR_CHECK_MSG(condition, message) implementation-defined //! @ingroup group-assertions //! Equivalent to `BOOST_HANA_CONSTEXPR_ASSERT`, but not influenced by the //! `BOOST_HANA_CONFIG_DISABLE_ASSERTIONS` config macro. //! For internal use only. # define BOOST_HANA_CONSTEXPR_CHECK(...) implementation-defined #elif defined(BOOST_HANA_CONFIG_HAS_CONSTEXPR_LAMBDA) # define BOOST_HANA_CONSTEXPR_CHECK_MSG(condition, message) \ static_assert(condition, message) \ /**/ # define BOOST_HANA_CONSTEXPR_CHECK(...) \ static_assert((__VA_ARGS__), BOOST_HANA_PP_STRINGIZE(__VA_ARGS__)) \ /**/ #else # define BOOST_HANA_CONSTEXPR_CHECK_MSG(condition, message) \ BOOST_HANA_RUNTIME_CHECK_MSG(condition, message) \ /**/ # define BOOST_HANA_CONSTEXPR_CHECK(...) \ BOOST_HANA_CONSTEXPR_CHECK_MSG( \ (__VA_ARGS__), \ BOOST_HANA_PP_STRINGIZE(__VA_ARGS__) \ ) \ /**/ #endif #endif // !BOOST_HANA_ASSERT_HPP PK �\�[x��/ / any.hppnu �[��� /*! @file Defines `boost::hana::any`. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_ANY_HPP #define BOOST_HANA_ANY_HPP #include <boost/hana/fwd/any.hpp> #include <boost/hana/any_of.hpp> #include <boost/hana/concept/searchable.hpp> #include <boost/hana/config.hpp> #include <boost/hana/core/dispatch.hpp> #include <boost/hana/functional/id.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @cond template <typename Xs> constexpr auto any_t::operator()(Xs&& xs) const { using S = typename hana::tag_of<Xs>::type; using Any = BOOST_HANA_DISPATCH_IF(any_impl<S>, hana::Searchable<S>::value ); #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS static_assert(hana::Searchable<S>::value, "hana::any(xs) requires 'xs' to be a Searchable"); #endif return Any::apply(static_cast<Xs&&>(xs)); } //! @endcond template <typename S, bool condition> struct any_impl<S, when<condition>> : default_ { template <typename Xs> static constexpr auto apply(Xs&& xs) { return hana::any_of(static_cast<Xs&&>(xs), hana::id); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_ANY_HPP PK �\�[|:X repeat.hppnu �[��� PK �\�[^��A A ; count_if.hppnu �[��� PK �\�[F�!�� � � group.hppnu �[��� PK �\�[�Z# # �) front.hppnu �[��� PK �\�[ġz� �. scan_right.hppnu �[��� PK �\�[!f�� � DC adapt_struct.hppnu �[��� PK �\�[y��� 9E fuse.hppnu �[��� PK �\�[�Dck k �J any_of.hppnu �[��� PK �\�[�� 3h lazy.hppnu �[��� PK �\�[?��Tb b v� core.hppnu �[��� PK �\�[�1�� � � unfold_left.hppnu �[��� PK �\�[�$�`� � � one.hppnu �[��� PK �\�[� �� � �� monadic_fold_left.hppnu �[��� PK �\�[�ݤ� � � zip_with.hppnu �[��� PK �\�[�$��5 5 � append.hppnu �[��� PK �\�[�h� � �� flatten.hppnu �[��� PK �\�[ �'� � �� fill.hppnu �[��� PK �\�[�)G�L L �� intersection.hppnu �[��� PK �\�['u��� � � functional.hppnu �[��� PK �\�[����x x �� empty.hppnu �[��� PK �\�[G�B}� � �� min.hppnu �[��� PK �\�[:r^]� � �� integral_constant.hppnu �[��� PK �\�[?�9k k �� transform.hppnu �[��� PK �\�[#v9� � -� replicate.hppnu �[��� PK �\�[�W�Ҷ& �& T� range.hppnu �[��� PK �\�[OJ�{� � C$ scan_left.hppnu �[��� PK �\�[���< < D8 none.hppnu �[��� PK �\�[{�� � �= find_if.hppnu �[��� PK �\�[��� � �M index_if.hppnu �[��� PK �\�[���� � w[ take_while.hppnu �[��� PK �\�[�^1�� � �b adapt_adt.hppnu �[��� PK �\�[�C�>< >< �d optional.hppnu �[��� PK �\�[+x� � � at_key.hppnu �[��� PK �\�[�Ky�� � �� drop_front_exactly.hppnu �[��� PK �\�[U� 4r r � symmetric_difference.hppnu �[��� PK �\�[j�bb' b' Ӿ type.hppnu �[��� PK �\�[���& & m� bool.hppnu �[��� PK �\�[� ��D D � or.hppnu �[��� PK �\�[mmH:� � 2 experimental/printable.hppnu �[��� PK �\�[&�˓ � 5 experimental/types.hppnu �[��� PK �\�[)p�E �E �J experimental/view.hppnu �[��� PK �\�[�*� � Ɛ experimental/type_name.hppnu �[��� PK �\�[#��[' ' ř permutations.hppnu �[��� PK �\�[G�/� � ,� greater_equal.hppnu �[��� PK �\�[ �� � e� config.hppnu �[��� PK �\�[w��/ / �� all.hppnu �[��� PK �\�[�G�a a �� greater.hppnu �[��� PK �\�[>>u�� � �� extend.hppnu �[��� PK �\�[� {" " �� all_of.hppnu �[��� PK �\�[#��� � cartesian_product.hppnu �[��� PK �\�[�]6oY Y Z� while.hppnu �[��� PK �\�[{�/ � functional/lockstep.hppnu �[��� PK �\�[�v\�2 �2 M functional/placeholder.hppnu �[��� PK �\�[�sF:A A PH functional/compose.hppnu �[��� PK �\�[Rʆى � �U functional/id.hppnu �[��� PK �\�[�&:6� � �Y functional/arg.hppnu �[��� PK �\�[I�} �m functional/flip.hppnu �[��� PK �\�[�%|| | 9v functional/apply.hppnu �[��� PK �\�[Ӓ�qn n �� functional/iterate.hppnu �[��� PK �\�[@P$�� � �� functional/partial.hppnu �[��� PK �\�[U�p�� � �� functional/always.hppnu �[��� PK �\�[a � � ۮ functional/on.hppnu �[��� PK �\�[��17y y � functional/overload.hppnu �[��� PK �\�[�=�{ { �� functional/overload_linearly.hppnu �[��� PK �\�[+�[Z> > �� functional/infix.hppnu �[��� PK �\�[�ƀ�� � � functional/fix.hppnu �[��� PK �\�[ �m=T T $� functional/curry.hppnu �[��� PK �\�[�hGN% N% � functional/demux.hppnu �[��� PK �\�[��� � N2 functional/capture.hppnu �[��� PK �\�[s��� � >@ functional/reverse_partial.hppnu �[��� PK �\�[\C QM minimum.hppnu �[��� PK �\�[�õ<� � �Z chain.hppnu �[��� PK �\�[k�| � � �` remove.hppnu �[��� PK �\�[( 7g g �g partition.hppnu �[��� PK �\�[�� +x concept.hppnu �[��� PK �\�[z�v+0 +0 {} string.hppnu �[��� PK �\�[x�� � � find.hppnu �[��� PK �\�[�,� � ܴ max.hppnu �[��� PK �\�[WL� � value.hppnu �[��� PK �\�[q֪� � D� mult.hppnu �[��� PK �\�[�z��T T � insert.hppnu �[��� PK �\�[M.�4 �� monadic_fold_right.hppnu �[��� PK �\�[�t� � replace.hppnu �[��� PK �\�[v���y y E� filter.hppnu �[��� PK �\�[, =Ⱥ � � define_struct.hppnu �[��� PK �\�[>q��A A � negate.hppnu �[��� PK �\�[kzZ[z z n fold.hppnu �[��� PK �\�[���QO O slice.hppnu �[��� PK �\�[U� �/ / � monadic_compose.hppnu �[��� PK �\�[ 75r� � # mod.hppnu �[��� PK �\�[ X+C* * -2 if.hppnu �[��� PK �\�[,'YD D �9 zip_shortest_with.hppnu �[��� PK �\�[d�w w B size.hppnu �[��� PK �\�[�~�~� � �C remove_at.hppnu �[��� PK �\�[����� � �O ordering.hppnu �[��� PK �\�[ F&H} } �T sum.hppnu �[��� PK �\�[��;� � n[ first.hppnu �[��� PK �\�[iU�?� � �` is_disjoint.hppnu �[��� PK �\�[�(+�l l �h remove_if.hppnu �[��� PK �\�[����K K ao fold_right.hppnu �[��� PK �\�[��V�� � �{ version.hppnu �[��� PK �\�[Z�?�� � � accessors.hppnu �[��� PK �\�[Kk�w� � ;� drop_back.hppnu �[��� PK �\�[� ܝ7 7 #� unpack.hppnu �[��� PK �\�[����{ { �� insert_range.hppnu �[��� PK �\�[5��� � O� unfold_right.hppnu �[��� PK �\�[O��� � ?� lexicographical_compare.hppnu �[��� PK �\�[�4 �� � �� power.hppnu �[��� PK �\�[Ĝ�S" " ]� detail/dispatch_if.hppnu �[��� PK �\�[LWld! ! �� detail/has_duplicates.hppnu �[��� PK �\�[���U /� detail/nested_to.hppnu �[��� PK �\�[B�]�d d �� detail/any_of.hppnu �[��� PK �\�[gQ�� � ,� detail/nested_by.hppnu �[��� PK �\�[ۃq�� � W� detail/concepts.hppnu �[��� PK �\�[�GyD' D' e� detail/integral_constant.hppnu �[��� PK �\�[5�X X �& detail/nested_than_fwd.hppnu �[��� PK �\�[�n!9q/ q/ �- detail/struct_macros.hppnu �[��� PK �\�[�XJ J P] detail/index_if.hppnu �[��� PK �\�[z�� � �c detail/preprocessor.hppnu �[��� PK �\�[�X�A� � �i detail/canonical_constant.hppnu �[��� PK �\�[� �. . �t detail/array.hppnu �[��� PK �\�[LUV � detail/operators/adl.hppnu �[��� PK �\�[˂�� ]� detail/operators/logical.hppnu �[��� PK �\�[��o�� � �� detail/operators/searchable.hppnu �[��� PK �\�[�� � detail/operators/monad.hppnu �[��� PK �\�[���!� � U� detail/operators/iterable.hppnu �[��� PK �\�[V�ha< < [� detail/operators/comparable.hppnu �[��� PK �\�[�# e e � detail/operators/orderable.hppnu �[��� PK �\�[-��� �� detail/operators/arithmetic.hppnu �[��� PK �\�[�V�N] ] �� detail/wrong.hppnu �[��� PK �\�[���8� � & �� detail/variadic/reverse_apply/flat.hppnu �[��� PK �\�[�n�=� � * �� detail/variadic/reverse_apply/unrolled.hppnu �[��� PK �\�[�� �� detail/variadic/split_at.hppnu �[��� PK �\�[�K�y y ! �� detail/variadic/reverse_apply.hppnu �[��� PK �\�[�0W9�, �, �� detail/variadic/foldr1.hppnu �[��� PK �\�[ (4l3 3 � detail/variadic/at.hppnu �[��� PK �\�[n��|. . & detail/variadic/drop_into.hppnu �[��� PK �\�[G�5�� � �! detail/variadic/take.hppnu �[��� PK �\�[ܖ�A�, �, �' detail/variadic/foldl1.hppnu �[��� PK �\�[7( = = �T detail/std_common_type.hppnu �[��� PK �\�[ۋ�*� � 5Y detail/decay.hppnu �[��� PK �\�[/Bʇ� � " (` detail/first_unsatisfied_index.hppnu �[��� PK �\�[B�: : =g detail/type_at.hppnu �[��� PK �\�[q�]U U �m detail/algorithm.hppnu �[��� PK �\�[��p p R� detail/unpack_flatten.hppnu �[��� PK �\�[�6ͤ[ [ � detail/nested_to_fwd.hppnu �[��� PK �\�[�ֽ�V V �� detail/nested_than.hppnu �[��� PK �\�[e�`mo o J� detail/hash_table.hppnu �[��� PK �\�[*���? ? �� detail/type_foldr1.hppnu �[��� PK �\�[N��L L �� detail/type_foldl1.hppnu �[��� PK �\�[@!��� � � detail/create.hppnu �[��� PK �\�[���(� � �� detail/has_common_embedding.hppnu �[��� PK �\�[�`" " �� detail/ebo.hppnu �[��� PK �\�[;��b� � U� detail/intrinsics.hppnu �[��� PK �\�[� �� Z� detail/void_t.hppnu �[��� PK �\�[_l-#� � �� detail/nested_by_fwd.hppnu �[��� PK �\�[���X X �� detail/fast_and.hppnu �[��� PK �\�[0�є� � J minus.hppnu �[��� PK �\�[u��N. N. ( set.hppnu �[��� PK �\�[��%AX AX �> map.hppnu �[��� PK �\�[[ϣl� � %� div.hppnu �[��� PK �\�[2�� � 8� hash.hppnu �[��� PK �\�[���� � d� take_front.hppnu �[��� PK �\�[{��H/ / I� suffix.hppnu �[��� PK �\�[&; ( �� eval.hppnu �[��� PK �\�[N� xE E �� span.hppnu �[��� PK �\�[�fd�= = m� prefix.hppnu �[��� PK �\�[�:#� �� drop_front.hppnu �[��� PK �\�[�$~� &� reverse.hppnu �[��� PK �\�[����$ �$ k� basic_tuple.hppnu �[��� PK �\�[���� � erase_key.hppnu �[��� PK �\�[��!� � � members.hppnu �[��� PK �\�[/�T� � � zip.hppnu �[��� PK �\�[^��8 8 �" fold_left.hppnu �[��� PK �\�['�� � */ back.hppnu �[��� PK �\�[�|� � `5 is_empty.hppnu �[��� PK �\�[vN�� � x: not_equal.hppnu �[��� PK �\�[?v��g g sB is_subset.hppnu �[��� PK �\�[�9�� � N zero.hppnu �[��� PK �\�[���D D �W prepend.hppnu �[��� PK �\�[#tX X da fwd/repeat.hppnu �[��� PK �\�[VTn�b b �g fwd/count_if.hppnu �[��� PK �\�[+� �n fwd/group.hppnu �[��� PK �\�[��cy y �} fwd/front.hppnu �[��� PK �\�[�'BF� � �� fwd/scan_right.hppnu �[��� PK �\�[C�#?2 2 Ԓ fwd/adapt_struct.hppnu �[��� PK �\�[�:, , J� fwd/fuse.hppnu �[��� PK �\�[,f5ۥ � �� fwd/any_of.hppnu �[��� PK �\�["��2� � �� fwd/lazy.hppnu �[��� PK �\�[Ud;k k · fwd/core.hppnu �[��� PK �\�[;���� � i� fwd/unfold_left.hppnu �[��� PK �\�[�pd\ \ �� fwd/one.hppnu �[��� PK �\�[3ooϰ � 5� fwd/monadic_fold_left.hppnu �[��� PK �\�[?��� � .� fwd/zip_with.hppnu �[��� PK �\�[?�h� � h� fwd/append.hppnu �[��� PK �\�[!^m�� � �� fwd/flatten.hppnu �[��� PK �\�[� >� � �� fwd/fill.hppnu �[��� PK �\�[���h h `� fwd/intersection.hppnu �[��� PK �\�[ � fwd/empty.hppnu �[��� PK �\�[�5�� � c� fwd/min.hppnu �[��� PK �\�[��qӷ � � fwd/integral_constant.hppnu �[��� PK �\�[�S��� � � fwd/transform.hppnu �[��� PK �\�[��_/� � � fwd/replicate.hppnu �[��� PK �\�[s��h h �( fwd/range.hppnu �[��� PK �\�[��ɀ � D> fwd/scan_left.hppnu �[��� PK �\�[ �� � M fwd/none.hppnu �[��� PK �\�[� X� � R fwd/find_if.hppnu �[��� PK �\�[� ��6 6 Y fwd/index_if.hppnu �[��� PK �\�[&��G� � }` fwd/take_while.hppnu �[��� PK �\�[�m~< < [g fwd/adapt_adt.hppnu �[��� PK �\�[7oqdI dI �m fwd/optional.hppnu �[��� PK �\�[m� |� fwd/at_key.hppnu �[��� PK �\�[c�ӑi i � fwd/drop_front_exactly.hppnu �[��� PK �\�[4?֎� � �� fwd/symmetric_difference.hppnu �[��� PK �\�[T�d�M �M �� fwd/type.hppnu �[��� PK �\�[��h� � K fwd/bool.hppnu �[��� PK �\�[�8��� � fwd/or.hppnu �[��� PK �\�[��I �# fwd/permutations.hppnu �[��� PK �\�[> 2* fwd/greater_equal.hppnu �[��� PK �\�[]��y� � �0 fwd/all.hppnu �[��� PK �\�[\g�� � n5 fwd/greater.hppnu �[��� PK �\�[�q3�� � e; fwd/extend.hppnu �[��� PK �\�[�T?� � hB fwd/all_of.hppnu �[��� PK �\�['}-- - jH fwd/cartesian_product.hppnu �[��� PK �\�[\��� � �O fwd/while.hppnu �[��� PK �\�[U�:j� � �Y fwd/minimum.hppnu �[��� PK �\�[� �� � �j fwd/chain.hppnu �[��� PK �\�[ �?� � �r fwd/remove.hppnu �[��� PK �\�[���0� � r{ fwd/partition.hppnu �[��� PK �\�[�d�** ** ^� fwd/string.hppnu �[��� PK �\�[R���� � ư fwd/find.hppnu �[��� PK �\�[��i�~ ~ � fwd/max.hppnu �[��� PK �\�[]�eW W �� fwd/value.hppnu �[��� PK �\�[�X� � A� fwd/mult.hppnu �[��� PK �\�[&�?� � � fwd/insert.hppnu �[��� PK �\�[�(pN N �� fwd/monadic_fold_right.hppnu �[��� PK �\�[� 2 2 � fwd/replace.hppnu �[��� PK �\�[�?t}( ( �� fwd/filter.hppnu �[��� PK �\�[U�)t. . V� fwd/define_struct.hppnu �[��� PK �\�[@��� � � fwd/negate.hppnu �[��� PK �\�[��H�* * fwd/fold.hppnu �[��� PK �\�[D*�� � k fwd/slice.hppnu �[��� PK �\�[��}#� � l fwd/monadic_compose.hppnu �[��� PK �\�[?��j� � � fwd/mod.hppnu �[��� PK �\�[˗!#s s �( fwd/if.hppnu �[��� PK �\�[��h�s s E/ fwd/zip_shortest_with.hppnu �[��� PK �\�[tVz�� � 8 fwd/size.hppnu �[��� PK �\�[+A�gC C �; fwd/remove_at.hppnu �[��� PK �\�[ ��n n bE fwd/ordering.hppnu �[��� PK �\�[A�%ߵ � M fwd/sum.hppnu �[��� PK �\�[b�H� � Z fwd/first.hppnu �[��� PK �\�[��q� � �_ fwd/is_disjoint.hppnu �[��� PK �\�[�"�k k �e fwd/remove_if.hppnu �[��� PK �\�[� ��y y �n fwd/fold_right.hppnu �[��� PK �\�[G�/ � � J{ fwd/accessors.hppnu �[��� PK �\�[_�B�� � z� fwd/drop_back.hppnu �[��� PK �\�[�{�j� � �� fwd/unpack.hppnu �[��� PK �\�[�q!�� � �� fwd/insert_range.hppnu �[��� PK �\�[��M� �� fwd/unfold_right.hppnu �[��� PK �\�[��O[� � D� fwd/lexicographical_compare.hppnu �[��� PK �\�[�� ~� fwd/power.hppnu �[��� PK �\�[�O;5 5 Ӿ fwd/minus.hppnu �[��� PK �\�[E E\�& �& E� fwd/set.hppnu �[��� PK �\�[vh5�V3 V3 }� fwd/map.hppnu �[��� PK �\�[A��U� � " fwd/div.hppnu �[��� PK �\�[}���n n 5) fwd/hash.hppnu �[��� PK �\�[��}c� � �1 fwd/take_front.hppnu �[��� PK �\�[ ��Q! ! �: fwd/suffix.hppnu �[��� PK �\�[��� � 7C fwd/eval.hppnu �[��� PK �\�[<*��* * OK fwd/span.hppnu �[��� PK �\�[C� H1 1 �V fwd/prefix.hppnu �[��� PK �\�[^We� � $_ fwd/drop_front.hppnu �[��� PK �\�[�Dӣ � Bh fwd/reverse.hppnu �[��� PK �\�[��T�� � $m fwd/basic_tuple.hppnu �[��� PK �\�[.b��l l [v fwd/erase_key.hppnu �[��� PK �\�[H���� � z fwd/members.hppnu �[��� PK �\�[#�!�~ ~ / fwd/zip.hppnu �[��� PK �\�[�D�� � � fwd/fold_left.hppnu �[��� PK �\�[�P�oK K � fwd/back.hppnu �[��� PK �\�[ � ?� � l� fwd/is_empty.hppnu �[��� PK �\�[ ?�%C C Y� fwd/not_equal.hppnu �[��� PK �\�[˩W� � ݦ fwd/is_subset.hppnu �[��� PK �\�[ ZY>G G � fwd/zero.hppnu �[��� PK �\�[P��,o o �� fwd/prepend.hppnu �[��� PK �\�[�i݈ � ?� fwd/pair.hppnu �[��� PK �\�[�yݬ� � � fwd/maximum.hppnu �[��� PK �\�[ Z&� � :� fwd/drop_while.hppnu �[��� PK �\�[���+� � {� fwd/adjust.hppnu �[��� PK �\�[�-�� � �� fwd/cycle.hppnu �[��� PK �\�[��o� � � fwd/second.hppnu �[��� PK �\�[ ��2� � � fwd/for_each.hppnu �[��� PK �\�[�;OKj! j! � fwd/tuple.hppnu �[��� PK �\�[KZ�� `/ fwd/extract.hppnu �[��� PK �\�[�1�� � �5 fwd/and.hppnu �[��� PK �\�[���. . �; fwd/concat.hppnu �[��� PK �\�[ؙQΓ � �B fwd/count.hppnu �[��� PK �\�[��6�� � �I fwd/length.hppnu �[��� PK �\�[D�F� �O fwd/at.hppnu �[��� PK �\�[�Ӏ�� � �Z fwd/adjust_if.hppnu �[��� PK �\�[�Ⓥ� � �c fwd/zip_shortest.hppnu �[��� PK �\�[ �SW (l fwd/equal.hppnu �[��� PK �\�[�V�J� � }v fwd/not.hppnu �[��� PK �\�[�_6� � |{ fwd/none_of.hppnu �[��� PK �\�[;��L L �� fwd/product.hppnu �[��� PK �\�[S(��� � � fwd/intersperse.hppnu �[��� PK �\�[2�� W� fwd/unique.hppnu �[��� PK �\�[ ( : : �� fwd/keys.hppnu �[��� PK �\�[a��& & � fwd/duplicate.hppnu �[��� PK �\�[& �� � {� fwd/sort.hppnu �[��� PK �\�[42��� � q� fwd/take_back.hppnu �[��� PK �\�[����F F 4� fwd/reverse_fold.hppnu �[��� PK �\�[Q��r r �� fwd/less.hppnu �[��� PK �\�[�� � l� fwd/tap.hppnu �[��� PK �\�[d��-� � .� fwd/remove_range.hppnu �[��� PK �\�[k�oJ J +� fwd/contains.hppnu �[��� PK �\�[QP?� � �� fwd/concept/group.hppnu �[��� PK �\�[�J�J J ! � fwd/concept/integral_constant.hppnu �[��� PK �\�[л�K� � 5 fwd/concept/foldable.hppnu �[��� PK �\�[�q� & fwd/concept/logical.hppnu �[��� PK �\�[b�#l< < LB fwd/concept/searchable.hppnu �[��� PK �\�[��� � �[ fwd/concept/comonad.hppnu �[��� PK �\�[�{�� � �j fwd/concept/hashable.hppnu �[��� PK �\�[%t��`$ `$ �t fwd/concept/monad.hppnu �[��� PK �\�[Xx=_ _ �� fwd/concept/iterable.hppnu �[��� PK �\�[u��*�' �' F� fwd/concept/constant.hppnu �[��� PK �\�[��1�� � c� fwd/concept/sequence.hppnu �[��� PK �\�[�k[�q q �� fwd/concept/applicative.hppnu �[��� PK �\�[��"� � [ fwd/concept/functor.hppnu �[��� PK �\�[�|R�n n s! fwd/concept/struct.hppnu �[��� PK �\�[n�=�� � '? fwd/concept/comparable.hppnu �[��� PK �\�[DD�g g ] fwd/concept/euclidean_ring.hppnu �[��� PK �\�[��� �o fwd/concept/metafunction.hppnu �[��� PK �\�[bzy�� � � fwd/concept/monoid.hppnu �[��� PK �\�[C Vu A� fwd/concept/orderable.hppnu �[��� PK �\�[�t��o o �� fwd/concept/product.hppnu �[��� PK �\�[�ǧ. . G� fwd/concept/ring.hppnu �[��� PK �\�[�O��L L �� fwd/concept/monad_plus.hppnu �[��� PK �\�[�5�+ + O� fwd/union.hppnu �[��� PK �\�[Zi��Y Y �� fwd/ap.hppnu �[��� PK �\�[D�ێ� � J� fwd/less_equal.hppnu �[��� PK �\�[)^WT T a� fwd/core/make.hppnu �[��� PK �\�[�$ � � �� fwd/core/when.hppnu �[��� PK �\�[W�\�B B � fwd/core/is_a.hppnu �[��� PK �\�[ ���G G ; fwd/core/default.hppnu �[��� PK �\�[c1%� � � fwd/core/tag_of.hppnu �[��� PK �\�[�b��_ _ �& fwd/core/to.hppnu �[��� PK �\�[�T� � � �C fwd/core/common.hppnu �[��� PK �\�[��= = �T fwd/replace_if.hppnu �[��� PK �\�[8�~� � \ fwd/comparing.hppnu �[��� PK �\�[�3�U5 5 �c fwd/eval_if.hppnu �[��� PK �\�[{!V V @} fwd/difference.hppnu �[��� PK �\�[�Hy� � fwd/lift.hppnu �[��� PK �\�[���� � �� fwd/then.hppnu �[��� PK �\�[��� � r� fwd/plus.hppnu �[��� PK �\�[�� њ � F� fwd/any.hppnu �[��� PK �\�[��{�p p � pair.hppnu �[��� PK �\�[�a�� ù maximum.hppnu �[��� PK �\�[�,Q�f f � drop_while.hppnu �[��� PK �\�[ ��� � �� adjust.hppnu �[��� PK �\�[6��(� � �� cycle.hppnu �[��� PK �\�[Ӫ�� � ~� second.hppnu �[��� PK �\�[���G G �� for_each.hppnu �[��� PK �\�[Z�~��- �- � tuple.hppnu �[��� PK �\�[]��� � �% extract.hppnu �[��� PK �\�[�y'Z� � �* and.hppnu �[��� PK �\�[�y�� � �1 concat.hppnu �[��� PK �\�[��>o� � �< count.hppnu �[��� PK �\�[�h�N �B length.hppnu �[��� PK �\�[% { { �H at.hppnu �[��� PK �\�[�d� � �O adjust_if.hppnu �[��� PK �\�[7X�D D �Y zip_shortest.hppnu �[��� PK �\�[�m�� � %` equal.hppnu �[��� PK �\�[!:� f f � ext/boost.hppnu �[��� PK �\�[~�7�I I �� ext/boost/mpl/list.hppnu �[��� PK �\�[� � ext/boost/mpl/integral_c.hppnu �[��� PK �\�[b�T w� ext/boost/mpl/vector.hppnu �[��� PK �\�[s��ټ � �� ext/boost/fusion/deque.hppnu �[��� PK �\�[%U/gA A �� ext/boost/fusion/list.hppnu �[��� PK �\�[�ոMJ J Y� ext/boost/fusion/vector.hppnu �[��� PK �\�[Y;�j� � " �� ext/boost/fusion/detail/common.hppnu �[��� PK �\�[ì� � � ext/boost/fusion/tuple.hppnu �[��� PK �\�[C�� � $ ext/boost/fusion.hppnu �[��� PK �\�[ ��� ext/boost/tuple.hppnu �[��� PK �\�[A��@b b d ext/boost/mpl.hppnu �[��� PK �\�[�2��� � ext/std/integral_constant.hppnu �[��� PK �\�[J^Lج � �# ext/std/integer_sequence.hppnu �[��� PK �\�[� �¢ � �8 ext/std/array.hppnu �[��� PK �\�[��C C �Q ext/std/vector.hppnu �[��� PK �\�[�1�h h Sa ext/std/ratio.hppnu �[��� PK �\�[A�7 �w ext/std/pair.hppnu �[��� PK �\�[�o��� � �� ext/std/tuple.hppnu �[��� PK �\�[a�D� � ext/std.hppnu �[��� PK �\�[��유' �' !� traits.hppnu �[��� PK �\�[�@ �� � �� not.hppnu �[��� PK �\�[+��� � �� none_of.hppnu �[��� PK �\�[���ȥ � � product.hppnu �[��� PK �\�[�F�� �� intersperse.hppnu �[��� PK �\�[�M��9 9 K� unique.hppnu �[��� PK �\�[��� �� keys.hppnu �[��� PK �\�[�!��p p � duplicate.hppnu �[��� PK �\�[LU�" �" �� sort.hppnu �[��� PK �\�[�;�� � � take_back.hppnu �[��� PK �\�[���x x �' reverse_fold.hppnu �[��� PK �\�[u�T� � Y, less.hppnu �[��� PK �\�[�� �P P [A tap.hppnu �[��� PK �\�[ x1- - �G remove_range.hppnu �[��� PK �\�[� 5� OW contains.hppnu �[��� PK �\�[�Ya� � �] concept/group.hppnu �[��� PK �\�[2d1� � �a concept/integral_constant.hppnu �[��� PK �\�[ 8+� � �f concept/foldable.hppnu �[��� PK �\�[$��2� � fj concept/logical.hppnu �[��� PK �\�[�16{� � �n concept/searchable.hppnu �[��� PK �\�[�mxe �r concept/comonad.hppnu �[��� PK �\�[�ź�C C �v concept/hashable.hppnu �[��� PK �\�[ *J � � mz concept/monad.hppnu �[��� PK �\�[�.�K 7~ concept/iterable.hppnu �[��� PK �\�[C�/ / �� concept/constant.hppnu �[��� PK �\�[�U� � � �� concept/sequence.hppnu �[��� PK �\�[��ˡ � concept/applicative.hppnu �[��� PK �\�[���� � �� concept/functor.hppnu �[��� PK �\�[ ���+ + �� concept/struct.hppnu �[��� PK �\�[�2;x x �� concept/comparable.hppnu �[��� PK �\�[a~n�' ' �� concept/euclidean_ring.hppnu �[��� PK �\�[��ߝ8 8 *� concept/metafunction.hppnu �[��� PK �\�[Ғ�� � �� concept/monoid.hppnu �[��� PK �\�[ω��u u �� concept/orderable.hppnu �[��� PK �\�[���� � i� concept/product.hppnu �[��� PK �\�[I�Z�� � ?� concept/ring.hppnu �[��� PK �\�[�w�^� � 4� concept/monad_plus.hppnu �[��� PK �\�[,� � union.hppnu �[��� PK �\�[�K�� � \� ap.hppnu �[��� PK �\�[}�'j� � R� less_equal.hppnu �[��� PK �\�['K�F F E� core/make.hppnu �[��� PK �\�[�{�{� � �� core/when.hppnu �[��� PK �\�[4,>o o �� core/is_a.hppnu �[��� PK �\�[`��� � 8� core/default.hppnu �[��� PK �\�[�E��j j w� core/tag_of.hppnu �[��� PK �\�[�s�:� � � core/to.hppnu �[��� PK �\�[8� 7! core/dispatch.hppnu �[��� PK �\�[�l�� � �! core/common.hppnu �[��� PK �\�[Nr�o� � T! replace_if.hppnu �[��� PK �\�[Bl�� � v! comparing.hppnu �[��� PK �\�[Ӽ��5 5 y ! eval_if.hppnu �[��� PK �\�[� �\ \ �-! difference.hppnu �[��� PK �\�[Z�5�� � �2! lift.hppnu �[��� PK �\�[�IV� � �8! then.hppnu �[��� PK �\�[� �� � g?! plus.hppnu �[��� PK �\�[����? �? NN! assert.hppnu �[��� PK �\�[x��/ / M�! any.hppnu �[��� PK ��Ɍ ��!
| ver. 1.6 |
Github
|
.
| PHP 8.2.30 | ??????????? ?????????: 0.86 |
proxy
|
phpinfo
|
???????????