sean-parent

teplate <class T>
auto split(future<T>&&) -> pair<future<T>, future<T>>;

// Q: Is the only way to attach a continuation to spawn/await?

class application {
  //...
  future<document> _document;
  vector<future<void>> _pending; // async scope
  

sean-parent

The use of "valid but unspecified" as a guarantee is useless and damaging. Consider std::list<>. A guarantee of std::list<> is that on move the iterators are not invalidated (different use of valid), except for the end iterator. The end iterator frequently points directly to an empty terminal node directly in the local instance so moving a list invalidates the end iterator. Invalidation can be a source of bugs so a library implementor decided their implementation would strengthen the guarantee by ensuring that the end iterator was valid even with a move. To do so, they heap-allocate the terminal node for each list.

If you move-construct this list, the rhs argument must be "valid but unspecified". To achieve that, an end node must be allocated in the rhs. Now the move constructor is not noexcept. Not having a noexcept move constructor is problematic because it makes it impossible to get robust transactional behavior to restore a system after a throw. Trying to complete a transaction by moving in the r

sean-parent

# 1 "/Users/sean-parent/Projects/github.com/sean-parent/scratch/scratch/main.cpp"
# 1 "<built-in>" 1
# 1 "<built-in>" 3
# 421 "<built-in>" 3
# 1 "<command line>" 1
# 1 "<built-in>" 2
# 1 "/Users/sean-parent/Projects/github.com/sean-parent/scratch/config.hpp" 1
# 2 "<built-in>" 2
# 1 "/Users/sean-parent/Projects/github.com/sean-parent/scratch/scratch/main.cpp" 2
# 1 "/Users/sean-parent/Projects/github.com/sean-parent/scratch/includes/stlab/concurrency/future.hpp" 1

sean-parent

#include <functional>
#include <iostream>
#include <string>

template <class T>
class maybe {
    std::aligned_storage_t<sizeof(T)> _value;
    bool _has_value = false;

public:

sean-parent

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

#include <dispatch/dispatch.h>

namespace stlab {

template <class Function, class... Args>

sean-parent

#include <deque>
#include <memory>
#include <mutex>
#include <future>
#include <boost/optional.hpp>
#include <boost/thread/future.hpp>

namespace stlab {

class process {

sean-parent

#include <tuple>
#include <iostream>
#include <cmath>

#include <stlab/future.hpp>
#include <stlab/channel.hpp>

using namespace stlab;
using namespace std;
using namespace std::chrono;

sean-parent

#include <future>
#include <iostream>
#include <memory>
#include <string>
#include <thread>
#include <unordered_map>

#include <dispatch/dispatch.h>

using namespace std;

sean-parent

#include <iostream>
#include <tuple>
#include <utility>

using namespace std;

template <typename F, typename T, size_t... I>
auto apply_(F f, T&& t, integer_sequence<size_t, I...>) {
    return f(get<I>(t)...);
}

sean-parent

#include <memory>

using namespace std;

template <typename C> // Concept base class
class any {
  public:
    template <typename T>
    any(T x) : self_(new model<T>(move(x))) { }