Uma introdução ao Pattern Matching
Tags: elixir, beginners, erlang, functional
Published: 2022-08-19 20:42:06

## Intro

Ufa, nós aprendemos bastante coisa sobre a linguagem de programação Elixir!

[Configuramos o nosso Setup](https://dev.to/trybe/meus-primeiro-passos-no-elixir-1n1j), [iniciamos um projeto no Mix, falamos sobre programação funcional e Aridade](https://dev.to/trybe/elixir-conceitos-iniciais-4m8k).

Agora falemos de um assunto, considerado um dos ‘cores’ do Elixir, falemos de **Pattern Matching** então prepara o café e vamos lá!

![the office](https://media.giphy.com/media/LG1ZZP1Go0D8j7YsWy/giphy.gif)

## Pattern Matching

Começaremos do início ok? Na maior parte das linguagens de programação o sinal de igual (=) é usado como um operador de atribuição, ou seja, eu atribuo um valor a uma determinada variável, **no Elixir isso não se aplica!**

No elixir o sinal de igual é um operador de correspondência (’Match operator’). 
Vamos dar uma olhada no exemplo abaixo:

```Elixir
x = 1    # 1
1 = x    # 1
2 = x    **(MatchError) no match of right hand side value: 1
```
Vamos entender o que esta acontecendo, na linha 1 estamos correspondendo o valor 1 a uma variável x, dando um match!

Na linha 2 estamos correspondendo o valor 1 a uma variável que possui valor 1, deu match com certeza!

Na linha 3 estamos correspondendo o valor 2 a variável x que possui valor 1, e isso nitidamente não da match, é exatamente isso que o log esta nos informando!

No Pattern Matching o lado direito deve ser correspondente ao lado esquerdo. Se você veio do JavaScript, deve estar pensando que o Pattern Matching é muito parecido com [Destrutcing](https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment). Na verdade, são coisas diferentes, mas através do Pattern Matching conseguimos fazer destruct no Elixir, vamos dar uma olhada neste outro exemplo:

```Elixir
[1, x, 3] = [1, 2, 3]
# [1, x, 3] = [1, 2, 3]

x
# 2
```

No exemplo anterior estamos correspondendo a variável x o segundo valor da lista a direita, também poderíamos fazer o seguinte:

```Elixir
[y, x, 3] = [1, 2, 3]
# [y, x, 3] = [1, 2, 3]

y
# 1

x
# 2
```

Lembrando que os dois lados devem ser correspondentes, nos exemplos abaixo temos o mesmo erro que vimos la atrás:

```Elixir
[y, x, 3] = [1, 2, 3, 4]
** (MatchError) no match of right hand side value: [1, 2, 3, 4]

[y, x, 3] = [1, 2]
** (MatchError) no match of right hand side value: [1, 2]
```

## Mais alguns exemplos de Pattern Matching

No caso do _map_ não precisamos referenciar todos os valores dos dois lados justamente porque no _map_ não importa a ordem dos elementos, portanto podemos corresponder somente a chave que precisamos do valor.

```Elixir
%{school: school_name} = %{school: "Trybe", country: "BR"}
# %{school: "Trybe", country: "BR"}

school_name
# "Trybe"
```

Para concluir veja no próximo exemplo como usamos Pattern Matching para controle de fluxo em uma função de cláusula múltipla. 

```Elixir
control_function = fn
	{:ok, response} -> "Great: #{response}"
	{:error, response} -> "Error: #{response}"
end


control_function.({:ok, "register concluded"})
# "Great: register concluded"

control_function.({:error, "Disconnected"})
# "Error: Disconnected"
```

Ao receber o argumento da função o Elixir faz a comparação com a cláusula, caso “dê match” ele envia o retorno esperado, senão envia uma exceção, por exemplo:

```Elixir
control_function.(5)

**(FunctionClauseError) no function clause matching in :erl_eval."-inside-an-interpreted-fun-"/1
```

## Conclusão
Vimos então como o Pattern Matching é poderoso e, porque ele faz parte do core do Elixir, no próximo artigo falaremos sobre funções built in e como usamos no nosso dia a dia, até lá!

![bye - the office](https://media.giphy.com/media/k3YNVBrbn2KqbXEgDJ/giphy.gif)