>
{ using type = _Res(_Args...); };
+#if __cpp_static_call_operator >= 202207L && __cpp_concepts >= 202002L
+ template<typename _StaticCallOp>
+ struct __function_guide_static_helper
+ { };
+
+ template<typename _Res, bool _Nx, typename... _Args>
+ struct __function_guide_static_helper<_Res (*) (_Args...) noexcept(_Nx)>
+ { using type = _Res(_Args...); };
+
+ template<typename _Fn, typename _Op>
+ using __function_guide_t = typename __conditional_t<
+ requires (_Fn& __f) { (void) __f.operator(); },
+ __function_guide_static_helper<_Op>,
+ __function_guide_helper<_Op>>::type;
+#else
+ template<typename _Fn, typename _Op>
+ using __function_guide_t = typename __function_guide_helper<_Op>::type;
+#endif
+
template<typename _Res, typename... _ArgTypes>
function(_Res(*)(_ArgTypes...)) -> function<_Res(_ArgTypes...)>;
- template<typename _Functor, typename _Signature = typename
- __function_guide_helper<decltype(&_Functor::operator())>::type>
- function(_Functor) -> function<_Signature>;
+ template<typename _Fn, typename _Signature
+ = __function_guide_t<_Fn, decltype(&_Fn::operator())>>
+ function(_Fn) -> function<_Signature>;
#endif
// [20.7.15.2.6] null pointer comparisons
template<typename _Res, typename... _ArgTypes>
packaged_task(_Res(*)(_ArgTypes...)) -> packaged_task<_Res(_ArgTypes...)>;
- template<typename _Fun, typename _Signature = typename
- __function_guide_helper<decltype(&_Fun::operator())>::type>
+ template<typename _Fun, typename _Signature
+ = __function_guide_t<_Fun, decltype(&_Fun::operator())>>
packaged_task(_Fun) -> packaged_task<_Signature>;
#endif
--- /dev/null
+// { dg-options "-std=gnu++23" }
+// { dg-do compile { target c++23 } }
+
+#include <functional>
+
+template<typename T, typename U> struct require_same;
+template<typename T> struct require_same<T, T> { using type = void; };
+
+template<typename T, typename U>
+ typename require_same<T, U>::type
+ check_type(U&) { }
+
+void
+test_static_call_operator()
+{
+ struct F1 { static long operator()() { return 0; } };
+ std::function func1 = F1{};
+ check_type<std::function<long()>>(func1);
+
+ struct F2 { static float operator()(char, void*) noexcept { return 0; } };
+ std::function func2 = F2{};
+ check_type<std::function<float(char, void*)>>(func2);
+}
--- /dev/null
+// { dg-options "-std=gnu++23" }
+// { dg-do compile { target c++23 } }
+
+#include <future>
+
+template<typename T, typename U> struct require_same;
+template<typename T> struct require_same<T, T> { using type = void; };
+
+template<typename T, typename U>
+ typename require_same<T, U>::type
+ check_type(U&) { }
+
+void
+test_static_call_operator()
+{
+ struct F1 { static long operator()() { return 0; } };
+ std::packaged_task task1{ F1{} };
+ check_type<std::packaged_task<long()>>(task1);
+
+ struct F2 { static float operator()(char, void*) noexcept { return 0; } };
+ std::packaged_task task2{ F2{} };
+ check_type<std::packaged_task<float(char, void*)>>(task2);
+}