template in lambda closure

Question

Can anyone tell me why the below code

namespace detail
{
    ...

    template<typename ... T_Args>
    void duk_get_args(duk_context*& context,  std::function<void(T_Args...)>& func)
    {

        duk_get_args_impl<T_Args ...>(context, func, std::index_sequence_for<T_Args ...>());
    }
}
template<typename ... T_Args>
duk_c_function duk_function(std::function<void(T_Args ...)> function_item)
{
    std::function<void(T_Args ...)> closure_function = function_item;
    duk_c_function function_return = [closure_function] (duk_context* ctx) -> duk_ret_t {
        detail::duk_get_args<T_Args ...>(ctx, closure_function);
        return 0;
    };
    return function_return;
}

throws the following error, and if there is a workaround for this?

||=== Build: Release_win64 in dukbind (compiler: GNU GCC Compiler) ===|
include\dukbind\detail.hpp||In instantiation of 'dukbind::duk_function(std::function<void(T_Args ...)>)::<lambda(duk_context*)> [with T_Args = {std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >}; duk_ret_t = int; duk_context = duk_hthread]':|
include\dukbind\detail.hpp|81|required from 'struct dukbind::duk_function(std::function<void(T_Args ...)>) [with T_Args = {std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >}; dukbind::duk_c_function = std::function<int(duk_hthread*)>]::<lambda(duk_context*)>'|
include\dukbind\detail.hpp|85|required from 'dukbind::duk_c_function dukbind::duk_function(std::function<void(T_Args ...)>) [with T_Args = {std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >}; dukbind::duk_c_function = std::function<int(duk_hthread*)>]'|
C:\Users\Daniel Wanner\Documents\Projekte\C++\dukbind\src\main.cpp|166|required from here|
include\dukbind\detail.hpp|83|error: no matching function for call to 'duk_get_args(duk_context*&, const std::function<void(std::__cxx11::basic_string<char>)>&)'|
include\dukbind\detail.hpp|70|note: candidate: template<class ... T_Args> void dukbind::detail::duk_get_args(duk_context*&, std::function<void(T_Args ...)>&)|
include\dukbind\detail.hpp|70|note:   template argument deduction/substitution failed:|
include\dukbind\detail.hpp|83|note:   types 'std::function<void(T_Args ...)>' and 'const std::function<void(std::__cxx11::basic_string<char>)>' have incompatible cv-qualifiers|
C:\TDM-GCC-64\lib\gcc\x86_64-w64-mingw32\5.1.0\include\c++\functional|2250|error: 'std::function<_Res(_ArgTypes ...)>::function(_Functor) [with _Functor = dukbind::duk_function(std::function<void(T_Args ...)>) [with T_Args = {std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >}; dukbind::duk_c_function = std::function<int(duk_hthread*)>]::<lambda(duk_context*)>; <template-parameter-2-2> = void; _Res = int; _ArgTypes = {duk_hthread*}]', declared using local type 'dukbind::duk_function(std::function<void(T_Args ...)>) [with T_Args = {std::__cxx11::basic_|
||=== Build failed: 2 error(s), 4 warning(s) (0 minute(s), 0 second(s)) ===|

Im sorry for the almost 90% code question, but i believe something is wrong in my very concept. Im trying to use templates arguments inside a lambda closure. is that even conceptually possible?

Answer 1

Lambda functions have a operator() that is marked const by default, which means the captured closure_function is const. However, duk_get_args is trying to take a non-const reference to a const parameter, and this is what the compiler is complaining about.

Either:

1. Change duk_get_args to take a const func.
2. Add mutable to the lambda's definition so you can take a non-const reference to closure_function.

Additionally, the closure_function variable is unnecessary. You could just capture the function_item variable and use that. This isn't part of your problem, but is something I felt to point out.