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. As tuplas são frequentemente usadas em Elixir para operações intensivas em leitura de memória, uma vez que o acesso de leitura a um elemento é uma operação de tempo constante. Normalmente não são usadas quando os elementos podem ter de ser adicionados ou removidos dinamicamente, porque, em vez de modificar a tupla existente, é criada uma nova tupla, o que exige que a memória seja alocada de antemão.

Na prática, as tuplas são criadas em Elixir com chavetas. Podes aceder individualmente aos elementos de uma tupla com a função elem/2, usando indexação a partir de 0:

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

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

Tuplas como informação agrupada

As tuplas são frequentemente usadas na prática para representar informação agrupada.

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

Correspondência de padrões

A utilização de correspondência de padrões é dominante em código Elixir assertivo e idiomático. Talvez te lembres de que =/2 é descrito como um operador de correspondência e não como um operador de atribuição. Ao usar o operador de correspondência, se o padrão à esquerda corresponder ao padrão da direita, quaisquer variáveis à esquerda ficam ligadas, e o valor do lado direito é devolvido. É lançado um MatchError se não houver correspondência.

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

Lembra-te: as correspondências ocorrem do lado direito para o lado esquerdo.

No último exemplo, se não precisarmos de uma variável numa correspondência de padrões, podemos descartá-la referindo _. Qualquer variável que comece por _ não é acompanhada pelo runtime.

Correspondência de padrões em funções nomeadas

A correspondência de padrões também é uma ferramenta útil quando se criam várias cláusulas de função. A correspondência de padrões pode ser usada nos argumentos das funções, o que determina qual cláusula de função é invocada, começando no topo do ficheiro e descendo até à primeira correspondência. As variáveis podem ser ligadas numa 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