#### defer (1 of 3 overloads)

Submits a completion token or function object for execution.

    template<
        typename NullaryToken>
    auto defer(
        NullaryToken && token);

This function submits an object for execution using the object's associated executor. The function object is queued for execution, and is never called from the current thread prior to returning from `defer()`.

The use of `defer()`, rather than `post`, indicates the caller's preference that the executor defer the queueing of the function object. This may allow the executor to optimise queueing for cases when the function object represents a continuation of the current call context.

###### Parameters

token

  The completion token that will be used to produce a completion handler. The function signature of the completion handler must be:

      void handler();

###### Return Value

This function returns `async_initiate<NullaryToken, void()>(Init{}, token)`, where `Init` is a function object type defined as:

    class Init
    {
    public:
      template <typename CompletionHandler>
        void operator()(CompletionHandler&& completion_handler) const;
    };

The function call operator of `Init:`

- Obtains the handler's associated executor object `ex` of type `Ex` by performing

  auto ex = get_associated_executor(handler);

- Obtains the handler's associated allocator object `alloc` by performing

  auto alloc = get_associated_allocator(handler);

- If `execution::is_executor<Ex>::value` is true, performs

  prefer( require(ex, execution::blocking.never), execution::relationship.continuation, execution::allocator(alloc) ).execute(std::forward<CompletionHandler>(completion_handler));

- If `execution::is_executor<Ex>::value` is false, performs

  ex.defer( std::forward<CompletionHandler>(completion_handler), alloc);

###### Completion Signature

    void()