Request for blog post feedback: understanding Enum.reduce at a fundamental level

Reduce (also know as left fold) is a way to “loop” in FP. It is defined as (in general case, not exactly in Elixir):

def reduce([], agg, _fun), do: agg
def reduce([hd | tl], agg, fun), do: reduce(tl, fun.(hd, agg), fun)

This is very basic operation, as from there you can define all other operations:

def reverse(list), do: reduce(list, [], &[&1 | &2])
def map(list, fun), do: list |> reduce([], &[fun.(&1) | &2]) |> reverse()
def filter(list, pred) do
  list
  |> reduce([], fn x, agg ->
    if pred.(x), do: [x | agg], else: agg
  end)
  |> reverse()
end
# Etc.

In other words - reduce is another way to represent TCO-recursive function.

Some things in your post:

1. There are no methods in Elixir, only functions.
2. Enum.reduce/2 will use the head of the input as initial accumulator, while reducing over the tail. The head is not included in the reduction, but in your post you suggest it were.

Those are the 2 points that I stumbled over.

TCO was the rabbit hole I was looking for. Thanks!