Enum.concat/2 for two lists is implemented as:

  @spec concat(t, t) :: t
  def concat(left, right) when is_list(left) and is_list(right) do
    left ++ right
  end

In 99% of the code I write performance is not important so I just use whichever is more expressive for the data I have. For example, compile-time list concatenation? Hell yeah use ++.

However, I believe many general libraries (and the enum module itself in some list building methods) take a prepend then reverse strategy. You’ll see that if you search for Enum.reverse in the elixir code.

Down in erlang, reversing a list executes a heavily optimized native BIF (built-in-function) because it’s a frequently used feature, so it’s probably not as expensive as you think. That being said, unless your lists are long or you’re in a performance critical part of code, don’t worry too much. Do what’s most expressive.

But if you do need to optimize, be sure to benchmark. For some length of list and algorithm append may be faster, but if the length of the list changes, then prepend-then-reverse may be faster.

I find many times the ordering does not have bearing on the correctness of the code. In those cases I prepend out of habit.

Thank you all for the comments. I think i was just overthinking it..

It’s very good to be curious – shows intellect.

IMO make a very small Elixir project where you benchmark all the approaches you can think of – and with differently sized lists. benchee is an excellent library for this.

Definitely do satisfy your curiosity but also do measure because often you’d end up quite surprised.

And, in real projects, absolutely go for what’s more readable as others said.

Or you can look at the fast-elixir benchmark which breaks down the various techniques by list size.

That’s a great resource. Based on the results with respect to this question, it makes me wonder why Enum.concat/1 is implemented the way that it is.

Because it removes one level of nesting, for any kind of enumerable.

In general, you should always append to the front of the list and reverse list only when needed, as often one will need to append to list much more often than reading it in order. This is one of the improvements that I have introduced in Sentry some time ago, as breadcrumbs were constructed much more often than these were used (only in case of error).

Say what now? You worked at Sentry?