add pop() to HashSet etc.?

[birkenfeld]

In Python I've often found the set.pop() method useful which would remove and return a single arbitrary element of the set (or raise if empty). In Rust this should return an Option<T>, of course.

I haven't found such a method on HashSet, have I just not looked hard enough?

[alexcrichton]

cc @gankro

[Gankra]

Pop doesn't make sense for our HashMaps -- it would be an O(m/n) expected linear search where m is the capacity and n the len.

If you want a good pop you should use https://libraries.io/cargo/linked-hash-map

BTree* could cleanly provide such functionality (pop_min, pop_max)

[birkenfeld]

I understand the desire to implement only efficient operations, but in that case my question is really how to get elements out of the set at all (without turning it into an iterator).

O(m/n) doesn't sound too bad for me, btw.

[birkenfeld]

Just saw a reimplementation of this: http://jneem.github.io/regex-dfa/src/regex_dfa/dfa.rs.html (PopArbitrary at the top).

[bluss]

For the BTreeSet it could be implemented in less than linear time, it's a much better alternative.

[ltratt]

Having just written code that needs some equivalent of pop on an arbitrary HashMap, I'd like to second this proposal. Since HashMap is used pervasively, sometimes that is simply what is one has to deal with, and using an alternative data-structure (e.g. BTreeMap) isn't possible. At the moment, the only way of doing this is via something like M.iter().next().unwrap().clone() followed by M.remove(...) which is ugly, inefficient, and obfuscatory. I imagine the same functionality is needed by HashSet and the like, though I see HashMap used much more often.

[Although it's a little off-topic, I have doubts about the performance and memory trade-offs of a linked hashmap. A more cache-friendly technique for ordered maps was first described -- as far as I know -- by Raymond Hettinger. It was then independently implemented (and possibly reinvented) in PHP (who have a nice description of it) and PyPy (who have a slightly shorter but still interesting description). Still, none of this helps if one has been passed a HashMap.]

[nagisa]

I need one for whatever set this is possible to implement on.

[uzytkownik]

@gankro that depends on frequency of operation. Even though this particular operation may be slow if the operation is performed unfrequently HashSet may be still a better option overall.

(And if you have a datatype which does not/cannot be Clone you cannot roll this primitive on your own.)

[przygienda]

second the pop on the HashSet. I see how drain( range ) is not a good idea but it's very painful right now to iterate over elements and then remove them in another pass performance-wise.

[bluss]

@ltratt ordermap now exists as a Rust implementation of that idea. It's got an efficient .pop() for this reason.

[canndrew]

I've wanted this a few times. If I wrote a PR for it is it likely to get merged?