slotmap VS stdx

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

There's none that I know of, aside from stdx which was last updated 4 years ago.

⭐ stdx - The missing batteries of Rust - Brian Anderson

brson had a repository called https://github.com/brson/stdx and it's a pity it isn't maintained anymore: some of them are in disuse now (for example, instead of lazy_static prefer stdlib's Lazy, or better yet, you don't need them if you just want to initialize a mutex or something; also error-chain) and the list could use some maintenance

You suggested creating a super-library of vetted crates. It has been tried before, but it didn’t get any adoption. stdx - The missing batteries of Rust was never used much. Looking at it now, it recommends crates that have been superseded by others.

As an example of the above, if you're not aware of it already, you might find brson/stdx interesting.

Big libraries like Boost or the Python standard library tend to develop as a workaround for weak package management so, with Cargo, efforts to produce Boost-like compilations (Eg. stdx) withered on the vine for lack of sufficient interest.

It's been suggested and people even tried doing that of their own volition with projects like stdx, but they withered away for lack of interest.

I second u/globulemix' attitude, searching on crates.io and then looking at Downloads and also git activity (might be misleading, as some projects are simply very stable). For a lot of tasks, you might wish to take a look at stdx

Seems abandoned, but there was https://github.com/brson/stdx

I've been here since before Rust 1.0 and I've seen various projects like stdx start, but fail to achieve critical mass... probably because that kind of approach tends to invite the worst kind of bikeshedding.