std::not_fn
From cppreference.com
                    
                                        
                    < cpp | utility | functional
                    
                                                            
                    | Defined in header  <functional> | ||
| template< class F> /*unspecified*/ not_fn( F&& f ); | (since C++17) | |
Creates a forwarding call wrapper that returns the complement of the callable object it holds.
| Contents | 
[edit] Parameters
| f | - | the object from which the Callableobject held by the wrapper is constructed | 
| Type requirements | ||
| - std::decay_t<F>must meet the requirements ofCallableandMoveConstructible. | ||
| -std::is_constructible_v<std::decay_t<F>, F> is required to be true | ||
[edit] Return value
A function object of unspecified type T. It has the following members:
std::not_fn return type
Member objects
The return type of std::not_fn holds a member object of type std::decay_t<F>.
Constructors
| explicit T(F&& f); | (1) | |
| T(T&& f) = default; T(const T& f) = default; | (2) | |
1) The constructor initializes the member object (of type std::decay_t<F>) from std::forward<F>(f). Throws any exception thrown by the constructor selected
2) Because std::decay_t<F> is required to be 
MoveConstructible, the returned call wrapper is always MoveConstructible, and is CopyConstructible if std::decay_t<F> is CopyConstructible. Member function operator()
| template<class... Args> auto operator()(Args&&... args) &  -> decltype(!std::declval<std::invoke_result_t<std::decay_t<F>&, Args...>>()); | (1) | |
| template<class... Args> auto operator()(Args&&... args) && -> decltype(!std::declval<std::invoke_result_t<std::decay_t<F>, Args...>>()); | (2) | |
1) Equivalent to return !std::invoke(fd, std::forward<Args>(args)...)
2) Equivalent to return !std::invoke(std::move(fd), std::forward<Args>(args)...)
where fd is the member object of type std::decay_t<F>
[edit] Exceptions
Throws no exceptions, unless the construction of fd throws.
[edit] Notes
not_fn is intended to replace the C++03-era negators std::not1 and std::not2.
[edit] See also
| (deprecated) | constructs custom std::unary_negate object (function template) | 
| (deprecated) | constructs custom std::binary_negate object (function template) | 


