As far as I understand that approach, it lets you detect dangling references but not prevent them, and it does nothing to detect when a node becomes unreachable. It also imposes a burden on the user to check every reference at runtime before it can be safely followed.

I think I’d much rather use Rc with strategic use of weak pointers to prevent cycles. That way at least some of your references can be trusted without verifying them on each use, and resources are freed when they become unreachable.

If you need to represent a fully general graph structure, you’re pretty much obligated to implement some kind of garage collection on it, so any solution you come up with will be pretty hairy. Fortunately I’ve never once in my career needed a fully general graph. If you think you need one, it’s a good sign that you’re in the process of building an ad hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp. At that point you’re much better off embedding a real implementation of a garage collected language in your system.

I also feel I should point out that the need for the ugly wrapper enum in the article is a side-effect of using an array to store everything. If you use proper references or pointers, you can use dyn to automatically support every possible implementation of a trait, not just the ones listed in an enum. You might still want to use the array/enum approach for other reasons, like memory locality, but dyn references provide a degree of freedom that can be very useful sometimes.