Separate keys and values, and simplify benchmarks

Author: JacobEvelyn

README.md

@@ -805,56 +805,43 @@ Comparison:
       Hash#keys.each:   869262.3 i/s - 1.21x slower
 ```
 
-#### `Hash#key?` instead of `Hash#keys.include?` and `Hash#value?` instead of `Hash#values.include?` [code](code/hash/keys-include-vs-key.rb)
+#### `Hash#key?` vs. `Hash#[]` vs. `Hash#keys.include?` [code](code/hash/keys-include-vs-\[\]-vs-key.rb)
 
 > `Hash#keys.include?` allocates an array of keys and performs an O(n) search; <br>
-> `Hash#key?` performs an O(1) hash lookup without allocating a new array. <br>
-> `Hash#values.include?` allocates an array of values and performs an O(n) search; <br>
-> `Hash#value?` performs an O(n) search without allocating a new array.
+> `Hash#key?` performs an O(1) hash lookup without allocating a new array; <br>
+> `Hash#[]` performs an O(1) hash lookup as well.
 
 ```
-$ ruby -v code/hash/keys-include-vs-key.rb
+$ ruby -v code/hash/keys-include-vs-\[\]-vs-key.rb
 ruby 2.5.1p57 (2018-03-29 revision 63029) [x86_64-darwin17]
 
 Calculating -------------------------------------
-Hash#key? (key is present)
-                          5.809M (± 2.1%) i/s -     29.038M in   5.000966s
-Hash#keys.include? (key is present)
-                          8.914k (± 3.9%) i/s -     44.564k in   5.007900s
+  Hash#keys.include?      8.293k (± 6.1%) i/s -     41.964k in   5.083215s
+             Hash#[]      6.412M (± 3.1%) i/s -     32.160M in   5.020295s
+           Hash#key?      6.616M (± 5.0%) i/s -     33.178M in   5.030955s
 
 Comparison:
-Hash#key? (key is present):  5809154.8 i/s
-Hash#keys.include? (key is present):     8913.6 i/s - 651.72x  slower
-
-Calculating -------------------------------------
-Hash#key? (key is absent)
-                          7.691M (± 1.9%) i/s -     38.520M in   5.010779s
-Hash#keys.include? (key is absent)
-                          2.991k (± 2.1%) i/s -     15.100k in   5.051475s
+           Hash#key?:  6615589.2 i/s
+             Hash#[]:  6412217.3 i/s - same-ish: difference falls within error
+  Hash#keys.include?:     8293.2 i/s - 797.71x  slower
+```
 
-Comparison:
-Hash#key? (key is absent):  7690551.0 i/s
-Hash#keys.include? (key is absent):     2990.5 i/s - 2571.62x  slower
+##### `Hash#value?` instead of `Hash#values.include?` [code](code/hash/values-include-vs-value.rb)
 
-Calculating -------------------------------------
-Hash#value? (value is present)
-                         14.780k (± 0.9%) i/s -     74.970k in   5.072806s
-Hash#values.include? (value is present)
-                         14.019k (± 4.4%) i/s -     70.533k in   5.041592s
+> `Hash#values.include?` allocates an array of values and performs an O(n) search; <br>
+> `Hash#value?` performs an O(n) search without allocating a new array.
 
-Comparison:
-Hash#value? (value is present):    14780.1 i/s
-Hash#values.include? (value is present):    14019.0 i/s - 1.05x  slower
+```
+$ ruby -v code/hash/values-include-vs-value.rb
+ruby 2.5.1p57 (2018-03-29 revision 63029) [x86_64-darwin17]
 
 Calculating -------------------------------------
-Hash#value? (value is absent)
-                          2.640k (± 2.1%) i/s -     13.200k in   5.002081s
-Hash#values.include? (value is absent)
-                          2.930k (± 6.1%) i/s -     14.994k in   5.144089s
+Hash#values.include?     23.187k (± 4.3%) i/s -    117.720k in   5.086976s
+         Hash#value?     38.395k (± 1.0%) i/s -    194.361k in   5.062696s
 
 Comparison:
-Hash#values.include? (value is absent):     2930.0 i/s
-Hash#value? (value is absent):     2640.1 i/s - 1.11x  slower
+         Hash#value?:    38395.0 i/s
+Hash#values.include?:    23186.8 i/s - 1.66x  slower
 ```
 
 ##### `Hash#merge!` vs `Hash#[]=` [code](code/hash/merge-bang-vs-\[\]=.rb)

code/hash/keys-include-vs-[]-vs-key.rb

@@ -0,0 +1,23 @@
+require "benchmark/ips"
+
+HASH = Hash[*("a".."zzz").to_a.shuffle]
+KEY = "zz"
+
+def key_fast
+  HASH.key? KEY
+end
+
+def key_resolve
+  !!HASH[KEY]
+end
+
+def key_slow
+  HASH.keys.include? KEY
+end
+
+Benchmark.ips do |x|
+  x.report("Hash#keys.include?") { key_slow }
+  x.report("Hash#[]") { key_resolve }
+  x.report("Hash#key?") { key_fast }
+  x.compare!
+end

code/hash/keys-include-vs-key.rb

@@ -0,0 +1,18 @@
+require "benchmark/ips"
+
+HASH = Hash[*("a".."zzz").to_a.shuffle]
+VALUE = "zz"
+
+def value_fast
+  HASH.value? VALUE
+end
+
+def value_slow
+  HASH.values.include? VALUE
+end
+
+Benchmark.ips do |x|
+  x.report("Hash#values.include?") { value_slow }
+  x.report("Hash#value?") { value_fast }
+  x.compare!
+end