Add support for a workable bind_front

Author: kunitoki

Manual.md

@@ -32,7 +32,8 @@ Contents
         *   [2.3.1 - Multiple Inheritance](#231---multiple-inheritance)
     *   [2.4 - Property Member Proxies](#24---property-member-proxies)
     *   [2.5 - Function Member Proxies](#25---function-member-proxies)
-    *   [2.5.1 - Function Overloading](#251---function-overloading)
+    *   [2.5.1 - Partial Application with luabridge::bind_front](#251---partial-application-with-luabridgebind_front)
+    *   [2.5.2 - Function Overloading](#252---function-overloading)
     *   [2.6 - Constructors](#26---constructors)
     *   [2.6.1 - Constructor Proxies](#261---constructor-proxies)
     *   [2.6.2 - Constructor Factories](#262---constructor-factories)
@@ -602,7 +603,38 @@ luabridge::getGlobalNamespace (L)
 
 Of course when not capturing, it is better to prefix the lambda with `+` so it is converted and stored internally to a function pointer instead of an `std::function`, so it is actually lighter to store and faster to call.
 
-### 2.5.1 - Function Overloading
+### 2.5.1 - Partial Application with luabridge::bind_front
+
+`std::bind_front` (C++20) returns a callable whose `operator()` is a template, so LuaBridge cannot statically resolve its argument types. Passing such a result directly to `addFunction` therefore fails to compile. The workaround without `luabridge::bind_front` is an explicit cast to `std::function`:
+
+```cpp
+int add (int a, int b) { return a + b; }
+
+// Verbose: explicit signature required
+ns.addFunction ("add10", std::function<int(int)> (std::bind_front (&add, 10)));
+```
+
+`luabridge::bind_front` is a drop-in replacement that deduces the remaining argument types from the underlying callable's signature, so no explicit cast is needed:
+
+```cpp
+// Concise: types are deduced automatically
+ns.addFunction ("add10", luabridge::bind_front (&add, 10));
+```
+
+It also works with member function pointers, where the bound object is not counted as a Lua-visible parameter:
+
+```cpp
+struct Vec { float coord [3]; };
+float getCoord (const Vec* v, int i) { return v->coord [i]; }
+
+ns.beginClass<Vec> ("Vec")
+  .addFunction ("x", luabridge::bind_front (&getCoord, 0))
+  .addFunction ("y", luabridge::bind_front (&getCoord, 1))
+  .addFunction ("z", luabridge::bind_front (&getCoord, 2))
+.endClass ();
+```
+
+### 2.5.2 - Function Overloading
 
 When specifying more than one method to the `addFunction` or `addStaticFunction` of both `Namespace` and `Class`, those overloads will be invoked in case of a call. Only overloads that have matched arguments arity will be considered, and they will be tried from first to last until the call succeeds.
 

Source/LuaBridge/detail/FuncTraits.h

@@ -195,8 +195,32 @@ struct function_traits_impl<R (__fastcall C::*)(Args...) const noexcept, true> :
 };
 #endif
 
+template <class F, class = void>
+struct has_call_operator : std::false_type
+{
+};
+
+template <class F>
+struct has_call_operator<F, std::void_t<decltype(&F::operator())>> : std::true_type
+{
+};
+
+template <class F>
+inline static constexpr bool has_call_operator_v = has_call_operator<F>::value;
+
+template <class F, class = void>
+struct functor_traits_impl
+{
+};
+
+template <class F>
+struct functor_traits_impl<F, std::enable_if_t<has_call_operator_v<F>>> : function_traits_impl<decltype(&F::operator()), true>
+{
+};
+
 template <class F>
-struct functor_traits_impl : function_traits_impl<decltype(&F::operator()), true>
+struct functor_traits_impl<F, std::enable_if_t<!has_call_operator_v<F> && std::is_invocable_v<F&>>>
+    : function_traits_base<false, false, std::invoke_result_t<F&>>
 {
 };
 
@@ -213,6 +237,19 @@ struct function_traits : std::conditional_t<std::is_class_v<F>,
 {
 };
 
+template <class T, bool IsClass = std::is_class_v<T>, class = void>
+struct has_function_traits : std::false_type
+{
+};
+
+template <class T>
+struct has_function_traits<T, true, std::void_t<typename function_traits<T>::result_type, typename function_traits<T>::argument_types>> : std::true_type
+{
+};
+
+template <class T>
+inline static constexpr bool has_function_traits_v = has_function_traits<T>::value;
+
 //=================================================================================================
 /**
  * @brief Deduces the argument type of a callble object or void in case it has no argument.
@@ -303,6 +340,12 @@ struct is_callable<T, std::void_t<decltype(&T::operator())>>
     static constexpr bool value = true;
 };
 
+template <class T>
+struct is_callable<T, std::enable_if_t<std::is_class_v<T> && !has_call_operator_v<T> && has_function_traits_v<T>>>
+{
+    static constexpr bool value = true;
+};
+
 template <class T>
 struct is_callable<T, std::enable_if_t<std::is_pointer_v<T> && std::is_function_v<std::remove_pointer_t<T>>>>
 {
@@ -547,5 +590,96 @@ struct remove_first_type<std::tuple<T, Ts...>>
 template <class T>
 using remove_first_type_t = typename remove_first_type<T>::type;
 
+//=================================================================================================
+/**
+ * @brief Drop the first N types from a tuple.
+ */
+template <std::size_t N, class Tuple>
+struct tuple_drop_first
+{
+    using type = typename tuple_drop_first<N - 1, remove_first_type_t<Tuple>>::type;
+};
+
+template <class Tuple>
+struct tuple_drop_first<0, Tuple>
+{
+    using type = Tuple;
+};
+
+template <std::size_t N, class Tuple>
+using tuple_drop_first_t = typename tuple_drop_first<N, Tuple>::type;
+
+//=================================================================================================
+/**
+ * @brief Internal storage for luabridge::bind_front — exposes a non-template operator() so that
+ *        function_traits can statically resolve result_type and argument_types.
+ */
+template <class R, class RemainingArgsTuple, class Fn, class... BoundArgs>
+struct bind_front_wrapper;
+
+template <class R, class... Remaining, class Fn, class... BoundArgs>
+struct bind_front_wrapper<R, std::tuple<Remaining...>, Fn, BoundArgs...>
+{
+    Fn fn_;
+    std::tuple<BoundArgs...> bound_;
+
+    template <class F, class... BA>
+    bind_front_wrapper(F&& f, BA&&... ba)
+        : fn_(std::forward<F>(f)), bound_(std::forward<BA>(ba)...)
+    {
+    }
+
+    R operator()(Remaining... args) const
+    {
+        return std::apply([&](const auto&... ba) { return std::invoke(fn_, ba..., args...); }, bound_);
+    }
+};
+
 } // namespace detail
+
+//=================================================================================================
+/**
+ * @brief Drop-in replacement for std::bind_front with statically introspectable argument types.
+ *
+ * std::bind_front returns an object whose operator() is a template, so its argument and result
+ * types cannot be resolved at compile time without an explicit std::function<Sig> cast. This
+ * wrapper stores the callable and its leading bound arguments, then exposes a concrete
+ * non-template operator() whose parameter types are derived directly from the underlying
+ * callable's signature. This lets LuaBridge register the result with addFunction / addProperty /
+ * addMethod without any extra annotation.
+ *
+ * @code
+ * // Instead of:
+ * ns.addFunction("add", std::function<int(int)>(std::bind_front(&add2, 10)));
+ *
+ * // Write:
+ * ns.addFunction("add", luabridge::bind_front(&add2, 10));
+ * @endcode
+ *
+ * For member function pointers the implicit object argument consumed by std::invoke is not
+ * counted as part of the remaining (Lua-visible) parameter list, matching std::bind_front
+ * semantics.
+ *
+ * @tparam F     Callable type (function pointer, member function pointer, functor).
+ * @tparam BoundArgs Leading argument types to bind.
+ * @param  f     The callable to wrap.
+ * @param  args  Leading arguments forwarded into the wrapper by value.
+ * @return A callable object whose operator() accepts the remaining (unbound) arguments.
+ */
+template <class F, class... BoundArgs>
+auto bind_front(F&& f, BoundArgs&&... args)
+{
+    using Fn = std::decay_t<F>;
+    using FnTraits = detail::function_traits<Fn>;
+
+    static constexpr std::size_t skip = FnTraits::is_member ? 1u : 0u;
+    static constexpr std::size_t num_effective_bound = sizeof...(BoundArgs) - skip;
+
+    using remaining = detail::tuple_drop_first_t<num_effective_bound, typename FnTraits::argument_types>;
+    using R = typename FnTraits::result_type;
+
+    return detail::bind_front_wrapper<R, remaining, Fn, std::decay_t<BoundArgs>...>(
+        std::forward<F>(f), std::forward<BoundArgs>(args)...);
+}
+
 } // namespace luabridge

Tests/Source/NamespaceTests.cpp

@@ -588,6 +588,12 @@ T Function(T param)
     return param;
 }
 
+template<class T>
+T Function2(T param1, T param2)
+{
+    return param1 + param2;
+}
+
 int LuaFunction(lua_State* L)
 {
     lua_pushnumber(L, 42);
@@ -622,6 +628,46 @@ TEST_F(NamespaceTests, StdFunctions)
     ASSERT_EQ(12, result<int>());
 }
 
+TEST_F(NamespaceTests, StdBindFunctions)
+{
+    {
+        luabridge::getGlobalNamespace(L).addFunction("Function", std::bind(&Function<int>, 1));
+
+        runLua("result = Function ()");
+        ASSERT_TRUE(result().isNumber());
+        ASSERT_EQ(1, result<int>());
+    }
+
+    {
+        luabridge::getGlobalNamespace(L).addFunction("Function",
+            std::function<int(int)>(std::bind(&Function2<int>, 1, std::placeholders::_1)));
+
+        runLua("result = Function (12)");
+        ASSERT_TRUE(result().isNumber());
+        ASSERT_EQ(13, result<int>());
+    }
+}
+
+TEST_F(NamespaceTests, StdBindFrontFunctions)
+{
+    {
+        luabridge::getGlobalNamespace(L).addFunction("Function", std::bind_front(&Function<int>, 1));
+
+        runLua("result = Function ()");
+        ASSERT_TRUE(result().isNumber());
+        ASSERT_EQ(1, result<int>());
+    }
+
+    {
+        luabridge::getGlobalNamespace(L).addFunction("Function",
+            luabridge::bind_front(&Function2<int>, 1));
+
+        runLua("result = Function (12)");
+        ASSERT_TRUE(result().isNumber());
+        ASSERT_EQ(13, result<int>());
+    }
+}
+
 TEST_F(NamespaceTests, CapturingLambdas)
 {
     int x = 30;