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

Hey y’all. Long time reader of the forum. I’m new to Elixir and I’m hoping writing technical blog posts will help me solidify my understanding.

I was wondering if anyone could take a look at a draft I wrote here: https://github.com/ealmz/elixir_from_first_principles/blob/master/reduce.md

It’s basically my current understanding of how reduce in Elixir works. I’m aware that there are many gaps in my knowledge but I’d love to hear what you think, especially strong critical feedback of how to make this post better.

What I think I’m missing:

• How Elixir’s reduce method compares to those in other languages
• Why reduce is important? In other words, what are the alternative ways to solve for the problem `reduce` addresses if not in this way.
• Core CS concepts I’m unaware of.

What are your thoughts on that list or what else do you think I should address to really get at the core of what this function is doing?

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.

4 Likes

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.

2 Likes

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