That wasn’t the point. Your statement was that a solution involving Enum.reduce/3 would be inelegant because you elected to use some conditional logic to select an appropriate initial value. I merely pointed out that it is possible with a multi clause anonymous function to simply swap out the supplied default value if and when the first element is processed.

I think that you have found the solution that works best for your particular situation.

That being said I find that Enum.reduce/2 isn’t as generally useful as the Enum.reduce/3 form - conceptually Enum.reduce/2 is simply a specialized case:

def reduce([h|t],f) do
  Enum.reduce(t,h,f)
end

of Enum.reduce/3 which results in the following limitations:

• The list has to have at least one item (as you have found out for yourself) as the presence of a “head” is required.
• The head of the list is (potentially) never processed in the same fashion by the supplied function as all the subsequent elements are - as it is simply treated as an initial value.

So even with your solution I’d still be tempted to use Enum.reduce/3 over Enum.reduce/2 in the following fashion:

  def run([]),
    do: :no_winner
  def run([x|xs]),
    do: (Enum.reduce xs, x, &iteratee/2)

simply because it is much clearer that the head of the list is being treated as an initial value and therefore may be processed differently to the remaining elements (depending on the logic in iteratee). When “reducing” Enum.reduce/3 should be the “goto”. When you know that you are dealing with a list you can use the equivalent List.foldl/3 or List.foldr/3 which processes the elements in the opposite order.

There is no harm in forgetting that Enum.reduce/2 even exists - it’s a “convenience” form that isn’t all that convenient.