Consider reordering arguments for Async* member functions.

[coryan]

In the original design document I recommended that a function like:

type1 Function(type2 a, type3 b);

was converted to an asynchronous version by (amongst other changes) appending two arguments:

template <typename Functor>
shared_ptr<AsyncOperation> AsyncFunction(
    type2 a, type3 b,
    CompletionQueue& cq, Functor&& f);

That works poorly for functions that have default parameters:

type1 WithDefault(type2 a, type3 b = 0);

template <typename Functor>
shared_ptr<AsyncOperation> AsyncWithDefault(
  type2 a, type3 b = 0,      // ERROR, cannot have default in the middle.
  CompletionQueue& cq,
  Functor&& f);

or with variadic arguments:

template <typename Args>
type1 WithVariadic(type2 a, Args&&... args);

template <typename Functor, typename Args>
shared_ptr<AsyncOperation> AsyncWithVariadic(
  type2 a, Args&&... args, // ERROR, cannot variadic args in the middle
  CompletionQueue& cq,
  Functor&& f);

I propose we change the order of the arguments to have the completion queue and the functor at the beginning:

type1 WithDefault(type2 a, type3 b = 0);

template <typename Functor>
shared_ptr<AsyncOperation> AsyncWithDefault(
  CompletionQueue& cq, Functor&& f,
  type2 a, type3 b = 0                                // OK.
  );

template <typename Args>
type1 WithVariadic(type2 a, Args&&... args);

template <typename Functor, typename Args>
shared_ptr<AsyncOperation> AsyncWithVariadic(
  CompletionQueue& cq, Functor&& f,
  type2 a, Args&&... args,                          // OK.
  );

The downside is that calling the function with a lambda at the end is more readable (most of the time):

auto op = AsyncWithDefault(cq, [](CompletionQueue& cq, type1 result, Status& status) {
  // Do callback stuff here.
  // it can get long....
  },
  arg1, arg2); // these may be hard to find and read in real code.

[coryan]

@dopiera @houglum @roopak-qlogic @manish-qlogic @deepankarsharma PTAL.

Comments (or simply up/down votes) are welcome.

[coryan]

If there are no opinions by 2018-12-07 I am going to consider this proposal accepted.

[dopiera]

upvote!

[houglum]

This seems reasonable, LGTM.

W.r.t. readability and passing a lambda in the middle args vs. at the end: As an alternative to creating it inline in the list of args, I'd imagine you could declare the lambda outside of the arg list, then pass its name as an argument (via std::move, if you don't want to copy it or have the calling scope keep ownership):

auto some_callable = ...;
auto op = AsyncWithFoo(cq, std::move(some_callable), arg1, arg2);