This document provides an introduction and overview of the Elixir programming language through a series of code examples and explanations. It begins with simple "Hello World" examples to demonstrate basic syntax and loading code. It then covers creating modules and functions, testing code with ExUnit, recursion techniques like calculating Fibonacci sequences and factorials, and refactoring code with the pipe operator. The document recommends additional Elixir learning resources and outlines next steps to explore lists, Mix, and the Phoenix web framework.

1. Elixir em um
final de semana
Pergunte-me como!
@marcosbrizeno

2. Quem sou eu?
@marcosbrizeno
brizeno.wordpress.com

3. Como?
O Simples Hello World!
Testes com ExUnit
Pattern Matching com Fibonacci
Tail Recursion com Cálculo Fatorial
O Operador |> (pipe)
Próximos finais de semana

4. Por que Elixir?
Porque sim Zequinha

5. Elixir e Erlang
Funcional BR HUE!
Divertida e performática
BEAM VM
Elixir <- Erlang

6. Hello World!

7. $> iex
iex(1)> IO.puts("Hello World!")
Hello World!
:ok

8. $> iex
iex(1)> IO.puts("Hello World!")
Hello World!
:ok
iex(1)> IO.puts("Hello World!")
Módulo IO
Função puts/1

9. Criando módulos

10. defmodule HelloWorld do
def hello() do
“Hello World”
end
end
hello_world.exs

11. defmodule HelloWorld do
def hello() do
“Hello World”
end
end
hello_world.exs
defmodule HelloWorld do
end
Módulo HelloWorld

12. defmodule HelloWorld do
def hello() do
“Hello World”
end
end
hello_world.exs
def hello() do
“Hello World”
end
Função hello/0

13. defmodule HelloWorld do
def hello() do
“Hello World”
end
end
hello_world.exs
$> iex
iex(1)> Code.load_file(“hello_world.exs")
iex(2)> HelloWorld.hello()
"Hello World"

14. $> iex
iex(1)> Code.load_file(“hello_world.exs")
iex(2)> HelloWorld.hello()
"Hello World"
iex(1)> Code.load_file(“hello_world.exs")
iex(2)> HelloWorld.hello()
Carrega arquivo ”hello_world.exs”
Chama função hello/0

15. Modificando módulos com hot reload

16. defmodule HelloWorld do
def hello() do
“Hello World”
end
def hello(name) do
“Hello #{name}”
end
end
hello_world.exs
defmodule HelloWorld do
def hello(name) do
“Hello #{name}”
end
end

17. defmodule HelloWorld do
def hello(name) do
“Hello #{name}”
end
end
hello_world.exs
$> iex
iex(1)> Code.load_file(“hello_world.exs")
iex(2)> HelloWorld.hello()
"Hello World”
iex(3)> HelloWorld.hello(“Lambda I/O“)
** (UndefinedFunctionError)

18. $> iex
iex(1)> Code.load_file(“hello_world.exs")
iex(2)> HelloWorld.hello()
"Hello World”
iex(3)> HelloWorld.hello(“Lambda I/O“)
** (UndefinedFunctionError)
iex(4)> r(HelloWorld)
iex(5)> HelloWorld.hello(“Lambda I/O“)
"Hello Lambda I/O”

19. $> iex
iex(1)> Code.load_file(“hello_world.exs")
iex(2)> HelloWorld.hello()
"Hello World”
iex(3)> HelloWorld.hello(“Lambda I/O“)
** (UndefinedFunctionError)
iex(4)> r(HelloWorld)
iex(5)> HelloWorld.hello(“Lambda I/O“)
"Hello Lambda I/O”
iex(4)> r(HelloWorld)
iex(5)> HelloWorld.hello(“Lambda I/O“)
"Hello Lambda I/O”
r Recarrega o módulo HelloWorld
Agora podemos acessar hello/1

20. Testes com ExUnit

21. defmodule HelloWorld do
def hello() do
“Hello World”
end
def hello(name) do
“Hello #{name}”
end
end
hello_world.exs

22. hello_world_test.exs
Code.load_file("hello_world.exs")
ExUnit.start
defmodule HelloWorldTest do
use ExUnit.Case, async: true
test "returns Hello World" do
assert
HelloWorld.hello == "Hello World"
end
end

23. $> elixir hello_world_test.exs
.
Finished in 0.1 seconds (0.1s on load,
0.00s on tests)
1 test, 0 failures

24. Anatomia de um caso de test ExUnit

25. hello_world_test.exs
Code.load_file("hello_world.exs")
ExUnit.start
defmodule HelloWorldTest do
use ExUnit.Case, async: true
test "returns Hello World" do
assert
HelloWorld.hello == "Hello World"
end
end
Code.load_file("hello_world.exs")

26. hello_world_test.exs
Code.load_file("hello_world.exs")
ExUnit.start
defmodule HelloWorldTest do
use ExUnit.Case, async: true
test "returns Hello World" do
assert
HelloWorld.hello == "Hello World"
end
end
ExUnit.start
defmodule HelloWorldTest do
use ExUnit.Case, async: true
end

27. hello_world_test.exs
Code.load_file("hello_world.exs")
ExUnit.start
defmodule HelloWorldTest do
use ExUnit.Case, async: true
test "returns Hello World" do
assert
HelloWorld.hello == "Hello World"
end
end
test "returns Hello World" do
assert
HelloWorld.hello == "Hello World"
end

28. Saída em caso de falhas

29. $> elixir hello_world_test.exs
1) test returns Hello World
(HelloWorldTest)
hello_world_test.exs:8
Assertion with == failed
code: HelloWorld.hello() == "Hello
not World"
left: "Hello World"
right: "Hello not World"
stacktrace:
hello_world_test.exs:9: (test)

30. Sequência Fibonacci
com Pattern
Matching

31. fib_test.exs
Code.load_file("fib.exs")
ExUnit.start
defmodule FibonacciTest do
use ExUnit.Case, async: true
test "fibonacci 0 is 0" do
assert Fibonacci.calculate(0) == 0
end
end

32. fib.exs
defmodule Fibonacci do
def calculate(number) do
0
end
end

33. $> elixir fib_test.exs
.
Finished in 0.1 seconds (0.1s on load,
0.00s on tests)
1 test, 0 failures

35. fib_test.exs
test "fibonacci 0 is 0" do
assert Fibonacci.calculate(0) == 0
end
test "fibonacci 1 is 1" do
assert Fibonacci.calculate(1) == 1
end
test "fibonacci 2 is 1" do
assert Fibonacci.calculate(2) == 1
end

36. fib.exs
def calculate(n) do
cond do
n <= 0 -> 0
n == 1 -> 1
true ->
calculate(n-2) + calculate(n-1)
end
end

37. $> elixir fib_test.exs
...
Finished in 0.1 seconds (0.1s on load,
0.00s on tests)
3 test, 0 failures

38. Utilizando Pattern Matching

39. fib.exs
def calculate(n) do
case n do
0 -> 0
1 -> 1
_ -> calculate(n-2) + calculate(n-1)
end
end

40. fib.exs
def calculate(n) do
case n do
0 -> 0
1 -> 1
_ -> calculate(n-2) + calculate(n-1)
end
end
case n do
0
1
_
end

41. $> elixir fib_test.exs
...
Finished in 0.1 seconds (0.1s on load,
0.00s on tests)
3 test, 0 failures

42. Utilizando Pattern Matching nos argumentos

43. fib.exs
def calculate(0), do: 0
def calculate(1), do: 1
def calculate(n) do
calculate(n-2) + calculate(n-1)
end

44. $> elixir fib_test.exs
...
Finished in 0.1 seconds (0.1s on load,
0.00s on tests)
3 test, 0 failures

45. Guard Clause nos métodos

46. fib_test.exs
test "raise ArgumentError" do
assert_raise ArgumentError, fn ->
Fibonacci.calculate(-1)
end
end

47. fib.exs
def calculate(0), do: 0
def calculate(1), do: 1
def calculate(n) when n < 0 do
raise ArgumentError
end
def calculate(n) do
calculate(n-2) + calculate(n-1)
end
def calculate(n) when n < 0 do
raise ArgumentError
end

48. Cálculo Fatorial com
Tail Recursion

49. factorial_test.exs
Code.load_file("factorial.exs")
ExUnit.start
defmodule FactorialTest do
use ExUnit.Case, async: true
test "factorial of 0 is 1" do
assert Factorial.of(0) == 1
end
end

50. factorial.exs
defmodule Factorial do
def of(0), do: 1
end

51. factorial_test.exs
test "factorial of 1 is 1" do
assert Factorial.of(1) == 1
end

52. factorial.exs
defmodule Factorial do
def of(0), do: 1
def of(n) do
of(n-1) * n
end
end

53. Otimizando com Tail recursion

54. factorial_test.exs
test "factorial of 100000" do
assert Factorial.of(100_000)
end
@tag timeout: 600_000
test "factorial of 500000" do
assert Factorial.of(500_000)
end

55. factorial.exs
defmodule Factorial do
def of(n), do: of(n, 1)
defp of(0, accumulator), do: accumulator
defp of(n, accumulator) do
of(n-1, accumulator*n)
end
end

56. factorial.exs
defmodule Factorial do
def of(n), do: of(n, 1)
defp of(0, accumulator), do: accumulator
defp of(n, accumulator) do
of(n-1, accumulator*n)
end
end
def of(n), do: of(n, 1)
of/1 of/2

57. factorial.exs
defmodule Factorial do
def of(n), do: of(n, 1)
defp of(0, accumulator), do: accumulator
defp of(n, accumulator) do
of(n-1, accumulator*n)
end
end
defp of(0, accumulator), do: accumulator

58. factorial.exs
defmodule Factorial do
def of(n), do: of(n, 1)
defp of(0, accumulator), do: accumulator
defp of(n, accumulator) do
of(n-1, accumulator*n)
end
end
defp of(n, accumulator) do
of(n-1, accumulator*n)
end

59. $> elixir factorial_test.exs
....
Finished in 254.2 seconds (0.05s on
load, 254.2s on tests)
4 tests, 0 failures

60. Formando acrônimos
e o operador |> (pipe)

61. acronym_test.exs
defmodule AcronymTest do
use ExUnit.Case, async: true
test "it produces acronyms from title
case" do
assert Acronym.abbreviate("Portable
Networks Graphic") === "PNG"
end
end

62. acronym.exs
defmodule Acronym do
def abbreviate(title) do
separated_names =
String.split(title, " ")
capitalized_letters =
capitalize_letters(separated_names)
Enum.join(capitalized_letters)
end
end

63. acronym.exs
defmodule Acronym do
defp capitalize_letters(names) do
Enum.map(names, fn(name) ->
first_letter = String.first(name)
String.capitalize(first_letter)
end)
end
end

64. $> elixir acronym.exs
.
Finished in 0.1 seconds (0.1s on load,
0.00s on tests)
1 test, 0 failures

65. Refatorando com o |>

66. acronym.exs
defp capitalize_letters(names) do
Enum.map(names, fn(name) ->
String.capitalize(String.first(name))
end
end

67. acronym.exs
defp capitalize_letters(names) do
Enum.map(names, fn(name) ->
String.capitalize(String.first(name))
end
end
String.capitalize(String.first(name))

68. acronym.exs
defp capitalize_letters(names) do
Enum.map(names, fn(name) ->
String.first(name)
|> String.capitalize()
end
end

69. acronym.exs
defp capitalize_letters(names) do
Enum.map(names, fn(name) ->
String.first(name)
|> String.capitalize()
end
end
String.first(name)
|> String.capitalize()

70. $> elixir acronym.exs
.
Finished in 0.1 seconds (0.1s on load,
0.00s on tests)
1 test, 0 failures

71. Refatorando com o |>, de novo

72. acronym.exs
defmodule Acronym do
def abbreviate(title) do
separated_names =
String.split(title, " ")
capitalized_letters =
capitalize_letters(separated_names)
Enum.join(capitalized_letters)
end
end

73. acronym.exs
def abbreviate(title) do
String.split(title, " ")
|> capitalize_letters()
|> Enum.join()
end

74. acronym.exs
def abbreviate(title) do
String.split(title, " ")
|> capitalize_letters()
|> Enum.join()
end
String.split(title, " ")
|> capitalize_letters()
|> Enum.join()

75. $> elixir acronym.exs
.
Finished in 0.1 seconds (0.1s on load,
0.00s on tests)
1 test, 0 failures

78. O que mais?
Meu blog (https://brizeno.wordpress.com/tag/
elixir/)
Elixir getting started (http://elixir-lang.org/
getting-started/introduction.html)
Grok Podcast
(http://www.grokpodcast.com/series/elixir/)
Elixir Koans
(https://github.com/dojo-toulouse/elixir-koans)
exercism.io

79. Próximos passos
Manipulação de listas
Mix
Phoenix web framework

80. Obrigado!
@marcosbrizeno