1/*!
2@file
3Defines `boost::hana::infix`.
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_FUNCTIONAL_INFIX_HPP
11#define BOOST_HANA_FUNCTIONAL_INFIX_HPP
12
13#include <boost/hana/config.hpp>
14#include <boost/hana/detail/decay.hpp>
15#include <boost/hana/functional/partial.hpp>
16#include <boost/hana/functional/reverse_partial.hpp>
17
18#include <type_traits>
19#include <utility>
20
21
22namespace boost { namespace hana {
23 //! @ingroup group-functional
24 //! Return an equivalent function that can also be applied in infix
25 //! notation.
26 //!
27 //! Specifically, `infix(f)` is an object such that:
28 //! @code
29 //! infix(f)(x1, ..., xn) == f(x1, ..., xn)
30 //! x ^infix(f)^ y == f(x, y)
31 //! @endcode
32 //!
33 //! Hence, the returned function can still be applied using the usual
34 //! function call syntax, but it also gains the ability to be applied in
35 //! infix notation. The infix syntax allows a great deal of expressiveness,
36 //! especially when used in combination with some higher order algorithms.
37 //! Since `operator^` is left-associative, `x ^infix(f)^ y` is actually
38 //! parsed as `(x ^infix(f))^ y`. However, for flexibility, the order in
39 //! which both arguments are applied in infix notation does not matter.
40 //! Hence, it is always the case that
41 //! @code
42 //! (x ^ infix(f)) ^ y == x ^ (infix(f) ^ y)
43 //! @endcode
44 //!
45 //! However, note that applying more than one argument in infix
46 //! notation to the same side of the operator will result in a
47 //! compile-time assertion:
48 //! @code
49 //! (infix(f) ^ x) ^ y; // compile-time assertion
50 //! y ^ (x ^ infix(f)); // compile-time assertion
51 //! @endcode
52 //!
53 //! Additionally, a function created with `infix` may be partially applied
54 //! in infix notation. Specifically,
55 //! @code
56 //! (x ^ infix(f))(y1, ..., yn) == f(x, y1, ..., yn)
57 //! (infix(f) ^ y)(x1, ..., xn) == f(x1, ..., xn, y)
58 //! @endcode
59 //!
60 //! @internal
61 //! ### Rationales
62 //! 1. The `^` operator was chosen because it is left-associative and
63 //! has a low enough priority so that most expressions will render
64 //! the expected behavior.
65 //! 2. The operator can't be customimzed because that would require more
66 //! sophistication in the implementation; I want to keep it as simple
67 //! as possible. There is also an advantage in having a uniform syntax
68 //! for infix application.
69 //! @endinternal
70 //!
71 //! @param f
72 //! The function which gains the ability to be applied in infix notation.
73 //! The function must be at least binary; a compile-time error will be
74 //! triggered otherwise.
75 //!
76 //! ### Example
77 //! @include example/functional/infix.cpp
78#ifdef BOOST_HANA_DOXYGEN_INVOKED
79 constexpr auto infix = [](auto f) {
80 return unspecified;
81 };
82#else
83 namespace infix_detail {
84 // This needs to be in the same namespace as `operator^` so it can be
85 // found by ADL.
86 template <bool left, bool right, typename F>
87 struct infix_t {
88 F f;
89
90 template <typename ...X>
91 constexpr decltype(auto) operator()(X&& ...x) const&
92 { return f(static_cast<X&&>(x)...); }
93
94 template <typename ...X>
95 constexpr decltype(auto) operator()(X&& ...x) &
96 { return f(static_cast<X&&>(x)...); }
97
98 template <typename ...X>
99 constexpr decltype(auto) operator()(X&& ...x) &&
100 { return std::move(f)(static_cast<X&&>(x)...); }
101 };
102
103 template <bool left, bool right>
104 struct make_infix {
105 template <typename F>
106 constexpr infix_t<left, right, typename detail::decay<F>::type>
107 operator()(F&& f) const { return {static_cast<F&&>(f)}; }
108 };
109
110 template <bool left, bool right>
111 struct Infix;
112 struct Object;
113
114 template <typename T>
115 struct dispatch { using type = Object; };
116
117 template <bool left, bool right, typename F>
118 struct dispatch<infix_t<left, right, F>> {
119 using type = Infix<left, right>;
120 };
121
122 template <typename, typename>
123 struct bind_infix;
124
125 // infix(f) ^ y
126 template <>
127 struct bind_infix<Infix<false, false>, Object> {
128 template <typename F, typename Y>
129 static constexpr decltype(auto) apply(F&& f, Y&& y) {
130 return make_infix<false, true>{}(
131 hana::reverse_partial(
132 static_cast<F&&>(f), static_cast<Y&&>(y)
133 )
134 );
135 }
136 };
137
138 // (x^infix(f)) ^ y
139 template <>
140 struct bind_infix<Infix<true, false>, Object> {
141 template <typename F, typename Y>
142 static constexpr decltype(auto) apply(F&& f, Y&& y) {
143 return static_cast<F&&>(f)(static_cast<Y&&>(y));
144 }
145 };
146
147 // x ^ infix(f)
148 template <>
149 struct bind_infix<Object, Infix<false, false>> {
150 template <typename X, typename F>
151 static constexpr decltype(auto) apply(X&& x, F&& f) {
152 return make_infix<true, false>{}(
153 hana::partial(static_cast<F&&>(f), static_cast<X&&>(x))
154 );
155 }
156 };
157
158 // x ^ (infix(f)^y)
159 template <>
160 struct bind_infix<Object, Infix<false, true>> {
161 template <typename X, typename F>
162 static constexpr decltype(auto) apply(X&& x, F&& f) {
163 return static_cast<F&&>(f)(static_cast<X&&>(x));
164 }
165 };
166
167 template <typename T>
168 using strip = typename std::remove_cv<
169 typename std::remove_reference<T>::type
170 >::type;
171
172 template <typename X, typename Y>
173 constexpr decltype(auto) operator^(X&& x, Y&& y) {
174 return bind_infix<
175 typename dispatch<strip<X>>::type,
176 typename dispatch<strip<Y>>::type
177 >::apply(static_cast<X&&>(x), static_cast<Y&&>(y));
178 }
179 } // end namespace infix_detail
180
181 BOOST_HANA_INLINE_VARIABLE constexpr infix_detail::make_infix<false, false> infix{};
182#endif
183}} // end namespace boost::hana
184
185#endif // !BOOST_HANA_FUNCTIONAL_INFIX_HPP
186

source code of boost/libs/hana/include/boost/hana/functional/infix.hpp