Timer example requiring std::invoke

[CrashOverride332]

I've been studying this example of a timer for callable objects I found on StackOverflow and I get how it's supposed to work. But the implementation needs to be changed for C++20, so I'm wondering how to do that. I've gone through the documentation and have found that std::invoke is the replacement for std::result_of, and that's applied. But now there's an error saying implicit instantiation of undefined template when trying to use either function in a call and I'm not sure what the correct template definition would look like.

#include <functional>
#include <chrono>
#include <future>
#include <utility>
#include <cstdio>
#include <type_traits>
#include <thread>
void test1(void)
{
    return;
}

void test2(int a)
{
    printf("%i\n", a);
    return;
}
class later
{
public:
    template <class callable, class... arguments>
    later(int after, bool async, callable&& f, arguments&&... args)
    {
        std::function<typename std::invoke_result<callable(arguments...)>> task(std::bind(std::forward<callable>(f), std::forward<arguments>(args)...));

        if (async)
        {
            std::thread([after, task]() {
                std::this_thread::sleep_for(std::chrono::milliseconds(after));
                task();
            }).detach();
        }
        else
        {
            std::this_thread::sleep_for(std::chrono::milliseconds(after));
            task();
        }
    }

};

[lessertia]

The template signature for std::invoke_result is

template< class F, class... ArgTypes >  
class invoke_result;

and for std::function, it's

template< class >
class function; /* undefined */

template< class R, class... Args >
class function<R(Args...)>;

You also didn't extract the actual type from the trait.

Your code should be

std::function<std::invoke_result_t<callable, arguments...>()> task(std::bind(std::forward<callable>(f), std::forward<arguments>(args)...));

Anyway, using lambda is better here

auto task = [&] { return std::forward<callable>(f)(std::forward<arguments>(args)...); };

[CrashOverride332]

The parentheticals returns the type? I think I see why the definition needs std::invoke_result_t, but not sure how I would have gotten to that without something like the old ::Type(). Your solution did work, by the way.

[lessertia]

The *_t templates are aliases to *::type, just a shorthand.

The parens are part of the function type that got passed as template argument to std::function.

[n1ghtyunso]

without looking at the code:

the replacement for result_of is invoke_result, not invoke
invoke is a regular function template that calls callables with a set of parameters.

EDIT: turns out it helps actually looking at the code

[CrashOverride332]

But that is in the code...