Update Proc#call and block arguments vs yield for Ruby 2.5

In Ruby 2.5, passing through a `block` argument has become a lot faster.
I renamed the 'block argument' benchmark because I felt the old name was misleading as the fastest on Ruby 2.5.

Author: bdewater

README.md

@@ -963,27 +963,40 @@ Comparison:
 
 ##### `Proc#call` and block arguments vs `yield`[code](code/proc-and-block/proc-call-vs-yield.rb)
 
-In MRI Ruby, block arguments [are converted to Procs](https://www.omniref.com/ruby/2.2.0/symbols/Proc/yield?#annotation=4087638&line=711), which incurs a heap allocation.
+In MRI Ruby before 2.5, block arguments [are converted to Procs](https://www.omniref.com/ruby/2.2.0/symbols/Proc/yield?#annotation=4087638&line=711), which incurs a heap allocation.
 
 ```
 $ ruby -v code/proc-and-block/proc-call-vs-yield.rb
-ruby 2.2.3p173 (2015-08-18 revision 51636) [x86_64-darwin15]
+ruby 2.4.4p296 (2018-03-28 revision 63013) [x86_64-darwin17]
 Calculating -------------------------------------
-          block.call    41.978k i/100ms
-       block + yield    42.674k i/100ms
-      block argument    41.722k i/100ms
-               yield    62.681k i/100ms
--------------------------------------------------
-          block.call    842.581k (±12.5%) i/s -      4.114M
-       block + yield    941.468k (±11.7%) i/s -      4.651M
-      block argument      1.043M (± 7.1%) i/s -      5.215M
-               yield      3.828M (±11.3%) i/s -     18.930M
+          block.call      1.761M (± 1.7%) i/s -      8.854M in   5.028508s
+       block + yield      1.910M (± 1.9%) i/s -      9.627M in   5.041105s
+        unused block      2.045M (± 1.7%) i/s -     10.290M in   5.033036s
+               yield      8.568M (± 1.7%) i/s -     43.004M in   5.020998s
+
+Comparison:
+               yield:  8567538.2 i/s
+        unused block:  2045057.9 i/s - 4.19x  slower
+       block + yield:  1910340.9 i/s - 4.48x  slower
+          block.call:  1761210.1 i/s - 4.86x  slower
+```
+
+MRI Ruby 2.5 implements [Lazy Proc allocation for block parameters](https://bugs.ruby-lang.org/issues/14045):
+
+```
+$ ruby -v code/proc-and-block/proc-call-vs-yield.rb
+ruby 2.5.1p57 (2018-03-29 revision 63029) [x86_64-darwin17]
+Calculating -------------------------------------
+          block.call      1.738M (± 2.0%) i/s -      8.771M in   5.048684s
+       block + yield      7.503M (± 1.6%) i/s -     37.593M in   5.011670s
+        unused block      8.914M (± 2.2%) i/s -     44.656M in   5.012279s
+               yield      8.537M (± 2.1%) i/s -     42.681M in   5.002066s
 
 Comparison:
-               yield:  3828436.1 i/s
-      block argument:  1042509.6 i/s - 3.67x slower
-       block + yield:   941467.7 i/s - 4.07x slower
-          block.call:   842581.2 i/s - 4.54x slower
+        unused block:  8913860.7 i/s
+               yield:  8536544.5 i/s - 1.04x  slower
+       block + yield:  7503151.2 i/s - 1.19x  slower
+          block.call:  1737948.9 i/s - 5.13x  slower
 ```
 
 

code/proc-and-block/proc-call-vs-yield.rb

@@ -19,7 +19,7 @@ def fast
 Benchmark.ips do |x|
   x.report('block.call') { slow { 1 + 1 } }
   x.report('block + yield') { slow2 { 1 + 1 } }
-  x.report('block argument') { slow3 { 1 + 1 } }
+  x.report('unused block') { slow3 { 1 + 1 } }
   x.report('yield')      { fast { 1 + 1 } }
   x.compare!
 end