Add generator<T> coroutine type

[lewissbaker]

Add a new type cppcoro::generator<T> that allows you to write a coroutine that yields a sequence of values procedurally from within the coroutine using the co_yield keyword.

eg.

cppcoro::generator<int> range(int n)
{
  for (int i = 0; i < n; ++i) co_yield i;
}

// Outputs: 0 1 2 3 4 5 6 7 8 9
void usage()
{
  for (auto i : range(10))
  {
    std::cout << i << " ";
  }
}

[lewissbaker]

Some questions for me as to the design:

• Should generator<T> yield a sequence of T& or const T& or should it return T by value?
• Should we allow generator<T&>?
  How would this differ from generator<T> above if it yields a sequence of T&?
• Should we allow generator<T&&>?
  ie. co_yield'ed value must be an r-value reference and iterator dereference is rvalue reference
• Should we allow co_yield T{} even if generator is yielding a sequence of T& lvalue references?
  Current C++ rules don't allow temporaries to bind to lvalue reference parameters.

There may be a performance advantage in storing a copy of the value in the generator's promise rather than a pointer to the value passed to co_yield, at least for fundamental types and possibly some other simple user-defined types. The elimination of an extra indirection when the consumer dereferences the iterator could be significant in some tight loops.

Need to evaluate the performance impact of this approach on Clang which has more advanced coroutine optimisation than MSVC at the moment.

[lewissbaker]

Also need to consider custom allocators for the coroutine frame.

I'm not a huge fan of making the allocator template parameter of the generator type (ie. generator<T, ALLOC>) as I feel that this decision should be made by the caller (eg. via parameters) rather than the implementer of the coroutine.

This would also allow callers to pass stateful allocators rather than being limited to stateless allocators.
This may be particularly applicable to recursive_generator class as such functions tend to be recursive and thus not applicable for allocation-elision. So an allocator that allocated space for batches of coroutine frames to allow for efficient allocation/deallocation of recursive coroutine frames could be a good performance improvement.

eg. Something like

template<typename ALLOCATOR>
cppcoro::generator<foo> some_func(std::allocator_arg_t,  ALLOCATOR& alloc, P1 arg1, P2 arg2);

[lewissbaker]

Commit 40c6216 adds initial generator<T> implementation.

Still need to update README with some documentation.

[lewissbaker]

README has now been updated.