libstdc++-v3/ChangeLog:
* include/Makefile.am: Add new headers.
* include/Makefile.in: Regenerate.
* include/std/functional: Include <bits/move_only_function.h>.
* include/std/version (__cpp_lib_move_only_function): Define.
* include/bits/mofunc_impl.h: New file.
* include/bits/move_only_function.h: New file.
* testsuite/20_util/move_only_function/call.cc: New test.
* testsuite/20_util/move_only_function/cons.cc: New test.
* testsuite/20_util/move_only_function/move.cc: New test.
* testsuite/20_util/move_only_function/version.cc: New test.
Tested powerpc64le-linux. Committed to trunk.
commit 881d1689a42cc7a1fd63bde53c883e52a56eded3
Author: Jonathan Wakely <jwak...@redhat.com>
Date: Wed Oct 6 13:28:57 2021
libstdc++: Implement std::move_only_function for C++23 (P0288R9)
libstdc++-v3/ChangeLog:
* include/Makefile.am: Add new headers.
* include/Makefile.in: Regenerate.
* include/std/functional: Include <bits/move_only_function.h>.
* include/std/version (__cpp_lib_move_only_function): Define.
* include/bits/mofunc_impl.h: New file.
* include/bits/move_only_function.h: New file.
* testsuite/20_util/move_only_function/call.cc: New test.
* testsuite/20_util/move_only_function/cons.cc: New test.
* testsuite/20_util/move_only_function/move.cc: New test.
* testsuite/20_util/move_only_function/version.cc: New test.
diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am
index 5a5b5fd1d1b..27b548607b9 100644
--- a/libstdc++-v3/include/Makefile.am
+++ b/libstdc++-v3/include/Makefile.am
@@ -154,7 +154,9 @@ bits_headers = \
${bits_srcdir}/mask_array.h \
${bits_srcdir}/max_size_type.h \
${bits_srcdir}/memoryfwd.h \
+ ${bits_srcdir}/mofunc_impl.h \
${bits_srcdir}/move.h \
+ ${bits_srcdir}/move_only_function.h \
${bits_srcdir}/node_handle.h \
${bits_srcdir}/ostream.tcc \
${bits_srcdir}/ostream_insert.h \
diff --git a/libstdc++-v3/include/bits/mofunc_impl.h
b/libstdc++-v3/include/bits/mofunc_impl.h
new file mode 100644
index 00000000000..543c6f547b7
--- /dev/null
+++ b/libstdc++-v3/include/bits/mofunc_impl.h
@@ -0,0 +1,200 @@
+// Implementation of std::move_only_function -*- C++ -*-
+
+// Copyright The GNU Toolchain Authors.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/bits/mofunc_impl.h
+ * This is an internal header file, included by other library headers.
+ * Do not attempt to use it directly. @headername{functional}
+ */
+
+#ifndef _GLIBCXX_MOF_CV
+# define _GLIBCXX_MOF_CV
+#endif
+
+#ifdef _GLIBCXX_MOF_REF
+# define _GLIBCXX_MOF_INV_QUALS _GLIBCXX_MOF_CV _GLIBCXX_MOF_REF
+#else
+# define _GLIBCXX_MOF_REF
+# define _GLIBCXX_MOF_INV_QUALS _GLIBCXX_MOF_CV &
+#endif
+
+#define _GLIBCXX_MOF_CV_REF _GLIBCXX_MOF_CV _GLIBCXX_MOF_REF
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ template<typename _Res, typename... _ArgTypes, bool _Noex>
+ class move_only_function<_Res(_ArgTypes...) _GLIBCXX_MOF_CV
+ _GLIBCXX_MOF_REF noexcept(_Noex)>
+ : _Mofunc_base
+ {
+ template<typename _Tp>
+ using __callable
+ = __conditional_t<_Noex,
+ is_nothrow_invocable_r<_Res, _Tp, _ArgTypes...>,
+ is_invocable_r<_Res, _Tp, _ArgTypes...>>;
+
+ // [func.wrap.mov.con]/1 is-callable-from<VT>
+ template<typename _Vt>
+ static constexpr bool __is_callable_from
+ = __and_v<__callable<_Vt _GLIBCXX_MOF_CV_REF>,
+ __callable<_Vt _GLIBCXX_MOF_INV_QUALS>>;
+
+ public:
+ using result_type = _Res;
+
+ move_only_function() noexcept { }
+
+ move_only_function(nullptr_t) noexcept { }
+
+ move_only_function(move_only_function&& __x) noexcept
+ : _Mofunc_base(static_cast<_Mofunc_base&&>(__x)),
+ _M_invoke(std::__exchange(__x._M_invoke, nullptr))
+ { }
+
+ template<typename _Fn, typename _Vt = decay_t<_Fn>>
+ requires (!is_same_v<_Vt, move_only_function>)
+ && (!__is_in_place_type_v<_Vt>) && __is_callable_from<_Vt>
+ move_only_function(_Fn&& __f) noexcept(_S_nothrow_init<_Vt, _Fn>())
+ {
+ if constexpr (is_function_v<remove_pointer_t<_Vt>>
+ || is_member_pointer_v<_Vt>
+ || __is_move_only_function_v<_Vt>)
+ {
+ if (__f == nullptr)
+ return;
+ }
+ _M_init<_Vt>(std::forward<_Fn>(__f));
+ _M_invoke = &_S_invoke<_Vt>;
+ }
+
+ template<typename _Tp, typename... _Args>
+ requires is_constructible_v<_Tp, _Args...>
+ && __is_callable_from<_Tp>
+ explicit
+ move_only_function(in_place_type_t<_Tp>, _Args&&... __args)
+ noexcept(_S_nothrow_init<_Tp, _Args...>())
+ : _M_invoke(&_S_invoke<_Tp>)
+ {
+ static_assert(is_same_v<decay_t<_Tp>, _Tp>);
+ _M_init<_Tp>(std::forward<_Args>(__args)...);
+ }
+
+ template<typename _Tp, typename _Up, typename... _Args>
+ requires is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>
+ && __is_callable_from<_Tp>
+ explicit
+ move_only_function(in_place_type_t<_Tp>, initializer_list<_Up> __il,
+ _Args&&... __args)
+ noexcept(_S_nothrow_init<_Tp, initializer_list<_Up>&, _Args...>())
+ : _Mofunc_base(nullptr), _M_invoke(&_S_invoke<_Tp>)
+ {
+ static_assert(is_same_v<decay_t<_Tp>, _Tp>);
+ _M_init<_Tp>(__il, std::forward<_Args>(__args)...);
+ }
+
+ move_only_function&
+ operator=(move_only_function&& __x) noexcept
+ {
+ _Mofunc_base::operator=(static_cast<_Mofunc_base&&>(__x));
+ _M_invoke = std::__exchange(__x._M_invoke, nullptr);
+ return *this;
+ }
+
+ move_only_function&
+ operator=(nullptr_t) noexcept
+ {
+ _Mofunc_base::operator=(nullptr);
+ _M_invoke = nullptr;
+ return *this;
+ }
+
+ template<typename _Fn>
+ requires is_constructible_v<move_only_function, _Fn>
+ move_only_function&
+ operator=(_Fn&& __f)
+ noexcept(is_nothrow_constructible_v<move_only_function, _Fn>)
+ {
+ move_only_function(std::forward<_Fn>(__f)).swap(*this);
+ return *this;
+ }
+
+ ~move_only_function() = default;
+
+ explicit operator bool() const noexcept { return _M_invoke != nullptr; }
+
+ _Res
+ operator()(_ArgTypes... __args) _GLIBCXX_MOF_CV_REF noexcept(_Noex)
+ {
+ __glibcxx_assert(*this != nullptr);
+ return _M_invoke(this, std::forward<_ArgTypes>(__args)...);
+ }
+
+ void
+ swap(move_only_function& __x) noexcept
+ {
+ _Mofunc_base::swap(__x);
+ std::swap(_M_invoke, __x._M_invoke);
+ }
+
+ friend void
+ swap(move_only_function& __x, move_only_function& __y) noexcept
+ { __x.swap(__y); }
+
+ friend bool
+ operator==(const move_only_function& __x, nullptr_t) noexcept
+ { return __x._M_invoke == nullptr; }
+
+ private:
+ template<typename _Tp>
+ using __param_t
+ = __conditional_t<is_trivially_copyable_v<_Tp>
+ && sizeof(_Tp) <= sizeof(long),
+ _Tp, _Tp&&>;
+
+ using _Invoker = _Res (*)(_Mofunc_base _GLIBCXX_MOF_CV*,
+ __param_t<_ArgTypes>...) noexcept(_Noex);
+
+ template<typename _Tp>
+ static _Res
+ _S_invoke(_Mofunc_base _GLIBCXX_MOF_CV* __self,
+ __param_t<_ArgTypes>... __args) noexcept(_Noex)
+ {
+ using _TpCv = _Tp _GLIBCXX_MOF_CV;
+ using _TpInv = _Tp _GLIBCXX_MOF_INV_QUALS;
+ return std::__invoke_r<_Res>(
+ std::forward<_TpInv>(*_S_access<_TpCv>(__self)),
+ std::forward<__param_t<_ArgTypes>>(__args)...);
+ }
+
+ _Invoker _M_invoke = nullptr;
+ };
+
+#undef _GLIBCXX_MOF_CV_REF
+#undef _GLIBCXX_MOF_CV
+#undef _GLIBCXX_MOF_REF
+#undef _GLIBCXX_MOF_INV_QUALS
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
diff --git a/libstdc++-v3/include/bits/move_only_function.h
b/libstdc++-v3/include/bits/move_only_function.h
new file mode 100644
index 00000000000..f96552a7c89
--- /dev/null
+++ b/libstdc++-v3/include/bits/move_only_function.h
@@ -0,0 +1,204 @@
+// Implementation of std::move_only_function -*- C++ -*-
+
+// Copyright The GNU Toolchain Authors.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/bits/move_only_function.h
+ * This is an internal header file, included by other library headers.
+ * Do not attempt to use it directly. @headername{functional}
+ */
+
+#ifndef _GLIBCXX_MOVE_ONLY_FUNCTION_H
+#define _GLIBCXX_MOVE_ONLY_FUNCTION_H 1
+
+#pragma GCC system_header
+
+#if __cplusplus > 202002L
+
+#include <bits/invoke.h>
+#include <bits/utility.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+#define __cpp_lib_move_only_function 202110L
+
+ template<typename... _Signature>
+ class move_only_function; // not defined
+
+ /// @cond undocumented
+ class _Mofunc_base
+ {
+ protected:
+ _Mofunc_base() noexcept
+ : _M_manage(_S_empty)
+ { }
+
+ _Mofunc_base(_Mofunc_base&& __x) noexcept
+ {
+ _M_manage = std::__exchange(__x._M_manage, _S_empty);
+ _M_manage(_M_storage, &__x._M_storage);
+ }
+
+ template<typename _Tp, typename... _Args>
+ static constexpr bool
+ _S_nothrow_init() noexcept
+ {
+ if constexpr (__stored_locally<_Tp>)
+ return is_nothrow_constructible_v<_Tp, _Args...>;
+ return false;
+ }
+
+ template<typename _Tp, typename... _Args>
+ void
+ _M_init(_Args&&... __args) noexcept(_S_nothrow_init<_Tp, _Args...>())
+ {
+ if constexpr (__stored_locally<_Tp>)
+ ::new (_M_storage._M_addr()) _Tp(std::forward<_Args>(__args)...);
+ else
+ _M_storage._M_p = new _Tp(std::forward<_Args>(__args)...);
+
+ _M_manage = &_S_manage<_Tp>;
+ }
+
+ _Mofunc_base&
+ operator=(_Mofunc_base&& __x) noexcept
+ {
+ _M_manage(_M_storage, nullptr);
+ _M_manage = std::__exchange(__x._M_manage, _S_empty);
+ _M_manage(_M_storage, &__x._M_storage);
+ return *this;
+ }
+
+ _Mofunc_base&
+ operator=(nullptr_t) noexcept
+ {
+ _M_manage(_M_storage, nullptr);
+ _M_manage = _S_empty;
+ return *this;
+ }
+
+ ~_Mofunc_base() { _M_manage(_M_storage, nullptr); }
+
+ void
+ swap(_Mofunc_base& __x) noexcept
+ {
+ // Order of operations here is more efficient if __x is empty.
+ _Storage __s;
+ __x._M_manage(__s, &__x._M_storage);
+ _M_manage(__x._M_storage, &_M_storage);
+ __x._M_manage(_M_storage, &__s);
+ std::swap(_M_manage, __x._M_manage);
+ }
+
+ template<typename _Tp, typename _Self>
+ static _Tp*
+ _S_access(_Self* __self) noexcept
+ {
+ if constexpr (__stored_locally<remove_const_t<_Tp>>)
+ return static_cast<_Tp*>(__self->_M_storage._M_addr());
+ else
+ return static_cast<_Tp*>(__self->_M_storage._M_p);
+ }
+
+ private:
+ struct _Storage
+ {
+ void* _M_addr() noexcept { return &_M_bytes[0]; }
+ const void* _M_addr() const noexcept { return &_M_bytes[0]; }
+
+ // We want to have enough space to store a simple delegate type.
+ struct _Delegate { void (_Storage::*__pfm)(); _Storage* __obj; };
+ union {
+ void* _M_p;
+ alignas(_Delegate) alignas(void(*)())
+ unsigned char _M_bytes[sizeof(_Delegate)];
+ };
+ };
+
+ template<typename _Tp>
+ static constexpr bool __stored_locally
+ = sizeof(_Tp) <= sizeof(_Storage) && alignof(_Tp) <= alignof(_Storage)
+ && is_nothrow_move_constructible_v<_Tp>;
+
+ // A function that either destroys the target object stored in __target,
+ // or moves the target object from *__src to __target.
+ using _Manager = void (*)(_Storage& __target, _Storage* __src) noexcept;
+
+ // The no-op manager function for objects with no target.
+ static void _S_empty(_Storage&, _Storage*) noexcept { }
+
+ // The real manager function for a target object of type _Tp.
+ template<typename _Tp>
+ static void
+ _S_manage(_Storage& __target, _Storage* __src) noexcept
+ {
+ if constexpr (__stored_locally<_Tp>)
+ {
+ if (__src)
+ {
+ _Tp* __rval = static_cast<_Tp*>(__src->_M_addr());
+ ::new (__target._M_addr()) _Tp(std::move(*__rval));
+ __rval->~_Tp();
+ }
+ else
+ static_cast<_Tp*>(__target._M_addr())->~_Tp();
+ }
+ else
+ {
+ if (__src)
+ __target._M_p = __src->_M_p;
+ else
+ delete static_cast<_Tp*>(__target._M_p);
+ }
+ }
+
+ _Storage _M_storage;
+ _Manager _M_manage;
+ };
+
+ template<typename _Tp>
+ inline constexpr bool __is_move_only_function_v = false;
+ template<typename _Tp>
+ constexpr bool __is_move_only_function_v<move_only_function<_Tp>> = true;
+ /// @endcond
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#include "mofunc_impl.h"
+#define _GLIBCXX_MOF_CV const
+#include "mofunc_impl.h"
+#define _GLIBCXX_MOF_REF &
+#include "mofunc_impl.h"
+#define _GLIBCXX_MOF_REF &&
+#include "mofunc_impl.h"
+#define _GLIBCXX_MOF_CV const
+#define _GLIBCXX_MOF_REF &
+#include "mofunc_impl.h"
+#define _GLIBCXX_MOF_CV const
+#define _GLIBCXX_MOF_REF &&
+#include "mofunc_impl.h"
+
+#endif // C++23
+#endif // _GLIBCXX_MOVE_ONLY_FUNCTION_H
diff --git a/libstdc++-v3/include/std/functional
b/libstdc++-v3/include/std/functional
index a13f67e4c7c..2db1c05349b 100644
--- a/libstdc++-v3/include/std/functional
+++ b/libstdc++-v3/include/std/functional
@@ -67,6 +67,9 @@
# include <bits/ranges_cmp.h>
# include <compare>
#endif
+#if __cplusplus > 202002L
+# include <bits/move_only_function.h>
+#endif
#endif // C++11
diff --git a/libstdc++-v3/include/std/version b/libstdc++-v3/include/std/version
index 3d4a4142eec..24b86e0fa63 100644
--- a/libstdc++-v3/include/std/version
+++ b/libstdc++-v3/include/std/version
@@ -284,6 +284,7 @@
#define __cpp_lib_adaptor_iterator_pair_constructor 202106L
#define __cpp_lib_invoke_r 202106L
#define __cpp_lib_is_scoped_enum 202011L
+#define __cpp_lib_move_only_function 202110L
#define __cpp_lib_string_contains 202011L
#define __cpp_lib_to_underlying 202102L
#endif // C++2b
diff --git a/libstdc++-v3/testsuite/20_util/move_only_function/call.cc
b/libstdc++-v3/testsuite/20_util/move_only_function/call.cc
new file mode 100644
index 00000000000..9ca0a60a24e
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/move_only_function/call.cc
@@ -0,0 +1,199 @@
+// { dg-options "-std=gnu++23" }
+// { dg-do run { target c++23 } }
+
+#include <functional>
+#include <utility>
+#include <testsuite_hooks.h>
+
+using std::move_only_function;
+
+using std::is_same_v;
+using std::is_invocable_v;
+using std::is_nothrow_invocable_v;
+using std::invoke_result_t;
+
+// Check return types
+static_assert( is_same_v<void, invoke_result_t<move_only_function<void()>>> );
+static_assert( is_same_v<int, invoke_result_t<move_only_function<int()>>> );
+static_assert( is_same_v<int&, invoke_result_t<move_only_function<int&()>>> );
+
+// With const qualifier
+static_assert( ! is_invocable_v< move_only_function<void()> const > );
+static_assert( ! is_invocable_v< move_only_function<void()> const &> );
+static_assert( is_invocable_v< move_only_function<void() const> > );
+static_assert( is_invocable_v< move_only_function<void() const> &> );
+static_assert( is_invocable_v< move_only_function<void() const> const > );
+static_assert( is_invocable_v< move_only_function<void() const> const &> );
+
+// With no ref-qualifier
+static_assert( is_invocable_v< move_only_function<void()> > );
+static_assert( is_invocable_v< move_only_function<void()> &> );
+static_assert( is_invocable_v< move_only_function<void() const> > );
+static_assert( is_invocable_v< move_only_function<void() const> &> );
+static_assert( is_invocable_v< move_only_function<void() const> const > );
+static_assert( is_invocable_v< move_only_function<void() const> const &> );
+
+// With & ref-qualifier
+static_assert( ! is_invocable_v< move_only_function<void()&> > );
+static_assert( is_invocable_v< move_only_function<void()&> &> );
+static_assert( is_invocable_v< move_only_function<void() const&> > );
+static_assert( is_invocable_v< move_only_function<void() const&> &> );
+static_assert( is_invocable_v< move_only_function<void() const&> const > );
+static_assert( is_invocable_v< move_only_function<void() const&> const &> );
+
+// With && ref-qualifier
+static_assert( is_invocable_v< move_only_function<void()&&> > );
+static_assert( ! is_invocable_v< move_only_function<void()&&> &> );
+static_assert( is_invocable_v< move_only_function<void() const&&> > );
+static_assert( ! is_invocable_v< move_only_function<void() const&&> &> );
+static_assert( is_invocable_v< move_only_function<void() const&&> const > );
+static_assert( ! is_invocable_v< move_only_function<void() const&&> const &> );
+
+// With noexcept-specifier
+static_assert( ! is_nothrow_invocable_v< move_only_function<void()> > );
+static_assert( ! is_nothrow_invocable_v< move_only_function<void()
noexcept(false)> > );
+static_assert( is_nothrow_invocable_v< move_only_function<void() noexcept> > );
+static_assert( is_nothrow_invocable_v< move_only_function<void()& noexcept>& >
);
+
+void
+test01()
+{
+ struct F
+ {
+ int operator()() { return 0; }
+ int operator()() const { return 1; }
+ };
+
+ move_only_function<int()> f0{F{}};
+ VERIFY( f0() == 0 );
+ VERIFY( std::move(f0)() == 0 );
+
+ move_only_function<int() const> f1{F{}};
+ VERIFY( f1() == 1 );
+ VERIFY( std::as_const(f1)() == 1 );
+ VERIFY( std::move(f1)() == 1 );
+ VERIFY( std::move(std::as_const(f1))() == 1 );
+
+ move_only_function<int()&> f2{F{}};
+ VERIFY( f2() == 0 );
+ // Not rvalue-callable: std::move(f2)()
+
+ move_only_function<int() const&> f3{F{}};
+ VERIFY( f3() == 1 );
+ VERIFY( std::as_const(f3)() == 1 );
+ VERIFY( std::move(f3)() == 1 );
+ VERIFY( std::move(std::as_const(f3))() == 1 );
+
+ move_only_function<int()&&> f4{F{}};
+ // Not lvalue-callable: f4()
+ VERIFY( std::move(f4)() == 0 );
+
+ move_only_function<int() const&&> f5{F{}};
+ // Not lvalue-callable: f5()
+ VERIFY( std::move(f5)() == 1 );
+ VERIFY( std::move(std::as_const(f5))() == 1 );
+}
+
+void
+test02()
+{
+ struct F
+ {
+ int operator()() & { return 0; }
+ int operator()() && { return 1; }
+ };
+
+ move_only_function<int()> f0{F{}};
+ VERIFY( f0() == 0 );
+ VERIFY( std::move(f0)() == 0 );
+
+ move_only_function<int()&&> f1{F{}};
+ // Not lvalue callable: f1()
+ VERIFY( std::move(f1)() == 1 );
+
+ move_only_function<int()&> f2{F{}};
+ VERIFY( f2() == 0 );
+ // Not rvalue-callable: std::move(f2)()
+}
+
+void
+test03()
+{
+ struct F
+ {
+ int operator()() const & { return 0; }
+ int operator()() && { return 1; }
+ };
+
+ move_only_function<int()> f0{F{}};
+ VERIFY( f0() == 0 );
+ VERIFY( std::move(f0)() == 0 );
+
+ move_only_function<int()&&> f1{F{}};
+ // Not lvalue callable: f1()
+ VERIFY( std::move(f1)() == 1 );
+
+ move_only_function<int() const> f2{F{}};
+ VERIFY( f2() == 0 );
+ VERIFY( std::as_const(f2)() == 0 );
+ VERIFY( std::move(f2)() == 0 );
+ VERIFY( std::move(std::as_const(f2))() == 0 );
+
+ move_only_function<int() const &&> f3{F{}};
+ // Not lvalue callable: f3()
+ VERIFY( std::move(f3)() == 0 );
+ VERIFY( std::move(std::as_const(f3))() == 0 );
+
+ move_only_function<int() const &> f4{F{}};
+ VERIFY( f4() == 0 );
+ VERIFY( std::as_const(f4)() == 0 );
+ // Not rvalue-callable: std::move(f4)()
+}
+
+void
+test04()
+{
+ struct F
+ {
+ int operator()() & { return 0; }
+ int operator()() && { return 1; }
+ int operator()() const & { return 2; }
+ int operator()() const && { return 3; }
+ };
+
+ move_only_function<int()> f0{F{}};
+ VERIFY( f0() == 0 );
+ VERIFY( std::move(f0)() == 0 );
+
+ move_only_function<int()&> f1{F{}};
+ VERIFY( f1() == 0 );
+ // Not rvalue-callable: std::move(f1)()
+
+ move_only_function<int()&&> f2{F{}};
+ // Not lvalue callable: f2()
+ VERIFY( std::move(f2)() == 1 );
+
+ move_only_function<int() const> f3{F{}};
+ VERIFY( f3() == 2 );
+ VERIFY( std::as_const(f3)() == 2 );
+ VERIFY( std::move(f3)() == 2 );
+ VERIFY( std::move(std::as_const(f3))() == 2 );
+
+ move_only_function<int() const &> f4{F{}};
+ VERIFY( f4() == 2 );
+ VERIFY( std::as_const(f4)() == 2 );
+ // Not rvalue-callable: std::move(f4)()
+
+ move_only_function<int() const &&> f5{F{}};
+ // Not lvalue callable: f5()
+ VERIFY( std::move(f5)() == 3 );
+ VERIFY( std::move(std::as_const(f5))() == 3 );
+}
+
+int main()
+{
+ test01();
+ test02();
+ test03();
+ test04();
+}
diff --git a/libstdc++-v3/testsuite/20_util/move_only_function/cons.cc
b/libstdc++-v3/testsuite/20_util/move_only_function/cons.cc
new file mode 100644
index 00000000000..0992f107003
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/move_only_function/cons.cc
@@ -0,0 +1,98 @@
+// { dg-options "-std=gnu++23" }
+// { dg-do compile { target c++23 } }
+
+#include <functional>
+
+#ifndef __cpp_lib_move_only_function
+# error "Feature-test macro for move_only_function missing in <functional>"
+#elif __cpp_lib_move_only_function != 202110L
+# error "Feature-test macro for move_only_function has wrong value in
<functional>"
+#endif
+
+using std::move_only_function;
+
+using std::is_constructible_v;
+using std::is_copy_constructible_v;
+using std::is_nothrow_default_constructible_v;
+using std::is_nothrow_move_constructible_v;
+using std::is_nothrow_constructible_v;
+using std::nullptr_t;
+using std::in_place_type_t;
+
+static_assert( is_nothrow_default_constructible_v<move_only_function<void()>>
);
+static_assert( is_nothrow_constructible_v<move_only_function<void()>,
nullptr_t> );
+static_assert( is_nothrow_move_constructible_v<move_only_function<void()>> );
+static_assert( ! is_copy_constructible_v<move_only_function<void()>> );
+
+static_assert( is_constructible_v<move_only_function<void()>, void()> );
+static_assert( is_constructible_v<move_only_function<void()>, void(&)()> );
+static_assert( is_constructible_v<move_only_function<void()>, void(*)()> );
+static_assert( is_constructible_v<move_only_function<void()>, int()> );
+static_assert( is_constructible_v<move_only_function<void()>, int(&)()> );
+static_assert( is_constructible_v<move_only_function<void()>, int(*)()> );
+static_assert( ! is_constructible_v<move_only_function<void()>, void(int)> );
+static_assert( is_constructible_v<move_only_function<void(int)>, void(int)> );
+
+static_assert( is_constructible_v<move_only_function<void(int)>,
+ in_place_type_t<void(*)(int)>, void(int)> );
+
+static_assert( is_constructible_v<move_only_function<void()>,
+ void() noexcept> );
+static_assert( is_constructible_v<move_only_function<void() noexcept>,
+ void() noexcept> );
+static_assert( ! is_constructible_v<move_only_function<void() noexcept>,
+ void() > );
+
+struct Q
+{
+ void operator()() const &;
+ void operator()() &&;
+};
+
+static_assert( is_constructible_v<move_only_function<void()>, Q> );
+static_assert( is_constructible_v<move_only_function<void() const>, Q> );
+static_assert( is_constructible_v<move_only_function<void() &>, Q> );
+static_assert( is_constructible_v<move_only_function<void() const &>, Q> );
+static_assert( is_constructible_v<move_only_function<void() &&>, Q> );
+static_assert( is_constructible_v<move_only_function<void() const &&>, Q> );
+
+struct R
+{
+ void operator()() &;
+ void operator()() &&;
+};
+
+static_assert( is_constructible_v<move_only_function<void()>, R> );
+static_assert( is_constructible_v<move_only_function<void()&>, R> );
+static_assert( is_constructible_v<move_only_function<void()&&>, R> );
+static_assert( ! is_constructible_v<move_only_function<void() const>, R> );
+static_assert( ! is_constructible_v<move_only_function<void() const&>, R> );
+static_assert( ! is_constructible_v<move_only_function<void() const&&>, R> );
+
+// The following nothrow-constructible guarantees are a GCC extension,
+// not required by the standard.
+
+static_assert( is_nothrow_constructible_v<move_only_function<void()>, void()>
);
+static_assert( is_nothrow_constructible_v<move_only_function<void(int)>,
+ in_place_type_t<void(*)(int)>,
+ void(int)> );
+
+// These types are all small and nothrow move constructible
+struct F { void operator()(); };
+struct G { void operator()() const; };
+static_assert( is_nothrow_constructible_v<move_only_function<void()>, F> );
+static_assert( is_nothrow_constructible_v<move_only_function<void()>, G> );
+static_assert( is_nothrow_constructible_v<move_only_function<void() const>, G>
);
+
+struct H {
+ H(int);
+ H(int, int) noexcept;
+ void operator()() noexcept;
+};
+static_assert( is_nothrow_constructible_v<move_only_function<void()>, H> );
+static_assert( is_nothrow_constructible_v<move_only_function<void() noexcept>,
+ H> );
+static_assert( ! is_nothrow_constructible_v<move_only_function<void()
noexcept>,
+ in_place_type_t<H>, int> );
+static_assert( is_nothrow_constructible_v<move_only_function<void() noexcept>,
+ in_place_type_t<H>, int, int> );
diff --git a/libstdc++-v3/testsuite/20_util/move_only_function/move.cc
b/libstdc++-v3/testsuite/20_util/move_only_function/move.cc
new file mode 100644
index 00000000000..f1f0fb597e5
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/move_only_function/move.cc
@@ -0,0 +1,109 @@
+// { dg-options "-std=gnu++23" }
+// { dg-do run { target c++23 } }
+
+#include <functional>
+#include <testsuite_hooks.h>
+
+using std::move_only_function;
+
+void
+test01()
+{
+ // Small type with non-throwing move constructor. Not allocated on the heap.
+ struct F
+ {
+ F() = default;
+ F(const F& f) : counters(f.counters) { ++counters.copy; }
+ F(F&& f) noexcept : counters(f.counters) { ++counters.move; }
+
+ F& operator=(F&&) = delete;
+
+ struct Counters
+ {
+ int copy = 0;
+ int move = 0;
+ } counters;
+
+ const Counters& operator()() const { return counters; }
+ };
+
+ F f;
+ std::move_only_function<const F::Counters&() const> m1(f);
+ VERIFY( m1().copy == 1 );
+ VERIFY( m1().move == 0 );
+
+ // This will move construct a new target object and destroy the old one:
+ auto m2 = std::move(m1);
+ VERIFY( m1 == nullptr && m2 != nullptr );
+ VERIFY( m2().copy == 1 );
+ VERIFY( m2().move == 1 );
+
+ m1 = std::move(m2);
+ VERIFY( m1 != nullptr && m2 == nullptr );
+ VERIFY( m1().copy == 1 );
+ VERIFY( m1().move == 2 );
+
+ m2 = std::move(f);
+ VERIFY( m2().copy == 0 );
+ VERIFY( m2().move == 2 ); // Move construct target object, then swap into m2.
+ const int moves = m1().move + m2().move;
+ // This will do three moves:
+ swap(m1, m2);
+ VERIFY( m1().copy == 0 );
+ VERIFY( m2().copy == 1 );
+ VERIFY( (m1().move + m2().move) == (moves + 3) );
+}
+
+void
+test02()
+{
+ // Move constructor is potentially throwing. Allocated on the heap.
+ struct F
+ {
+ F() = default;
+ F(const F& f) noexcept : counters(f.counters) { ++counters.copy; }
+ F(F&& f) noexcept(false) : counters(f.counters) { ++counters.move; }
+
+ F& operator=(F&&) = delete;
+
+ struct Counters
+ {
+ int copy = 0;
+ int move = 0;
+ } counters;
+
+ Counters operator()() const noexcept { return counters; }
+ };
+
+ F f;
+ std::move_only_function<F::Counters() const> m1(f);
+ VERIFY( m1().copy == 1 );
+ VERIFY( m1().move == 0 );
+
+ // The target object is on the heap so this just moves a pointer:
+ auto m2 = std::move(m1);
+ VERIFY( m1 == nullptr && m2 != nullptr );
+ VERIFY( m2().copy == 1 );
+ VERIFY( m2().move == 0 );
+
+ m1 = std::move(m2);
+ VERIFY( m1 != nullptr && m2 == nullptr );
+ VERIFY( m1().copy == 1 );
+ VERIFY( m1().move == 0 );
+
+ m2 = std::move(f);
+ VERIFY( m2().copy == 0 );
+ VERIFY( m2().move == 1 );
+ const int moves = m1().move + m2().move;
+ // This just swaps the pointers, so no moves:
+ swap(m1, m2);
+ VERIFY( m1().copy == 0 );
+ VERIFY( m2().copy == 1 );
+ VERIFY( (m1().move + m2().move) == moves );
+}
+
+int main()
+{
+ test01();
+ test02();
+}
diff --git a/libstdc++-v3/testsuite/20_util/move_only_function/version.cc
b/libstdc++-v3/testsuite/20_util/move_only_function/version.cc
new file mode 100644
index 00000000000..9fe52f46123
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/move_only_function/version.cc
@@ -0,0 +1,10 @@
+// { dg-options "-std=gnu++23" }
+// { dg-do compile { target c++23 } }
+
+#include <version>
+
+#ifndef __cpp_lib_move_only_function
+# error "Feature-test macro for move_only_function missing in <version>"
+#elif __cpp_lib_move_only_function != 202110L
+# error "Feature-test macro for move_only_function has wrong value in
<version>"
+#endif
