Step 1: Add Symbol vs frozen String vs String keys in a 1000-key Hash (#135)

From #135 by @konung: whether String keys cost more than Symbol keys, and
whether freezing the String closes the gap. Symbol keys are the faster
ones, both to build a Hash with and to read it by.

Changes to the PR:
- Its 1000-pair file measured two things, so it is split into
  hash/symbol-vs-string-keys-building.rb and
  hash/symbol-vs-string-keys-reading.rb.
- Fixed keys and values instead of shuffle, rand and sample, so every
  run measures the same work.
- Rank names: faster Symbol, fast frozen String, slow plain String. A
  comment says why frozen keys are close when building: a Hash copies and
  freezes a plain String key but keeps a frozen one as it is (checked on
  Ruby 2.1 and 4.0).
- Not taken: the one-pair literal file ({symbol: 42} and friends). On
  Ruby 3.4 and 4.0 each literal compiles to one duphash instruction, a
  copy of a prebuilt Hash, so the reports measure the same work. It also
  used Ruby 2.2 syntax ('sym_str': 42) and called the wrong method in one
  report.
- Not taken either: code/hash/.tool-versions, and the CONTRIBUTING typo
  fix, which main already has.

No README entry: the results move to the results site.

Co-authored-by: Nick Gorbikoff <72493+konung@users.noreply.github.com>

Author: JuanVqz

code/hash/symbol-vs-string-keys-building.rb

@@ -0,0 +1,31 @@
+require 'benchmark/ips'
+
+# The same 1000 keys, as Symbols, frozen Strings and plain Strings, each mapped to its index.
+SYMBOL_KEYS = (1..1000).map { |i| :"key_#{i}" }
+FROZEN_KEYS = (1..1000).map { |i| "key_#{i}".freeze }
+STRING_KEYS = (1..1000).map { |i| "key_#{i}" }
+
+def build(keys)
+  keys.each_with_index.map { |key, index| [key, index] }.to_h
+end
+
+# Symbol and frozen String keys tie on Ruby 4.0.
+def faster
+  build(SYMBOL_KEYS)
+end
+
+# A Hash copies and freezes a plain String key, but keeps a frozen one as it is.
+def fast
+  build(FROZEN_KEYS)
+end
+
+def slow
+  build(STRING_KEYS)
+end
+
+Benchmark.ips do |x|
+  x.report('Symbol Keys') { faster }
+  x.report('Frozen Keys') { fast }
+  x.report('String Keys') { slow }
+  x.compare!
+end

code/hash/symbol-vs-string-keys-reading.rb

@@ -0,0 +1,30 @@
+require 'benchmark/ips'
+
+# The same 1000 keys, as Symbols, frozen Strings and plain Strings, each mapped to its index.
+SYMBOL_KEYS = (1..1000).map { |i| :"key_#{i}" }
+FROZEN_KEYS = (1..1000).map { |i| "key_#{i}".freeze }
+STRING_KEYS = (1..1000).map { |i| "key_#{i}" }
+
+SYMBOL_HASH = SYMBOL_KEYS.each_with_index.map { |key, index| [key, index] }.to_h
+FROZEN_HASH = FROZEN_KEYS.each_with_index.map { |key, index| [key, index] }.to_h
+STRING_HASH = STRING_KEYS.each_with_index.map { |key, index| [key, index] }.to_h
+
+# Reads every key once.
+def faster
+  SYMBOL_KEYS.each { |key| SYMBOL_HASH[key] }
+end
+
+def fast
+  FROZEN_KEYS.each { |key| FROZEN_HASH[key] }
+end
+
+def slow
+  STRING_KEYS.each { |key| STRING_HASH[key] }
+end
+
+Benchmark.ips do |x|
+  x.report('Symbol Keys') { faster }
+  x.report('Frozen Keys') { fast }
+  x.report('String Keys') { slow }
+  x.compare!
+end