rust-typed-arena VS slotmap

As an aside, this is a well-known enough problem in game development that there is a data structure called an arena to make it easier. A well-known example: https://github.com/SimonSapin/rust-typed-arena

For graph-like structures in Rust, you might want to use the arena allocation technique. This means that you store all your nodes in a single Vec (or a specialized type like typed-arena or the already mentioned slotmap) and use indices into the Vec instead of pointers.

It looks like .get_disjoint_mut() from slotmap failed under stacked borrows, but seems to pass under tree borrows

I think slotmap is meant to solve this exact issue. Basically when you insert into a collection you get an Id:Version tuple as key. When you reuse a slot, next time the key will be Id:Version+1 and when you try to access the removed value by using Id:Version, it will return None. You can think about it as delayed invalidation.

Dunno about existing implementations, but it looks like it's a feature they'd accept: https://github.com/orlp/slotmap/issues/73

It's actually quite easy.

You can use either slot map or slab to side step rust borrow checker. Example https://github.com/orlp/slotmap/blob/master/examples/rand_meld_heap.rs

I don't know, only have some theories.

1. The name isn't particularly catchy or descriptive. It is the correct name for the data structure, but not too many people know the data structure.

2. People don't even know what they're missing. It's not a very Google-able problem to begin with. Slotmap provides an interesting solution to (circular) ownership and safe allocator / weak pointer design problems, but people don't recognize that they're having them or that slotmap could help.

As an example of this, the doubly linked list example (https://github.com/orlp/slotmap/blob/master/examples/doubly_...) can safely remove nodes from the linked list given their handle, in O(1), even from the middle, completely safely and correctly, even in the presence of double deletions or ABA memory re-use. You can't replicate this with just pointers, without introducing heavy refcounting solutions.

Nope, it's perfectly safe: https://github.com/orlp/slotmap/blob/master/examples/doubly_linked_list.rs.

I think keeping the relationship between child and parent elements in the node graph might be better accommodating better via a psuedo-ECS system, see https://www.reddit.com/r/rust/comments/cnjhup/idiomatic_way_to_reference_parent_struct/. The https://github.com/orlp/slotmap crate looks promising. I think I'm just going to ditch the global shared HashMap in favor of something that can better accommodate child/parent relations.

I think the slotmap crate is similar to what you're trying to write: https://github.com/orlp/slotmap