RedBeard0531

#include <type_traits>
#include <future>
#include <functional>

template <typename T>
struct expected {
    expected(const T&) {}
};
template <typename T>
struct Promise {

RedBeard0531

#include <utility>
#include <exception>

// This is probably customizable
using Error = std::exception_ptr;

template <typename R, typename T>
concept ValueReciever = requires (T a, R r) {
    std::move(r).value(std::move(a));
};

RedBeard0531

Supplement to this video. Watch first 35 min (the language bits), then 1:14:30 - 1:18:15 (the new map features).

You can find a fairly comprehensive list of new features on cppreference or here if you really want to see it all.

Recap of features described in the video

RedBeard0531

#include <cstdlib>
#include <boost/optional.hpp>
#include <string>

using boost::optional;

template <typename T>
struct Future{};

template <typename T>

RedBeard0531

template <typename T>
struct ValueReceiver {
    virtual void value(T) = 0;
};

template <typename T>
struct ValueOrErrorReceiver : ValueReceiver<T> {
    virtual void value(T) = 0;
    virtual void error(std::exception_ptr) = 0;
};

RedBeard0531

#include <functional>
#include <exception>
#include <optional>
#include <memory>
#include <cassert>
#include <atomic>
#include <iostream>
#include <mutex>
#include <condition_variable>
#include <thread>

RedBeard0531

Magic #includes (and eventually imports)

By: Mathias Stearn
Please provide feedback either by email, or on #sg15-tooling in cpplang.slack.com.

This is an alternative to a proposal that I'm sure was offered with good intentions, but that I and several others shuddered at the sight of:

RedBeard0531

#include <tuple>
#include <optional>
#include <functional>

/////////////////////
/// PRIMARY TEMPLATES

template <typename T>
struct future_then_return_traits {
    // Future::then(cb) for a callback that returns T,

RedBeard0531

enum State {INIT, PHASE2, DONE};

std::atomic<State> state{INIT};
int non_atomic = 0; // placeholder for actual data.

auto phase1 = std::thread([&] {
    non_atomic = 1;
    state.store(PHASE2, std::memory_order_release);

    auto phase2 = std::thread([&] {

RedBeard0531

Document Number:	P0911R0
Date:	2018-02-03
Project:	Programming Language C++, CWG, LWG
Revises:	none
Reply to:	gorn@microsoft.com

Rebase the Coroutines TS onto the C++17 Standard