Inject and reduce are different names for the same thing. In other languages these functions are often called folds (like foldl or foldr). These methods are available on every Enumerable object.

Inject takes a two argument function and applies that to all of the pairs of elements in the Array.

For the array `[1, 2, 3]`

we can add all of these together with the starting value of zero by specifying a starting value and block like so:

```
[1,2,3].reduce(0) {|a,b| a + b} # => 6
```

Here we pass the function a starting value and a block that says to add all of the values together. The block is first run with `0`

as `a`

and `1`

as `b`

it then takes the result of that as the next `a`

so we are then adding `1`

to the second value `2`

. Then we take the result of that (`3`

) and add that on to the final element in the list (also `3`

) giving us our result (`6`

).

If we omit the first argument, it will set `a`

to being the first element in the list, so the example above is the same as:

```
[1,2,3].reduce {|a,b| a + b} # => 6
```

In addition, instead of passing a block with a function, we can pass a named function as a symbol, either with a starting value, or without. With this, the above example could be written as:

```
[1,2,3].reduce(0, :+) # => 6
```

or omitting the starting value:

```
[1,2,3].reduce(:+) # => 6
```