In our root `object` module we have a function "to reclaim non-memory resources without compromising memory safety" (yes, its a correct definition as it is what Andrei said and what it really do).

The problem is that it works not only for classes but also for all other types and behaves differently for each type.

As an example of the current situation danger consider the following code (an `std.algorithm.move` implementation):

---
void move(T)(ref T source, ref T target)
in { assert(&source == &target || !pointsTo(source, source)); }
body
{
    if (&source == &target) return;

    static if (hasElaborateDestructor!T)
        destroy(target);

    static if (hasElaborateAssign!T || !isAssignable!T)
        memcpy(cast(void*) &target, cast(const void*) &source, T.sizeof);
    else
        target = source;

    static if (hasElaborateCopyConstructor!T || hasElaborateDestructor!T)
        ... // set `source` to its `init` state here
}
---

This code compiles fine. And it looks fine not only for D newbies but also for rather skilled programmers. It also behaves fine in some cases. But it will do unpredictable things in other cases.