I’ve been learning Elixir lately, and so far it’s been fascinating. Elixir is a functional programming language with a very ruby-like syntax. You get immutable state, actor-based concurrency model, and a modern syntax, all running on the Erlang VM. It’s my first foray into functional programming, and I’m enjoying learning the differences between OOP.
This post will get Elixir installed and introduce you to two important parts of Elixir: Immutable Data and Pattern Matching.
Start your dive by installing Elixir. You need at least Erlang R16bB. Don’t worry what that is, just install a precompiled version from here. Next, install Elixir. There are packages here, but you should roll with Elixir from the master branch of the repo for now (Elixir gets a little better every day):
$ brew install --HEAD elixir
==> Cloning https://github.com/elixir-lang/elixir.git
Updating /Library/Caches/Homebrew/elixir--git
==> make
🍺 /Users/clint/Developer/Cellar/elixir/HEAD: 278 files, 3.3M...
$Now you can use interactive mode and start learning:
$ iex
Interactive Elixir (0.10.2-dev)...
iex(1)> 1 + 12
13
iex(2)> dog_name = "Nero Dog, II"
"Nero Dog, II"
iex(3)> String.length dog_name
12Press 1
control+c
1
a
1
(1)
1
(2)
Now that you’re up and running, let’s look at some Elixir basics.
Everything in Elixir is immutable. You can’t append to a list; you can only get a new list with those additional items included in it. You cannot increment a value; you can only get a new value returned. Elixir is all about transforming data. Here we think about data and what we’re doing to and with it; we’re not thinking about instances, inheritance, state, or encapsulation.
Let’s look at variable binding, a thing that looks a lot like normal assignment. It’s not. For example:
# ruby
>> numbers = [1,2,3]
=> [1, 2, 3]With assignment (in most OOP languages), the variable 1
numbers
1
[1,2,3]
# Elixir
iex(1)> numbers = [1,2,3]
[1, 2, 3]In Elixir, the variable 1
numbers
1
[1,2,3]
1
2
3
4
5
6
7
8
# Elixir
iex(2)> a = 1
1
iex(3)> 1 = a
1
iex(4)> 2 = a
** (MatchError) no match of right hand side value: 1
:erl_eval.expr/3
Doing so in Ruby will throw a syntax error. Take note of line 6; this
yields an error because 1
a
1
1
1
2
1
1
1
a
1
=
Immutable data is great because you never have to worry about someone else changing something from under your feet. When you get a block of data, that’s what you get. Not a shared reference to something, you never have to worry about someone else (say another thread of execution) changing that thing you have; they may change something similar, but not your thing. Your thought process and concerns become more local, only worrying about what you’re doing in that particular function with that particular data.
Pattern matching is the process where Elixir binds values to variables,
but not your conventional “assignment”. It’s a fundamental part of
programming here. In the above example with 1
a = 1
1
1 = a
Some further examples, with lists (not arrays):
1
2
3
4
5
6
7
8
9
10
11
iex(6)> animals = ['dog', 'cat', 'chocobo']
['dog', 'cat', 'chocobo']
iex(7)> [friend, enemy, awesome_bird] = animals
['dog', 'cat', 'chocobo']
iex(8)> friend
'dog'
iex(9)> enemy
'cat'
iex(10)> awesome_bird
'chocobo'
iex(11)>
On line 1
1
1
3
1
[friend, enemy, awesome_bird]
Look what happens when we try to use the same variable:
1
2
3
iex(11)> [d, c, c] = animals
** (MatchError) no match of right hand side value: ['dog', 'cat', 'chocobo']
:erl_eval.expr/3
In something like Ruby 1
c
1
chocobo
1
c
1
cat
1
chocobo
Another example:
1
2
3
4
5
6
iex(1)> [dog, name, dog] = ["Nero", "Adelbert Steiner", "Nero"]
["Nero", "Adelbert Steiner", "Nero"]
iex(2)> dog
"Nero"
iex(3)> name
"Adelbert Steiner"
Here, 1
dog
1
Nero
1
name
Back to the 1
['dog', 'cat', 'chocobo']
1
2
3
4
5
6
7
8
9
iex(12)> [d,_,c] = ['dog', 'cat', 'chocobo']
['dog', 'cat', 'chocobo']
iex(13)> d
'dog'
iex(14)> c
'chocobo'
iex(15)> _
** (ErlangError) erlang error: {:unbound_var, :_}
:erl_eval.exprs/2
On line 7 we get an error when trying to reference 1
_
That’s all for now. Go install Elixir if you haven’t already and try out some pattern matching to get a feel for it. Immutable data and pattern matching are important parts of the things I’ll cover in my next Dive Into post covering functions, anonymous functions, and recursive functions.
If you like what you’ve seen, go pick up Programming Elixir from Dave Thomas at The Pragmatic Bookshelf.
no, not really ↩