Learning Elixir, my thoughts and study notes

How and why you should Learn Elixir

Learning Elixir: Why?

Why am I learning Elixir?

The short answer is: I have to know some Elixir for my current job, but I actually ended up really liking it. Elixirs functional programming paradigm reminds me of my first programming language, R, which brings back nostalgic memories. Although I initially learned R without knowing what a functional language was, Elixir is helping me appreciate the beauty of functional programming and how to create abstractions with just functions, without the need for mutable objects, methods, or classes.

Elixir’s syntax is concise and elegant, and it comes with several impressive features, such as pattern matching, which is explained further in this blog. One of the main draws of Elixir for me is that it’s built on Erlang, making it incredibly robust and highly concurrent, which I find really appealing. Additionally, Elixir has good documentation that is very accessible just like R, and it comes built-in with the language. The fact that Elixir has built-in pipes (|>) like Linux or R, is also something that any R enthusiast can appreciate.

Learning Elixir: Where to start?

The main resource for learning is the official Getting Started. You can find everything there.

I am currently reading 2 books:

And I like them both.

And here you can find an Elixir style guide so you can code in style.

Learning Elixir: My notes

When learning a new programming language, the first thing I like to learn is:

  • What is the language about?
  • What are the most important data types?
  • What are the semantics of the language?

When you know these things, you can effectively read the documentation and really get going.

I use these notes as a quick reference in case I forget something. Its a good intermediate between the documentation and reading the official Elixir tutorial (which is good).

These notes are verbose enough so you have some context, but terse enough that you don’t have to scroll through too much text.

Elixir: A dense summary

Elixir is a functional language.

Elixir is dynamically typed.

All data types in elixir are immutable. Copies are always returned because everything is immutable. To reduce the copying overhead, Elixir creates copies in a smart way, so they seem like copies but under the hood they aren’t.

Functions do not have side effects. They return their output, and do nothing else! Check out this video why that is something you want.

The Documentation of Elixir is amazing.

# Get documentation on function, modules, operators:

h Enum.each
h File
h case

All code can be run in an interactive shell: iex

Elixir: My notes

Next are my notes where I summarize the very basics of Elixir.

My suggestion for following along: get the raw markdown of these notes. And run the examples in iex. The examples try to show things that took me by surprise whenever I first encountered them.

What I personally do is, I use my own [vim plugin](https://niekdeschipper.com/projects/nvim_python_repl.md] in nvim to send code to iex) Although I really like my own plugin, I am using it for Python, NodeJS, R for a long time already and have no problems with it.

But if you are a (n)vim user you should probably use something like iron nvim, never tried it out, but probably does exactly the same thing as my plugin and much more.

The = match operator

= is the match operator, it tries to bind the right-hand side to the left-hand side to make the statement true. This is an very important feature of Elixir.


list = [1, 2, 3]
[a, b, c] = list

{_, {hour, _, _}} = :calendar.local_time  # ignore a match with _
{_date, time} = :calendar.local_time      # ignore a a match with _<var_name>

[head | tail] = [1, 2, 3]  # head has first item, tail the rest of the the list in a list

{:ok, file} = File.open("./myfile")

Pattern matches can be chained:

a = (b = 3 + 1)

datetime = {_date, time} = :calendar.local_time

# This ensures x will be a map if the patternmatching succeeds
x = %{} = y

You can pattern match in function based on arguments:

defmodule Mul do
  def mul({:two, a}) do
    a * 2
  def mul({:three, a}) do
    a * 3

Mul.mul({:two, 2})
Mul.mul({:three, 2})

Ignoring a value with underscore:

[a, _b] = [1, 1]
[a, _] = [1, 1]

Variable can only be bounded once:

[a, a] = [1, 1]
[a, a] = [1, 2]  # does not work

Keep value of a fixed with caret called pin operator:

a = 1
^a = 2

See this example

list1 = [1,2,3]
list2 = [4 | list1]

Types in Elixir

The most important complex data types are: Map, Tuple, List. The primitive types I skipped well as the atom. Atoms are constants whose values are their own name. They are easy to grasp, read more here.


Map is a key value store (dict in Python).

# Map declarations
%{:a => "c", :b => "b"}
%{a: "a", b: "b"}

a = %{a: "a", b: "b"}

# Check if map has key:
%{ a: _ } = %{ a: "aaa", b: "bbb" }
%{ c: _ } = %{ a: "aaa", b: "bbb" }
Map.has_key?(%{ a: "aaa"}, :a)

# Update the value of key in map
my_map = %{ a: "a", b: "b", c: "c" } 
%{my_map | a: "aaa"}


Tuple module has function to work with tuples

person = {"Bob", 30}
elem(person, 0)
put_elem(person, 2, "Frikandel")

import Tuple
Tuple.append(person, "Alice")


Lists are implemented as singly linked lists. Most operations are O(n).

person = ["Bob", "Alice"]

# Enum is the go to module to work with enumerables
Enum.at(person, 1)
Enum.fetch(person, 1)      # Returns {:ok, "Alice"}
Enum.fetch(person, 3)      # Returns :error
Enum.fetch!(person, 5)     # Throws Enum.OutOfBoundsError
[head | tail] = person     # Used a lot in recursion
[1,2,3] ++ [4]   # concatenation
[1,2,3] -- [1]   # difference 
1 in list        # element in list

Keyword Lists

An example how you can use default arguments:

# Keyword list
[aap: "aap", crocodile: "crocodile"]

# A keyword list just a normal list
[a: 1, b: 2] == [{:a, 1}, {:b, 2}]

If a keyword list appears as the last item in any context, you can leave the square brackets off. This is useful for supplying arguments to a function. This really tripped me up the first time I saw it.

# Example of keyword list as the last item
# notice the lack of square brackets
fun.(x, y, a: "a", b: "b", c: "c")


Is the set data structure:

x = MapSet.new()
x = MapSet.put(x, "ASD")
x = MapSet.put(x, "QWE")
x = MapSet.put(x, "QWE")
MapSet.member?(x, "QWE")


Struct is a typed map. One module can only define a single struct:

defmodule MyStruct do
  # Keyword list provides fields and their initial values
  defstruct a: "A", b: "B"

my_struct = %MyStruct{}
my_struct = %MyStruct{a: "a", b: "b"}

# Patternmatch a struct
%MyStruct{a: a, b: b} = my_struct

# Struct can't patternmatch a map
%MyStruct{a: a, b: b} = %{a: "a", b: "b"}
%{a: a, b: b} =  %MyStruct{a: "a", b: "b"} 



# format strings, string interpolation
x =  "format strings, string interpolation"
"text: #{x}"

# <> is used for concatenating binaries, strings are binaries
"concatenate" <> "strings"


A list of characters:

char_list = 'abcdefg'
is_list(char_list) == true
Enum.each(char_list, fn x -> IO.puts(x) end)


Sigils are custom functions that work on text. They are useful, and a means to extend the language.

# Create a list of words
h ~w{}
~w(the cat sat on the mat)   # list with strings
~w(the cat sat on the mat)a  # list with atoms
~w(the cat sat on the mat)c  # list with charlists

# Create a regex
h ~r{}
my_regex = ~r/foo/
Regex.replace(my_regex, "foobar", "chill")


Functions are defined by their name and arity (the number of input arguments).

Anonymous functions

Anonymous function can be assigned to a variable. Function can return functions, and can be used as arguments. Functions are defined by their name and arity (the number of arguments a function has)


list = [1, 2, 3]
sum = fn list -> Enum.sum(list) end

Single function can have multiple bodies. I was blown away when I saw this at first. The function body that matches the input argument is returned. Conditional logic without if else statements!

fizz = fn 
  (0, 0, _) -> "FizzBuzz"
  (0, _, _) -> "Fizz"
  (_, 0, _) -> "Buzz"
  (_, _, c) -> c

IO.puts(fizz.(0, 1, 1))
IO.puts(fizz.(1, 0, 1))
IO.puts(fizz.(0, 0, 1))
IO.puts(fizz.(1, 1, 1))

Anonymous functions have a shorthand:

# Shorthand
fun1 = fn x -> x + 1 end 
fun2 = &(&1 + 1)

fun1.(1) == fun2.(1)  # 1 == 1

# You can capture functions
x = &IO.puts/1

Named functions

Named functions have to be in modules:

defmodule Times do
  def double(n) do
    n * 2

defmodule Times do
  def double(n), do: n * 2


Functions can be pattern matched, it will try to match based on the function definition order. This is a means to create conditional logic in your code, without if else statements. Define from most specific to general

defmodule Add do
  def add(n) when is_integer(n), do: n + n

  def add([x, y]), do: x + y

  def add({a, b}), do: a + b

Add.add([2, 3])
Add.add({2, 3})
Add.add([])     # error, no match found

You can clause guard with “when” first patternmatch then guard clauses. Check where guards can be used, its in quite a lot of places.

defmodule Guard do
  def what_is(x) when is_number(x) do
    IO.puts "#{x} is a number"

  def what_is(x) when is_list(x) do
    IO.puts "#{inspect(x)} is a list"

  def what_is(x) when is_atom(x) do
    IO.puts "#{x} is an atom"


Functions with an !, will raise an exception if the function encounters an error:

h File.stream!

defp defines a private function which can only be used in the module.

Conditional logic

The most important conditional logic in Elixir: case, cond and pattern matching on function arguments.

case: matches values

The case statement matches values!

result1 = {:ok, "lets, go!"}
result2 = {:error, "lets, go!"}

case_example = fn pattern ->
  case pattern do
    {:ok, str} -> IO.puts(str)
      {:success, "we can continue"}
    _ -> IO.puts("whomp, whomp")  # _ matches anything
      {:faillure, ":("}


cond: matches conditions

cond matches conditions:

x = 1
cond do 
  x == 1 -> "I am true"
  x != 1 -> "I am false"
  true -> :error  # a catch all, because it always matches

with: traverse a matching chain

with keeps evaluating, and enters the do block if all patterns match If not match return that pattern: for example {:error, “reason why failed”}

with {:ok, name} <- {:ok, "banaan"},
     {:ok, login_id} <- {:ok, "banaan"} do
  %{name: name, login_id: login_id}

if else/unless

You have if and its inverse unless. For more than one else statement use cond.

compare_int = fn x ->
  if x >= 1 do


Processing collections

Enum: eager

Enum is the go to library to process collections. Enum is eager.

h Enum
list = [1, 2, 3]
Enum.filter(list, &(&1 != 2))

# Maps are also enumerables
# This example shows how maps are treated by enum
# Similar to [(k, v) for k, v in my_dictionary.items()] in Python
Enum.each(%{a: 1, b: 2}, fn {key, value} -> IO.puts("key #{key}, value #{value}") end)

# Also works for keyword lists
Enum.each([a: 1, b: 2], fn {key, value} -> IO.puts("key #{key}, value #{value}") end)

Stream: lazy

Streams are lazy, they only deliver the next item in line when requested.

my_stream = ["a", "b", "c", "d"]

  |> Stream.map(fn x -> x <> x end)  # <> concatenates binaries ( asequence of bits divisible by 8): strings are binaries
  |> Enum.take(1)

Stream.unfold(0, fn   # check: h Stream.unfold
  x -> {x,  x + 1}
  |> Stream.map(fn x -> x + x end)
  |> Enum.take(20)

List comprehension

List comprehension exists!

It evaluates all combinations of multiple input sequences. If conditions is true do something and return the result.

for a <- 1..10, a  > 1 and a <= 4, do: a
for a when a < 5 <- 1..10, do: a

# Creative zip using list comprehension
my_zip =  fn(list1, list2) ->
  for {x_value, x_index} <- Enum.with_index(list1),
    {y_value, y_index} <- Enum.with_index(list2),
    x_index == y_index,
    into: [] do
  {x_value, y_value}

my_zip.([1,2,3], [3,2,1])