So far we've encountered tt(co_yield) and tt(co_return). What about
tt(co_await)? The verb em(to await) is more formal than em(to wait), but the
two verbs mean the same. The added level of formality of em(to await) is
illustrated by a second description offered by the em(Merrian Webster)
dictionary: em(to remain in abeyance until), and em(abeyance's) meaning takes
us home again: em(a state of temporary inactivity) or em(suspension). So when
tt(co_await) is used the coroutine enters a state of temporary inactivity,
i.e., it is suspended. In that sense tt(co_yield) is no different, as it also
suspends the coroutine, but different from tt(co_yield co_await) expects a
so-called emi(awaitable) expression. I.e., an expression resulting in an
tt(Awaitable), or that is convertible to an tt(Awaitable)
object (see also figure ref(CoAwaitFig)).
    figure(coroutines/coawait)
        (co_await)
        (CoAwaitFig)
    Figure ref(CoAwaitFig) shows that the expression that's passed to
tt(co_await) may be an tt(Awaitable) object, or if the coroutine handle's
tt(State) class has a member ti(await_transform) accepting an argument of some
tt(expr's) type, the value returned by tt(await_transform) is the tt(
Awaitable) (cf. figure ref(AwaitableFig)). These tt(await_transform) members
may be overloaded, so in any concrete situation several tt(Awaitable) types
could be used.
    figure(coroutines/awaitable)
        (awaitable)
        (AwaitableFig)

The tt(Awaiter) type that's eventually used is either an object of
tt(co_await's expr's) type, or it is the return type of the (implicitly called
when defined) coroutine handler's tt(State::await_transform(expr)) member.

Thus, the tt(Awaitable) object is a em(middle-man), that's only used to obtain
an tt(Awaiter) object. The tt(Awaiter) is the real work-horse in the context
of tt(co_await).

hi(operator co_await) tt(Awaitable) classes may define a member
tt(Awaiter Awaitable::operator co_await()), which may also be provided as a
free function (tt(Awaiter operator co_await(Awaitable &&))). If such a
tt(co_await) conversion operator is available then it is used to obtain the
tt(Awaiter) object from the tt(Awaitable) object. If such a conversion
operator is em(not) available then the tt(Awaitable) object em(is) the
tt(Awaiter) object.

As an aside: the types tt(Awaitable) and tt(Awaiter) are used here as formal
class names, and in actual programs the software engineer is free to use other
(maybe more descriptive) names.

