Members of the class tt(std::future) may return errors by throwing
tt(std::future_error) exceptions. These error conditions are represented by
the values of the strongly typed enumeration
    hi(future_errc)tt(std::future_errc) which defines the following symbolic
constants:
    itemization(
    iti(broken_promise)
        quote( 
   tt(Broken_promise) is thrown when a tt(future) object was received whose
    value was never assigned by a tt(promise) or tt(packaged_task). For
    example, an object of the class tt(promise<int>) should set the value of
    the tt(future<int>) object returned by its tt(get_future) member
    (cf. section ref(PROMISE)), but if it doesn't do so, then a
    tt(broken_promise) exception is thrown, as illustrated by the following
    program:
   verbinclude(-n //code examples/brokenpromise.cc)
   At line 3 a tt(promise) object is created, but its value is never
    set. Consequently, it `breaks its promise' to produce a value: when
    tt(main) tries to retrieve its value (in line 9) a tt(std::futue_error)
    exception is thrown containing the tt(future_errc::broken_promise)
    value)

    iti(future_already_retrieved) 
        quote(
   tt(Future_already_retrieved) is thrown when multiple attempts are made to
    retrieve the tt(future) object from, e.g., a tt(promise) or
    tt(packaged_task) object that (eventually) should be ready. For example:
   verbinclude(-n //code examples/alreadyretrieved.cc)
   Note that after defining the tt(std::promise) object in line 3 it has
    merely been defined: no value is ever assigned to its tt(future). Even
    though no value is assigned to the tt(future) object, it em(is) a valid
    object. I.e., after some time the future em(should) be ready, and the
    future's tt(get) member should produce a value. Hence, line 4 succeeds,
    but then, in line 5, the exception is thrown as `the future has already
    been retrieved'.)

    iti(promise_already_satisfied) 
        quote(
   tt(Promise_already_satisfied) is thrown when multiple attempts are made to
    assign a value to a tt(promise) object. Assigning a value or
    tt(exception_ptr) to the tt(future) of a tt(promise) object may happen
    only once.  For example:
   verbinclude(-n //code examples/promisealreadysatisfied.cc)
        )

    iti(no_state) 
        quote(
   tt(No_state) is thrown when a member function (other than tt(valid), see
    below) of a tt(future) object is called when its tt(valid) member returns
    tt(false). This happens, e.g., when calling members of a default
    constructed tt(future) object. tt(No_state) is not thrown for tt(future)
    objects returned by the tt(async) factory function or returned by the
    tt(get_future) members of tt(promise) or tt(packaged_task) type
    of objects. Here is an example:
   verbinclude(-n //code examples/nostate.cc)
        )
    )

The class   hi(future_error)tt(std::future_error) is derived from the class
tt(std::exception), and offers, in addition to the tt(char const *what()
const) member also the member hi(code)tt(std::error_code const &code() const),
returning an hi(error_code)tt(std::error_code) object associated
with the thrown exception. 





