Unfortunately, as you probably already know, Ruby. To be absolutely clear, I really like it (though I have little to compare it against), but it has its … idiosyncracies. For example, there are approximately 837 methods that will return you the size of a list:

``````array = [1, 2, 3, 4]

array.count
=> 4

array.size
=> 4

array.length
=> 4
``````

But should you want to add all the numbers in `array` together, you will find exactly zero methods in Ruby called `sum`.

Fortunately (?) there’s a completely opaque and advanced Ruby solution that you can use to perform literally the simplest mathematical operation on a list of numbers in the most convoluted way possible. It’s called `inject`.

With thanks to my friend nelhage (and apologies where they are due – any inaccuracies are most definitely mine), let’s do some simple addition:

``````array = [1, 2, 3, 4]
array.inject(0) { |sum, x| sum + x }
=> 10
``````

Don’t panic. We’re gonna get through this together.

`inject` takes both an argument and a block. (The argument I’ve specified, `0`, is actually the default, meaning I could have left it out entirely and Ruby would have been just fine with that. I included it for illustrative purposes, but the cool thing is if I had made it `1`, the whole thing would have returned 11. Play around in pry and see for yourself.)

The block is just a bit of code like others you’ve seen. It takes two arguments of its own, which I’ve named `sum` and `x`, but these are of course arbitrary and while I was playing around with `inject` I literally named them `grapes` and `bananas` for a bit just to prove their arbitrariness to myself. (But remember, computer programs are handcranked by people, so give your variables and arguments names that are meaningful to people!) `sum` is the result of what’s happening in the block, so the first time it runs (before the block has had a chance to do anything), `inject`’s argument (in this case `0`) is the value of `sum`. `x` is the next array item in sequence.

^^^^ but that’s all super confusing. Let’s walk through what’s actually happening. Recall:

``````array = [1, 2, 3, 4]
array.inject(0) { |sum, x| sum + x }
``````
• `inject` calls the starting value `0` and conveniently sticks that in `sum`. It adds `sum` to the first value in our array, `1`, meaning where `sum = 0` and `x = 1`, `sum + x = 0 + 1`. This returns a sum of `1`, which is looped back into the block now as the new value of `sum`.

• Now in our second pass through the block, `sum = 1` and `x = 2`, the next value in the array. So now `sum + x = 1 + 2`. This returns a value of `3`, which is passed back into the block as the new new value of `sum`.

• On our third iteration, `sum` is `3` and now `x` is `3` (the third item in our array). So `sum + x = 3 + 3` returns of value of `6`, which is passed back into the block as the next value of `sum`.

• Now `sum` equals `6` and the value of `x` is `4`, the fourth (and final) value in the array. Therefore, `sum + x = 6 + 4`, which returns a final value of `10`.

`=> 10`

Congratulations! You are now equipped to define your own `sum` method:

Turns out there’s more cool stuff you can do with `inject`! But I’m saving it for my next post because there’s already enough words on this page.