Lists and Tuples in Elixir

Elixir gives you two fundamentally different ways to group values in order: lists and tuples. A list, written as [1, 2, 3], is a singly linked list built out of head/tail pairs called cons cells — each element points to the rest of the list. A tuple, written as {1, 2, 3}, is a fixed-size, contiguous block of memory where every element sits at a known offset. Because they are stored so differently, they behave very differently under the hood: lists are cheap to grow at the front but expensive to index into, while tuples are cheap to read from any position but expensive to change.

Internally, an Elixir list is either the empty list [] or a cons cell of a head element and a tail that is itself a list, so [1, 2, 3] is really [1 | [2 | [3 | []]]]. This structure makes prepending with the | (cons) operator an O(1) operation, because you're just creating one new cell pointing at the existing list — nothing is copied. Appending to the end, or reading the element at index n, is O(n) because Elixir must walk the entire chain from the head. Functions like Enum.at/2, List.first/1, and hd/1 reflect this: hd/1 and List.first/1 are fast, but Enum.at(list, 500) is not.

Tuples store a fixed number of elements in contiguous memory with a size header, so elem(tuple, index) is an O(1) direct-offset read regardless of tuple size. This makes tuples ideal for fixed-shape data that you read often but rarely restructure, such as coordinates {x, y}, RGB colors {255, 0, 0}, or the ubiquitous {:ok, value} and {:error, reason} result tuples returned by functions like File.read/1 or Map.fetch/2. Because the tuple's tag (the first element, usually an atom like :ok or :error) is known at the call site, pattern matching on tuples in a case or function clause is both fast and expressive.

The rule of thumb is: use lists for collections whose length varies and that you mostly traverse from the front (recursion, Enum pipelines, streaming), and use tuples for a fixed, small number of heterogeneous values you access by position, especially return values. Because tuples are contiguous, put_elem/3 or setelem-style updates must copy the entire tuple to produce a new one, so tuples are a poor fit for anything that grows or shrinks, or that you update repeatedly in a loop — that pattern belongs to a list, a map, or an accumulator passed through recursion.

The List module offers List.flatten/1 to collapse nested lists, List.first/1 and List.last/1 for endpoints, and List.delete/2 for removing a value, while the broader Enum module (map, filter, reduce, sort) works on any list because lists implement the Enumerable protocol. The Tuple module is deliberately small: Tuple.to_list/1, Tuple.insert_at/3, Tuple.delete_at/2, and elem/2 cover most needs, reflecting that tuples are meant to stay small and fixed rather than be manipulated like collections.