Generate a promise from a template Callable

Refresh

December 2018

Views

106 time

4

I'm trying to create a promise from a template function which accepts a Callable type. But I'm not sure how to do it. I tried using std::invoke_result_t, but that needs the arguments to know the result type, something which I won't know when I construct the promise.

Any way in which I can deduce the return type? I guess it may be impossible in the case of a generic lambda, but does anything work on non generic lambda cases?

template <typename Callable, typename Promise>
class Job {

  public:
    Job(Callable&& c, Promise&& p) 
    : callable(std::move(c))
    , promise(std::move(p))
    {}

    auto getFuture() {
        return /* a std::shared_future */;
    }   

    template<typename... Args>
    void call(Args&&... args) {
        promise.set_value(std::invoke(callable, args...));
    }

  private:
    Callable callable;
    Promise promise;
};

template<typename Callable>
decltype(auto) makeJob(Callable&& c) {
    std::promise</* some type */> promise = /* something */;
    return Job(std::forward<Callable>(c), std::move(promise));
}

int main() {
    f1 = [](int arg){return arg;};
    auto job = makeJob(std::move(f1));
    auto future = job.getFuture();
    job.call(1);
    std::cout << future.get() << '\n';
 }

1 answers

4

В любом случае, в котором я могу вывести возвращаемый тип? Я предполагаю, что это может оказаться невозможным в случае общего лямбда, но ничего не делает работу на не общих случаях лямбды?

Вы помечены C ++ 17 , так ... std::functionи дедукция гиды являются вашими друзьями.

Вы можете определить тип возвращаемого из вызываемых с чем-то, как

typename decltype(std::function{c})::result_type;

так что ваша makeJob()функция может быть записана

template <typename Callable>
auto makeJob (Callable && c)
 {
   using retT = typename decltype(std::function{c})::result_type;

   return Job{std::forward<Callable>(c), std::promise<retT>{}};
 }

То же самое в Jobклассе.

Очевидно, что это работает, потому что f1

auto f1 = [](int arg){return arg;};

имеет тип возвращаемого значения, который не зависит от аргументов; с общим лямбда

// ..........vvvv
auto f1 = [](auto arg){return arg;};

это решение не работает больше, и я не думаю, что вы можете написать что-то, чтобы получить тип возвращаемого значения, не зная тип аргумента.

Ниже приводится полный пример компиляции

#include <future>
#include <memory>
#include <iostream>
#include <functional>

template <typename C, typename P>
class Job
 {
   public:
      using retT
         = typename decltype(std::function{std::declval<C>()})::result_type;

      Job (C && c, P && p) : callable{std::move(c)}, promise{std::move(p)}
       { }

      auto getFuture ()
       { return std::shared_future<retT>{ promise.get_future() }; }   

      template <typename ... Args>
      void call (Args && ... args)
       { promise.set_value(std::invoke(callable, args...)); }

   private:
      C callable;
      P promise;
 };

template <typename Callable>
auto makeJob (Callable && c)
 {
   using retT
      = typename decltype(std::function{c})::result_type;

   return Job{std::forward<Callable>(c), std::promise<retT>{}};
 }

int main ()
 {
   auto f1 = [](int arg){return arg;};
   auto job = makeJob(std::move(f1));
   auto future = job.getFuture();

   job.call(42);

   std::cout << future.get() << '\n';
 }