This should be fastest and current fastest should be removed, as they will always will be around the same. Constant lookup is not slower than local variable in terms of code execution. It's not even micro-optimization it some sort of pseudo-scientific nano-optimization :D

In fact whole benchmark seems a bit wrong to me. It compares oranges to potatoes. It should test each* vs while not different memoization tricks:

require "benchmark/ips"

ARRAY = [*1..100]

def fastest
  index = 0
  size  = ARRAY.size

  while index < size
    ARRAY[index] + index
    index += 1
  end

  ARRAY
end

def faster
  index = 0

  ARRAY.each do |number|
    number + index
    index += 1
  end

  ARRAY
end

def slow
  ARRAY.each_with_index { |number, index| number + index }
end

Benchmark.ips do |x|
  x.report("fastest", 'fastest;' * 1000)
  x.report("faster", 'faster;' * 1000)
  x.report("slow", 'slow;' * 1000)
  x.compare!
end

Results will be:

Warming up --------------------------------------
             fastest    37.000  i/100ms
              faster    23.000  i/100ms
                slow    24.000  i/100ms
Calculating -------------------------------------
             fastest    375.210  (± 1.1%) i/s -      1.887k in   5.029639s
              faster    242.769  (± 2.1%) i/s -      1.219k in   5.023745s
                slow    236.484  (± 1.3%) i/s -      1.200k in   5.074932s

Comparison:
             fastest:      375.2 i/s
              faster:      242.8 i/s - 1.55x  slower
                slow:      236.5 i/s - 1.59x  slower

I thought about removing the fastest micro optimized version but I decided to include it because local variables should be able to be optimized much better than other lookups. The difference may be very small with the current Ruby implementation but benchmarks do consistently show a performance difference in many cases even if it's overkill for most use cases. The Linux benchmarks I ran were up to 12 i/s faster which is 12k calls per second and an average of 19 i/s faster under Windows (constants are 1.04x slower). I'm running these benchmarks with high CPU priority on Windows and real-time scheduling on Linux to maximize consistency.

As for whether the benchmark should be comparing different memoization tricks or not, that may be a good reason to only include one while loop but when comparing a while loop to a native abstraction, it should ideally be written as optimally as possible. Array#each_with_index gets to take advantage of the C stack and avoid all the overhead of any kind of ruby variable when it comes to referencing the array and doing comparisons and increments on the index.

I agree that local variable will be slower on such synthetic tests. But in real world example where payload of iteration is something less stupid it will seek to nothing. And I think the aim of this project is providing somewhat "better practices". If real code suffers from overhead of local var vs constant lookup - i would consider it as ruby issue.