1 /*! 2 @file 3 Forward declares `boost::hana::pair`. 4 5 @copyright Louis Dionne 2013-2017 6 Distributed 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_FWD_PAIR_HPP 11 #define BOOST_HANA_FWD_PAIR_HPP 12 13 #include <boost/hana/config.hpp> 14 #include <boost/hana/fwd/core/make.hpp> 15 16 17 BOOST_HANA_NAMESPACE_BEGIN 18 //! @ingroup group-datatypes 19 //! Generic container for two elements. 20 //! 21 //! `hana::pair` is conceptually the same as `std::pair`. However, 22 //! `hana::pair` automatically compresses the storage of empty types, 23 //! and as a result it does not have the `.first` and `.second` members. 24 //! Instead, one must use the `hana::first` and `hana::second` free 25 //! functions to access the elements of a pair. 26 //! 27 //! @note 28 //! When you use a container, remember not to make assumptions about its 29 //! representation, unless the documentation gives you those guarantees. 30 //! More details [in the tutorial](@ref tutorial-containers-types). 31 //! 32 //! 33 //! Modeled concepts 34 //! ---------------- 35 //! 1. `Comparable`\n 36 //! Two pairs `(x, y)` and `(x', y')` are equal if and only if both 37 //! `x == x'` and `y == y'`. 38 //! @include example/pair/comparable.cpp 39 //! 40 //! 2. `Orderable`\n 41 //! Pairs are ordered as-if they were 2-element tuples, using a 42 //! lexicographical ordering. 43 //! @include example/pair/orderable.cpp 44 //! 45 //! 3. `Foldable`\n 46 //! Folding a pair is equivalent to folding a 2-element tuple. In other 47 //! words: 48 //! @code 49 //! fold_left(make_pair(x, y), s, f) == f(f(s, x), y) 50 //! fold_right(make_pair(x, y), s, f) == f(x, f(y, s)) 51 //! @endcode 52 //! Example: 53 //! @include example/pair/foldable.cpp 54 //! 55 //! 4. `Product`\n 56 //! The model of `Product` is the simplest one possible; the first element 57 //! of a pair `(x, y)` is `x`, and its second element is `y`. 58 //! @include example/pair/product.cpp 59 #ifdef BOOST_HANA_DOXYGEN_INVOKED 60 template <typename First, typename Second> 61 struct pair { 62 //! Default constructs the `pair`. Only exists when both elements 63 //! of the pair are default constructible. 64 constexpr pair(); 65 66 //! Initialize each element of the pair with the corresponding element. 67 //! Only exists when both elements of the pair are copy-constructible. 68 constexpr pair(First const& first, Second const& second); 69 70 //! Initialize both elements of the pair by perfect-forwarding the 71 //! corresponding argument. Only exists when both arguments are 72 //! implicitly-convertible to the corresponding element of the pair. 73 template <typename T, typename U> 74 constexpr pair(T&& t, U&& u); 75 76 //! Copy-initialize a pair from another pair. Only exists when both 77 //! elements of the source pair are implicitly convertible to the 78 //! corresponding element of the constructed pair. 79 template <typename T, typename U> 80 constexpr pair(pair<T, U> const& other); 81 82 //! Move-initialize a pair from another pair. Only exists when both 83 //! elements of the source pair are implicitly convertible to the 84 //! corresponding element of the constructed pair. 85 template <typename T, typename U> 86 constexpr pair(pair<T, U>&& other); 87 88 //! Assign a pair to another pair. Only exists when both elements 89 //! of the destination pair are assignable from the corresponding 90 //! element in the source pair. 91 template <typename T, typename U> 92 constexpr pair& operator=(pair<T, U> const& other); 93 94 //! Move-assign a pair to another pair. Only exists when both elements 95 //! of the destination pair are move-assignable from the corresponding 96 //! element in the source pair. 97 template <typename T, typename U> 98 constexpr pair& operator=(pair<T, U>&& other); 99 100 //! Equivalent to `hana::equal` 101 template <typename X, typename Y> 102 friend constexpr auto operator==(X&& x, Y&& y); 103 104 //! Equivalent to `hana::not_equal` 105 template <typename X, typename Y> 106 friend constexpr auto operator!=(X&& x, Y&& y); 107 108 //! Equivalent to `hana::less` 109 template <typename X, typename Y> 110 friend constexpr auto operator<(X&& x, Y&& y); 111 112 //! Equivalent to `hana::greater` 113 template <typename X, typename Y> 114 friend constexpr auto operator>(X&& x, Y&& y); 115 116 //! Equivalent to `hana::less_equal` 117 template <typename X, typename Y> 118 friend constexpr auto operator<=(X&& x, Y&& y); 119 120 //! Equivalent to `hana::greater_equal` 121 template <typename X, typename Y> 122 friend constexpr auto operator>=(X&& x, Y&& y); 123 }; 124 #else 125 template <typename First, typename Second> 126 struct pair; 127 #endif 128 129 //! Tag representing `hana::pair`. 130 //! @relates hana::pair 131 struct pair_tag { }; 132 133 #ifdef BOOST_HANA_DOXYGEN_INVOKED 134 //! Creates a `hana::pair` with the given elements. 135 //! @relates hana::pair 136 //! 137 //! 138 //! Example 139 //! ------- 140 //! @include example/pair/make.cpp 141 template <> 142 constexpr auto make<pair_tag> = [](auto&& first, auto&& second) 143 -> hana::pair<std::decay_t<decltype(first)>, std::decay_t<decltype(second)>> __anon88a82bbe0102(auto&& first, auto&& second) 144 { 145 return {forwarded(first), forwarded(second)}; 146 }; 147 #endif 148 149 //! Alias to `make<pair_tag>`; provided for convenience. 150 //! @relates hana::pair 151 //! 152 //! Example 153 //! ------- 154 //! @include example/pair/make.cpp 155 constexpr auto make_pair = make<pair_tag>; 156 BOOST_HANA_NAMESPACE_END 157 158 #endif // !BOOST_HANA_FWD_PAIR_HPP 159