In practice almost everything can be used as an exception. But at the same
time any exception that is thrown can be reached using the function
hi(current_exception)(tt(std::current_exception)), and access to any exception
can be standardized using hi(make_exception_ptr)tt(std::make_exception_ptr).
These functions expect or use objects of the class
hi(exception_ptr)tt(std::exception_ptr), and in this section we take a closer
look at tha class.

The class tt(exception_ptr's) default constructor initializes it to a
null-pointer. In the following code snippet the variable tt(isNull) is set to
true:
        verb(    std::exception_ptr obj;
    bool isNull =  obj == nullptr && obj == 0;)

The class tt(exception_ptr) provides copy and move constructors as well as
copy and move assignment operators.

    Two tt(exception_ptr) objects can be compared for equality. They are equal
if they refer to the same exception. Move assignment transfers the exception
referred to by the right-hand side operand to the left-hand side operand, and
turns the right-hand side operand into a null pointer.

There is no published method directly retrieving the exception to which an
tt(exception_ptr) object refers. However, there are some free functions
constructing or handling tt(exception_ptr) objects:
    itemization(
    ithtq(current_exception)
        (std::exception_ptr std::current_exception() noexcept)
       (An tt(exception_ptr) object is returned referring to the currently
        handled exception (or a copy of the currently handled exception, or a
        default constructed tt(exception_ptr) object if no current exception
        is available). This function can also be called when a default
        exception catcher is used. 
COMMENT(
E.g., assuming that tt(obj) refers to an
        available tt(std::promise) object, then the following code snippet
        assigns the exception caught by default catch clause to tt(obj):
       verb(    ...
    catch (...)
    {
        obj.set_exception(std::current_exception());
    })
)

The exception referred to by tt(current_exception) does not have to
        be an object of the class tt(std::exception). Any type of object or
        value thrown as an exception is retrieved as an tt(exception_ptr) by
        tt(current_exception). The exception referred to by an
        tt(exception_ptr) object remains valid for at least as long as there
        exists an tt(exception_ptr) object that refers to it. Calling
        tt(current_exception) twice in a row then the two returned
        tt(exception_ptr) objects may or may not refer to the same exception
        object.)

    ithtq(make_exception_ptr)(std::exception_ptr make_exception_ptr(Type
        value) noexcept)
       (This function template constructs an tt(exception_ptr) from a value of
        any type which is passed as its argument. tt(Type) does not
        necessarily have to be a tt(std::exception) but can be anything that
        can be thrown as an exception: an tt(int), a tt(std::string), a
        tt(std::exception), you name it.

COMMENT(
The constructed
        tt(exception_ptr) could, e.g., be assigned to a tt(std::promise). When
        the promise's future's tt(get) member is subsequently called (possibly
        from within another thread) the exception will be thrown. 
END)
        Here are
        some examples, showing how values of different types can be passed as
        arguments to tt(make_exception_ptr)
COMMENT(
, and showing how the eventually
        constructed tt(exception_ptr) is assigned to the tt(obj), which is
        assumed to be of a tt(std::promise) type:
END)
       verb(    auto ptr = make_exception_ptr(exception());
    ptr = make_exception("hello world"s);
    ptr = make_exception(12);)
COMMENT(
    obj.set_exception(make_exception_ptr(ptr));
END)
)

    ithtq(rethrow_exception)(void std::rethrow_exception(exception_ptr obj))
       (The exception to which tt(obj) refers is thrown. Note: tt(obj)
        cannot be a tt(nullptr).)

    )
