A hybrid between a cond statement and a multi, does it exist?

Wouldn’t Enum.find_value/3 be more appropriate here? Something along the lines:

Enum.find_value(inventory, fn
  %{id: id, name: "Moon Cake"} -> {:eat, id}
  %{id: id, name: "Space Cake", count: count} when count > 10 -> {:eat, id}
  _ -> nil
end)

Enum.find_value is an interesting one, I will start using this thanks! But not fitting to this usecase.

EDIT: Oh a problem with find_value is priority, say we wanna ALWAYS eat the Moon Cake (if we have it) before the Space Cake. Depending on the order of the elements in the inventory that is not guaranteed.

In this particular case imagine the conditional is more complex with many more checks, for example:

cond do
    is_dead(state) -> nil
    is_full(state) -> nil
   ..
end

Using Enum.find_value we will be checking is_dead and is_full on every iteration.

You can do something along the lines of

Enum.reduce_while(inventory, nil, fn                                                                                                                       
  %{id: id, name: "Moon Cake"}, _ -> {:halt, {:eat, id}}                                                                                                     
  %{id: id, name: "Space Cake", count: count}, _ when count > 10 -> {:cont, {:eat, id}}                                                                      
  _, acc -> {:cont, acc}                                                                                                                                     
end)

For anyone else like myself who somehow missed this syntax when they were in elixir school: pattern matching on anonymous functions

I am now cringing thinking of all the fn arg -> case arg do end end in my code

This is getting there but imagine you have an inventory and warehouse now. You want to check if the Moon Cake is in the inventory, then also in the warehouse, in the same cond. So reducing just the inventory is not enough.

@tfwright, Haha its nice.

Sounds to me like you can just reduce both in one go.

I am not seeing it, at least not cleanly. And again the reduce_while loses the order, so if we want to ALWAYS eat Moon Cake BEFORE Space Cake if we have both, the reduce_while does not fit the bill.

It doesn’t, it terminates as soon as you find a Moon Cake.

[
  %{count: 12, id: 1, name: "Space Cake"},
  %{id: 2, name: "Moon Cake"},
  %{count: 8, id: 3, name: "Space Cake"},
  %{count: 16, id: 4, name: "Space Cake"},
  %{count: 3, id: 5, name: "Space Cake"},
  %{count: 11, id: 6, name: "Space Cake"},
  %{count: 1, id: 7, name: "Space Cake"},
  %{count: 15, id: 8, name: "Space Cake"},
  %{count: 7, id: 9, name: "Space Cake"},
  %{count: 18, id: 10, name: "Space Cake"}
]
iex(19)> Enum.reduce_while(inventory, nil, fn                                                                                                                       
...(19)>   %{id: id, name: "Moon Cake"}, _ -> {:halt, {:eat, id}}                                                                                                     
...(19)>   %{id: id, name: "Space Cake", count: count}, _ when count > 10 -> {:cont, {:eat, id}}                                                                      
...(19)>   _, acc -> {:cont, acc}                                                                                                                                     
...(19)> end)
{:eat, 2}

Sigh, but this is just fitting a ironcast mold to the exact problem, with the cont and halt. Okay new requirement there is a Blackhole Cake now. And it should be prioritized last (so if have Moon Cake, Space Cake and Blackhole Cake) eat only 1 in that priority.

All of a sudden this new requirement which is very practical as the system grows is going to lead to a nasty refactor.

Does not sound like a big deal honestly.
Store the whole map in the acc and build your logic around that.