A short talk on functional programming in elixir

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

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

3. Elixir Makes Functional
Programming Accessible
It’s for everyone!

4. Some history.
Influenced by Ruby Runs on Erlang VM

5. WHAT IS FUNCTIONAL PROGRAMMING?
Declarative
Paradigm

6. 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)

7. WHAT IS FUNCTIONAL PROGRAMMING?
Declarative
Paradigm
Functions as
First Class
Citizens

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

9. WHAT IS FUNCTIONAL PROGRAMMING?
Declarative
Paradigm
Functions as
First Class
Citizens
Immutability

10. 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}]

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

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

13. 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)

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

15. 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

16. 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"}

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

18. 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

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

20. 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])

21. 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.

22. Elixir Processes

23. 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.

24. More Elixir?
● Genserver
● Supervisors
● Nodes

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

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

27. A Recap