Although the compiler won't provide (default) implementations for constructors
and destructors of unrestricted unions, em(we) can. The task isn't difficult,
but there are some caveats.

Consider our unrestricted union's destructor. It clearly should destroy
tt(u_string)'s data if that is its currently active field; but it should do
nothing if tt(u_int) is its currently active field. But how does the
destructor know what field to destroy? It doesn't as the unrestricted union
holds no information about what field is currently active.

Here is one way to tackle this problem:

If we embed the unrestricted union in a larger aggregate, like a class or a
struct, then the class or struct can be provided with a emi(tag) data member
storing the currently active union-field. The tag can be an enumeration type,
defined by the aggregate. The unrestricted union may then be controlled by the
aggregate. Under this approach we start out with an explicit empty
implementation of the destructor, as there's no way to tell the destructor
itself what field to destroy:
        verb(
    Data::Union::~Union()
    {};
        )
