These include:

* Coroutine Types

* Awaitable Types

* Functions

* `cancellation_token`

* `cancellation_source`

* `cancellation_registration`

* Schedulers and I/O

* Metafunctions

* Concepts

This library is an experimental library that is exploring the space of high-performance,

scalable asynchronous programming abstractions that can be built on top of the C++ coroutines

lineCount += std::count(buffer, buffer + bytesRead, '\n');

offset += bytesRead;

} while (bytesRead > 0);

co_return lineCount;

}

// Calling function creates a new task but doesn't start

// executing the coroutine yet.

cppcoro::task<int> countTask = count_lines("foo.txt");

// ...

// Coroutine is only started when we later co_await the task.

int lineCount = co_await countTask;

// is available.

//

// The result is not returned from the co_await expression.

// possibility of the co_await expression throwing an exception.

Awaiter<void> when_ready() const noexcept;

}

const-methods on the same instance from multiple threads. It is not safe to call

non-const methods of `shared_task<T>` concurrently with any other method on the

same instance of a `shared_task<T>`.

generator(generator&& other) noexcept;

generator& operator=(generator&& other) noexcept;

generator(const generator& other) = delete;

generator& operator=(const generator&) = delete;

This is a simple manual-reset event type that supports only a single

coroutine awaiting it at a time.

API Summary:

wait until the event is signalled by a call to the `set()` method.

Once the coroutine that is awaiting the event is released by either a prior or subsequent call to `set()`

to wait until the event is signalled by a thread that calls `set()`.

The event is in one of two states; *'set'* and *'not set'*.

wait until a counter has been decremented to zero.

The latch is a single-use object. Once the counter reaches zero the latch becomes 'ready'

coordinate access to a ring-buffer for a single producer and one or more consumers.

A producer first acquires one or more slots in a ring-buffer, writes to the ring-buffer

// Populate the message.

auto& msg = buffer[seq & indexMask];

msg.id = i;

msg.data = s;

// Publish the message.

A `cancellation_token` is a value that can be passed to a function that allows the caller to subsequently communicate a request to cancel the operation to that function.

The `io_service` class provides an abstraction for processing I/O completion events

from asynchronous I/O operations.

This allows a coroutine to suspend execution on the current thread and schedule itself for resumption

on an I/O thread associated with a particular `io_service` object.

constexpr const bytes_t& bytes() const;

static constexpr ipv4_address loopback();

completes.

The specified awaitable will be `co_await`ed on current thread inside a newly created coroutine.

an unhandled exception.

The `sync_wait()` function is mostly useful for starting a top-level task from within `main()`

`task`.

API Summary:

of `when_all_task<RESULT>` objects. These objects allow you to obtain the result (or exception)

of each input awaitable separately by calling the `when_all_task<RESULT>::result()`

method of the corresponding output task.

their completion while still retaining the ability to subsequently inspect the results of

each of the `co_await` operations for success/failure.

You can also use the bleeding-edge Clang version by building Clang from source yourself.

To do this you will need to install the following pre-requisites: