Update README

Author: peacalm

CHANGELOG.md

@@ -3,8 +3,8 @@
 
 ## Currently Unreleased - TBD
 
-* Add static assertion to explicitly forbid using reference type as return type 
-or argument type in `luaw::function`.
+* Add static assertion to explicitly forbid using non-const lvalue reference 
+as argument or using any reference as return for `luaw::function`.
 * Add new class `subluaw`, and add method `luaw::make_subluaw`.
 * add method `luaw::function::unref`, `luaw::function::ref_id` etc.
 * Add method `luavalueref::setglobal`, `luavalueref::unref` etc. 

README.md

@@ -954,6 +954,9 @@ l.set("co", co); // set const instance by copy
 l.set("co", std::move(co)); // set const instance by move
 // or
 l.set("co", std::add_const_t<Obj>{}); // set const instance by move
+// or
+l.set<const Obj>("co", o); // copy non-const "o" to a const instance
+
 // The variable "co" is const, it can access all registered members variables 
 // and registered const member functins of Obj.
 ```
@@ -1903,24 +1906,27 @@ if (f.failed()) {
 
 #### 3.3 Type of argument and return
 
-Do not support using C++ reference type as function's argument or return type.
-      
-If using reference as argument, it will make a copy of the referenced 
-argument into Lua, won't implicitly take its address, meaning that it 
-will not share the same object in Lua with that in C++, and this 
-behaves differently with that in C++. This may confuse users, so 
-explicitly forbid it. 
+##### Argument
 
-Directly using the underlying type if you want to make a copy of the 
-argument into Lua. 
+Do not support non-const lvalue reference as luaw::function's argument.
+
+If using this kind of reference, it will make a copy of the referenced 
+argument into Lua, won't implicitly take its address, meaning that it 
+will not share the same object in Lua with C++. 
+And this behaves differently with that in C++. This may confuse users, 
+so explicitly forbid it. 
 
-Or if you want to share the same argument objects in Lua with C++, 
+If you want to share the same argument objects in Lua with C++, 
 so you can modify them in Lua, you can use raw pointer type if there is 
 only one kind of raw pointer type in all arguments, or use smart 
-pointer type or `luaw::ptrw` type, and these are safer and more reassuring.
+pointer type or `peacalm::luaw::ptrw` type, and these two are safer and 
+more reassuring.
+
+##### Return
 
 Since we cannot make C++ reference type of reference to values in Lua,
-so using C++ reference type as return type is also forbidden.
+so using any C++ reference type as return type is forbidden.
+
 To get a reference of a Lua value, can use type 
 [`luaw::luavalueref`](https://github.com/peacalm/cpp-luaw?tab=readme-ov-file#9-reference-of-lua-values-in-c).
 
@@ -3173,38 +3179,50 @@ int main() {
 ##### Set const instances to Lua
 
 Const property of an instance in C++ will be perfectly transfered to Lua using
-"set" method.
+`set` method (if `Hint` was not provided).
+
+Or explicitly provide a const type as `Hint` then `set` will construct a const 
+instance by a given value, which must be convertible to type `Hint`.
+
 
 Example:
 
 ```C++
+
+// ==== Set const instance:
 const Obj co;
 l.set("co", co); // set const instance by copy
 // or
 l.set("co", std::move(co)); // set const instance by move
 // or
 l.set("co", std::add_const_t<Obj>{}); // set const instance by move
 // or
+l.set<const Obj>("co", Obj{}); // copy non-const instance to be a const instance
+
+// ==== Set raw pointer of const instance:
 const Obj co2;
 // set low-level const pointer to be a lightuserdata which is also const
-l.set("co", &co2); 
-// The variable "co" (set by any method above) is const in Lua, 
-// it can access all registered member variables (but can't modify) and 
-// registered const member functins of Obj.
+l.set("cop", &co2); 
 
-
-// Set underlying const instance using smart pointer.
+// ==== Set underlying const instance using smart pointer:
 // "sco" is not const, by it's underlying object is const,
 // so it behaves same as "co":
 auto sco = std::make_shared<const Obj>();
 l.set("sco", sco); // by copy
 l.set("sco", std::move(sco)); // by move
 l.set("sco", std::make_shared<const Obj>()); // by move
-// or
+
+// ==== Set raw pointer of smart pointer:
 auto sco2 = std::make_shared<const Obj>();
-l.set("sco", &sco2); // set as lightuserdata, also underlying const
+l.set("scop", &sco2); // set as lightuserdata, also underlying const
+
 ```
 
+The variables set by methods above can read all registered member variables 
+and call registered const member functins of `Obj`.
+But can't modify member variables and can't call non-const member functions.
+
+
 #### 5.10 Get instances from Lua
 
 Use "get" method, we can get an instance or a pointer of an instance from Lua.

include/peacalm/luaw.h

@@ -3931,7 +3931,8 @@ struct luaw::convertor<luaw::placeholder_tag> {
 
 namespace luaw_detail {
 
-// Has any reference type in a std::tuple
+// Whether the type T is a std::tuple and has element of reference type.
+
 template <typename T>
 struct tuple_has_ref : std::false_type {};
 
@@ -3945,31 +3946,47 @@ struct tuple_has_ref<std::tuple<T, Ts...>>
 template <>
 struct tuple_has_ref<std::tuple<>> : std::false_type {};
 
-// Has any reference type in Ts
+// Whether the type T is a std::tuple and has element of non-const lvalue
+// reference type.
+
+template <typename T>
+struct tuple_has_non_const_lvalue_ref : std::false_type {};
+
+template <typename T, typename... Ts>
+struct tuple_has_non_const_lvalue_ref<std::tuple<T, Ts...>>
+    : public std::integral_constant<
+          bool,
+          (std::is_lvalue_reference<T>::value &&
+           !std::is_const<std::remove_reference_t<T>>::value) ||
+              tuple_has_non_const_lvalue_ref<std::tuple<Ts...>>::value> {};
+
+template <>
+struct tuple_has_non_const_lvalue_ref<std::tuple<>> : std::false_type {};
+
+// Whether have any non-const lvalue reference type in Ts
 template <typename... Ts>
-struct has_ref : public tuple_has_ref<std::tuple<Ts...>> {};
+struct has_non_const_lvalue_ref
+    : public tuple_has_non_const_lvalue_ref<std::tuple<Ts...>> {};
 
 }  // namespace luaw_detail
 
 template <typename Return, typename... Args>
 class luaw::function<Return(Args...)> {
   static_assert(
-      !luaw_detail::has_ref<Args...>::value,
-      "Do not support reference type as luaw::function's argument. "
+      !luaw_detail::has_non_const_lvalue_ref<Args...>::value,
+      "Do not support non-const lvalue reference as luaw::function's argument. "
       ""
-      "If using reference as argument, it will make a copy of the referenced "
+      "If using this kind of reference, it will make a copy of the referenced "
       "argument into Lua, won't implicitly take its address, meaning that it "
-      "will not share the same object in Lua with that in C++, and this "
-      "behaves differently with that in C++. This may confuse users, so "
-      "explicitly forbid it. "
+      "will not share the same object in Lua with C++. "
+      "And this behaves differently with that in C++. This may confuse users, "
+      "so explicitly forbid it. "
       ""
-      "Directly using the underlying type if you want to make a copy of the "
-      "argument into Lua. "
-      "Or if you want to share the same argument objects in Lua with C++, "
+      "If you want to share the same argument objects in Lua with C++, "
       "so you can modify them in Lua, you can use raw pointer type if there is "
       "only one kind of raw pointer type in all arguments, or use smart "
-      "pointer type or peacalm::luaw::ptrw type, and these are safer and more "
-      "reassuring.");
+      "pointer type or peacalm::luaw::ptrw type, and these two are safer and "
+      "more reassuring.");
   static_assert(!std::is_reference<Return>::value &&
                     !luaw_detail::tuple_has_ref<Return>::value,
                 "Do not support reference type as luaw::function's result. "
@@ -4090,7 +4107,7 @@ class luaw::function<Return(Args...)> {
     return luaw::pusher_for_return<std::decay_t<Return>>::size;
   }
 
-  Return operator()(const Args&... args) const {
+  Return operator()(Args... args) const {
     // reset all states first
     function_failed_  = false;
     function_exists_  = false;
@@ -4127,7 +4144,9 @@ class luaw::function<Return(Args...)> {
       function_exists_ = true;
     }
 
-    int narg      = push_args(l, args...);
+    // push args by copy or move
+    int narg = push_args(l, std::forward<Args>(args)...);
+
     int pcall_ret = l.pcall(narg, LUA_MULTRET, 0);
     PEACALM_LUAW_ASSERT(l.gettop() >= sz);