Solve a list twice

Compare explicit recursion with `Enum.reduce/3`.

01 · Start with the whole example

Run this first

Run it once, change one input, and compare the new result.

Elixir

# Compare recursion with a library fold
defmodule Totals do
  def sum([]), do: 0
  def sum([head | tail]), do: head + sum(tail)
end

numbers = [1, 2, 3, 4]
{Totals.sum(numbers), Enum.reduce(numbers, 0, fn n, acc -> n + acc end)}

Check the result first

Both paths return 10, so the result is {10, 10}.

02 · Take the code apart

Read from the first line down

Read sum([]): Stop at an empty list.
Read sum([head | tail]): Handle one item and the remaining list.
Read Enum.reduce/3: Fold values into one accumulator.

03 · Meet the new symbols

Symbols are not secret signs

sum([])

Stop at an empty list.

sum([head | tail])

Handle one item and the remaining list.

Enum.reduce/3

Fold values into one accumulator.

04 · Ideas inside the code

Match each name to its meaning

base clause

A recursive function needs a clause that returns without calling itself.

recursive clause

The recursive clause handles one piece and calls itself with a smaller input.

fold

Enum.reduce/3 carries an accumulator through a collection.

05 · Make the idea clear

Why these forms are useful

Run the example first. Predict one result, then change one input and run it again.

A recursive function needs a clause that returns without calling itself.

The recursive clause handles one piece and calls itself with a smaller input.

06 · Change it yourself

Close the answer and try

Multiply [2, 3, 4] with Enum.reduce/3.

Practice starting point

Enum.reduce([2, 3, 4], ____, fn number, acc -> ____ end)

Target result: Return 24.

Stuck? Read one hint

Start the accumulator at 1 and multiply it by each number.

After you run it, see one answer

One answer

Enum.reduce([2, 3, 4], 1, fn number, acc -> number * acc end)

Think about it: What stops `Totals.sum/1`?

The sum([]) clause returns 0 without another call.

Take with you

Remember these three lines

1
Every recursion needs a stopping clause.
2
Make recursive input smaller.
3
Prefer clear Enum functions for common collection work.

Lesson completeRun the code once, then mark this lesson as done.