1/*!
2@file
3Defines `boost::hana::experimental::types`.
4
5Copyright Louis Dionne 2013-2022
6Distributed under the Boost Software License, Version 1.0.
7(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
8 */
9
10#ifndef BOOST_HANA_EXPERIMENTAL_TYPES_HPP
11#define BOOST_HANA_EXPERIMENTAL_TYPES_HPP
12
13#include <boost/hana/bool.hpp>
14#include <boost/hana/concept/metafunction.hpp>
15#include <boost/hana/config.hpp>
16#include <boost/hana/detail/any_of.hpp>
17#include <boost/hana/detail/type_at.hpp>
18#include <boost/hana/fwd/at.hpp>
19#include <boost/hana/fwd/contains.hpp>
20#include <boost/hana/fwd/core/tag_of.hpp>
21#include <boost/hana/fwd/equal.hpp>
22#include <boost/hana/fwd/is_empty.hpp>
23#include <boost/hana/fwd/transform.hpp>
24#include <boost/hana/fwd/unpack.hpp>
25#include <boost/hana/type.hpp>
26
27#include <cstddef>
28#include <type_traits>
29#include <utility>
30
31
32namespace boost { namespace hana {
33 namespace experimental {
34 //! @ingroup group-experimental
35 //! Container optimized for holding types.
36 //!
37 //! It is often useful to manipulate a sequence that contains types
38 //! only, without any associated runtime value. This container allows
39 //! storing and manipulating pure types in a much more compile-time
40 //! efficient manner than using `hana::tuple`, which must assume that
41 //! its contents might have runtime values.
42 template <typename ...T>
43 struct types;
44
45 struct types_tag;
46
47 template <typename ...T>
48 struct types { };
49 } // end namespace experimental
50
51 template <typename ...T>
52 struct tag_of<experimental::types<T...>> {
53 using type = experimental::types_tag;
54 };
55
56 // Foldable
57 template <>
58 struct unpack_impl<hana::experimental::types_tag> {
59 template <typename ...T, typename F, typename = typename std::enable_if<
60 !hana::Metafunction<F>::value
61 >::type>
62 static constexpr decltype(auto) apply(hana::experimental::types<T...> const&, F&& f) {
63 return static_cast<F&&>(f)(hana::type<T>{}...);
64 }
65
66 template <typename ...T, typename F, typename = typename std::enable_if<
67 hana::Metafunction<F>::value
68 >::type>
69 static constexpr hana::type<typename F::template apply<T...>::type>
70 apply(hana::experimental::types<T...> const&, F const&) { return {}; }
71 };
72
73 // Functor
74 template <>
75 struct transform_impl<hana::experimental::types_tag> {
76 template <typename ...T, typename F, typename = typename std::enable_if<
77 !hana::Metafunction<F>::value
78 >::type>
79 static constexpr auto apply(hana::experimental::types<T...> const&, F&& f)
80 -> hana::experimental::types<typename decltype(+f(hana::type<T>{}))::type...>
81 { return {}; }
82
83 template <typename ...T, typename F, typename = typename std::enable_if<
84 hana::Metafunction<F>::value
85 >::type>
86 static constexpr hana::experimental::types<typename F::template apply<T>::type...>
87 apply(hana::experimental::types<T...> const&, F const&) { return {}; }
88 };
89
90 // Iterable
91 template <>
92 struct at_impl<hana::experimental::types_tag> {
93 template <typename ...T, typename N>
94 static constexpr auto
95 apply(hana::experimental::types<T...> const&, N const&) {
96 using Nth = typename detail::type_at<N::value, T...>::type;
97 return hana::type<Nth>{};
98 }
99 };
100
101 template <>
102 struct is_empty_impl<hana::experimental::types_tag> {
103 template <typename ...T>
104 static constexpr hana::bool_<sizeof...(T) == 0>
105 apply(hana::experimental::types<T...> const&)
106 { return {}; }
107 };
108
109 template <>
110 struct drop_front_impl<hana::experimental::types_tag> {
111 template <std::size_t n, typename ...T, std::size_t ...i>
112 static hana::experimental::types<typename detail::type_at<i + n, T...>::type...>
113 helper(std::index_sequence<i...>);
114
115 template <typename ...T, typename N>
116 static constexpr auto
117 apply(hana::experimental::types<T...> const&, N const&) {
118 constexpr std::size_t n = N::value > sizeof...(T) ? sizeof...(T) : N::value;
119 using Indices = std::make_index_sequence<sizeof...(T) - n>;
120 return decltype(helper<n, T...>(Indices{})){};
121 }
122 };
123
124 // Searchable
125 template <>
126 struct contains_impl<hana::experimental::types_tag> {
127 template <typename U>
128 struct is_same_as {
129 template <typename T>
130 struct apply {
131 static constexpr bool value = std::is_same<U, T>::value;
132 };
133 };
134
135 template <typename ...T, typename U>
136 static constexpr auto apply(hana::experimental::types<T...> const&, U const&)
137 -> hana::bool_<
138 detail::any_of<is_same_as<typename U::type>::template apply, T...>::value
139 >
140 { return {}; }
141
142 static constexpr hana::false_ apply(...) { return {}; }
143 };
144
145 // Comparable
146 template <>
147 struct equal_impl<hana::experimental::types_tag, hana::experimental::types_tag> {
148 template <typename Types>
149 static constexpr hana::true_ apply(Types const&, Types const&)
150 { return {}; }
151
152 template <typename Ts, typename Us>
153 static constexpr hana::false_ apply(Ts const&, Us const&)
154 { return {}; }
155 };
156}} // end namespace boost::hana
157
158#endif // !BOOST_HANA_EXPERIMENTAL_TYPES_HPP
159

source code of boost/libs/hana/include/boost/hana/experimental/types.hpp