Além do when: apresentando case/in

Uma pergunta diferente da que case/when responde

O curso anterior, "Lógica Ruby", terminou com case/when. Ele responde bem a um tipo de pergunta: a qual destas possibilidades este único valor corresponde? grade_letter e day_type compararam um valor com uma lista.

Este curso trata de outra ferramenta, case/in, chamada pattern matching. Ela responde a uma pergunta diferente: este valor tem um certo formato e, se tiver, em que partes ele se divide?

Um exemplo que motiva

Imagine um array que guarda um par de coordenadas. O seu código precisa conferir que ele tem dois elementos e extrair os dois.

point = [3, 4]

case point
in [x, y]
  puts "x is #{x}, y is #{y}"
end
# x is 3, y is 4

in [x, y] faz duas coisas ao mesmo tempo. Confirma que point é um array de dois elementos, nem mais nem menos, e liga esses elementos a variáveis locais novas, x e y, dentro do próprio padrão.

O case/when consegue verificar se um array é igual a [3, 4]. Ele não tem como dizer "um array de quaisquer duas coisas, e me entregue as duas".

Por que isso se chama pattern matching

[x, y] descreve um formato com duas posições, e não dois valores específicos. O Ruby compara esse formato com o valor real. Se o formato encaixa, as posições são preenchidas com o que estava lá.

case [3, 4]
in [x, y]
  puts "matches: #{x}, #{y}"
end

case [3, 4, 5]
in [x, y]
  puts "this won't print, three elements don't fit a two-slot pattern"
else
  puts "no match"
end

O segundo case cai no else, porque [3, 4, 5] tem três elementos e [x, y] descreve dois. O pattern matching confere a estrutura primeiro e só preenche as posições quando a estrutura encaixa.

Onde você vai encontrar esse formato

Código Ruby muitas vezes devolve um array pequeno que diz o que aconteceu. Uma convenção comum é um par cujo primeiro elemento é um símbolo, como [:ok, value] ou [:error, message].

result = [:error, "email is taken"]

case result
in [:ok, user]
  puts "created #{user}"
in [:error, message]
  puts "failed: #{message}"
end
# failed: email is taken

:ok e :error são valores fixos dentro do padrão, então precisam corresponder como estão escritos. user e message são posições vazias, então capturam o que estiver na segunda posição. Um único case confere que tipo de resultado chegou e extrai o conteúdo no mesmo passo. A mesma ideia funciona com hashes, que é como JSON costuma chegar depois de interpretado, e a lição 3 trata disso.

Um acréscimo ao case/when

Este curso não aposenta o case/when, porque os dois fazem trabalhos diferentes. O case/when é a ferramenta certa para comparar um valor simples com várias possibilidades, como as faixas do grade_letter. O case/in é a ferramenta certa quando o valor é uma estrutura composta, um array ou um hash, e você quer conferir o formato e extrair as partes num passo só. A lição 6 traça essa linha com precisão.

O que este curso cobre

1. Além do when: apresentando case/in. Pattern matching responde a uma pergunta diferente (você está aqui).
2. Casando a estrutura de arrays. Arrays pelo formato, incluindo um splat para "o resto" e a busca por um elemento.
3. Casando a estrutura de hashes. Hashes pela chave, sem exigir que todas as chaves estejam presentes.
4. Guardas e o operador pin. Uma condição extra que o formato casado também precisa satisfazer, e como casar com uma variável que você já tem.
5. Alternativas, intervalos e =>. Um entre vários formatos numa única cláusula in, padrões de valor e a captura do que casou.
6. case/in vs case/when, e o casamento numa linha. Uma regra de decisão, a única diferença de comportamento e as formas de uma linha.
7. Juntando tudo. Um desafio pequeno que usa tudo.

Aqui você só precisa ler literais de array e de hash, como [3, 4] e {name: "Ada"}. Os dois cursos depois deste, "Arrays Ruby" e "Hashes Ruby", ensinam os dois direito.

No fim, você vai reconhecer quando o formato de um valor importa tanto quanto o conteúdo, e vai usar o case/in quando for o caso.