Joining list and tuple?

That works for any term:

iex> [] ++ 3
3

iex> [] ++ "foo"
"foo"

The return value is an improper list. As you can read in the documentation, when the right-hand side of this function (++/2) is not a list, the return value is an improper list. (Point being, a tuple is not a list).

In this case as the lhs of ++ is [], an empty list, it will be skipped by ++. The reason is that ++ appends it rhs to the end of the list in the lhs. It doesn’t check the rhs just appends it to the lhs.

iex(2)> [1,2,3] ++ [:a,:b,:c]
[1, 2, 3, :a, :b, :c]
iex(3)> [] ++ [:a,:b,:c]
[:a, :b, :c]
iex(4)> [1,2,3] ++ {:ok,42}
[1, 2, 3 | {:ok, 42}]
iex(5)> [] ++ {:ok,42}
{:ok, 42}

If the rhs is not a list then result will be an improper list.

What exactly is an improper list? If a list is a singly-linked list, it has hierarchical structure something like ["a", ["b", ["c"]]], yes? Sorry if I am not understanding.

An improper list is a linked list that does not have a list as its last element. So

# this is fine 
[1 | [2 | [3]]] 

# this is an improper list 
[1 | [2 | 3]]

Which you can see if you type the above into an iex shell.

ok, so lists in elixir are linked lists, so the list [1, 2] is actually (1 → (2 → ??))

That ?? has to be something, it can’t be dangling. By convention we pick [], because it makes a lot of recursion type things look really nice, and as a bonus [] at two bytes is the smallest object in the erlang world.

so really it’s (1 → (2 → []))

However, ?? could be literally anything, so if it’s anything besides [], then it’s called an improper list. A lot of things (like the entire Enum module) break with improper lists, and you have to handle recursion with care - so be careful. Why would you use it? It does take slightly less space, so if you are implementing something on a system with tight storage requirements (like embedded) with a ton ton ton of really short lists, it might be worth it.

Also note the notational differences, if you have an improper list (1 → (2 → 3)), the default notate it is:

[1, 2 | 3]

which is not the same as

[1, 2, 3]

which is (1 → (2 → (3 → [])))

This strikes me as not a great tradeoff. Is this really the only reason improper lists are allowed?

Iirc it’s generally considered to be a 'legacy concept from an earlier era". Just know you might run into it if you’re using an older erlang library, otherwise you will probably not run into it. Also certain datatypes allow it, e.g. iodata, as you send to IO.iodata_to_string

thanks this is very much helpful!

I guess my concern was that I might create an improper list inadvertently, and the compiler won’t flag it. So then your Enum breaks and you don’t understand why.

I think it’s pretty unlikely. In about 2.5 years of elixir and probably about 60 kloc that’s never happened to me that I can recall.

Besides, now you’ll understand why!