Not the author, and still new to Rust, but I think this approach is interesting in Rust as well.

Consider visiting a tree:

    enum Tree {
       Branch(Box<Tree>, Box<Tree>), // left, right
       Leaf(i32)
    }

    fn postorder_visit(t: &mut Tree, f: fn(&mut Tree)) {
         // ???
    }

A recursive implementation of `postorder_visit` is trivial but risks stack overflow. A heap-allocated stack (say, `Vec<&mut Tree>`) runs into problems with the borrow checker, which knows about the C stack, but not your stack.

So an overflow-safe implementation must use unsafe, but still wants to have confidence in ordered destruction. You could make it a `Vec<*mut Tree>`, but now there are zero checks!

The idea here is, in debug mode only, replace `Box` with `Rc` that checks its refcount upon drop, and `&mut Tree` with Rc as well. Now your debug mode does not require unsafe, and your release mode is fast. You have dynamically enforced ownership in a regime inaccessible to the borrow checker.