[QUESTION] Register CRTP classes

I'm deriving a class using CRTP (as I have overloaded function that are templated), and I wanted to discuss if my solution is the best way to include the classes in the Python binding. Here is the minimal example I came up with:

#include <vector>
#include <pybind11/pybind11.h>
#include <pybind11/stl.h>

namespace py = pybind11;

template <class Derived>
class BaseImpl
{
public:

    template <class T>
    T myfunc(const T& t)
    {
        return static_cast<Derived*>(this)->myfunc_impl(t);
    }

private:
    template <class T>
    T myfunc_impl(const T& t)
    {
        T ret = t;
        for (auto& i : ret) {
            i *= 2.0;
        }
        return ret;
    }
};

class Base : public BaseImpl<Base>
{
public:
    Base() = default;

private:
    friend class BaseImpl<Base>;
};

class Derived : public BaseImpl<Derived>
{
public:
    Derived() = default;

private:
    template <class T>
    T myfunc_impl(const T& t)
    {
        T ret = t;
        for (auto& i : ret) {
            i *= 3.0;
        }
        return ret;
    }

private:
    friend class BaseImpl<Derived>;
};

template <class T, class M>
auto registerBaseImpl(M& self)
{
    self.def(py::init<>())
        .def("myfunc", &T::template myfunc<std::vector<double>>);
}

PYBIND11_MODULE(mymodule, m)
{
    m.doc() = "CRTP example";

    py::class_<BaseImpl<Base>> BaseBase(m, "BaseBase");
    py::class_<BaseImpl<Derived>> BaseDerived(m, "BaseDerived");

    registerBaseImpl<BaseImpl<Base>>(BaseBase);
    registerBaseImpl<BaseImpl<Derived>>(BaseDerived);

    py::class_<Base, BaseImpl<Base>>(m, "Base")
        .def(py::init<>());

    py::class_<Derived, BaseImpl<Derived>>(m, "Derived")
        .def(py::init<>());
}

Start with the minimal C++ example, the PYBIND11_MODULE entry point, registerBaseImpl, and the py::class_ declarations shown in the issue. Determine the supported approach for registering these CRTP classes; done means a clear recommendation or concrete scope, since no file or test is named.