How to extract info from an Enum.reduce function other than a single item

I have a need to extract the individual items from an Enum.reduce function but I get is the single value from the acc.

Here is the sample code:

defmodule Demo do
  def add_sequence_number(business_card) do

        |> String.split("\n")
        |> Enum.reduce(1, fn (x, acc) -> IO.inspect "#{acc}$#$#{x}"; acc + 1 end)


business_card = """
Bruce Waine,Batman
Bat cave
Gotham City, NY 12345

Gotham Security Services Co
Crime fighter
Wonder Woman

new_card = Demo.add_sequence_number(business_card)

IO. puts "\nthis is the result:  #{new_card}\n"

here is a screen shot of the result:

what I need is the array from the inner reduce function but I am getting is the result of 10 and I need to access the list as in the image.

any tips, thank you

Whatever the function returns become acc on the next iteration. And whatever acc is at the end is returned by Enum.reduce/3. Therefore you will be accumulating a list of results in many common cases, including this one.

Think more along the lines of:

{count, results} =
  Enum.reduce(cards, {0, []}, fn (x, {seq, acc) ->
    seq = seq + 1
    {seq, "#{seq}$#$#{x}"}
1 Like

You don’t exactly need Enum.reduce then, you likely need Enum.with_index plus, but it can be done with Enum.reduce by using a tuple accumulator as @kip showed you.


thanks kip, will try that…

thanku dimitarvp working on kip’s suggestion. I’m trying to wrap my head around the reduce function…

thanks again

Also Enum.map_reduce !

thanks lud, that was the answer…

1 Like

also list comprehensions, (for)

A helpful way to think about these situations is to think about the types.

Enum.reduce expects a function of type (element, accumulator) -> accumulator and returns a result of type accumulator.

Enum.scan expects a function of type (element, accumulator) -> accumulator and returns a result of type [accumulator], so it’s worth considering if you’re expecting a list of results.

A good example for comparing the two is with lists of integers:

numbers = [1, 2, 3, 4]

Enum.reduce(numbers, 0, fn n, acc ->
  n + acc
# returns the TOTAL: 10

Enum.scan(numbers, 0, fn n, acc ->
  n + acc
# returns the list of SUBTOTALS: [1, 3, 6, 10]

In your example, using binaries (like "1$#$Bruce Waine, Batman") as an accumulator type is less than ideal. A better intermediate format would be a tuple like {1, "Bruce Waine, Batman"}, resulting in code like:

|> String.split("\n")
|> Enum.scan({0, ""}, fn line, {acc_number, _} ->
  {acc_number+1, line}
|> {n, line} ->

@al2o3cr thanks Matt great explanation, I’m starting from scratch again. this little exercise was to practice pattern matching using a sample business card and reformat two sections the personal profile and the company profile. so much for easy examples…

thanks for you help, I guess I have to go back and ready all of the Enums, Maps and related docs… it never ends…

thanku more reading… LoL

1 Like

Knowing Enum and Stream inside out is essential for practicing functional programming. You can read less on almost everything else but those two you should be intimately familiar with.

yeah, I got you on the one, been reading on Enum and it’s beginning to come out of my ears… LoL :slight_smile: thanks

1 Like

btw you can also go and do Exercism.IO’s Elixir track. There is also a chapter where you have to reinvent part of the Enum module yourself – that was a huge eye-opener for me.