[func.wrap.move.ctor]

🔗

template<class VT>
  static constexpr bool is-callable-from = see below;

If noex is true, is-callable-from<VT> is equal to: is_nothrow_invocable_r_v<R, VT cv ref, ArgTypes..> && is_nothrow_invocable_r_v<R, VT inv-quals, ArgTypes..>

Otherwise, is-callable-from<VT> is equal to: is_invocable_r_v<R, VT cv ref, ArgTypes..> && is_invocable_r_v<R, VT inv-quals, ArgTypes..>

🔗

move_only_function() noexcept;
move_only_function(nullptr_t) noexcept;

Postconditions: *this has no target object.

🔗

move_only_function(move_only_function&& f) noexcept;

Postconditions: The target object of *this is the target object f had before construction, and f is in a valid state with an unspecified value.

🔗

template<class F> move_only_function(F&& f);

Preconditions: VT meets the Cpp17Destructible requirements, and if is_move_constructible_v<VT> is true, VT meets the Cpp17MoveConstructible requirements.

Postconditions: *this has no target object if any of the following hold:

(8.1)
f is a null function pointer value,
(8.2)
f is a null member pointer value, or
(8.3)
remove_cvref_t<F> is a specialization of the move_only_function or copyable_function class template, and f has no target object.

Otherwise, *this has a target object of type VT direct-non-list-initialized with std::forward<F>(f).

Throws: Any exception thrown by the initialization of the target object.

May throw bad_alloc unless VT is a function pointer or a specialization of reference_wrapper.

🔗

template<class T, class. Args>
  explicit move_only_function(in_place_type_t<T>, Args&&. args);

Preconditions: VT meets the Cpp17Destructible requirements, and if is_move_constructible_v<VT> is true, VT meets the Cpp17MoveConstructible requirements.

Postconditions: *this has a target object of type VT direct-non-list-initialized with std::forward<Args>(args)..

Throws: Any exception thrown by the initialization of the target object.

May throw bad_alloc unless VT is a function pointer or a specialization of reference_wrapper.

🔗

template<class T, class U, class. Args>
  explicit move_only_function(in_place_type_t<T>, initializer_list<U> ilist, Args&&. args);

Constraints:

(17.1)
is_constructible_v<VT, initializer_list<U>&, Args..> is true, and
(17.2)
is-callable-from<VT> is true.

Preconditions: VT meets the Cpp17Destructible requirements, and if is_move_constructible_v<VT> is true, VT meets the Cpp17MoveConstructible requirements.

Postconditions: *this has a target object of type VT direct-non-list-initialized with ilist, std::forward<Args>(args)..

Throws: Any exception thrown by the initialization of the target object.

May throw bad_alloc unless VT is a function pointer or a specialization of reference_wrapper.

🔗

move_only_function& operator=(move_only_function&& f);

Returns: *this.

🔗

move_only_function& operator=(nullptr_t) noexcept;

Returns: *this.

🔗

template<class F> move_only_function& operator=(F&& f);

Returns: *this.

🔗

~move_only_function();

Effects: Destroys the target object of *this, if any.

22 General utilities library [utilities]

22.10 Function objects [function.objects]

22.10.17 Polymorphic function wrappers [func.wrap]

22.10.17.4 Move-only wrapper [func.wrap.move]

22.10.17.4.3 Constructors, assignments, and destructor [func.wrap.move.ctor]