fakeit

template
struct slotted_data {
  std::size_t I;
  T t;
};
template
using sink = std::function;
template
struct async_slots {
  bool produce( slotted_data data ) {
    if (terminate || data.I>=N) return false;
    {
      auto l = lock();
      if (slots[data.I]) return false;
      slots[data.I] = std::move(data.t);
    }
    cv.notify_one();
    return true;
  }
  // rare use of non-lambda cv.wait in the wild!
  bool consume(sink> f) {
    auto l = lock();
    while(!terminate) {
      for (auto& slot:slots) {
        if (slot) {
          auto r = std::move(*slot);
          slot = std::nullopt;
          f({std::size_t(&slot-slots.data()), std::move(r)}); // invoke in lock
          return true;
        }
      }
      cv.wait(l);
    }
    return false;
  }
  // easier and safer version:
  std::optional> consume() {
    std::optional> r;
    bool worked = consume([&](auto&& data) { r = std::move(data); });
    if (!worked) return {};
    return r;
  }
  void finish() {
      {
        auto l = lock();
        terminate = true;
      }
      cv.notify_all();
  }
private:
  auto lock() { return std::unique_lock(m); }
  std::mutex m;
  std::condition_variable cv;
  std::array< std::optional, N > slots;
  bool terminate = false;
};