Index: doc/papers/concurrency/examples/C++Cor-ts.cpp
===================================================================
--- doc/papers/concurrency/examples/C++Cor-ts.cpp	(revision aa22c608e49b47fb3a0880d3a273b38cd519d4f4)
+++ doc/papers/concurrency/examples/C++Cor-ts.cpp	(revision aa22c608e49b47fb3a0880d3a273b38cd519d4f4)
@@ -0,0 +1,42 @@
+
+
+auto result = co_await expression;
+
+//   |  |
+//   |  |
+//  \    /
+//   \  /
+//    \/
+
+auto&& __a = expression;
+if (!__a.await_ready()) {
+	__a.await_suspend(coroutine-handle)
+	// ...suspend/resume point...
+}
+auto result = __a.await_resume();
+
+//==================================================
+
+co_yield i;
+
+//   |  |
+//   |  |
+//  \    /
+//   \  /
+//    \/
+
+co_await __promise.yield_value(i);
+
+//==================================================
+
+... coroutine() {
+	__coroutine_context* __context = new __coroutine_context{};
+	__return = __context->_promise.get_return_object();
+	co_await   __context->_promise.initial_suspend();
+
+	...
+
+__final_suspend_label:
+	co_await __context->promise.final_suspend();
+	delete __context;
+}
Index: doc/papers/concurrency/examples/Fib.cpp
===================================================================
--- doc/papers/concurrency/examples/Fib.cpp	(revision aa22c608e49b47fb3a0880d3a273b38cd519d4f4)
+++ doc/papers/concurrency/examples/Fib.cpp	(revision aa22c608e49b47fb3a0880d3a273b38cd519d4f4)
@@ -0,0 +1,119 @@
+#include "base.hpp"
+
+#include <algorithm>
+#include <iterator>
+#include <vector>
+
+template<typename T>
+struct cor_range {
+	struct promise_type {
+		T _value;
+
+		cor_range get_return_object() {
+			return cor_range(std::experimental::coroutine_handle<promise_type>::from_promise(*this));
+		}
+
+		auto initial_suspend() { return suspend_always(); }
+		auto final_suspend()   { return suspend_always(); }
+
+		void return_value(T value) {
+			_value = value;
+		}
+
+		auto yield_value(T value) {
+			_value = value;
+			return suspend_always();
+		}
+
+		void unhandled_exception() {}
+	};
+
+	std::experimental::coroutine_handle<promise_type> _coroutine = nullptr;
+
+	explicit cor_range(std::experimental::coroutine_handle<promise_type> coroutine)
+		: _coroutine(coroutine)
+	{}
+
+	~cor_range() {
+		if(_coroutine) { _coroutine.destroy(); }
+	}
+
+	cor_range() = default;
+	cor_range(cor_range const &) = delete;
+	cor_range& operator=(cor_range const &) = delete;
+
+	cor_range(cor_range&& other) {
+		std::swap(_coroutine, other._coroutine);
+	}
+
+	cor_range& operator=(cor_range&& other) {
+		if(&other != this) {
+			_coroutine = other._coroutine;
+			other._coroutine = nullptr;
+		}
+		return *this;
+	}
+
+	T next() {
+		_coroutine.resume();
+		return _coroutine.promise()._value;
+	}
+
+	struct iterator : std::iterator<std::input_iterator_tag, T> {
+		std::experimental::coroutine_handle<promise_type> _coroutine = nullptr;
+
+		iterator() = default;
+		explicit iterator(std::experimental::coroutine_handle<promise_type> coroutine)
+			: _coroutine(coroutine)
+		{}
+
+		iterator& operator++() {
+			_coroutine.resume();
+			return *this;
+		}
+
+		T const & operator*() const {
+			return _coroutine.promise()._value;
+		}
+	};
+
+	iterator begin() {
+		if(_coroutine) {
+			_coroutine.resume();
+			if(_coroutine.done()) { return end(); }
+		}
+
+		return iterator{ _coroutine };
+	}
+
+	iterator end() { return iterator{}; }
+};
+
+cor_range<int> fib() {
+	int fn;
+	fn = 0; int fn1 = fn; co_yield fn;
+	fn = 1; int fn2 = fn1; fn1 = fn; co_yield fn;
+	for(;;) {
+		fn = fn1 + fn2; fn2 = fn1; fn1 = fn; co_yield fn;
+	}
+}
+
+int main() {
+	{
+		auto f1 = fib();
+		auto f2 = fib();
+		for(int i = 0; i < 10; i++) {
+			std::cout << f1.next() << " " << f2.next() << std::endl;
+		}
+	}
+
+	{
+		auto f1 = fib();
+		std::vector<int> fibs;
+		std::copy_n(f1.begin(), 10, std::back_inserter(fibs));
+
+		for(auto i : fibs) {
+			std::cout << i << std::endl;
+		}
+	}
+}
Index: doc/papers/concurrency/examples/Format.cpp
===================================================================
--- doc/papers/concurrency/examples/Format.cpp	(revision aa22c608e49b47fb3a0880d3a273b38cd519d4f4)
+++ doc/papers/concurrency/examples/Format.cpp	(revision aa22c608e49b47fb3a0880d3a273b38cd519d4f4)
@@ -0,0 +1,87 @@
+
+#include "base.hpp"
+
+struct fmt_cor {
+	struct promise_type {
+		char _value;
+		int g, b;
+
+		fmt_cor get_return_object() {
+			return fmt_cor(std::experimental::coroutine_handle<promise_type>::from_promise(*this));
+		}
+
+		auto initial_suspend() { return suspend_never(); }
+		auto final_suspend()   { return suspend_always(); }
+
+		void return_void() {}
+		void unhandled_exception() {}
+	};
+
+	struct get {
+		promise_type * _promise = nullptr;
+
+		bool await_ready() noexcept {
+			return false;
+		}
+
+		void await_suspend(std::experimental::coroutine_handle<promise_type> _coroutine) noexcept {
+			_promise = &_coroutine.promise();
+		}
+		char await_resume() noexcept {
+			assert(_promise);
+			return _promise->_value;
+		}
+	};
+
+	std::experimental::coroutine_handle<promise_type> _coroutine = nullptr;
+
+	explicit fmt_cor(std::experimental::coroutine_handle<promise_type> coroutine)
+		: _coroutine(coroutine)
+	{}
+
+	~fmt_cor() {
+		if(_coroutine) { _coroutine.destroy(); }
+	}
+
+	fmt_cor() = default;
+	fmt_cor(fmt_cor const &) = delete;
+	fmt_cor& operator=(fmt_cor const &) = delete;
+
+	fmt_cor(fmt_cor&& other) {
+		std::swap(_coroutine, other._coroutine);
+	}
+
+	fmt_cor& operator=(fmt_cor&& other) {
+		if(&other != this) {
+			_coroutine = other._coroutine;
+			other._coroutine = nullptr;
+		}
+		return *this;
+	}
+
+	void send(char a) {
+		_coroutine.promise()._value = a;
+		_coroutine.resume();
+	}
+};
+
+fmt_cor Fmt() {
+	int g; // = co_await fmt_cor::g();
+	int b; // = co_await fmt_cor::b();
+	for(;;) {
+		for(g = 0; g < 5; g++) {
+			for(b = 0; b < 4; b++) {
+				std::cout << co_await fmt_cor::get();
+			}
+			std::cout << "  ";
+		}
+		std::cout << std::endl;
+	}
+}
+
+int main() {
+	auto fmt = Fmt();
+	for(int i = 0; i < 41; i++) {
+		fmt.send('a');
+	}
+}
Index: doc/papers/concurrency/examples/base.hpp
===================================================================
--- doc/papers/concurrency/examples/base.hpp	(revision aa22c608e49b47fb3a0880d3a273b38cd519d4f4)
+++ doc/papers/concurrency/examples/base.hpp	(revision aa22c608e49b47fb3a0880d3a273b38cd519d4f4)
@@ -0,0 +1,20 @@
+#include <iostream>
+#include <experimental/coroutine>
+
+struct suspend_never {
+	bool await_ready() noexcept {
+		return true;
+	}
+
+	void await_suspend(std::experimental::coroutine_handle<>) noexcept {}
+	void await_resume() noexcept {}
+};
+
+struct suspend_always {
+	bool await_ready() noexcept {
+		return false;
+	}
+
+	void await_suspend(std::experimental::coroutine_handle<>) noexcept {}
+	void await_resume() noexcept {}
+};
Index: doc/papers/concurrency/examples/counter.cpp
===================================================================
--- doc/papers/concurrency/examples/counter.cpp	(revision aa22c608e49b47fb3a0880d3a273b38cd519d4f4)
+++ doc/papers/concurrency/examples/counter.cpp	(revision aa22c608e49b47fb3a0880d3a273b38cd519d4f4)
@@ -0,0 +1,61 @@
+#include "base.hpp"
+
+struct counter_cor {
+	struct promise_type {
+		counter_cor get_return_object() {
+			return counter_cor(std::experimental::coroutine_handle<promise_type>::from_promise(*this));
+		}
+
+		auto initial_suspend() { return suspend_never(); }
+		auto final_suspend()   { return suspend_never(); }
+
+		void return_void() {}
+
+		void unhandled_exception() {}
+	};
+
+	std::experimental::coroutine_handle<promise_type> _coroutine = nullptr;
+
+	explicit counter_cor(std::experimental::coroutine_handle<promise_type> coroutine)
+		: _coroutine(coroutine)
+	{}
+
+	~counter_cor() {
+		if(_coroutine) { _coroutine.destroy(); }
+	}
+
+	counter_cor() = default;
+	counter_cor(counter_cor const &) = delete;
+	counter_cor& operator=(counter_cor const &) = delete;
+
+	counter_cor(counter_cor&& other) {
+		std::swap(_coroutine, other._coroutine);
+	}
+
+	counter_cor& operator=(counter_cor&& other) {
+		if(&other != this) {
+			_coroutine = other._coroutine;
+			other._coroutine = nullptr;
+		}
+		return *this;
+	}
+
+	void resume() { _coroutine.resume(); }
+};
+
+counter_cor counter() {
+	std::cout << "Counter: called\n";
+	for(unsigned i = 1;; i++) {
+		co_await suspend_always{};
+		std::cout << "Counter: Resumed " << i << " time(s)\n";
+	}
+}
+
+int main() {
+	std::cout << "Main: calling counter\n";
+	auto c = counter();
+	std::cout << "Main: resumes\n";
+	c.resume();
+	c.resume();
+	std::cout << "Main: done\n";
+}