# std::experimental::future<T>::then

> C++ Atlas: `cppatlas.com/w/cpp/experimental/future/then` | Source: https://en.cppreference.com/w/cpp/experimental/future/then | Domain: Technical specifications

Attach the continuation func to *this. The behavior is undefined if *this has no associated shared state (i.e., valid() == false).

## Official Specification Summary (cppreference)

```cpp
template< class F >
future</* see below */> then( F&& func ) ;
```

Attach the continuation `func` to `*this`. The behavior is undefined if `*this` has no associated shared state (i.e., `valid() == false`).

Creates a shared state associated with the `future` object to be returned, and a copy `fd` of `func` constructed as if by `DECAY_COPY(std::forward<F>(func))` evaluated in the thread calling `then`, where `DECAY_COPY` is defined as

```cpp
template<class T>
std::decay_t<T> DECAY_COPY(T&& v)
{
    return std::forward<T>(v);
}
```

When the shared state currently associated with `*this` is ready, the *continuation* `INVOKE(std::move(fd), std::move(*this))` is called on an unspecified thread of execution, where `INVOKE` is the operation defined in *Callable*. If that expression is invalid, the behavior is undefined.

Any value returned from the continuation is stored as the result in the shared state of the returned `future` object. Any exception propagated from the execution of the continuation is stored as the exceptional result in the shared state of the returned `future` object.

Let `U` be the return type of the continuation (i.e. `std::result_of_t<std::decay_t<F>(std::experimental::future<T>)>`). If `U` is `std::experimental::future<T2>` for some type `T2`, then the return type of `then` is `std::experimental::future<T2>`, otherwise it is `std::experimental::future<U>`. This is known as *implicit unwrapping*.

If implicit unwrapping takes place and the continuation returns an invalid `future`, then the shared state is made ready with an exception of type `std::future_error` with an error condition of `std::future_errc::broken_promise`.

After this function returns, `valid()` is `false`.

### Parameters

- `func` - a continuation to be attached

### Return value

A `std::experimental::future` object associated with the shared state created by this object. `valid() == true` for the returned object.

### Example

> Note: This section is incomplete Reason: no example

---
Attribution: content from https://en.cppreference.com/w/cpp/experimental/future/then (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.