Избегание повторения для SFINAE Различие между пустыми и непустыми типами возврата

Вы можете изолировать код вызова и сохранения:

template<class R>
struct invoke_and_store_t {
  std::experimental::optional<R> ret;
  template<class F, class...Args>
  invoker_t&& operator()(F&& f, Args&&...args)&& {
    ret.emplace( std::forward<F>(f)(std::forward<Args>(args)...) );
    return std::move(*this);
  }
  R&& get()&&{ return std::move( *ret ) ); }
  template<class F>
  auto chain(F&& f)&&{
    return [r = std::move(*this).get(),f=std::move<F>(f)](auto&&...args)mutable
    {
      return std::move(f)(std::move(r), decltype(args)(args)...);
    };
  }
};
template<>
struct invoke_and_store_t<void> {
  template<class F, class...Args>
  invoker_t&& operator()(F&& f, Args&&...args)&& {
    std::forward<F>(f)(std::forward<Args>(args)...);
    return std::move(*this);
  }
  void get()&&{}
  template<class F>
  auto chain(F&& f)&&{
    return [f=std::move<F>(f)](auto&&...args)mutable{
      return std::move(f)(decltype(args)(args)...);
    };
  }
};
template<class F, class...Args, class R=std::decay_t<std::result_of_t<F(Args...)>>>
auto invoke_and_store(F&& f, Args&&...args) {
  return invoke_and_store_t<R>{}(std::forward<F>(f), std::forward<Arg>(args)...);
}

теперь ваш код становится:

template <class R, class Fn, class... Args>
R time_it(tag<R>, Fn&& fn, Args&&... args)
{
  const auto start = std::chrono::system_clock::now();
  auto&& res = invoke_and_store(
    std::forward<Fn>(fn), std::forward<Args>(args)...
  );
  const auto end = std::chrono::system_clock::now();
  std::cout << "elapsed " << (end - start).count() << std::endl;
  return std::move(res).get();
}

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

Я также включил chain, который принимает объект функции и либо передает ему предыдущее возвращаемое значение в качестве первого аргумента, либо нет, в зависимости от того, было ли предыдущее возвращаемое значение недействительным. Я нахожу этот шаблон довольно распространенным в коде, подобном монаде/функтору.

template<class A, class B>
auto then( A&& a, B&& b ) {
  return [a = std::forward<A>(a), B=std::forward<B>(b)](auto&&...args)mutable{
    return
      invoke_and_store(std::move(a))
      .chain(std::move(b))(decltype(args)(args)...);
  };
}

then(a,b)(...) вызывает a(), затем b(a(),...) или a(), а затем b(...) в зависимости от того, что возвращает a().

Иногда все, что вам нужно, это простой тип тега:

template <class > struct tag { };

Вы можете отправить свой time_it на основе обернутого типа результата:

template <class Fn, class... Args, class R = std::result_of_t<Fn&&(Args&&...)>>
R time_it(Fn fn, Args&&... args)
{
    return time_it(tag<R>{}, fn, std::forward<Args>(args)...);
}

И тогда у нас просто есть перегрузки для версий void и не-void:

template <class R, class Fn, class... Args>
R time_it(tag<R>, Fn fn, Args&&... args)
{
    const auto start = std::chrono::system_clock::now();
    auto const res = fn(std::forward<Args>(args)...);
    const auto end = std::chrono::system_clock::now();
    std::cout << "elapsed " << (end - start).count() << std::endl;
    return res;    
}

template <class Fn, class... Args>
void time_it(tag<void>, Fn fn, Args&&... args)
{
    const auto start = std::chrono::system_clock::now();
    fn(std::forward<Args>(args)...);
    const auto end = std::chrono::system_clock::now();
    std::cout << "elapsed " << (end - start).count() << std::endl;
}

Конечно, было бы особенно хорошо, если бы обычный void получает одобрение, и в этот момент нам вообще не нужен специальный регистр!

Может быть, какая-то вспомогательная структура поможет?

template <class T>
struct enable_if_not_void: enable_if<!is_void<T>::value, T> { };

И использование:

template<class Fn, typename ...Args>
auto time_it(Fn fn, Args &&... args) -> typename enable_if_not_void<typename std::result_of<Fn(Args &&...)>::type>::type {
  //...
}