Why do tuples exist?

Older functional language such as Lisp do not have tuples. So they are not strictly speaking necessary. However, they make certain ideas clearer, certain operations cheaper, so most modern languages, functional or not, tend to have it.

As for where to draw the line, just look at elixir’s core library. Ask yourself why a tuple is used instead of a list anywhere you see it. Eventually you will have the idea.

Tuples and Lists are both compound data structures. Lists typically store multiple instances of the same type of thing. Tuples typically store different types of things. Tuples are lousy at enumerating through the elements. Lists are great at that.

Ok, thanks.

I guess it is going to come down to how the community has decided that tuples should be used? For example in function responses and representing things like x,y coordinates. That is where I have seen them.

To me, it seems that if Tuples are not great at enumerating, then Lists have them covered.

Tuples have an advantage over lists because they’re stored contiguously. They have better ‘spatial locality’. Caching benefits from two types of locality, ‘temporal’ which is reusing a specific part of memory, or ‘spatial’ locality, which is the ability to load a segment of data into a CPU cache / RAM and have fast access to parts of that data because they’re close together. Tuples help with the later. Lists potentially require more random memory access.

Due to these characteristics, tuples are comparatively fast to read and create but slow to modify. More detailed information can be found here: Client Challenge

Thanks!

Tuples are like immutable arrays in other languages.

Additionally, they are used as a workaround to overcome the problem of functions not being able to return more than one value. With tuples you can encapsulate an arbitrary amount of return values.

I would say the main benefit is access time. Tuple are fast for reading but not for adding elements.
If the size of your data structure is not going to change, tuple is a good option. You can determine the size of a time in constant time, while with a list you need to traverse the whole list to find out how long it is.

To pile in on this one

Tuples are: strictly positional (you won’t be moving their contents around, nor will you be referencing the contents by keys, and pattern matches must be exact), are not Enumerable (so you won’t get to use the Enum module), relatively space efficient (caveats apply) and fast for random access (due to positional nature). Various mutations are provided in the Tuple module.

Maps are: fast lookups, good update performance, values have lookup keys, they are Enumerable, and pattern matches are quite free-form due to the key’d values

Lists are: Enumerable, suited to collections of items, poor for random access at large sizes, but good for iterating and modifying. The swiss-army-knife data bag of Elixir, and often more than fast-enough in most cases.

Keyword lists are: Lists of 2-Tuples!

As Keyword lists show, these can all be mixed and matched: tuples as the values (or keys!) of maps, maps as the values in a list, lists as elements in tuples .. algebraic types ftw!

This blog from @sasajuric is also a great resource. Comparing some different data structures in different scenarios. Seems like tuples definitely have their place in some use cases

Indeed, and not only for performance reasons. When one wants to ensure that the data is of a specific size, they are perfect.

Lists and maps can be of different sizes, though they can be checked for length (at a cost), while with a tuple ensuring an exact count of elements can be done with a simple pattern match.

Keyword is a neat example of this. As a list of tagged tuples, it guarantees that each entry has exactly 2 members, and that the entries appear in the order of creation (thanks to being in a list). This would be more awkward with either lists-only or a map, and given how Keyword lists tend to be used would likely be slower (well, I haven’t benchmarked that, but it wouldn’t surprise me in the least)

The common {:ok, data} | {:error, reason} pattern for function returns is another.