ofats / any_invocable

Сonservative, move-only equivalent of std::function

any_invocable

One of possible implementations of std::any_invocable proposed in P0288R5.

This paper proposes a conservative, move-only equivalent of std::function.

Current build

Motivating Example

Such a code:

// requires: C++14
#include <functional>
#include <memory>

struct widget {
    // ...
};

int main() {
    std::function<void()> f = [w_ptr = std::make_unique<widget>()] { /*...*/ };
}

Will result in:

error: use of deleted function ‘std::unique_ptr<_Tp, _Dp>::unique_ptr(const std::unique_ptr<_Tp, _Dp>&) [with _Tp = widget; _Dp = std::default_delete<widget>]

In other words, we can't store move-only callables in std::function.

At the same time such a code will work:

std::any_invocable<void()> f = [w_ptr = std::make_unique<widget>()] { /*...*/ };

any_invocable's Issues

const any_invocable seems to be uninvokable

Not sure if this is an issue with the implementation or I did something wrong.

Trying to invoke const ofats::any_invocable<void()> or const ofats::any_invocable<void() const> results in compilation errors. The former because matching call operator could not be found, the latter is because any_invocable_impl::call doesn't have a const variant. Please see an example on godbolt: https://godbolt.org/z/Wczddnsoh

The const qualifier comes from being a member of a class and being invoked in const function, like:

struct stuff
{
  void call() const { f(); }
  ofats::any_invocable<void()> f; // or `void() const`
}

Clarify license

Nice early preview,

What's the license?

Remove extra semicolons

I'm using your implementation now. It compiles now. I did apply the linked patch to silence pedantic warnings: uNetworking/uWebSockets@d13aac1

std::vector incompatible?

The following fails to compile on macOS Clang but does compile on Linux (both GCC and Clang):

    std::vector<ofats::any_invocable<void()>> v;
    
    v.emplace_back([]() {
    
    });

You can test with GitHub Actions on macos-latest. This code should compile, right?