diff --git a/include/pybind11/detail/init.h b/include/pybind11/detail/init.h
index 79cc930c8d..5ecf0b4b0a 100644
--- a/include/pybind11/detail/init.h
+++ b/include/pybind11/detail/init.h
@@ -201,14 +201,14 @@ void construct(value_and_holder &v_h, Alias<Class> &&result, bool) {
 template <typename... Args>
 struct constructor {
     template <typename Class, typename... Extra, enable_if_t<!Class::has_alias, int> = 0>
-    static void execute(Class &cl, const Extra &...extra) {
+    static void execute(Class &cl, Extra &&...extra) {
         cl.def(
             "__init__",
             [](value_and_holder &v_h, Args... args) {
                 v_h.value_ptr() = construct_or_initialize<Cpp<Class>>(std::forward<Args>(args)...);
             },
             is_new_style_constructor(),
-            extra...);
+            std::forward<Extra>(extra)...);
     }
 
     template <
@@ -216,7 +216,7 @@ struct constructor {
         typename... Extra,
         enable_if_t<Class::has_alias && std::is_constructible<Cpp<Class>, Args...>::value, int>
         = 0>
-    static void execute(Class &cl, const Extra &...extra) {
+    static void execute(Class &cl, Extra &&...extra) {
         cl.def(
             "__init__",
             [](value_and_holder &v_h, Args... args) {
@@ -229,7 +229,7 @@ struct constructor {
                 }
             },
             is_new_style_constructor(),
-            extra...);
+            std::forward<Extra>(extra)...);
     }
 
     template <
@@ -237,7 +237,7 @@ struct constructor {
         typename... Extra,
         enable_if_t<Class::has_alias && !std::is_constructible<Cpp<Class>, Args...>::value, int>
         = 0>
-    static void execute(Class &cl, const Extra &...extra) {
+    static void execute(Class &cl, Extra &&...extra) {
         cl.def(
             "__init__",
             [](value_and_holder &v_h, Args... args) {
@@ -245,7 +245,7 @@ struct constructor {
                     = construct_or_initialize<Alias<Class>>(std::forward<Args>(args)...);
             },
             is_new_style_constructor(),
-            extra...);
+            std::forward<Extra>(extra)...);
     }
 };
 
@@ -257,7 +257,7 @@ struct alias_constructor {
         typename... Extra,
         enable_if_t<Class::has_alias && std::is_constructible<Alias<Class>, Args...>::value, int>
         = 0>
-    static void execute(Class &cl, const Extra &...extra) {
+    static void execute(Class &cl, Extra &&...extra) {
         cl.def(
             "__init__",
             [](value_and_holder &v_h, Args... args) {
@@ -265,7 +265,7 @@ struct alias_constructor {
                     = construct_or_initialize<Alias<Class>>(std::forward<Args>(args)...);
             },
             is_new_style_constructor(),
-            extra...);
+            std::forward<Extra>(extra)...);
     }
 };
 
@@ -290,7 +290,7 @@ struct factory<Func, void_type (*)(), Return(Args...)> {
     // inheriting from the C++ type) the returned value needs to either already be an alias
     // instance, or the alias needs to be constructible from a `Class &&` argument.
     template <typename Class, typename... Extra>
-    void execute(Class &cl, const Extra &...extra) && {
+    void execute(Class &cl, Extra &&...extra) && {
 #if defined(PYBIND11_CPP14)
         cl.def(
             "__init__",
@@ -306,7 +306,7 @@ struct factory<Func, void_type (*)(), Return(Args...)> {
                     v_h, func(std::forward<Args>(args)...), Py_TYPE(v_h.inst) != v_h.type->type);
             },
             is_new_style_constructor(),
-            extra...);
+            std::forward<Extra>(extra)...);
     }
 };
 
@@ -334,7 +334,7 @@ struct factory<CFunc, AFunc, CReturn(CArgs...), AReturn(AArgs...)> {
     // The class factory is called when the `self` type passed to `__init__` is the direct
     // class (i.e. not inherited), the alias factory when `self` is a Python-side subtype.
     template <typename Class, typename... Extra>
-    void execute(Class &cl, const Extra &...extra) && {
+    void execute(Class &cl, Extra &&...extra) && {
         static_assert(Class::has_alias,
                       "The two-argument version of `py::init()` can "
                       "only be used if the class has an alias");
@@ -359,7 +359,7 @@ struct factory<CFunc, AFunc, CReturn(CArgs...), AReturn(AArgs...)> {
                 }
             },
             is_new_style_constructor(),
-            extra...);
+            std::forward<Extra>(extra)...);
     }
 };
 
@@ -409,7 +409,7 @@ struct pickle_factory<Get, Set, RetState(Self), NewInstance(ArgState)> {
     pickle_factory(Get get, Set set) : get(std::forward<Get>(get)), set(std::forward<Set>(set)) {}
 
     template <typename Class, typename... Extra>
-    void execute(Class &cl, const Extra &...extra) && {
+    void execute(Class &cl, Extra &&...extra) && {
         cl.def("__getstate__", std::move(get));
 
 #if defined(PYBIND11_CPP14)
@@ -427,7 +427,7 @@ struct pickle_factory<Get, Set, RetState(Self), NewInstance(ArgState)> {
                     v_h, func(std::forward<ArgState>(state)), Py_TYPE(v_h.inst) != v_h.type->type);
             },
             is_new_style_constructor(),
-            extra...);
+            std::forward<Extra>(extra)...);
     }
 };
 
diff --git a/include/pybind11/operators.h b/include/pybind11/operators.h
index 16a88ae171..92bcb9a671 100644
--- a/include/pybind11/operators.h
+++ b/include/pybind11/operators.h
@@ -86,20 +86,20 @@ template <op_id id, op_type ot, typename L, typename R>
 struct op_ {
     static constexpr bool op_enable_if_hook = true;
     template <typename Class, typename... Extra>
-    void execute(Class &cl, const Extra &...extra) const {
+    void execute(Class &cl, Extra &&...extra) const {
         using Base = typename Class::type;
         using L_type = conditional_t<std::is_same<L, self_t>::value, Base, L>;
         using R_type = conditional_t<std::is_same<R, self_t>::value, Base, R>;
         using op = op_impl<id, ot, Base, L_type, R_type>;
-        cl.def(op::name(), &op::execute, is_operator(), extra...);
+        cl.def(op::name(), &op::execute, is_operator(), std::forward<Extra>(extra)...);
     }
     template <typename Class, typename... Extra>
-    void execute_cast(Class &cl, const Extra &...extra) const {
+    void execute_cast(Class &cl, Extra &&...extra) const {
         using Base = typename Class::type;
         using L_type = conditional_t<std::is_same<L, self_t>::value, Base, L>;
         using R_type = conditional_t<std::is_same<R, self_t>::value, Base, R>;
         using op = op_impl<id, ot, Base, L_type, R_type>;
-        cl.def(op::name(), &op::execute_cast, is_operator(), extra...);
+        cl.def(op::name(), &op::execute_cast, is_operator(), std::forward<Extra>(extra)...);
     }
 };
 
diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
index bcdf641f43..881c9863d3 100644
--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -110,12 +110,13 @@ class cpp_function : public function {
     // NOLINTNEXTLINE(google-explicit-constructor)
     cpp_function(std::nullptr_t) {}
     cpp_function(std::nullptr_t, const is_setter &) {}
+    cpp_function(std::nullptr_t, is_setter &&) {}
 
     /// Construct a cpp_function from a vanilla function pointer
     template <typename Return, typename... Args, typename... Extra>
     // NOLINTNEXTLINE(google-explicit-constructor)
-    cpp_function(Return (*f)(Args...), const Extra &...extra) {
-        initialize(f, f, extra...);
+    cpp_function(Return (*f)(Args...), Extra &&...extra) {
+        initialize(f, f, std::forward<Extra>(extra)...);
     }
 
     /// Construct a cpp_function from a lambda function (possibly with internal state)
@@ -123,19 +124,20 @@ class cpp_function : public function {
               typename... Extra,
               typename = detail::enable_if_t<detail::is_lambda<Func>::value>>
     // NOLINTNEXTLINE(google-explicit-constructor)
-    cpp_function(Func &&f, const Extra &...extra) {
-        initialize(
-            std::forward<Func>(f), (detail::function_signature_t<Func> *) nullptr, extra...);
+    cpp_function(Func &&f, Extra &&...extra) {
+        initialize(std::forward<Func>(f),
+                   (detail::function_signature_t<Func> *) nullptr,
+                   std::forward<Extra>(extra)...);
     }
 
     /// Construct a cpp_function from a class method (non-const, no ref-qualifier)
     template <typename Return, typename Class, typename... Arg, typename... Extra>
     // NOLINTNEXTLINE(google-explicit-constructor)
-    cpp_function(Return (Class::*f)(Arg...), const Extra &...extra) {
+    cpp_function(Return (Class::*f)(Arg...), Extra &&...extra) {
         initialize(
             [f](Class *c, Arg... args) -> Return { return (c->*f)(std::forward<Arg>(args)...); },
             (Return(*)(Class *, Arg...)) nullptr,
-            extra...);
+            std::forward<Extra>(extra)...);
     }
 
     /// Construct a cpp_function from a class method (non-const, lvalue ref-qualifier)
@@ -143,21 +145,21 @@ class cpp_function : public function {
     /// but with an added `&`.
     template <typename Return, typename Class, typename... Arg, typename... Extra>
     // NOLINTNEXTLINE(google-explicit-constructor)
-    cpp_function(Return (Class::*f)(Arg...) &, const Extra &...extra) {
+    cpp_function(Return (Class::*f)(Arg...) &, Extra &&...extra) {
         initialize(
             [f](Class *c, Arg... args) -> Return { return (c->*f)(std::forward<Arg>(args)...); },
             (Return(*)(Class *, Arg...)) nullptr,
-            extra...);
+            std::forward<Extra>(extra)...);
     }
 
     /// Construct a cpp_function from a class method (const, no ref-qualifier)
     template <typename Return, typename Class, typename... Arg, typename... Extra>
     // NOLINTNEXTLINE(google-explicit-constructor)
-    cpp_function(Return (Class::*f)(Arg...) const, const Extra &...extra) {
+    cpp_function(Return (Class::*f)(Arg...) const, Extra &&...extra) {
         initialize([f](const Class *c,
                        Arg... args) -> Return { return (c->*f)(std::forward<Arg>(args)...); },
                    (Return(*)(const Class *, Arg...)) nullptr,
-                   extra...);
+                   std::forward<Extra>(extra)...);
     }
 
     /// Construct a cpp_function from a class method (const, lvalue ref-qualifier)
@@ -165,11 +167,11 @@ class cpp_function : public function {
     /// but with an added `&`.
     template <typename Return, typename Class, typename... Arg, typename... Extra>
     // NOLINTNEXTLINE(google-explicit-constructor)
-    cpp_function(Return (Class::*f)(Arg...) const &, const Extra &...extra) {
+    cpp_function(Return (Class::*f)(Arg...) const &, Extra &&...extra) {
         initialize([f](const Class *c,
                        Arg... args) -> Return { return (c->*f)(std::forward<Arg>(args)...); },
                    (Return(*)(const Class *, Arg...)) nullptr,
-                   extra...);
+                   std::forward<Extra>(extra)...);
     }
 
     /// Return the function name
@@ -1184,12 +1186,12 @@ class module_ : public object {
         details on the ``Extra&& ... extra`` argument, see section :ref:`extras`.
     \endrst */
     template <typename Func, typename... Extra>
-    module_ &def(const char *name_, Func &&f, const Extra &...extra) {
+    module_ &def(const char *name_, Func &&f, Extra &&...extra) {
         cpp_function func(std::forward<Func>(f),
                           name(name_),
                           scope(*this),
                           sibling(getattr(*this, name_, none())),
-                          extra...);
+                          std::forward<Extra>(extra)...);
         // NB: allow overwriting here because cpp_function sets up a chain with the intention of
         // overwriting (and has already checked internally that it isn't overwriting
         // non-functions).
@@ -1572,7 +1574,7 @@ class class_ : public detail::generic_type {
     PYBIND11_OBJECT(class_, generic_type, PyType_Check)
 
     template <typename... Extra>
-    class_(handle scope, const char *name, const Extra &...extra) {
+    class_(handle scope, const char *name, Extra &&...extra) {
         using namespace detail;
 
         // MI can only be specified via class_ template options, not constructor parameters
@@ -1601,7 +1603,7 @@ class class_ : public detail::generic_type {
         PYBIND11_EXPAND_SIDE_EFFECTS(add_base<options>(record));
 
         /* Process optional arguments, if any */
-        process_attributes<Extra...>::init(extra..., &record);
+        process_attributes<Extra...>::init(std::forward<Extra>(extra)..., &record);
 
         generic_type::initialize(record);
 
@@ -1627,65 +1629,65 @@ class class_ : public detail::generic_type {
     static void add_base(detail::type_record &) {}
 
     template <typename Func, typename... Extra>
-    class_ &def(const char *name_, Func &&f, const Extra &...extra) {
+    class_ &def(const char *name_, Func &&f, Extra &&...extra) {
         cpp_function cf(method_adaptor<type>(std::forward<Func>(f)),
                         name(name_),
                         is_method(*this),
                         sibling(getattr(*this, name_, none())),
-                        extra...);
+                        std::forward<Extra>(extra)...);
         add_class_method(*this, name_, cf);
         return *this;
     }
 
     template <typename Func, typename... Extra>
-    class_ &def_static(const char *name_, Func &&f, const Extra &...extra) {
+    class_ &def_static(const char *name_, Func &&f, Extra &&...extra) {
         static_assert(!std::is_member_function_pointer<Func>::value,
                       "def_static(...) called with a non-static member function pointer");
         cpp_function cf(std::forward<Func>(f),
                         name(name_),
                         scope(*this),
                         sibling(getattr(*this, name_, none())),
-                        extra...);
+                        std::forward<Extra>(extra)...);
         auto cf_name = cf.name();
         attr(std::move(cf_name)) = staticmethod(std::move(cf));
         return *this;
     }
 
     template <typename T, typename... Extra, detail::enable_if_t<T::op_enable_if_hook, int> = 0>
-    class_ &def(const T &op, const Extra &...extra) {
-        op.execute(*this, extra...);
+    class_ &def(const T &op, Extra &&...extra) {
+        op.execute(*this, std::forward<Extra>(extra)...);
         return *this;
     }
 
     template <typename T, typename... Extra, detail::enable_if_t<T::op_enable_if_hook, int> = 0>
-    class_ &def_cast(const T &op, const Extra &...extra) {
-        op.execute_cast(*this, extra...);
+    class_ &def_cast(const T &op, Extra &&...extra) {
+        op.execute_cast(*this, std::forward<Extra>(extra)...);
         return *this;
     }
 
     template <typename... Args, typename... Extra>
-    class_ &def(const detail::initimpl::constructor<Args...> &init, const Extra &...extra) {
+    class_ &def(const detail::initimpl::constructor<Args...> &init, Extra &&...extra) {
         PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(init);
-        init.execute(*this, extra...);
+        init.execute(*this, std::forward<Extra>(extra)...);
         return *this;
     }
 
     template <typename... Args, typename... Extra>
-    class_ &def(const detail::initimpl::alias_constructor<Args...> &init, const Extra &...extra) {
+    class_ &def(const detail::initimpl::alias_constructor<Args...> &init, Extra &&...extra) {
         PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(init);
-        init.execute(*this, extra...);
+        init.execute(*this, std::forward<Extra>(extra)...);
         return *this;
     }
 
     template <typename... Args, typename... Extra>
-    class_ &def(detail::initimpl::factory<Args...> &&init, const Extra &...extra) {
-        std::move(init).execute(*this, extra...);
+    class_ &def(detail::initimpl::factory<Args...> &&init, Extra &&...extra) {
+        std::move(init).execute(*this, std::forward<Extra>(extra)...);
         return *this;
     }
 
     template <typename... Args, typename... Extra>
-    class_ &def(detail::initimpl::pickle_factory<Args...> &&pf, const Extra &...extra) {
-        std::move(pf).execute(*this, extra...);
+    class_ &def(detail::initimpl::pickle_factory<Args...> &&pf, Extra &&...extra) {
+        std::move(pf).execute(*this, std::forward<Extra>(extra)...);
         return *this;
     }
 
@@ -1723,88 +1725,96 @@ class class_ : public detail::generic_type {
     }
 
     template <typename C, typename D, typename... Extra>
-    class_ &def_readwrite(const char *name, D C::*pm, const Extra &...extra) {
+    class_ &def_readwrite(const char *name, D C::*pm, Extra &&...extra) {
         static_assert(std::is_same<C, type>::value || std::is_base_of<C, type>::value,
                       "def_readwrite() requires a class member (or base class member)");
         cpp_function fget([pm](const type &c) -> const D & { return c.*pm; }, is_method(*this)),
             fset([pm](type &c, const D &value) { c.*pm = value; }, is_method(*this));
-        def_property(name, fget, fset, return_value_policy::reference_internal, extra...);
+        def_property(name,
+                     fget,
+                     fset,
+                     return_value_policy::reference_internal,
+                     std::forward<Extra>(extra)...);
         return *this;
     }
 
     template <typename C, typename D, typename... Extra>
-    class_ &def_readonly(const char *name, const D C::*pm, const Extra &...extra) {
+    class_ &def_readonly(const char *name, const D C::*pm, Extra &&...extra) {
         static_assert(std::is_same<C, type>::value || std::is_base_of<C, type>::value,
                       "def_readonly() requires a class member (or base class member)");
         cpp_function fget([pm](const type &c) -> const D & { return c.*pm; }, is_method(*this));
-        def_property_readonly(name, fget, return_value_policy::reference_internal, extra...);
+        def_property_readonly(
+            name, fget, return_value_policy::reference_internal, std::forward<Extra>(extra)...);
         return *this;
     }
 
     template <typename D, typename... Extra>
-    class_ &def_readwrite_static(const char *name, D *pm, const Extra &...extra) {
+    class_ &def_readwrite_static(const char *name, D *pm, Extra &&...extra) {
         cpp_function fget([pm](const object &) -> const D & { return *pm; }, scope(*this)),
             fset([pm](const object &, const D &value) { *pm = value; }, scope(*this));
-        def_property_static(name, fget, fset, return_value_policy::reference, extra...);
+        def_property_static(
+            name, fget, fset, return_value_policy::reference, std::forward<Extra>(extra)...);
         return *this;
     }
 
     template <typename D, typename... Extra>
-    class_ &def_readonly_static(const char *name, const D *pm, const Extra &...extra) {
+    class_ &def_readonly_static(const char *name, const D *pm, Extra &&...extra) {
         cpp_function fget([pm](const object &) -> const D & { return *pm; }, scope(*this));
-        def_property_readonly_static(name, fget, return_value_policy::reference, extra...);
+        def_property_readonly_static(
+            name, fget, return_value_policy::reference, std::forward<Extra>(extra)...);
         return *this;
     }
 
     /// Uses return_value_policy::reference_internal by default
     template <typename Getter, typename... Extra>
-    class_ &def_property_readonly(const char *name, const Getter &fget, const Extra &...extra) {
+    class_ &def_property_readonly(const char *name, const Getter &fget, Extra &&...extra) {
         return def_property_readonly(name,
                                      cpp_function(method_adaptor<type>(fget)),
                                      return_value_policy::reference_internal,
-                                     extra...);
+                                     std::forward<Extra>(extra)...);
     }
 
     /// Uses cpp_function's return_value_policy by default
     template <typename... Extra>
-    class_ &
-    def_property_readonly(const char *name, const cpp_function &fget, const Extra &...extra) {
-        return def_property(name, fget, nullptr, extra...);
+    class_ &def_property_readonly(const char *name, const cpp_function &fget, Extra &&...extra) {
+        return def_property(name, fget, nullptr, std::forward<Extra>(extra)...);
     }
 
     /// Uses return_value_policy::reference by default
     template <typename Getter, typename... Extra>
-    class_ &
-    def_property_readonly_static(const char *name, const Getter &fget, const Extra &...extra) {
-        return def_property_readonly_static(
-            name, cpp_function(fget), return_value_policy::reference, extra...);
+    class_ &def_property_readonly_static(const char *name, const Getter &fget, Extra &&...extra) {
+        return def_property_readonly_static(name,
+                                            cpp_function(fget),
+                                            return_value_policy::reference,
+                                            std::forward<Extra>(extra)...);
     }
 
     /// Uses cpp_function's return_value_policy by default
     template <typename... Extra>
-    class_ &def_property_readonly_static(const char *name,
-                                         const cpp_function &fget,
-                                         const Extra &...extra) {
-        return def_property_static(name, fget, nullptr, extra...);
+    class_ &
+    def_property_readonly_static(const char *name, const cpp_function &fget, Extra &&...extra) {
+        return def_property_static(name, fget, nullptr, std::forward<Extra>(extra)...);
     }
 
     /// Uses return_value_policy::reference_internal by default
     template <typename Getter, typename Setter, typename... Extra>
     class_ &
-    def_property(const char *name, const Getter &fget, const Setter &fset, const Extra &...extra) {
-        return def_property(
-            name, fget, cpp_function(method_adaptor<type>(fset), is_setter()), extra...);
+    def_property(const char *name, const Getter &fget, const Setter &fset, Extra &&...extra) {
+        return def_property(name,
+                            fget,
+                            cpp_function(method_adaptor<type>(fset), is_setter()),
+                            std::forward<Extra>(extra)...);
     }
     template <typename Getter, typename... Extra>
     class_ &def_property(const char *name,
                          const Getter &fget,
                          const cpp_function &fset,
-                         const Extra &...extra) {
+                         Extra &&...extra) {
         return def_property(name,
                             cpp_function(method_adaptor<type>(fget)),
                             fset,
                             return_value_policy::reference_internal,
-                            extra...);
+                            std::forward<Extra>(extra)...);
     }
 
     /// Uses cpp_function's return_value_policy by default
@@ -1812,8 +1822,9 @@ class class_ : public detail::generic_type {
     class_ &def_property(const char *name,
                          const cpp_function &fget,
                          const cpp_function &fset,
-                         const Extra &...extra) {
-        return def_property_static(name, fget, fset, is_method(*this), extra...);
+                         Extra &&...extra) {
+        return def_property_static(
+            name, fget, fset, is_method(*this), std::forward<Extra>(extra)...);
     }
 
     /// Uses return_value_policy::reference by default
@@ -1821,9 +1832,12 @@ class class_ : public detail::generic_type {
     class_ &def_property_static(const char *name,
                                 const Getter &fget,
                                 const cpp_function &fset,
-                                const Extra &...extra) {
-        return def_property_static(
-            name, cpp_function(fget), fset, return_value_policy::reference, extra...);
+                                Extra &&...extra) {
+        return def_property_static(name,
+                                   cpp_function(fget),
+                                   fset,
+                                   return_value_policy::reference,
+                                   std::forward<Extra>(extra)...);
     }
 
     /// Uses cpp_function's return_value_policy by default
@@ -1831,7 +1845,7 @@ class class_ : public detail::generic_type {
     class_ &def_property_static(const char *name,
                                 const cpp_function &fget,
                                 const cpp_function &fset,
-                                const Extra &...extra) {
+                                Extra &&...extra) {
         static_assert(0 == detail::constexpr_sum(std::is_base_of<arg, Extra>::value...),
                       "Argument annotations are not allowed for properties");
         auto rec_fget = get_function_record(fget), rec_fset = get_function_record(fset);
@@ -2238,8 +2252,8 @@ class enum_ : public class_<Type> {
                                          Underlying>;
 
     template <typename... Extra>
-    enum_(const handle &scope, const char *name, const Extra &...extra)
-        : class_<Type>(scope, name, extra...), m_base(*this, scope) {
+    enum_(const handle &scope, const char *name, Extra &&...extra)
+        : class_<Type>(scope, name, std::forward<Extra>(extra)...), m_base(*this, scope) {
         constexpr bool is_arithmetic = detail::any_of<std::is_same<arithmetic, Extra>...>::value;
         constexpr bool is_convertible = std::is_convertible<Type, Underlying>::value;
         m_base.init(is_arithmetic, is_convertible);