Elixir Lists and Tuples

Welcome to another tutorial on Lists and Tuples in Elixir.

Linked Lists

A linked list refers to a heterogeneous list of elements that are stored at different locations in memory and are kept track of by making use of references. Linked lists are data structures used in functional programming.

Elixir makes use of square brackets to specify a list of values. Values can be of any type, as shown below.

[1, 2, true, 3]

So, when Elixir sees a list of printable ASCII numbers, it will print that as a char list (just like a list of characters). Anytime you see a value in IEx and you are not sure what it is, you can just use the i function to retrieve information about it.

IO.puts([104, 101, 108, 108, 111])

The characters above in the list are all printable. So, when you run the program, you will get this:

hello

Also, you can define lists in another way by using single quotes.

IO.puts(is_list('Hello'))

The output will be:

true

Note that single-quoted and double-quoted representations are not equivalent in Elixir as they are represented by different types.

Length of a List

In order to find the length of a list, we use the length function as shown below.

IO.puts(length([1, 2, :true, "str"]))

The output is:

Concatenation and Subtraction

We can concatenate and subtract two lists by using the ++ and -- operators. Check out the example below.

IO.puts([1, 2, 3] ++ [4, 5, 6])
IO.puts([1, true, 2, false, 3, true] -- [true, false])

This will give you a concatenated string in the first case and a subtracted string in the second, as shown below.

[1, 2, 3, 4, 5, 6]
[1, 2, 3, true]

Head and Tail of a List

The head is the first element of a list, while the tail is the remainder of a list. These lists can be retrieved with the functions hd and tl.

Let’s assign a list to a variable and retrieve its head and tail.

list = [1, 2, 3]
IO.puts(hd(list))
IO.puts(tl(list))

The output is the head and tail of the list. This is shown:

1
[2, 3]

Note: that getting the head or the tail of an empty list is an error.

Other List functions

The standard library in Elixir provides a whole lot of functions to deal with lists. The table below highlights some list functions.

S.no.	Function Name and Description
1	delete(list, item): This deletes the given item from the list, and returns a list without the item. But, if the item occurs more than once in the list, just the first occurrence is removed.
2	delete_at(list, index): This produces a new list by removing the value at the specified index. But, negative indices indicate an offset from the end of the list, and if the index is out of bounds, the original list is returned.
3	first(list): This returns the first element in the list or nil if a list is empty.
4	flatten(list): It Flattens the given list of nested lists.
5	insert_at(list, index, value): This returns a list with a value inserted at the specified index. Take note that the index is capped at the list length. And the negative indices indicate an offset from the end of the list.
6	last(list): This returns the last element in the list or nil if the list is empty.

Tuples

Tuples are data structures that store a number of other structures within them. This is quite unlike lists, as they store elements in a contiguous block of memory. It means that accessing a tuple element per index or getting the tuple size is a fast operation. The indexes always start from zero.

The curly brackets are used to define tuples in Elixir. Just like lists, tuples can hold any value, as shown below.

{:ok, "hello"}

Length of a Tuple

In order to obtain the length of a tuple, use the tuple_size function as shown below.

IO.puts(tuple_size({:ok, "hello"}))

The output is:

Appending a Value

To append a value to the tuple, the Tuple.append function is used.

tuple = {:ok, "Hello"}
Tuple.append(tuple, :world)

This will create and return a new tuple, as shown below

 {:ok, "Hello", :world}

Inserting a Value

In order to insert a value at a given position, either the Tuple.insert_at function or the put_elem function is used. Check out the example below to understand better.

tuple = {:bar, :baz}
new_tuple_1 = Tuple.insert_at(tuple, 0, :foo)
new_tuple_2 = put_elem(tuple, 1, :foobar)

In the above code, you can see that put_elem and insert_at returned new tuples. But, the original tuple stored in the tuple variable was not modified because Elixir data types are immutable. What this means is that Elixir code is easier to reason about, as you never need to worry if a particular code is mutating your data structure in place.

Tuples vs. Lists

What is the difference between lists and tuples?

Lists are stored in memory as linked lists, which means that every element in a list holds its value and points to the following element until the end of the list is reached. But we can call each pair of values and pointer a cons cell, meaning that accessing the length of a list is a linear operation: there is a need to traverse the whole list in order to figure out its size. Hence, updating a list is fast as long as we are prepending elements.

While Tuples are stored contiguously in memory, meaning that getting the tuple size or accessing an element by an index is fast. But, updating or adding elements to tuples is expensive as it requires copying the whole tuple in memory.