class scope

Provides a mechanism for binding promises to the lifetime of another object

such that they are destroyed before that object goes out of scope. It is

particularly useful for ensuring that the lifetime of a promise does not

exceed the lifetime of any variables that it has captured by reference.

A scope is thread-safe but non-reentrant: it must not be destroyed while

any of its associated promises are running.

EXAMPLE

Define a |fpromise::scope| as a member of the object to whose lifetime the

promises should be bound.

// We mark this class final because its destructor has side-effects

// that rely on the order of destruction. If this object were

// subclassed there would be a possibility for promises bound to its

// scope to inadvertently access the subclass's state while the object

// was being destroyed.

class accumulator final {

public:

accumulator() = default;

~accumulator() = default;

fpromise::promise

<int

> accumulate(int value);

private:

int prior_total_ = 0;

// This member is last so that the scope is exited before all

// other members of the object are destroyed. Alternately, we

// could enforce this ordering by explicitly invoking

// |fpromise::scope::exit()| where appropriate.

fpromise::scope scope_;

};

Use |fpromise::promise::wrap_with()| to wrap up promises that capture pointers

to the object. In this example, the captured pointer is "this".

fpromise::promise

<int

> accumulator::accumulate(int value) {

return fpromise::make_promise([this, value] {

prior_total_ += value;

return fpromise::ok(prior_total_);

}).wrap_with(scope_); /* binding to scope happens here */

}