Getting functional with elixir

Getting Functional
with Elixir
Because functions love to be First class citizens.

Whoami
Athira Mukundan
Solution Consultant @Sahaj
athira_tech@yahoo.in

Elixir Makes Functional
Programming Accessible
It’s for everyone!

Some history.
Influenced by Ruby Runs on Erlang VM

WHAT IS FUNCTIONAL PROGRAMMING?
Declarative
Paradigm

What vs How
Imperative paradigm Declarative paradigm
var activeUsers = new List<User>();
for(var i = 0; i < users.length;
i++){
if(users[i].isActive){
activeUsers.add(users[i]);
}
}
Enum.filter(users, fn u ->
u.is_active end)

Declarative
Paradigm
Functions as
First Class
Citizens

Functions have power
is_active = fn u -> u.is_active end
Enum.filter(users, is_active)

Declarative
Paradigm
Functions as
First Class
Citizens
Immutability

Data doesn’t change
users = [%{is_active: true}, %{is_active: false}]
active_users = Enum.filter(users, is_active)
users = [%{is_active: true}, %{is_active: false}]
active_users = [%{is_active: true}]

How I Want to Filter Users
users.filter(is_active)
Enum.filter(users, is_active)

That’s it! Let’s see some
ELIXIR now!

Pipe Operator |>
Enum.filter(Enum.map(String.split(File.read!("tweets.txt"),
~r{n}), &String.strip/1), fn x -> String.length(x) <= 140 end)
Path
|> File.read!
|> String.split(~r{n})
|> Enum.map(&String.trim/1)
|> Enum.filter(fn x -> String.length(x) <= 140 end)

Debugging with |>
my_list = [[1], [2,3], [4,5,6]]
My_list
|> Enum.at(1)
|> IO.inspect #[2,3]
|> Enum.at(0)

Functions have power: Composition
def get_contents(path) do
path
|> File.read!
|> String.split(~r{n})
|> Enum.map(&String.strip/1)
|> Enum.filter(fn x -> String.length(x) <= 140 end)
end

Pattern Matching
{first, last} = {“Athira”, “Mukundan”}
first: “Athira”
last: “Mukundan”
{first, “Mukundan”} = {“Athira”, “Mukundan”}
first: “Athira”
{first, “Abc”} = {“Athira”, “Diaz”}
** (MatchError) no match of right hand side value:
{"Abc", ”Diaz"}

Pattern Matching: Return Values
case File.read(filename) do
{:ok, file} -> IO.puts(file)
{:error, reason} -> IO.puts(reason)
end

Pattern Matching: Structs
def special_event(date) do
case date do
{10, 31, _} -> :halloween
{1, 1, _} -> :new_years
{_, 1, _} -> :first_of_the_month
{_, _, 2000} -> :y2k
_ -> :boring
end
end

Pattern Matching: Function Parameters
def is_dynamic(:c), do: :false
def is_dynamic(:elixir), do: :true
def is_dynamic(_other), do: :unknown

Pattern Matching: Recursion
def reverse(list) do
reverse(list, [])
end
def reverse([], reversed), do: reversed
def reverse([head | tail], reversed), do:
reverse(tail, [head | reversed])

Elixir Processes
● all code runs inside processes
● isolated from each other
● communicate via message passing
● < ~1Kb
● basis for concurrency in Elixir
● provide the means for building distributed and fault-
tolerant programs.

Actor concurrency model
● An actor is the primitive unit of computation. It’s the thing that
receives a message and do some kind of computation based on it.
● Actors are completely isolated from each other
● Never share memory.

More Elixir?
● Genserver
● Supervisors
● Nodes

So How Do I Get Started?
https://elixir-lang.org/
http://exercism.io/

Recap
What not How
Functions have
Power
Data doesn’t
change

Getting functional with elixir

More Related Content

What's hot (20)

Similar to Getting functional with elixir (20)

Recently uploaded (20)

Getting functional with elixir