std::function alternative with no dependencies

Question

An alternative to std::function for when compile time is more important than runtime performance. Doesn't pull in any headers.

(#include <functional> pulls in 19k lines of code.)

This satisfies my needs, but I'm curious how it could be improved (without adding any dependencies).

template<typename>
class func;

// Alternative to std::function for when compile time is
// more important than runtime performance. Doesn't pull in
// any headers.
template<typename Result, typename... Arguments>
class func<Result (Arguments...)> {

  struct holder {
    virtual ~holder() {}
    virtual Result call(Arguments...) = 0;
    virtual holder* clone() = 0;
  };

  template<typename Lambda>
  struct lambda_holder : public holder {
    virtual ~lambda_holder() {}
    Lambda lambda;
    lambda_holder(Lambda l) : lambda(l) { }
    Result call(Arguments... args) override {
      return lambda(args...);
    }
    holder* clone() override {
      return new lambda_holder<Lambda>(lambda);
    }
  };

public:

  func() { }

  func(const func& f) {
    holder = f.holder->clone();
  }

  func& operator=(const func& f) {
    if(holder) { delete holder; }
    holder = f.holder ? f.holder->clone() : nullptr;
    return *this;
  }

  // Create from a lambda.
  template<class F>
  func(F f) {
    holder = new lambda_holder<F>{f};
  }

  ~func() {
    if(holder) { delete holder; }
  }

  Result operator()(Arguments... args) const {
    assert(holder);
    return holder->call(args...);
  }

  operator bool() const {
    return holder;
  }

private:

  holder *holder = nullptr;

};

Answer 1

1. Self-assignment may be expensive, but it should be a no-op instead of UB. I suggest copy-and-swap.

2. Omitting move-semantics will most certainly cost you.

3. Your naming of the internal class suggests all callables are lambdas. Not true!

4. You cannot store any move-only callables. Admittedly std::function is also crippled in that respect. Just throw an exception if the non-copyable object needs to be copied.

5. If your function has return-type void, it should simply discard the callables return-value. You don't.

6. std::function throws an exception if empty when called. Using assert() is less than a pale imitation.

7. delete p; if p is a null pointer is a no-op. No need to double-check.

8. Conversion to bool should be explicit. Otherwise, conversion to any arithmetic type can happen.

9. As you said, yours is less efficient. That's especially the case when std::function benefits from mandatory small-object-optimization.

10. You don't use SFINAE when creating from a callable. That can be inconvenient.