Array#concat vs Array#+

[hvenables]

require "benchmark/ips"

RANGE = (0..100_000)

def fast
  array = []
  RANGE.each { |number| array.concat([number]) }
end

def slow
  array = []
  RANGE.each { |number| array += [number] }
end

Benchmark.ips do |x|
  x.report("Array#concat") { fast }
  x.report("Array#+")      { slow }
  x.compare!
end

ruby 2.5.1p57 (2018-03-29 revision 63029) [x86_64-darwin18]

Warming up --------------------------------------
        Array#concat     5.000  i/100ms
             Array#+     1.000  i/100ms
Calculating -------------------------------------
        Array#concat     62.530  (±11.2%) i/s -    310.000  in   5.037308s
             Array#+      0.194  (± 0.0%) i/s -      1.000  in   5.155399s

Comparison:
        Array#concat:       62.5 i/s
             Array#+:       0.2 i/s - 322.37x  slower

Happy to make a PR if you want this added

[wasifhossain]

Hi @hvenables do you think the above benchmark could also include << and push. The benchmark is also quite interesting:

def append
  a = []
  RANGE.each { |i| a << i }
end

def push
  a = []
  RANGE.each { |i| a.push i }
end

Benchmark.ips do |x|
  ...
  x.report('Array#<<') { append }
  x.report('Array#push') { push }
end

Comparison:
                  Array#<<:      148.0 i/s
                Array#push:      130.9 i/s - same-ish: difference falls within error
              Array#concat:       69.5 i/s - 2.13x  slower
                Array#plus:        0.1 i/s - 1074.86x  slower

[hvenables]

The case i had was where i wanted to put two arrays together (each array had more than one item in the array) I just used the above examples for simplicity. The examples you stated above could only be for a single item being pushed into an array unless it was flattened after which i will add

[hvenables]

So i have changed it to add a 10 element array to an existing array

require "benchmark/ips"

RANGE = (0..10_000)

def concat
  array = []
  RANGE.each { |number| array.concat(Array.new(10, number)) }
end

def plus
  array = []
  RANGE.each { |number| array += Array.new(10, number) }
end

def append_flatten
  array = []
  RANGE.each { |number| (array << Array.new(10, number)).flatten! }
end

def push_flatten
  array = []
  RANGE.each { |number| array.push(Array.new(10, number)).flatten! }
end

Benchmark.ips do |x|
  x.report("Array#concat") { concat }
  x.report("Array#+")      { plus }
  x.report("Array#<<, #flatten") { append_flatten }
  x.report("Array#push, #flatten") { push_flatten }
  x.compare!
end

~ » ruby -v concat_vs_+.rb                                                                                                                                                                                                                     harryvenables@Harrys-MacBook-Pro
ruby 2.5.1p57 (2018-03-29 revision 63029) [x86_64-darwin18]
Warming up --------------------------------------
        Array#concat    20.000  i/100ms
             Array#+     1.000  i/100ms
  Array#<<, #flatten     1.000  i/100ms
Array#push, #flatten     1.000  i/100ms
Calculating -------------------------------------
        Array#concat    230.591  (± 5.2%) i/s -      1.160k in   5.044022s
             Array#+      1.571  (± 0.0%) i/s -      8.000  in   5.117191s
  Array#<<, #flatten      0.033  (± 0.0%) i/s -      1.000  in  30.413678s
Array#push, #flatten      0.034  (± 0.0%) i/s -      1.000  in  29.547885s

Comparison:
        Array#concat:      230.6 i/s
             Array#+:        1.6 i/s - 146.77x  slower
Array#push, #flatten:        0.0 i/s - 7719.24x  slower
  Array#<<, #flatten:        0.0 i/s - 7945.42x  slower

[wasifhossain]

aha! now I get your context 👍 thanks for the clarification.
In that case, your first example looks much better given that you mention about the context :)

[ixti]

I'm not sure why comparing destructive ops to non-destructive ones in a first place, but at least push_flatten and append_flatten should call flatten! after adding all the elements.

[hvenables]

Yeah tbh i added them after the comments above but i think the first example should be the one to be used i dont see push_flatten or append_flatten as real answers to the problem

[ixti]

My biggest concern is that + and concat are actually serving different purposes. + creates new array, while concat modifies in-place. So the comparison to me seems as good as comparing Hash#dig to IO#read (also serve different purposes). :D

[hvenables]

Cool, i see your point ill close the issue then :)

[ixti]

In fact I think we can have this but with bold statement on difference.

[mikegee]

Users might be aware of the difference between creating a new array versus modifying it in-place, as long as their code behaves correctly. This benchmark seems valuable to me.