Calculadora de cozinha

Tuplas

Em Elixir, uma tupla é uma estrutura de dados que organiza dados, guardando um número fixo de itens de qualquer tipo, mas sem nomes explícitos para cada elemento. Tuplas são muito usadas em Elixir em operações com uso intenso de leitura de memória, já que o acesso de leitura a um elemento é uma operação de tempo constante. Elas normalmente não são usadas quando os elementos podem precisar ser adicionados ou removidos dinamicamente, porque, em vez de modificar a tupla existente, cria-se uma nova tupla, o que exige alocar memória de antemão.

Na prática, as tuplas são criadas em Elixir usando chaves. Os elementos de uma tupla podem ser acessados individualmente com a função elem/2, usando indexação baseada em zero:

empty_tuple = {}
one_element_tuple = {1}
multiple_element_tuple = {1, :a, "hello"}

elem(multiple_element_tuple, 2)
# => "hello"

Tuplas como informações agrupadas

Na prática, as tuplas são muito usadas para representar informações agrupadas.

Float.ratio(0.25)
# => {1, 4} indicating the numerator and denominator of the fraction ¼

Casamento de padrões

O uso do casamento de padrões predomina no código Elixir assertivo e idiomático. Talvez você lembre que =/2 é descrito como um operador de casamento, e não como um operador de atribuição. Ao usar o operador de casamento, se o padrão à esquerda casar com o lado direito, as variáveis à esquerda são vinculadas e o valor do lado direito é retornado. Um MatchError é lançado se não houver casamento.

2 = 2
# => 2
# Literals can be matched if they are the same

2 = 3
# => ** (MatchError) no match of right hand side value: 3

{_, denominator} = Float.ratio(0.25)
# => {1, 4}
# the variable `denominator` is bound to the value 4

Lembre-se: o casamento acontece do lado direito para o lado esquerdo.

No último exemplo, se não precisarmos de uma variável em um casamento de padrões, podemos descartá-la usando _. Qualquer variável que comece com um _ não é rastreada pelo runtime.

Casamento de padrões em funções nomeadas

O casamento de padrões também é uma ferramenta útil ao criar várias cláusulas de função. O casamento de padrões pode ser usado nos argumentos das funções, o que determina qual cláusula de função será invocada, começando do topo do arquivo e descendo até o primeiro casamento. Variáveis podem ser vinculadas em uma cabeça de função e usadas no corpo da função.

defmodule Example do
  def named_function(:a = variable_a) do
    {variable_a, 1}
  end

  def named_function(:b = variable_b) do
    {variable_b, 2}
  end
end

Example.named_function(:a)
# => {:a, 1}

Example.named_function(:b)
# => {:b, 2}

Example.named_function(:c)
# => ** (FunctionClauseError) no function clause matching in Example.named_function/1