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

Questions / Help
, ,
1

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

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

  end
end

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

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:

Screen Shot 2022-01-30 at 12.34.45 PM
Screen Shot 2022-01-30 at 12.34.45 PM1200Ă—607 41.4 KB

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

2

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}"}
  end)
1 Like
3

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

2 Likes
4

thanks kip, will try that…

5

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

thanks again

6

Also Enum.map_reduce !

7

thanks lud, that was the answer…

1 Like
8

also list comprehensions, (for)

9

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
end)
# returns the TOTAL: 10

Enum.scan(numbers, 0, fn n, acc ->
  n + acc
end)
# 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:

business_card
|> String.split("\n")
|> Enum.scan({0, ""}, fn line, {acc_number, _} ->
  {acc_number+1, line}
end)
|> Enum.map(fn {n, line} ->
  "#{n}$#$#{line}
end)
6 Likes
10

@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…

11

thanku more reading… LoL

1 Like
12

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.

13

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
14

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.