Map, filter and reduce

I’d go for roughly the following as an avg function:

def avg(list)
  list
  |> Enum.reduce({0, 0}, &avg/2)
  |> avg_finalize
end

defp avg(x, {sum, count}), do: {sum + x, count + 1}
defp avg_finalize({sum, count}), do: sum / count

The cool thing about this is, that you only need to iterate a single time over the input list.

Currently it would fail on non-numeric input, but you can easily define appropriate guards. Adding one which does simply ignore nils should be easy.

And as a small rule of thumb, when you start chaining from one Enum-function into another, you might think about using Stream instead to reduce the number of iterations over the complete input.

But this really depends on the size of your input, if your input is short enough and the Enum-chains also, then Stream might take much more time.

Applying @NobbZ’s approach to your specific situation, I’d be looking at something like:

people = [%{name: 'Mary', height: 160},
                %{name: 'Paul', height: 180},
                %{name: 'Hugo'}]

{total_height, count_people_with_height} =  
  Enum.reduce(people, {0,0}, fn %{height: height}, {sum, count} -> {sum + height, count + 1}
                                                _, {sum, count} -> {sum, count}
end)

IO.puts total_height / count_people_with_height

You are almost at the stage where it is easier to write the loop directly and not use Enum.

You say “loop” and that makes me wonder. I don’t see a good way to do it in one pass with a list comprehension. I can do it with recursion, but I prefer Enum.reduce

defmodule Test do
  def avg(maps), do: avg(maps, {0,0})
  def avg([], {total, count}) when count > 0, do: total / count
  def avg([%{height: height} | tail], {total, count}), do: avg(tail, {total + height, count + 1})
  def avg([_ | tail], acc), do: avg(tail, acc)
end

people = [%{name: 'Mary', height: 160},
          %{name: 'Paul', height: 180},
          %{name: 'Hugo'}]
IO.puts Test.avg(people)

My professor for functional programming used to say, that “loop” is just another word for recursion

Thanks for your replies! I really appreciate ! I’m a totally noob with functional programming and elixir. This is far different from traditional OOP…

Hi,
I am at very nascent stage in elixir , was wondering how can we achieve below case scenario in elixir

var doctors=[
    { doctorNumber: "#9",  playedBy: "Christopher Eccleston", yearsPlayed: 1 },
    { doctorNumber: "#10", playedBy: "David Tennant",         yearsPlayed: 6 },
    { doctorNumber: "#11", playedBy: "Matt Smith",            yearsPlayed: 4 },
    { doctorNumber: "#12", playedBy: "Peter Capaldi",         yearsPlayed: 1 }
] 

I only require to get only two columns out of three with new column names !

doctors = doctors.map(function(doctor) {
    return { // return what new object will look like
        doctorNumber:doctor.number,
        playedBy: doctor.actor,
        
    };
});

Assuming that above is javascript, the equivalent in Elixir would be:

doctors=[
  %{ doctorNumber: "#9", playedBy: "Christopher Eccleston", yearsPlayed: 1 },
  %{ doctorNumber: "#10", playedBy: "David Tennant", yearsPlayed: 6 },
  %{ doctorNumber: "#11", playedBy: "Matt Smith", yearsPlayed: 4 },
  %{ doctorNumber: "#12", playedBy: "Peter Capaldi", yearsPlayed: 1 }
]

So getting just a list of maps containing all of the dockerNumber’s and playedBy’s only would be as a direct translation of your next javascript (assuming you meant to swap the keys and values since they were backwards):

doctors = Enum.map(doctors, fn doctor -> %{
  number: doctor.doctorNumber,
  actor: doctor.playedBy
} end)

As seen here:

iex> doctors=[
  %{ doctorNumber: "#9", playedBy: "Christopher Eccleston", yearsPlayed: 1 },
  %{ doctorNumber: "#10", playedBy: "David Tennant", yearsPlayed: 6 },
  %{ doctorNumber: "#11", playedBy: "Matt Smith", yearsPlayed: 4 },
  %{ doctorNumber: "#12", playedBy: "Peter Capaldi", yearsPlayed: 1 }
]
[%{doctorNumber: "#9", playedBy: "Christopher Eccleston", yearsPlayed: 1},
 %{doctorNumber: "#10", playedBy: "David Tennant", yearsPlayed: 6},
 %{doctorNumber: "#11", playedBy: "Matt Smith", yearsPlayed: 4},
 %{doctorNumber: "#12", playedBy: "Peter Capaldi", yearsPlayed: 1}]
iex> doctors = Enum.map(doctors, fn doctor -> %{
  number: doctor.doctorNumber,
  actor: doctor.playedBy
} end)
[%{actor: "Christopher Eccleston", number: "#9"},
 %{actor: "David Tennant", number: "#10"},
 %{actor: "Matt Smith", number: "#11"},
 %{actor: "Peter Capaldi", number: "#12"}]

There are other more traditionally elixir’y ways, but for such a simple example this is a simple output.

Woah, thanks a lot ,excellent ! can we also club filter with existing map, just curious though !

doctors = doctors.filter(function(doctor) {
    return doctor.begin > 2000; // if truthy then keep item
}).map(function(doctor) {
    return { // return what new object will look like
        doctorNumber: "#" + doctor.number,
        playedBy: doctor.actor,
        yearsPlayed: doctor.end - doctor.begin + 1
    };
});

The ‘traditional’ Elixir way of writing that is in one of two forms, either via Enum piping:

doctors
|> Enum.filter(fn doctor -> doctor.begin > 2000 end)
|> Enum.map(fn doctor -> %{
  doctorNumber: "#" <> to_string(doctor.number),
  playedBy: doctor.actor,
  yearsPlayed: doctor.end - doctor.begin + 1
} end)

Or via a for comprehension:

for
  %{doctorNumber: doctorNumber, playedBy: playedBy} <- doctors, # First grab each doctor out of the list (you can also match out parts here too, but it is numerous in this example so keeping it short)
  doctor.begin > 2000, # Then filter on a condition
  do: %{ # Then return the result after filtering, this example can be arbitrarily complex and remains easier to read when it does
    doctorNumber: "#" <> to_string(doctor.number),
    playedBy: doctor.actor,
    yearsPlayed: doctor.end - doctor.begin + 1
  }

Or something like that.

EDIT: Also, this forum is Discourse, it supports normal markdown, so using code fences like:

```elixir
def Some elixir code
```
```javascript
var Some javascript code
```

Gets turned into this:

def Some elixir code

var Some javascript code

With syntax coloring and all.