Weight-based random sampling

That really helped clarify it for me, thank you

Pattern matching‡ is the conditional construct - the case expression is just one way of utilizing it.

‡ Not to be confused with destructuring:

• Kernel.destructure/2
• JavaScript destructuring assignment

I’m not sure if elixir does this already, but yes, at least for the core-erlang representation it is necessary to do so, as core erlang only has single clause functions IIRC.

Not only semantically. Afaik the compiler does take functions with many function heads and makes them be a single function with a case statement inside.

As @LostKobrakai already pointed out, both do the same thing. They select the item from the list of items.

The multiheaded function you see there, has nothing to do with “differentiating functions by arity”, in fact, nothing is differentiated there, both are the same function, as both have the same name and the same arity.

What though I do use there is “pattern matching”, something very important to learn and understand when writing elixir.

To be honest, those 2 function clauses are semantically equivalent with the following single-clause function:

defp select_item(items, idx) do
  case items do
    [{name, weight}|_] when idx < weight -> name
    [{_, weight} | tail] -> select_item(tail, idx - weight)
  end
end

But it is idiomatic to move such a case which matches on an argument directly and spans the full function body into a multi clause function.

Also in general pattern matching in the functions head or a case is usually prefered of using if and some predicate functions and/or using getter functions.

I’d say both select an item. So they’re doing the same job. Just some inputs might recurse a few more times than others to get to an answer.

Thank you so much everyone! This is way more than I expected. It’s a lot to digest, I’ve learned so much. I like @gregvaughn’s suggestion the most, not because of the struct idea, but because it seems to me to realise the thought process in my original approach, except without all the noobish bloat. The struct idea is also fascinating as well of course.

A quick question about differentiating functions by arity, like this:

This of course seems to be quite idiomatic, but I’m struggling with reaching for it myself. I just feel that if a function does something different it should have a different name. Perhaps naively I think it’s better to make the condition explicit in say a case statement, and then call out to differently named functions just so that the intent of the code becomes more intuitive. Thoughts?

I side with you. I see @peerreynders’s point but I’ve done my exercises and re-implemented most of Enum.

For such problems, start with idiomatic Elixir code and only go for hand-rolled algorithms if performance is of utmost importance.

Yes. I sign this. During learning you are totally correct.

But the question was about idiomatic code, not what would I write when I learn about recursion. And using Enum and Stream is by far the most idiomatic way dealing with lists and other “iterables”.

FYI …

Of course, one should be able to implement some functions in Enum on their own (for lists at least). map , reduce , reverse , concat , those are my personal favorites …

When learning to a certain degree it can be helpful to make Enum off-limits until recursion (body and tail) is well understood - otherwise Enum can be come a crutch.