A C++17 std::function implementation

Question

Some time ago I implemented dynamic_array and posted it on Code Review. It used std::function internally for type erasure. This inspired me to implement a standard-conforming std::function myself. This is just a showcase of how static polymorphism with templates can play well with dynamic polymorphism with inheritance and virtual functions.

Incidentally, some time ago I implemented std::invoke and my own invoke_r and also posted it on Code Review. Internally, function uses invoke_r. Its implementation is very short, so I included it as part of the code.

Here is the function.hpp header: (the deduction guide was really painful to write)

// C++17 std::function implementation
// [func.wrap] and [depr.func.adaptor.typedefs]

#ifndef INC_FUNCTION_HPP_QLxVtsa5Mv
#define INC_FUNCTION_HPP_QLxVtsa5Mv

#include <cstddef>
#include <exception>
#include <functional>
#include <memory>
#include <typeinfo>
#include <type_traits>

namespace my_std {

  // [func.wrap.badcall], class bad_function_call
  struct bad_function_call :std::exception {
    // [func.wrap.badcall.const], constructor
    bad_function_call() = default;
  };

  // [func.wrap.func], class template function
  template <class F>
  class function; // not defined

  namespace detail {
    // [depr.func.adaptor.typedefs], typedefs to support function binders
    template <class... Args>
    struct function_base {};
    template <class T>
    struct function_base<T> {
      using argument_type [[deprecated]] = T;
    };
    template <class T, class U>
    struct function_base<T, U> {
      using first_argument_type [[deprecated]] = T;
      using second_argument_type [[deprecated]] = U;
    };

    // trait to check if a type is a pointer to function
    template <class T>
    struct is_function_pointer :std::false_type {};
    template <class T>
    struct is_function_pointer<T*> :std::is_function<T> {};
    template <class T>
    inline constexpr bool is_function_pointer_v = is_function_pointer<T>::value;

    // trait to check if a type is a specialization of the class template function
    template <class T>
    struct is_function :std::false_type {};
    template <class T>
    struct is_function<function<T>> :std::true_type {};
    template <class T>
    inline constexpr bool is_function_v = is_function<T>::value;

    // INVOKE<R>(f, args...), see [func.require]/2
    template <class R, class F, class... Args>
    R invoke_r(F&& f, Args&&... args)
      noexcept(std::is_nothrow_invocable_r_v<R, F, Args...>)
    {
      if constexpr (std::is_void_v<R>)
        return static_cast<void>(
            std::invoke(std::forward<F>(f), std::forward<Args>(args)...)
          );
      else
        return std::invoke(std::forward<F>(f), std::forward<Args>(args)...);
    }

    // polymorphic base for callable wrappers
    template <class R, class... Args>
    struct callable_base {
      virtual ~callable_base() {}
      virtual R invoke(Args...) const = 0;
      virtual std::unique_ptr<callable_base> clone() const = 0;
      virtual const std::type_info& target_type() const noexcept = 0;
      virtual void* target() const noexcept = 0;
    };

    // callable wrapper
    template <class F, class R, class... Args>
    struct callable :callable_base<R, Args...> {
      using Base = callable_base<R, Args...>;
    public:
      callable(F f)
        :func{std::move(f)}
      {
      }

      ~callable() {}

      R invoke(Args... args) const override
      {
        return invoke_r<R>(func, std::forward<Args>(args)...);
      }

      std::unique_ptr<Base> clone() const override
      {
        return std::unique_ptr<Base>{new callable{func}};
      }

      const std::type_info& target_type() const noexcept override
      {
        return typeid(F);
      }

      void* target() const noexcept override
      {
        return &func;
      }

    private:
      mutable F func;
    };
  }

  // [func.wrap.func], class template function
  template <class R, class... Args>
  class function<R(Args...)> :public detail::function_base<Args...> {
  public:
    using result_type = R;

    // [func.wrap.func.con], construct/copy/destroy
    function() noexcept
    {
    }

    function(std::nullptr_t) noexcept
    {
    }

    function(const function& f)
      :func{f ? f.func->clone() : nullptr}
    {
    }

    function(function&& f) noexcept // strengthened
    {
      swap(f);
    }

    template <class F,
              std::enable_if_t<std::is_invocable_r_v<R, F&, Args...>, int> = 0>
    function(F f)
    {
      if constexpr (detail::is_function_pointer_v<F> ||
                    std::is_member_pointer_v<F> ||
                    detail::is_function_v<F>) {
        if (!f) return;
      }

      func.reset(new detail::callable<F, R, Args...>{std::move(f)});
    }

    function& operator=(const function& f)
    {
      function{f}.swap(*this);
      return *this;
    }

    function& operator=(function&& f)
    {
      swap(f);
      return *this;
    }

    function& operator=(std::nullptr_t) noexcept
    {
      func.reset();
      return *this;
    }

    template <class F,
              std::enable_if_t<
                std::is_invocable_r_v<R, std::decay_t<F>&, Args...>,
                int> = 0>
    function& operator=(F&& f)
    {
      function{std::forward<F>(f)}.swap(*this);
      return *this;
    }

    template <class F>
    function& operator=(std::reference_wrapper<F> f) noexcept
    {
      function{f}.swap(*this);
      return *this;
    }

    ~function() = default;

    // [func.wrap.func.mod], function modifiers
    void swap(function& other) noexcept
    {
      using std::swap;
      swap(func, other.func);
    }

    // [func.wrap.func.cap], function capacity
    explicit operator bool() const noexcept
    {
      return static_cast<bool>(func);
    }

    // [func.wrap.func.inv], function invocation
    R operator()(Args... args) const
    {
      if (*this)
        return func->invoke(std::forward<Args>(args)...);
      else
        throw bad_function_call{};
    }

    // [func.wrap.func.targ], function target access
    const type_info& target_type() const noexcept
    {
      if (*this)
        return func->target_type();
      else
        return typeid(void);
    }

    template <class T>
    T* target() noexcept
    {
      if (target_type() == typeid(T))
        return reinterpret_cast<T*>(func->target());
      else
        return nullptr;
    }

    template <class T>
    const T* target() const noexcept
    {
      if (target_type() == typeid(T))
        return reinterpret_cast<const T*>(func->target());
      else
        return nullptr;
    }

  private:
    std::unique_ptr<detail::callable_base<R, Args...>> func = nullptr;
  };

  namespace detail {
    template <typename T>
    struct deduce_function {};
    template <typename T>
    using deduce_function_t = typename deduce_function<T>::type;

    template <typename G, typename R, typename... Args>
    struct deduce_function<R (G::*)(Args...)> {
      using type = R(Args...);
    };
    template <typename G, typename R, typename... Args>
    struct deduce_function<R (G::*)(Args...) const> {
      using type = R(Args...);
    };
    template <typename G, typename R, typename... Args>
    struct deduce_function<R (G::*)(Args...) volatile> {
      using type = R(Args...);
    };
    template <typename G, typename R, typename... Args>
    struct deduce_function<R (G::*)(Args...) const volatile> {
      using type = R(Args...);
    };
    template <typename G, typename R, typename... Args>
    struct deduce_function<R (G::*)(Args...) &> {
      using type = R(Args...);
    };
    template <typename G, typename R, typename... Args>
    struct deduce_function<R (G::*)(Args...) const &> {
      using type = R(Args...);
    };
    template <typename G, typename R, typename... Args>
    struct deduce_function<R (G::*)(Args...) volatile &> {
      using type = R(Args...);
    };
    template <typename G, typename R, typename... Args>
    struct deduce_function<R (G::*)(Args...) const volatile &> {
      using type = R(Args...);
    };
    template <typename G, typename R, typename... Args>
    struct deduce_function<R (G::*)(Args...) noexcept> {
      using type = R(Args...);
    };
    template <typename G, typename R, typename... Args>
    struct deduce_function<R (G::*)(Args...) const noexcept> {
      using type = R(Args...);
    };
    template <typename G, typename R, typename... Args>
    struct deduce_function<R (G::*)(Args...) volatile noexcept> {
      using type = R(Args...);
    };
    template <typename G, typename R, typename... Args>
    struct deduce_function<R (G::*)(Args...) const volatile noexcept> {
      using type = R(Args...);
    };
    template <typename G, typename R, typename... Args>
    struct deduce_function<R (G::*)(Args...) & noexcept> {
      using type = R(Args...);
    };
    template <typename G, typename R, typename... Args>
    struct deduce_function<R (G::*)(Args...) const & noexcept> {
      using type = R(Args...);
    };
    template <typename G, typename R, typename... Args>
    struct deduce_function<R (G::*)(Args...) volatile & noexcept> {
      using type = R(Args...);
    };
    template <typename G, typename R, typename... Args>
    struct deduce_function<R (G::*)(Args...) const volatile & noexcept> {
      using type = R(Args...);
    };
  }

  template <class R, class... Args>
  function(R (*)(Args...)) -> function<R(Args...)>;

  template <class F, class Op = decltype(&F::operator())>
  function(F) -> function<detail::deduce_function_t<Op>>;

  // [func.wrap.func.nullptr], null pointer comparisons
  template <class R, class... Args>
  bool operator==(const function<R(Args...)>& f, std::nullptr_t) noexcept
  {
    return !f;
  }
  template <class R, class... Args>
  bool operator==(std::nullptr_t, const function<R(Args...)>& f) noexcept
  {
    return !f;
  }
  template <class R, class... Args>
  bool operator!=(const function<R(Args...)>& f, std::nullptr_t) noexcept
  {
    return static_cast<bool>(f);
  }
  template <class R, class... Args>
  bool operator!=(std::nullptr_t, const function<R(Args...)>& f) noexcept
  {
    return static_cast<bool>(f);
  }

  // [func.wrap.func.alg], specialized algorithms
  template <class R, class... Args>
  void swap(function<R(Args...)>& lhs, function<R(Args...)>& rhs) noexcept
  {
    lhs.swap(rhs);
  }

}

#endif

Answer 1

Nice, clean and functional.
Still, there are a few things:

1. If you don't have to declare a special member-function, just don't:
   bad_function_call::bad_function_call(), callable::~callable(), and function::~function() are superfluous.

2. If you actually have to declare a special member-function, explicitly default it in-class where that is enough:
   callable_base::~ callable_base(), and function::function() should be explicitly defaulted.

3. Consider investing in small-object-optimization. Yes, it will make the code a bit more complicated, but on the flip-side it should result in much improved efficiency. Also, it is mandatory.

4. Consider using the null-object-pattern to pare down on checks. There is considerable synergy with the previous point.

5. You can replace (most of) your uses of static_cast<bool>() with double-negation.

6. Personally, I prefer a bigger indentation-step, but whatever. Also, not having colon : followed by any whitespace takes some getting used to.