I have the following code which implements a memoize function.

note The question is not about how to write a memoize function specifically but rather about the compile error I get with this implementation and the smallest change to get it to work.

The implementation.

#include <functional>
#include <map>
#include <functional>
#include <iostream>

using namespace std;

template<typename T>
struct memfun_type
{
    using type = void;
};

template<typename Ret, typename Class, typename... Args>
struct memfun_type<Ret(Class::*)(Args...) const>
{
    using type = std::function<Ret(Args...)>;
};

template<typename F>
typename memfun_type<decltype(&F::operator())>::type
FFL(F const &func)
{ // Function from lambda !
    return func;
}

template <typename ReturnType, typename... Args>
std::function<ReturnType (Args...)>
memoizeImp(std::function<ReturnType (Args...)> func)
{
    std::map<std::tuple<Args...>, ReturnType> cache;
    return ([=](Args... args) mutable {
            std::tuple<Args...> t(args...);
            if (cache.find(t) == cache.end())                
                cache[t] = func(args...);
            return cache[t];
    });
}

template <typename Fn>
auto memoize(Fn && fn){
    return memoizeImp(FFL(fn));
}

and test program

int main()
{
    auto a = 2.;
    auto foo = [a](double x){return x a;};
    auto foom = memoize(foo);

    std::cout << foo(1) << std::endl;
    std::cout << foom(1) << std::endl;
}

the output as expected is

3
3

However if I make a small change to the test program changing

auto foo = [a](double x){return x a;};

to

auto foo = [a](double x)mutable{return x a;};

I get the following compile error on gcc

Could not execute the program
Compiler returned: 1
Compiler stderr
<source>: In instantiation of 'auto memoize(Fn&&) [with Fn = main()::<lambda(double)>&]':
<source>:49:24:   required from here
<source>:42:26: error: invalid use of void expression
   42 |     return memoizeImp(FFL(fn));
      |                       ~~~^~~~
<source>: In instantiation of 'typename memfun_type<decltype (& F::operator())>::type FFL(const F&) [with F = main()::<lambda(double)>; typename memfun_type<decltype (& F::operator())>::type = void; decltype (& F::operator()) = double (main()::<lambda(double)>::*)(double)]':
<source>:42:26:   required from 'auto memoize(Fn&&) [with Fn = main()::<lambda(double)>&]'
<source>:49:24:   required from here
<source>:24:12: error: return-statement with a value, in function returning 'memfun_type<double (main()::<lambda(double)>::*)(double)>::type' {aka 'void'} [-fpermissive]
   24 |     return func;
      |            ^~~~

The failing code and compile error can be viewed and tested at https://godbolt.org/z/74PKWvqr4

I'm not sure what the fix is to make it work with mutable lambdas.

CodePudding user response：

You are lacking a specialisation.

Adding this makes it work

template<typename Ret, typename Class, typename... Args>
struct memfun_type<Ret(Class::*)(Args...)>
{
    using type = std::function<Ret(Args...)>;
};

The operator() of the closure-type of a lambda is const qualified iff the lambda is not declared mutable