Add Hash#put and optimize Set#add?

[asterite]

Right now Set#add? is implemented doing:

if includes?(object)
  false
else
  add(object)
  true
end

That's a bit inefficient because there's a double hash lookup.

It would be cool to be be able to insert a key-value pair in a Hash and know if that was a new value or not (well, what Set#add? does) but that method doesn't exist. So here we introduce it as Hash#store.

Then we rewrite Set#add? using that new method.

Benchmark code:

require "benchmark"

set = Set{0}
1000.times do |i|
  set.add?(i)
end

Benchmark.ips do |x|
  x.report("add?") do
    set.clear
    1000.times do |i|
      set.add?(i)
    end
  end
end

Results:

old: 66.60k ( 15.01µs) (± 2.27%)
new: 99.17k ( 10.08µs) (± 4.75%)

Not a big difference but I still think it's bad if this can't be implemented efficiently, and I also think Hash#put might be a generally useful method because you can't do that efficiently right now.

[rdp]

store is a bit of an overlapping name with "add" etc. hmm...maybe set_if_absent or something like that?

[asterite]

I borrowed the name store from Ruby's API. It also exists there though with a slightly different semantic. But I think nobody uses store so it's probably fine to change the meaning (and it's fine either way because we are a separate language).

[jhass]

I think the most common name for the "insert into map" operation is put. We could even do put(key, value) #=> old_value besides put(key) { value } #=> old_value and let []= be put(key, value); value.

This also brings me to the somewhat weird behavior of store returning the old value in case of an existing value and the new value in case of an updated value, I think it might be more consistent to return the default value in the latter case, or just always nil (again, in the no existing value case) even.

[asterite]

@jhass Great idea! I like the name put, I think it's present in C# and Java. It's also shorter than store.

I thought about having a put overload returning the old value or nil if it didn't exist. Or maybe the default value if it didn't exist? The problem with that is that the resulting type will always include nil because we can't statically know that there's a default value.

That's why I think a single put overload that gives you a block to return whatever you want might be better.

Maybe we can make it return nil if it was not present. But I'm not sure... I don't know how frequent this method will be used, I just needed something to be able to efficiently implement Set#add? and this is enough.

Let's vote for a name:

• 👀 put
• 🚀 store

[jhass]

I wouldn't mind put's return value being V? and ignoring the default value, that's already the case for []?.

[asterite]

@jhass Hm, good point. I though []? would return the default value in case it was missing, but I guess it makes sense for it to return nil because one usually knows whether a hash has a default value or not and if it does then one uses [] instead of []?. So I guess put returning the old value or nil makes sense. Once we decide on the name I'll update this PR.

[RX14]

Looks like everyone's agreed on put, this can probably be moved forward.

[asterite]

Renamed! If we merge we can squash the commits or I can rewrite the history, but maybe it's not bad to keep the commit about the decision to rename store to put.

[straight-shoota]

I don't think wee need the history leading to the result. There is still a reference to the PR and the discussion behind it.

[RX14]

I'm having second thoughts about this, since I was confused by the name and thought this was a "put this value if it doesn't exist, else do nothing" call, which Hash is missing (but seems useful).

This method should probably be #replace, and have a version without the block which always returns the previous value, in addition to the current version.

[straight-shoota]

Java has Map.put(key, value) (equal to Hash#[]=) and HashMap.putIfAbsent(key, value) which only stores if the key does not exist. The counterpart Map.replace(key, value) only stores if the key exists. There is also an overload Map.replace(key, old_value, new_value) which only stores if the key is set to old_value.