/* * Copyright (c) Meta Platforms, Inc. and affiliates. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include <functional> #include <type_traits> #include <boost/preprocessor/control/expr_iif.hpp> #include <boost/preprocessor/facilities/is_empty_variadic.hpp> #include <boost/preprocessor/list/for_each.hpp> #include <boost/preprocessor/logical/not.hpp> #include <boost/preprocessor/tuple/to_list.hpp> #include <folly/CppAttributes.h> #include <folly/Portability.h> #include <folly/Preprocessor.h> #include <folly/Traits.h> #include <folly/Utility.h> #include <folly/lang/CustomizationPoint.h> #define FOLLY_DETAIL_FORWARD_REF(a) static_cast<decltype(a)&&>(a) #define FOLLY_DETAIL_FORWARD_BODY(e) \ noexcept(noexcept(e))->decltype(e) { return e; } /** * include or backport: * * std::invoke * * std::invoke_result * * std::invoke_result_t * * std::is_invocable * * std::is_invocable_v * * std::is_invocable_r * * std::is_invocable_r_v * * std::is_nothrow_invocable * * std::is_nothrow_invocable_v * * std::is_nothrow_invocable_r * * std::is_nothrow_invocable_r_v */ namespace folly { // invoke_fn // invoke // // mimic: std::invoke, C++17 struct invoke_fn { template <typename F, typename... A> FOLLY_ERASE constexpr auto operator()(F&& f, A&&... a) const noexcept(noexcept(static_cast<F&&>(f)(static_cast<A&&>(a)...))) -> decltype(static_cast<F&&>(f)(static_cast<A&&>(a)...)) { return static_cast<F&&>(f)(static_cast<A&&>(a)...); } template <typename M, typename C, typename... A> FOLLY_ERASE constexpr auto operator()(M C::*f, A&&... a) const noexcept(noexcept(std::mem_fn(f)(static_cast<A&&>(a)...))) -> decltype(std::mem_fn(f)(static_cast<A&&>(a)...)) { return std::mem_fn(f)(static_cast<A&&>(a)...); } }; FOLLY_INLINE_VARIABLE constexpr invoke_fn invoke; } // namespace folly namespace folly { namespace invoke_detail { template <typename F> struct traits { template <typename... A> using result = decltype( // FOLLY_DECLVAL(F &&)(FOLLY_DECLVAL(A &&)...)); template <typename... A> static constexpr bool nothrow = noexcept( // FOLLY_DECLVAL(F&&)(FOLLY_DECLVAL(A&&)...)); }; template <typename P> struct traits_member_ptr { template <typename... A> using result = decltype( // std::mem_fn(FOLLY_DECLVAL(P))(FOLLY_DECLVAL(A &&)...)); template <typename... A> static constexpr bool nothrow = noexcept( // std::mem_fn(FOLLY_DECLVAL(P))(FOLLY_DECLVAL(A&&)...)); }; template <typename M, typename C> struct traits<M C::*> : traits_member_ptr<M C::*> {}; template <typename M, typename C> struct traits<M C::*const> : traits_member_ptr<M C::*> {}; template <typename M, typename C> struct traits<M C::*&> : traits_member_ptr<M C::*> {}; template <typename M, typename C> struct traits<M C::*const&> : traits_member_ptr<M C::*> {}; template <typename M, typename C> struct traits<M C::*&&> : traits_member_ptr<M C::*> {}; template <typename M, typename C> struct traits<M C::*const&&> : traits_member_ptr<M C::*> {}; // adapted from: http://en.cppreference.com/w/cpp/types/result_of, CC-BY-SA template <typename F, typename... A> using invoke_result_t = typename traits<F>::template result<A...>; template <typename Void, typename F, typename... A> struct invoke_result {}; template <typename F, typename... A> struct invoke_result<void_t<invoke_result_t<F, A...>>, F, A...> { using type = invoke_result_t<F, A...>; }; template <typename Void, typename F, typename... A> FOLLY_INLINE_VARIABLE constexpr bool is_invocable_v = false; template <typename F, typename... A> FOLLY_INLINE_VARIABLE constexpr bool is_invocable_v<void_t<invoke_result_t<F, A...>>, F, A...> = true; template <typename Void, typename R, typename F, typename... A> FOLLY_INLINE_VARIABLE constexpr bool is_invocable_r_v = false; template <typename R, typename F, typename... A> FOLLY_INLINE_VARIABLE constexpr bool is_invocable_r_v<void_t<invoke_result_t<F, A...>>, R, F, A...> = std::is_convertible<invoke_result_t<F, A...>, R>::value; template <typename Void, typename F, typename... A> FOLLY_INLINE_VARIABLE constexpr bool is_nothrow_invocable_v = false; template <typename F, typename... A> FOLLY_INLINE_VARIABLE constexpr bool is_nothrow_invocable_v<void_t<invoke_result_t<F, A...>>, F, A...> = traits<F>::template nothrow<A...>; template <typename Void, typename R, typename F, typename... A> FOLLY_INLINE_VARIABLE constexpr bool is_nothrow_invocable_r_v = false; template <typename R, typename F, typename... A> FOLLY_INLINE_VARIABLE constexpr bool is_nothrow_invocable_r_v<void_t<invoke_result_t<F, A...>>, R, F, A...> = std::is_convertible<invoke_result_t<F, A...>, R>::value&& traits<F>::template nothrow<A...>; } // namespace invoke_detail // mimic: std::invoke_result, C++17 template <typename F, typename... A> using invoke_result = invoke_detail::invoke_result<void, F, A...>; // mimic: std::invoke_result_t, C++17 using invoke_detail::invoke_result_t; // mimic: std::is_invocable_v, C++17 template <typename F, typename... A> FOLLY_INLINE_VARIABLE constexpr bool is_invocable_v = invoke_detail::is_invocable_v<void, F, A...>; // mimic: std::is_invocable, C++17 template <typename F, typename... A> struct is_invocable : bool_constant<is_invocable_v<F, A...>> {}; // mimic: std::is_invocable_r_v, C++17 template <typename R, typename F, typename... A> FOLLY_INLINE_VARIABLE constexpr bool is_invocable_r_v = invoke_detail::is_invocable_r_v<void, R, F, A...>; // mimic: std::is_invocable_r, C++17 template <typename R, typename F, typename... A> struct is_invocable_r : bool_constant<is_invocable_r_v<R, F, A...>> {}; // mimic: std::is_nothrow_invocable_v, C++17 template <typename F, typename... A> FOLLY_INLINE_VARIABLE constexpr bool is_nothrow_invocable_v = invoke_detail::is_nothrow_invocable_v<void, F, A...>; // mimic: std::is_nothrow_invocable, C++17 template <typename F, typename... A> struct is_nothrow_invocable : bool_constant<is_nothrow_invocable_v<F, A...>> {}; // mimic: std::is_nothrow_invocable_r_v, C++17 template <typename R, typename F, typename... Args> FOLLY_INLINE_VARIABLE constexpr bool is_nothrow_invocable_r_v = invoke_detail::is_nothrow_invocable_r_v<void, R, F, Args...>; // mimic: std::is_nothrow_invocable_r, C++17 template <typename R, typename F, typename... A> struct is_nothrow_invocable_r : bool_constant<is_nothrow_invocable_r_v<R, F, A...>> {}; } // namespace folly namespace folly { namespace detail { struct invoke_private_overload; template <bool, typename I> struct invoke_traits_base_ {}; template <typename I> struct invoke_traits_base_<false, I> {}; template <typename I> struct invoke_traits_base_<true, I> { FOLLY_INLINE_VARIABLE static constexpr I invoke{}; }; template <typename I> using invoke_traits_base = invoke_traits_base_<is_constexpr_default_constructible_v<I>, I>; } // namespace detail // invoke_traits // // A traits container struct with the following member types, type aliases, and // variables: // // * invoke_result // * invoke_result_t // * is_invocable // * is_invocable_v // * is_invocable_r // * is_invocable_r_v // * is_nothrow_invocable // * is_nothrow_invocable_v // * is_nothrow_invocable_r // * is_nothrow_invocable_r_v // // These members have behavior matching the behavior of C++17's corresponding // invocation traits types, type aliases, and variables, but using invoke_type // as the invocable argument passed to the usual nivocation traits. // // The traits container struct also has a member type alias: // // * invoke_type // // And an invocable variable as a default-constructed instance of invoke_type, // if the latter is constexpr default-constructible: // // * invoke template <typename I> struct invoke_traits : detail::invoke_traits_base<I> { public: using invoke_type = I; // If invoke_type is constexpr default-constructible: // // inline static constexpr invoke_type invoke{}; template <typename... A> using invoke_result = invoke_detail::invoke_result<void, I, A...>; template <typename... A> using invoke_result_t = invoke_detail::invoke_result_t<I, A...>; template <typename... A> FOLLY_INLINE_VARIABLE static constexpr bool is_invocable_v = invoke_detail::is_invocable_v<void, I, A...>; template <typename... A> struct is_invocable // : bool_constant<invoke_detail::is_invocable_v<void, I, A...>> {}; template <typename R, typename... A> FOLLY_INLINE_VARIABLE static constexpr bool is_invocable_r_v = invoke_detail::is_invocable_r_v<void, R, I, A...>; template <typename R, typename... A> struct is_invocable_r // : bool_constant<invoke_detail::is_invocable_r_v<void, R, I, A...>> {}; template <typename... A> FOLLY_INLINE_VARIABLE static constexpr bool is_nothrow_invocable_v = invoke_detail::is_nothrow_invocable_v<void, I, A...>; template <typename... A> struct is_nothrow_invocable // : bool_constant<invoke_detail::is_nothrow_invocable_v<void, I, A...>> {}; template <typename R, typename... A> FOLLY_INLINE_VARIABLE static constexpr bool is_nothrow_invocable_r_v = invoke_detail::is_nothrow_invocable_r_v<void, R, I, A...>; template <typename R, typename... A> struct is_nothrow_invocable_r // : bool_constant< invoke_detail::is_nothrow_invocable_r_v<void, R, I, A...>> {}; }; } // namespace folly #define FOLLY_DETAIL_CREATE_FREE_INVOKE_TRAITS_USING_1(_, funcname, ns) \ using ns::funcname; #define FOLLY_DETAIL_CREATE_FREE_INVOKE_TRAITS_USING(_, funcname, ...) \ BOOST_PP_EXPR_IIF( \ BOOST_PP_NOT(BOOST_PP_IS_EMPTY(__VA_ARGS__)), \ BOOST_PP_LIST_FOR_EACH( \ FOLLY_DETAIL_CREATE_FREE_INVOKE_TRAITS_USING_1, \ funcname, \ BOOST_PP_TUPLE_TO_LIST((__VA_ARGS__)))) /*** * FOLLY_CREATE_FREE_INVOKER * * Used to create an invoker type bound to a specific free-invocable name. * * Example: * * FOLLY_CREATE_FREE_INVOKER(foo_invoker, foo); * * The type `foo_invoker` is generated in the current namespace and may be used * as follows: * * namespace Deep { * struct CanFoo {}; * int foo(CanFoo const&, Bar&) { return 1; } * int foo(CanFoo&&, Car&&) noexcept { return 2; } * } * * using traits = folly::invoke_traits<foo_invoker>; * * traits::invoke(Deep::CanFoo{}, Car{}) // 2 * * traits::invoke_result<Deep::CanFoo, Bar&> // has member * traits::invoke_result_t<Deep::CanFoo, Bar&> // int * traits::invoke_result<Deep::CanFoo, Bar&&> // empty * traits::invoke_result_t<Deep::CanFoo, Bar&&> // error * * traits::is_invocable_v<CanFoo, Bar&> // true * traits::is_invocable_v<CanFoo, Bar&&> // false * * traits::is_invocable_r_v<int, CanFoo, Bar&> // true * traits::is_invocable_r_v<char*, CanFoo, Bar&> // false * * traits::is_nothrow_invocable_v<CanFoo, Bar&> // false * traits::is_nothrow_invocable_v<CanFoo, Car&&> // true * * traits::is_nothrow_invocable_v<int, CanFoo, Bar&> // false * traits::is_nothrow_invocable_v<char*, CanFoo, Bar&> // false * traits::is_nothrow_invocable_v<int, CanFoo, Car&&> // true * traits::is_nothrow_invocable_v<char*, CanFoo, Car&&> // false * * When a name has one or more primary definition in a fixed set of namespaces * and alternate definitions in the namespaces of its arguments, the primary * definitions may automatically be found as follows: * * FOLLY_CREATE_FREE_INVOKER(swap_invoker, swap, std); * * In this case, `swap_invoke_traits::invoke(int&, int&)` will use the primary * definition found in `namespace std` relative to the current namespace, which * may be equivalent to `namespace ::std`. In contrast: * * namespace Deep { * struct HasData {}; * void swap(HasData&, HasData&) { throw 7; } * } * * using traits = invoke_traits<swap_invoker>; * * HasData a, b; * traits::invoke(a, b); // throw 7 */ #define FOLLY_CREATE_FREE_INVOKER(classname, funcname, ...) \ namespace classname##__folly_detail_invoke_ns { \ FOLLY_MAYBE_UNUSED void funcname( \ ::folly::detail::invoke_private_overload&); \ FOLLY_DETAIL_CREATE_FREE_INVOKE_TRAITS_USING(_, funcname, __VA_ARGS__) \ struct __folly_detail_invoke_obj { \ template <typename... Args> \ FOLLY_MAYBE_UNUSED FOLLY_ERASE_HACK_GCC constexpr auto operator()( \ Args&&... args) const \ noexcept(noexcept(funcname(static_cast<Args&&>(args)...))) \ -> decltype(funcname(static_cast<Args&&>(args)...)) { \ return funcname(static_cast<Args&&>(args)...); \ } \ }; \ } \ struct classname \ : classname##__folly_detail_invoke_ns::__folly_detail_invoke_obj {} /*** * FOLLY_CREATE_FREE_INVOKER_SUITE * * Used to create an invoker type and associated variable bound to a specific * free-invocable name. The invoker variable is named like the free-invocable * name and the invoker type is named with a suffix of _fn. * * See FOLLY_CREATE_FREE_INVOKER. */ #define FOLLY_CREATE_FREE_INVOKER_SUITE(funcname, ...) \ FOLLY_CREATE_FREE_INVOKER(funcname##_fn, funcname, __VA_ARGS__); \ FOLLY_MAYBE_UNUSED FOLLY_INLINE_VARIABLE constexpr funcname##_fn funcname {} /*** * FOLLY_CREATE_QUAL_INVOKER * * Used to create an invoker type bound to a specific free-invocable qualified * name. It is permitted that the qualification be empty and that the name be * unqualified in practice. This differs from FOLLY_CREATE_FREE_INVOKER in that * it is required that the name be in scope and that it is not possible to * provide a list of namespaces in which to look up the name.. */ #define FOLLY_CREATE_QUAL_INVOKER(classname, funcpath) \ struct classname { \ template <typename... A> \ FOLLY_MAYBE_UNUSED FOLLY_ERASE_HACK_GCC constexpr auto operator()( \ A&&... a) const \ FOLLY_DETAIL_FORWARD_BODY(funcpath(static_cast<A&&>(a)...)) \ } /*** * FOLLY_CREATE_QUAL_INVOKER_SUITE * * Used to create an invoker type and associated variable bound to a specific * free-invocable qualified name. * * See FOLLY_CREATE_QUAL_INVOKER. */ #define FOLLY_CREATE_QUAL_INVOKER_SUITE(name, funcpath) \ FOLLY_CREATE_QUAL_INVOKER(name##_fn, funcpath); \ FOLLY_MAYBE_UNUSED FOLLY_INLINE_VARIABLE constexpr name##_fn name {} /*** * FOLLY_INVOKE_QUAL * * An invoker expression resulting in an invocable which, when invoked, invokes * the free-invocable qualified name with the given arguments. */ #define FOLLY_INVOKE_QUAL(funcpath) \ [](auto&&... __folly_param_a) \ FOLLY_CXX17_CONSTEXPR FOLLY_DETAIL_FORWARD_BODY( \ funcpath(FOLLY_DETAIL_FORWARD_REF(__folly_param_a)...)) /*** * FOLLY_CREATE_MEMBER_INVOKER * * Used to create an invoker type bound to a specific member-invocable name. * * Example: * * FOLLY_CREATE_MEMBER_INVOKER(foo_invoker, foo); * * The type `foo_invoker` is generated in the current namespace and may be used * as follows: * * struct CanFoo { * int foo(Bar&) { return 1; } * int foo(Car&&) noexcept { return 2; } * }; * * using traits = folly::invoke_traits<foo_invoker>; * * traits::invoke(CanFoo{}, Car{}) // 2 * * traits::invoke_result<CanFoo, Bar&> // has member * traits::invoke_result_t<CanFoo, Bar&> // int * traits::invoke_result<CanFoo, Bar&&> // empty * traits::invoke_result_t<CanFoo, Bar&&> // error * * traits::is_invocable_v<CanFoo, Bar&> // true * traits::is_invocable_v<CanFoo, Bar&&> // false * * traits::is_invocable_r_v<int, CanFoo, Bar&> // true * traits::is_invocable_r_v<char*, CanFoo, Bar&> // false * * traits::is_nothrow_invocable_v<CanFoo, Bar&> // false * traits::is_nothrow_invocable_v<CanFoo, Car&&> // true * * traits::is_nothrow_invocable_v<int, CanFoo, Bar&> // false * traits::is_nothrow_invocable_v<char*, CanFoo, Bar&> // false * traits::is_nothrow_invocable_v<int, CanFoo, Car&&> // true * traits::is_nothrow_invocable_v<char*, CanFoo, Car&&> // false */ #define FOLLY_CREATE_MEMBER_INVOKER(classname, membername) \ struct classname { \ template <typename O, typename... Args> \ FOLLY_MAYBE_UNUSED FOLLY_ERASE_HACK_GCC constexpr auto operator()( \ O&& o, Args&&... args) const \ noexcept(noexcept( \ static_cast<O&&>(o).membername(static_cast<Args&&>(args)...))) \ -> decltype(static_cast<O&&>(o).membername( \ static_cast<Args&&>(args)...)) { \ return static_cast<O&&>(o).membername(static_cast<Args&&>(args)...); \ } \ } /*** * FOLLY_CREATE_MEMBER_INVOKER_SUITE * * Used to create an invoker type and associated variable bound to a specific * member-invocable name. The invoker variable is named like the member- * invocable name and the invoker type is named with a suffix of _fn. * * See FOLLY_CREATE_MEMBER_INVOKER. */ #define FOLLY_CREATE_MEMBER_INVOKER_SUITE(membername) \ FOLLY_CREATE_MEMBER_INVOKER(membername##_fn, membername); \ FOLLY_MAYBE_UNUSED FOLLY_INLINE_VARIABLE constexpr membername##_fn \ membername {} /*** * FOLLY_INVOKE_MEMBER * * An invoker expression resulting in an invocable which, when invoked, invokes * the member on the object with the given arguments. * * Example: * * FOLLY_INVOKE_MEMBER(find)(map, key) * * Equivalent to: * * map.find(key) * * But also equivalent to: * * std::invoke(FOLLY_INVOKE_MEMBER(find), map, key) * * As an implementation detail, the resulting callable is a lambda. This has * two observable consequences. * * Since C++17 only, lambda invocations may be marked constexpr. * * Since C++20 only, lambda definitions may appear in an unevaluated context, * namely, in an operand to decltype, noexcept, sizeof, or typeid. */ #define FOLLY_INVOKE_MEMBER(membername) \ [](auto&& __folly_param_o, auto&&... __folly_param_a) \ FOLLY_CXX17_CONSTEXPR FOLLY_DETAIL_FORWARD_BODY( \ FOLLY_DETAIL_FORWARD_REF(__folly_param_o) \ .membername(FOLLY_DETAIL_FORWARD_REF(__folly_param_a)...)) /*** * FOLLY_CREATE_STATIC_MEMBER_INVOKER * * Used to create an invoker type template bound to a specific static-member- * invocable name. * * Example: * * FOLLY_CREATE_STATIC_MEMBER_INVOKER(foo_invoker, foo); * * The type template `foo_invoker` is generated in the current namespace and * may be used as follows: * * struct CanFoo { * static int foo(Bar&) { return 1; } * static int foo(Car&&) noexcept { return 2; } * }; * * using traits = folly::invoke_traits<foo_invoker<CanFoo>>; * * traits::invoke(Car{}) // 2 * * traits::invoke_result<Bar&> // has member * traits::invoke_result_t<Bar&> // int * traits::invoke_result<Bar&&> // empty * traits::invoke_result_t<Bar&&> // error * * traits::is_invocable_v<Bar&> // true * traits::is_invocable_v<Bar&&> // false * * traits::is_invocable_r_v<int, Bar&> // true * traits::is_invocable_r_v<char*, Bar&> // false * * traits::is_nothrow_invocable_v<Bar&> // false * traits::is_nothrow_invocable_v<Car&&> // true * * traits::is_nothrow_invocable_v<int, Bar&> // false * traits::is_nothrow_invocable_v<char*, Bar&> // false * traits::is_nothrow_invocable_v<int, Car&&> // true * traits::is_nothrow_invocable_v<char*, Car&&> // false */ #define FOLLY_CREATE_STATIC_MEMBER_INVOKER(classname, membername) \ template <typename T> \ struct classname { \ template <typename... Args, typename U = T> \ FOLLY_MAYBE_UNUSED FOLLY_ERASE constexpr auto operator()(Args&&... args) \ const noexcept(noexcept(U::membername(static_cast<Args&&>(args)...))) \ -> decltype(U::membername(static_cast<Args&&>(args)...)) { \ return U::membername(static_cast<Args&&>(args)...); \ } \ } /*** * FOLLY_CREATE_STATIC_MEMBER_INVOKER_SUITE * * Used to create an invoker type template and associated variable template * bound to a specific static-member-invocable name. The invoker variable * template is named like the static-member-invocable name and the invoker type * template is named with a suffix of _fn. * * See FOLLY_CREATE_STATIC_MEMBER_INVOKER. */ #define FOLLY_CREATE_STATIC_MEMBER_INVOKER_SUITE(membername) \ FOLLY_CREATE_STATIC_MEMBER_INVOKER(membername##_fn, membername); \ template <typename T> \ FOLLY_MAYBE_UNUSED FOLLY_INLINE_VARIABLE constexpr membername##_fn<T> \ membername {} namespace folly { namespace detail_tag_invoke_fn { void tag_invoke(); struct tag_invoke_fn { template <typename Tag, typename... Args> constexpr auto operator()(Tag tag, Args&&... args) const noexcept(noexcept( tag_invoke(static_cast<Tag&&>(tag), static_cast<Args&&>(args)...))) -> decltype(tag_invoke( static_cast<Tag&&>(tag), static_cast<Args&&>(args)...)) { return tag_invoke(static_cast<Tag&&>(tag), static_cast<Args&&>(args)...); } }; // Manually implement the traits here rather than defining them in terms of // the corresponding std::invoke_result/is_invocable/is_nothrow_invocable // traits to improve compile-times. We don't need all of the generality of // the std:: traits and the tag_invoke traits can be used heavily in CPO-based // code so optimising them for compile times can make a big difference. // Use the immediately-invoked function-pointer trick here to avoid // instantiating the std::declval<T>() template. template <typename Tag, typename... Args> using tag_invoke_result_t = decltype(tag_invoke( static_cast<Tag && (*)() noexcept>(nullptr)(), static_cast<Args && (*)() noexcept>(nullptr)()...)); template <typename Tag, typename... Args> auto try_tag_invoke(int) noexcept( noexcept(tag_invoke(FOLLY_DECLVAL(Tag&&), FOLLY_DECLVAL(Args&&)...))) -> decltype( static_cast<void>( tag_invoke(FOLLY_DECLVAL(Tag &&), FOLLY_DECLVAL(Args&&)...)), std::true_type{}); template <typename Tag, typename... Args> std::false_type try_tag_invoke(...) noexcept(false); template <template <typename...> class T, typename... Args> struct defer { using type = T<Args...>; }; struct empty {}; } // namespace detail_tag_invoke_fn // The expression folly::tag_invoke(tag, args...) is equivalent to performing // a call to the expression tag_invoke(tag, args...) using argument-dependent // lookup (ADL). // // This is intended to be used by customization-point objects, which dispatch // a call to the CPO to an ADL call to tag_invoke(cpo, args...), using the type // of the first argument to disambiguate between customisations for different // CPOs rather than using different ADL names for this. // // For example: Defining a new CPO in terms of tag_invoke. // struct FooCpo { // template<typename A, typename B> // auto operator()(A&& a, B&& b) const // noexcept(folly::is_nothrow_tag_invocable_v<FooCpo, A, B>) // -> folly::tag_invoke_result_t<FooCpo, A, B> { // return folly::tag_invoke(*this, (A&&)a, (B&&)b); // } // }; // FOLLY_DEFINE_CPO(FooCpo, Foo) // // And then customising the Foo CPO for a particular type: // class SomeType { // ... // template<typename B> // friend int tag_invoke(folly::cpo_t<Foo>, const SomeType& a, B&& b) { // // implementation goes here // } // }; // // For more details see the C++ standards proposal: https://wg21.link/P1895R0. FOLLY_DEFINE_CPO(detail_tag_invoke_fn::tag_invoke_fn, tag_invoke) // Query if the 'folly::tag_invoke()' CPO can be invoked with a tag and // arguments of the the specified types. // // This checks whether an overload of the free-function tag_invoke() found // by ADL can be invoked with the specified types. template <typename Tag, typename... Args> FOLLY_INLINE_VARIABLE constexpr bool is_tag_invocable_v = decltype(detail_tag_invoke_fn::try_tag_invoke<Tag, Args...>(0))::value; template <typename Tag, typename... Args> struct is_tag_invocable : bool_constant<is_tag_invocable_v<Tag, Args...>> {}; // Query whether the 'folly::tag_invoke()' CPO can be invoked with a tag // and arguments of the specified type and that such an invocation is // noexcept. template <typename Tag, typename... Args> FOLLY_INLINE_VARIABLE constexpr bool is_nothrow_tag_invocable_v = noexcept(detail_tag_invoke_fn::try_tag_invoke<Tag, Args...>(0)); template <typename Tag, typename... Args> struct is_nothrow_tag_invocable : bool_constant<is_nothrow_tag_invocable_v<Tag, Args...>> {}; // Versions of the above that check in addition that the result is // convertible to the given return type R. template <typename R, typename Tag, typename... Args> using is_tag_invocable_r = folly::is_invocable_r<R, decltype(folly::tag_invoke), Tag, Args...>; template <typename R, typename Tag, typename... Args> FOLLY_INLINE_VARIABLE constexpr bool is_tag_invocable_r_v = is_tag_invocable_r<R, decltype(folly::tag_invoke), Tag, Args...>::value; template <typename R, typename Tag, typename... Args> using is_nothrow_tag_invocable_r = folly::is_nothrow_invocable_r<R, decltype(folly::tag_invoke), Tag, Args...>; template <typename R, typename Tag, typename... Args> FOLLY_INLINE_VARIABLE constexpr bool is_nothrow_tag_invocable_r_v = is_nothrow_tag_invocable_r<R, Tag, Args...>::value; using detail_tag_invoke_fn::tag_invoke_result_t; template <typename Tag, typename... Args> struct tag_invoke_result : conditional_t< is_tag_invocable_v<Tag, Args...>, detail_tag_invoke_fn::defer<tag_invoke_result_t, Tag, Args...>, detail_tag_invoke_fn::empty> {}; } // namespace folly