2 * Copyright 2017-present Facebook, Inc.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
20 #include <type_traits>
22 #include <folly/Traits.h>
25 * include or backport:
27 * * std::invoke_result
28 * * std::invoke_result_t
30 * * std::is_invocable_r
31 * * std::is_nothrow_invocable
32 * * std::is_nothrow_invocable_r
35 #if __cpp_lib_invoke >= 201411 || _MSC_VER
39 /* using override */ using std::invoke;
47 // mimic: std::invoke, C++17
48 template <typename F, typename... Args>
49 constexpr auto invoke(F&& f, Args&&... args) noexcept(
50 noexcept(std::forward<F>(f)(std::forward<Args>(args)...)))
51 -> decltype(std::forward<F>(f)(std::forward<Args>(args)...)) {
52 return std::forward<F>(f)(std::forward<Args>(args)...);
54 template <typename M, typename C, typename... Args>
55 constexpr auto invoke(M(C::*d), Args&&... args)
56 -> decltype(std::mem_fn(d)(std::forward<Args>(args)...)) {
57 return std::mem_fn(d)(std::forward<Args>(args)...);
64 // Only available in >= MSVC 2017 15.3
65 #if __cpp_lib_is_invocable >= 201703 || _MSC_VER >= 1911
69 /* using override */ using std::invoke_result;
70 /* using override */ using std::invoke_result_t;
71 /* using override */ using std::is_invocable;
72 /* using override */ using std::is_invocable_r;
73 /* using override */ using std::is_nothrow_invocable;
74 /* using override */ using std::is_nothrow_invocable_r;
84 template <typename F, typename... Args>
85 using invoke_result_ =
86 decltype(invoke(std::declval<F>(), std::declval<Args>()...));
88 template <typename F, typename... Args>
89 using invoke_nothrow_ = std::integral_constant<
91 noexcept(invoke(std::declval<F>(), std::declval<Args>()...))>;
93 // from: http://en.cppreference.com/w/cpp/types/result_of, CC-BY-SA
95 template <typename Void, typename F, typename... Args>
96 struct invoke_result {};
98 template <typename F, typename... Args>
99 struct invoke_result<void_t<invoke_result_<F, Args...>>, F, Args...> {
100 using type = invoke_result_<F, Args...>;
103 template <typename Void, typename F, typename... Args>
104 struct is_invocable : std::false_type {};
106 template <typename F, typename... Args>
107 struct is_invocable<void_t<invoke_result_<F, Args...>>, F, Args...>
110 template <typename Void, typename R, typename F, typename... Args>
111 struct is_invocable_r : std::false_type {};
113 template <typename R, typename F, typename... Args>
114 struct is_invocable_r<void_t<invoke_result_<F, Args...>>, R, F, Args...>
115 : std::is_convertible<invoke_result_<F, Args...>, R> {};
117 template <typename Void, typename F, typename... Args>
118 struct is_nothrow_invocable : std::false_type {};
120 template <typename F, typename... Args>
121 struct is_nothrow_invocable<void_t<invoke_result_<F, Args...>>, F, Args...>
122 : invoke_nothrow_<F, Args...> {};
124 template <typename Void, typename R, typename F, typename... Args>
125 struct is_nothrow_invocable_r : std::false_type {};
127 template <typename R, typename F, typename... Args>
128 struct is_nothrow_invocable_r<void_t<invoke_result_<F, Args...>>, R, F, Args...>
130 std::is_convertible<invoke_result_<F, Args...>, R>,
131 invoke_nothrow_<F, Args...>> {};
133 } // namespace detail
135 // mimic: std::invoke_result, C++17
136 template <typename F, typename... Args>
137 struct invoke_result : detail::invoke_result<void, F, Args...> {};
139 // mimic: std::invoke_result_t, C++17
140 template <typename F, typename... Args>
141 using invoke_result_t = typename invoke_result<F, Args...>::type;
143 // mimic: std::is_invocable, C++17
144 template <typename F, typename... Args>
145 struct is_invocable : detail::is_invocable<void, F, Args...> {};
147 // mimic: std::is_invocable_r, C++17
148 template <typename R, typename F, typename... Args>
149 struct is_invocable_r : detail::is_invocable_r<void, R, F, Args...> {};
151 // mimic: std::is_nothrow_invocable, C++17
152 template <typename F, typename... Args>
153 struct is_nothrow_invocable : detail::is_nothrow_invocable<void, F, Args...> {};
155 // mimic: std::is_nothrow_invocable_r, C++17
156 template <typename R, typename F, typename... Args>
157 struct is_nothrow_invocable_r
158 : detail::is_nothrow_invocable_r<void, R, F, Args...> {};
165 * FOLLY_CREATE_MEMBER_INVOKE_TRAITS
167 * Used to create traits container, bound to a specific member-invocable name,
168 * with the following member traits types and aliases:
174 * * is_nothrow_invocable
175 * * is_nothrow_invocable_r
177 * The container also has a static member function:
181 * These members have behavior matching the behavior of C++17's corresponding
182 * invocation traits types, aliases, and functions, but substituting canonical
183 * invocation with member invocation.
187 * FOLLY_CREATE_MEMBER_INVOKE_TRAITS(foo_invoke_traits, foo);
189 * The traits container type `foo_invoke_traits` is generated in the current
190 * namespace and has the listed member types and aliases. They may be used as
194 * int foo(Bar const&) { return 1; }
195 * int foo(Car&&) noexcept { return 2; }
198 * using traits = foo_invoke_traits;
200 * traits::invoke(CanFoo{}, Bar{}) // 1
202 * traits::invoke_result<CanFoo, Bar&&> // has member
203 * traits::invoke_result_t<CanFoo, Bar&&> // int
204 * traits::invoke_result<CanFoo, Bar&> // empty
205 * traits::invoke_result_t<CanFoo, Bar&> // error
207 * traits::is_invocable<CanFoo, Bar&&>::value // true
208 * traits::is_invocable<CanFoo, Bar&>::value // false
210 * traits::is_invocable_r<int, CanFoo, Bar&&>::value // true
211 * traits::is_invocable_r<char*, CanFoo, Bar&&>::value // false
213 * traits::is_nothrow_invocable<CanFoo, Bar&&>::value // false
214 * traits::is_nothrow_invocable<CanFoo, Car&&>::value // true
216 * traits::is_nothrow_invocable<int, CanFoo, Bar&&>::value // false
217 * traits::is_nothrow_invocable<char*, CanFoo, Bar&&>::value // false
218 * traits::is_nothrow_invocable<int, CanFoo, Car&&>::value // true
219 * traits::is_nothrow_invocable<char*, CanFoo, Car&&>::value // false
221 #define FOLLY_CREATE_MEMBER_INVOKE_TRAITS(classname, membername) \
224 template <typename T> \
225 using v_ = ::folly::void_t<T>; \
226 template <typename F, typename... Args> \
228 decltype(::std::declval<F>().membername(::std::declval<Args>()...)); \
229 template <typename F, typename... Args> \
230 struct nothrow_ : std::integral_constant< \
232 noexcept(::std::declval<F>().membername( \
233 ::std::declval<Args>()...))> {}; \
235 template <typename, typename F, typename... Args> \
236 struct invoke_result_ {}; \
237 template <typename F, typename... Args> \
238 struct invoke_result_<v_<result_<F, Args...>>, F, Args...> { \
239 using type = result_<F, Args...>; \
242 template <typename, typename F, typename... Args> \
243 struct is_invocable_ : ::std::false_type {}; \
244 template <typename F, typename... Args> \
245 struct is_invocable_<v_<result_<F, Args...>>, F, Args...> \
246 : ::std::true_type {}; \
248 template <typename, typename R, typename F, typename... Args> \
249 struct is_invocable_r_ : ::std::false_type {}; \
250 template <typename R, typename F, typename... Args> \
251 struct is_invocable_r_<v_<result_<F, Args...>>, R, F, Args...> \
252 : ::std::is_convertible<result_<F, Args...>, R> {}; \
254 template <typename, typename F, typename... Args> \
255 struct is_nothrow_invocable_ : ::std::false_type {}; \
256 template <typename F, typename... Args> \
257 struct is_nothrow_invocable_<v_<result_<F, Args...>>, F, Args...> \
258 : nothrow_<F, Args...> {}; \
260 template <typename, typename R, typename F, typename... Args> \
261 struct is_nothrow_invocable_r_ : ::std::false_type {}; \
262 template <typename R, typename F, typename... Args> \
263 struct is_nothrow_invocable_r_<v_<result_<F, Args...>>, R, F, Args...> \
264 : ::folly::StrictConjunction< \
265 ::std::is_convertible<result_<F, Args...>, R>, \
266 nothrow_<F, Args...>> {}; \
269 template <typename F, typename... Args> \
270 struct invoke_result : invoke_result_<void, F, Args...> {}; \
271 template <typename F, typename... Args> \
272 using invoke_result_t = typename invoke_result<F, Args...>::type; \
273 template <typename F, typename... Args> \
274 struct is_invocable : is_invocable_<void, F, Args...> {}; \
275 template <typename R, typename F, typename... Args> \
276 struct is_invocable_r : is_invocable_r_<void, R, F, Args...> {}; \
277 template <typename F, typename... Args> \
278 struct is_nothrow_invocable : is_nothrow_invocable_<void, F, Args...> {}; \
279 template <typename R, typename F, typename... Args> \
280 struct is_nothrow_invocable_r \
281 : is_nothrow_invocable_r_<void, R, F, Args...> {}; \
283 template <typename F, typename... Args> \
284 static constexpr result_<F, Args...> invoke( \
286 Args&&... args) noexcept(nothrow_<F, Args...>::value) { \
287 return std::forward<F>(f).membername(std::forward<Args>(args)...); \