DEV Community: Daniel Cunha

Elixir :: Aninhando funções com operador pipe ( |> )

Daniel Cunha — Wed, 26 Jan 2022 14:06:43 +0000

Algumas vezes nosso código pode ficar muito confuso, principalmente quando precisamos encadear várias funções. Imagine ler um código com funções aninhadas como o exemplo abaixo:

my_function(get_result_from(foo(new_function(other_function()))))

Aqui, nós estamos passando o valor other_function/0 para new_function/1, e new_function/1 para foo/1, foo/1 para get_result_from/1, e finalmente o resultado de get_result_from/1 para my_functoin/1.

Elixir possui um modo pragmático que melhora o entendimento do código quando temos chamadas como esta, com a utilização do operador pipe. O operador pipe |>, recebe o resultado de uma expressão e passa ele adiante. Assim, poderiamos reescrever o código acima da seguinte maneira:

other_function() |> new_function() |> foo() |> get_result_from() |> my_function()

Se você possui alguma familiaridade com shell script, o pipe do Elixir é exatamente como do shell, ou seja o valor retornado da esqueda é passado para a função da direita.

Alguns exemplos de utilização do pipe

Posso fazer split de uma string simplesmente assim:

iex> "Daniel Soro" |> String.split()
["Daniel", "Soro"]

Posso transformar uma string em caixa alta e fazer split simplesmente assim:

iex> "Daniel Soro" |> String.upcase() |> String.split()
["DANIEL", "SORO"]

Com o pipe, podemos produzir código mais legívies e elegante, um operador muito legal em Elixir para deixar nosso código sinteticamente mais elegante e fácil de entender!

Elixir :: Function, Pattern Matching, default values e when

Daniel Cunha — Sat, 15 Jan 2022 12:56:28 +0000

Em Elixir o pattern matching não está apenas associado com variáveis, mas também com function, podemos utilizar pattern matching em nossas functions, tornando nossas functions específica para cada situação.

Vamos pensar em um jogo de adivinhação, queremos criar um jogo onde podemos adivinhar um número secreto. Com base no número que você recebe como palpite, você pode ter as seguintes saídas:

Condição	Respostas
Quando o palpite corresponde ao número secreto	Correto
Quando o palpite é um a mais ou um a menos que o número secreto	Próximo
Quando o palpite é maior que o número secreto	Maior
Quando o palpite for menor que o número secreto	Menor
Quando um palpite não é feito	Faça um palpite

Todas as suposições e números secretos são números inteiros.

O nosso programa tem as seguintes regras:

1. Dê resposta quando o palpite corresponder ao número secreto

Vamos implementar a função compare/2 que recebe dois argumentos, secret_number e guess, que são ambos inteiros.

GuessingGame.compare(5, 5)
# => "Correto"

2. Dê resposta quando o palpite for maior que o número secreto

Nesta situação queremos que a função de comparação responda com Maior.

GuessingGame.compare(5, 8)
# => "Maior"

3. Dê resposta quando o palpite for menor que o número secreto

Nesta situação queremos que a função de comparação responda com Menor.

GuessingGame.compare(5, 2)
# => "Menor"

4. Dê respostas quando o palpite for um a mais ou um a menos que o número secreto

Nessa situação se o valor inserido tiver diferença de 1 seja para maior ou menor queremos que a função de comparação responda com Próximo

GuessingGame.compare(5, 6)
# => "Próximo"
GuessingGame.compare(5, 4)
# => "Próximo"

5. Dê resposta quando não houver palpite

Nessa situação queremos que quando não houve palpite, a função compare responda com Faça um palpite

GuessingGame.compare(5)
# => "Faça um palpite"
GuessingGame.compare(5, :no_guess)
# => "Faça um palpite"

E como podemos resolver este problema? Como falamos anteriormente o Elixir possui um Pattern Matching que também podemos usar em functions. Então, para iniciar nossa implementaçao vamos começar pela parte onde não enviamos palpite.

Inicialmente vamos começar com a function que recebe apenas 1 parâmetro, vamos definir a nossa function para retornar exatamente o que esperamos, que é uma string: “Faça um palpite”

defmodule GuessingGame do
  def compare(secret_number), do: "Faça um palpite"
end

Ok, assim sabemos que ao chamar a function GuessingGame.compare(1) por exemplo, receberemos como retorno a frase "Faça um palpite”

iex(1)> GuessingGame.compare(1)
"Faça um palpite"

Mas também queremos que quando executarmos GuessingGame.compare(1, :no_guess) também receber o mesmo resultado. Para solucionar esse problema vamos precisar utilizar do default value e também do when.

Em Elixir, podemos definir parâmetros em nossas functions com valores defaults e com when podemos escolher que function executar a partir desta condição. Levando isto em consideração, nossa solução final facaria assim:

defmodule GuessingGame do
  def compare(secret_number, guess \\ :no_guess)
  def compare(secret_number, guess) when guess == :no_guess, do: "Faça um palpite"
end

E o resultado seria como este:

iex(1)> GuessingGame.compare(1)
"Faça um palpite"
iex(2)> GuessingGame.compare(1, :no_guess)
"Faça um palpite"

Agora, para atender as demais questões levantadas em nosso sistema, podemos utilizar o when para definir as demais funções e solucionar nosso problema.

defmodule GuessingGame do
  def compare(secret_number, guess \\ :no_guess)
  def compare(secret_number, guess) when guess == :no_guess, do: "Faça um palpite"
  def compare(secret_number, guess) when secret_number == guess, do: "Correto"
  def compare(secret_number, guess) when secret_number - 1 == guess, do: "Próximo"
  def compare(secret_number, guess) when secret_number + 1 == guess, do: "Próximo"
  def compare(secret_number, guess) when  secret_number > guess, do: "Menor"
  def compare(secret_number, guess) when  secret_number < guess, do: "Maior"
end

Elixir :: Pattern Matching

Daniel Cunha — Wed, 22 Dec 2021 12:22:36 +0000

Uma das coisas que inicialmente me deram um nó ao estudar Elixir foi o operador =. Apesar de ser utilizado para atribuir valores a variáveis, esse operador no Elixir é chamado de match operator

Ao executar um trecho de código como este:

iex> x = 1
1
iex> 1 = x
1
iex> 2 = x
** (MatchError) no match of right hand side value: 1

Podemos notar que a expressão 1 = x é uma expressão válida e isso é possível porque ambos os lados (direito e esquerdo) representam o mesmo valor, que no caso é 1. Entretando quando esses dois lados não dão match, um MatchError é retornado.

Só podemos atribuir valor para uma variável quando definida no lado esquerdo do operador =:

iex> x = 1
1

Pattern Matching não funciona apenas para valores simples, você também pode utilizar para outros tipos, como:

iex> {a, b, c} = {:hello, "world", 42}
{:hello, "world", 42}
iex> a
:hello
iex> b
"world"

Os dois lados (esquerdo e direto) devem ser do mesmo tipo, caso contrário um MatchError acontecerá, como no exemplo abaixo que tento fazer um match entre uma tupla e uma lista:

iex> {a, b, c} = [:hello, "world", 42]
** (MatchError) no match of right hand side value: [:hello, "world", 42]

Para solucionar este problema, poderíamos fazer:

iex> [a, b, c] = [:hello, "world", 42]
[:hello, "world", 42]
iex> a
:hello
iex> b
"world"
iex> c
42

Utilizar tamanhos diferentes entre os dois lados, também resultará em erro.

iex> [a, b] = [:hello, "world", "aloha"]    
** (MatchError) no match of right hand side value: [:hello, "world", "aloha"]

Algumas vezes queremos mesmo ignorar certos valores em nosso matching, para isso o Elixir possui uma variável especial, que é o _. Essa variável nos possibilita ignorar certos valores em um pattern matching, ou seja, se quizermos ignorar o último elemento no matching entra as listas acima, poderíamos fazer da seguinte forma:

iex> [a, b, _] = [:hello, "world", "aloha"]
[:hello, "world", "aloha"]
iex> a
:hello
iex> b
"world"

Pattern Matching vai além das variáveis, podemos utilizar isso com functions e muito mais, porém veremos como utilizar isto em um próximo post!

Elixir :: Instalando Erlang/OTP e Elixir

Daniel Cunha — Mon, 20 Dec 2021 00:55:46 +0000

Depois de muitos anos dedicado ao Java, resolvi que queria aprender algo novo e me deparei com esta linguagem chamada Elixir!

Elixir é uma linguagem funcional e dinâmica para a construção de aplicativos escaláveis e de fácil manutenção. O Elixir aproveita a VM do Erlang, conhecido por executar sistemas de baixa latência, distribuídos e tolerantes a falhas.

Nesse tutorial, vou mostrar como instalar o Erlang e o Elixir utilizando ASDF! Recomendo que você siga as instruções descrita na documentação oficial para ter ASDF em seu computador

Plugins

ASDF funciona com adição de plugins. Se você pretende gerenciar algo via ASDF você precisa adicionar esses plugins.

No nosso caso, queremos gerenciar as verões do Erlang e do Elixir, para isso, vamos adicionar estes plugins da seguinte forma:

asdf plugin add erlang
asdf plugin add elixir

Instalando Erlang

Antes de iniciar a instalação do Elixir, precisamos instalar o Erlang, para isto vamos executar o seguinte comando:

asdf install erlang latest

Após finalização da instalação do Erlang, você pode verificar se tudo correu bem, executando o seguinte comando:

erl

Você terá a confirmação após iniciar um shell interativo do Erlang parecido com:

Erlang/OTP 24 [erts-12.2] [source] [64-bit] [smp:8:8] [ds:8:8:10] [async-threads:1]

Eshell V12.2  (abort with ^G)
1>

Instalando Elixir

A instalação do Elixir não é muito diferente da do Erlang, então faça:

asdf install elixir latest

Após finalização da instalação do Elixir, você pode verificar se tudo correu bem, executando o seguinte comando:

iex --version

Em seu shell deve aparecer algo como:

Erlang/OTP 24 [erts-12.2] [source] [64-bit] [smp:8:8] [ds:8:8:10] [async-threads:1]

IEx 1.13.1 (compiled with Erlang/OTP 24)

Conclusão

Com Erlang e Elixir já instalados, é hora de configurar seu shell.

Configure seu shell com a versão padrão a utilizar:

asdf global erlang latest
asdf global elixir latest

Pronto, agora é hora de iniciar as aventuras com Erlang e Elixir! :)