pattern matching -> casamento de padrões

(termo da documentação PT-BR do Python)

Author: ramalho

online/cap02.adoc

@@ -865,7 +865,7 @@ Então o primeiro alvo seria  `(record,)` e o segundo `((field,),)`.
 Nos dois casos, esquecer aquela vírgula causa um bug
 silencioso.footnote:[Agradeço ao revisor técnico Leonardo Rochael por esse exemplo.]
 
-Agora vamos estudar _pattern matching_,
+Agora vamos estudar casamento de padrões,
 que suporta maneiras ainda mais poderosas para desempacotar
 sequências.((("", startref="Sunpack02")))((("", startref="iterun02")))
 
@@ -874,21 +874,21 @@ sequências.((("", startref="Sunpack02")))((("", startref="iterun02")))
 === Pattern matching com sequências
 
 O((("match/case statement")))((("sequences", "pattern matching with", id="Spattern02")))((("pattern matching", "match/case statement")))
-novo recurso mais visível de Python 3.10 é o _pattern matching_
-(casamento de padrões) com a instrução `match/case`, proposta na
+novo recurso mais visível de Python 3.10 é o
+casamento de padrões (_pattern matching_) com a instrução `match/case`, proposta na
 https://fpy.li/pep634[PEP 634—Structural Pattern Matching: Specification (_Casamento Estrutural de Padrões: Especificação_)] (EN).
 
 [role="man-height2"]
 [NOTE]
 ====
 Carol Willing, uma das desenvolvedoras principais de Python,
-escreveu uma excelente introdução ao _pattern matching_ na seção
-https://fpy.li/2r["Casamento de padrão estrutural"]footnote:[NT: A tradução em português da documentação de
-Python adotou o termo "casamento de padrões" no lugar de _pattern matching_.
+escreveu uma excelente introdução ao casamento de padrões na seção
+https://fpy.li/2r["Casamento de padrão estrutural"]footnote:[NT:
+Os tradutores da documentação de Python em português do Brasil
+adotaram o termo "casamento de padrões" no lugar de _pattern matching_.
 O termo em inglês é usado nas comunidades brasileiras
-de linguagens que implementam _pattern matching_ há muitos anos, como por exemplo Scala,
-Elixir e Haskell.
-Naturalmente mantivemos os títulos originais nos links externos.]
+de linguagens que implementam casamento de padrões há muitos anos,
+como por exemplo Scala, Elixir e Haskell.]
 em https://fpy.li/2s["O que há de novo no Python 3.10"].
 Você pode querer ler aquela revisão rápida.
 Neste livro, dividi o tratamento do casamento de padrões em diferentes capítulos,
@@ -947,7 +947,7 @@ Uma melhoria fundamental do `match` sobre o `switch` é((("destructuring")))
 a _desestruturação_—uma forma mais avançada de desempacotamento.
 Desestruturação é uma palavra nova no vocabulário de Python,
 mas é usada com frequência na documentação de linguagens
-que suportam o _pattern matching_—como Scala e Elixir.
+que suportam o casamento de padrões—como Scala e Elixir.
 
 Como um primeiro exemplo de desestruturação, o <<ex_nested_tuple_match>>
 mostra parte do <<ex_nested_tuple>> reescrito com `match/case`.
@@ -1102,7 +1102,7 @@ https://fpy.li/2-10["A very deep iterable and type match with extraction" (_Um m
 
 O <<ex_nested_tuple_match>> não é melhor que o <<ex_nested_tuple>>.
 É apenas um exemplo para contrastar duas formas de fazer a mesma coisa.
-O próximo exemplo mostra como o _pattern matching_ contribui para a criação de código claro, conciso e eficaz.
+O próximo exemplo mostra como o casamento de padrões contribui para a criação de código claro, conciso e eficaz.
 
 [[pattern_matching_seq_interp_sec]]
 ==== Casando padrões de sequência em um interpretador
@@ -1115,7 +1115,7 @@ https://fpy.li/2-11[_lis.py_]:
 um interpretador de um subconjunto do dialeto Scheme da linguagem de programação Lisp,
 em 132 belas linhas de código Python legível.
 Peguei o código-fonte de Norvig (publicado sob a licença MIT) e o atualizei para Python 3.10,
-para exemplificar o _pattern matching_.
+para exemplificar o casamento de padrões.
 Nessa seção, vamos comparar uma parte fundamental do código de Norvig—que usa `if/elif` e
 desempacotamento—com uma nova versão usando `match/case`.
 
@@ -1166,7 +1166,7 @@ include::../code/02-array-seq/lispy/py3.9/lis.py[tags=EVAL_IF_MIDDLE]
 ====
 
 Observe como cada instrução `elif` verifica o primeiro item da lista, e então desempacota a lista, ignorando o primeiro item.
-O uso extensivo do desempacotamento sugere que Norvig é um fã do _pattern matching_,
+O uso extensivo do desempacotamento sugere que Norvig é um fã do casamento de padrões,
 mas ele originalmente escreveu aquele código em Python 2 (apesar de agora ele funcionar com qualquer Python 3)
 
 Usando `match/case` em Python ≥ 3.10, podemos refatorar `evaluate`, como mostrado no <<ex_match_eval>>.
@@ -1194,7 +1194,7 @@ Sem o último `case`, para pegar tudo que tiver passado pelos anteriores,
 o bloco `match` não faz nada quando o sujeito não casa com algum `case`—e isso pode causar uma falha silenciosa.
 
 Norvig deliberadamente evitou a checagem e o tratamento de erros em _lis.py_, para manter o código fácil de entender.
-Com _pattern matching_, podemos acrescentar mais verificações e ainda manter o programa legível.
+Com casamento de padrões, podemos acrescentar mais verificações e ainda manter o programa legível.
 Por exemplo, no padrão `'define'`,
 o código original não se assegura que `name` é uma instância de `Symbol`—isso exigiria um bloco `if`,
 uma chamada a `isinstance`, e mais código.
@@ -1275,10 +1275,10 @@ o segundo elemento deve ser um `Symbol` na forma original de `define`,
 mas deve ser uma sequência começando com um `Symbol` na sintaxe de `define` para definição de função.
 
 Agora pense em quanto trabalho teríamos para adicionar o suporte a essa segunda sintaxe de `define`
-sem a ajuda do _pattern matching_ no <<ex_norvigs_eval>>.
+sem a ajuda do casamento de padrões no <<ex_norvigs_eval>>.
 A instrução `match` faz mais que o `switch` das linguagens similares ao C.
 
-O _pattern matching_ é um exemplo de programação declarativa:
+O casamento de padrões é um exemplo de programação declarativa:
 o código descreve "o que" você quer casar,
 em vez de "como" casar.
 A forma do código segue a forma dos dados, como ilustra a <<syntax_and_pattern_tbl>>.
@@ -1295,7 +1295,7 @@ A forma do código segue a forma dos dados, como ilustra a <<syntax_and_pattern_
 | `(define (name parms…) body1 body2…)` | `['define', [Symbol() as name, *parms], *body] if body`
 |============================================================================
 
-Espero que a refatoração do `evaluate` de Norvig com _pattern matching_
+Espero que a refatoração do `evaluate` de Norvig com casamento de padrões
 tenha convencido você que `match/case` pode tornar seu código mais legível e mais seguro.
 
 [NOTE]
@@ -1306,7 +1306,7 @@ Se você quiser aprender mais sobre o _lys.py_ de Norvig, leia seu maravilhoso p
 https://fpy.li/2-12["(How to Write a (Lisp) Interpreter (in Python))" _(Como Escrever um Interpretador (Lisp) em (Python))_].
 ====
 
-Isso conclui nossa primeira passagem por desempacotamento, desestruturação e _pattern matching_ com sequências.
+Isso conclui nossa primeira passagem por desempacotamento, desestruturação e casamento de padrões com sequências.
 Vamos tratar de outros tipos de padrões mais adiante, em outros capítulos.
 
 Todo programador Python sabe que sequências podem ser fatiadas usando a sintaxe `s[a:b]`.

online/cap03.adoc

@@ -30,7 +30,7 @@ evitando o excesso de laços e condicionais aninhados.
 Aqui está um breve esquema do capítulo:
 
 * A sintaxe moderna((("dictionaries and sets", "topics covered"))) para criar e manipular `dicts`
-e mapeamentos, incluindo desempacotamento aumentado e _pattern matching_ (casamento de padrões)
+e mapeamentos, incluindo desempacotamento aumentado e casamento de padrões (_pattern matching_)
 * Métodos comuns dos tipos de mapeamentos
 * Tratamento especial para chaves ausentes
 * Variantes de `dict` na biblioteca padrão
@@ -202,7 +202,7 @@ https://fpy.li/pep584[PEP 584—Add Union Operators To dict (_Acrescentar Operad
 (EN) inclui um bom resumo das outras formas de mesclar mapeamentos.
 ====
 
-Agora vamos ver como o pattern matching se aplica aos mapeamentos.((("", startref="DASsyntax03")))
+Agora vamos ver como o casamento de padrões se aplica aos mapeamentos.((("", startref="DASsyntax03")))
 
 [[pattern_matching_mappings_sec]]
 === Pattern matching com mapeamentos
@@ -222,7 +222,7 @@ Veja https://fpy.li/2z[`Py_TPFLAGS_MAPPING`] (EN).]
 
 No <<ch_sequences>> nos concentramos apenas nos padrões de sequência,
 mas tipos diferentes de padrões podem ser combinados e aninhados.
-Graças à desestruturação, o pattern matching é uma ferramenta poderosa para
+Graças à desestruturação, o casamento de padrões é uma ferramenta poderosa para
 processar registros estruturados como sequências e mapeamentos aninhados,
 que frequentemente precisamos ler de APIs JSON ou bancos de dados
 que suportam registros ou campos semi-estruturados,
@@ -292,13 +292,13 @@ Ice cream details: {'flavor': 'vanilla', 'cost': 199}
 Na <<mappings_flexible_sec>>, vamos estudar o `defaultdict` e
 outros mapeamentos onde buscas com chaves via `+__getitem__+`
 (isto é, `d[chave]`) funcionam porque itens ausentes são criados na hora.
-No contexto do pattern matching,
+No contexto do casamento de padrões,
 um match é bem sucedido apenas se o sujeito já tem as chaves necessárias no início do bloco `match`.
 
 [TIP]
 ====
 O tratamento automático de chaves ausentes não é acionado porque
-o pattern matching sempre usa o método `d.get(key, sentinel)`—onde o
+o casamento de padrões sempre usa o método `d.get(key, sentinel)`—onde o
 `sentinel` default é um marcador com valor especial, que não pode aparecer nos dados do usuário.
 ====
 
@@ -1562,7 +1562,7 @@ Com isso, encerramos esse capítulo.
 
 Dicionários((("dictionaries and sets", "overview of"))) são a pedra fundamental de Python.
 Ao longo dos anos, a sintaxe literal familiar `{k1: v1, k2: v2}`
-foi aperfeiçoada para suportar desempacotamento com `**` e pattern matching, bem como com compreensões de `dict`.
+foi aperfeiçoada para suportar desempacotamento com `**` e casamento de padrões, bem como com compreensões de `dict`.
 
 Além do `dict` básico, a biblioteca padrão oferece mapeamentos práticos prontos para serem usados,
 como o `defaultdict`, o `ChainMap`, e o `Counter`, todos definidos no módulo `collections`.

online/cap05.adoc

@@ -1453,8 +1453,8 @@ id="DCBpattern05")))((("pattern matching", "pattern matching class instances", i
 são projetados para "casar" com instâncias de classes por tipo e—opcionalmente—por atributos.
 O sujeito de um padrão de classe pode ser uma instância de qualquer classe,
 não apenas instâncias de classes de dados.footnote:[Trato desse conteúdo aqui por ser o
-primeiro capítulo sobre classes definidas pelo usuário, e acho que _pattern matching_ com classes
-é um assunto muito importante para esperar até a <<function_objects_part>> do livro.
+primeiro capítulo sobre classes definidas pelo usuário, e considero o casamento de padrões com classes
+um assunto importante demais para esperar até a <<function_objects_part>> do livro.
 Minha filosofia: é mais importante saber como usar classes que como defini-las.]
 
 Há três variantes de padrões de classes: simples, nomeado e posicional.
@@ -1701,7 +1701,7 @@ frustrando um princípio básico da programação orientada a objetos:
 os dados e as funções que acessam os dados devem estar juntos na mesma classe.
 Classes sem uma lógica podem ser um sinal de uma lógica fora de lugar.
 
-Na última seção, vimos como o _pattern matching_
+Na última seção, vimos como o casamento de padrões
 funciona com instâncias de qualquer classe como sujeitos—e
 não apenas das classes criadas com as fábricas apresentadas nesse capítulo.
 

online/cap07.adoc

@@ -520,7 +520,7 @@ Após esse mergulho nos recursos flexíveis de declaração de argumentos no Pyt
 
 === Pacotes para programação funcional
 
-Apesar((("functions, as first-class objects", "packages for functional programming", id="FAFfp07")))((("functional programming", "packages for", id="fprogpack07"))) de Guido deixar claro que não projetou Python para ser uma linguagem de programação funcional, o estilo de programação funcional pode ser amplamente utilizado, graças a funções de primeira classe, _pattern matching_ e o suporte de pacotes como `operator` e `functools`, dos quais falaremos nas próximas duas seções.
+Apesar((("functions, as first-class objects", "packages for functional programming", id="FAFfp07")))((("functional programming", "packages for", id="fprogpack07"))) de Guido deixar claro que não projetou Python para ser uma linguagem de programação funcional, o estilo de programação funcional pode ser amplamente utilizado, graças a funções de primeira classe, casamento de padrões e o suporte de pacotes como `operator` e `functools`, dos quais falaremos nas próximas duas seções.
 
 
 [[operator_module_sec]]

online/cap11.adoc

@@ -686,10 +686,10 @@ construtor embutido `complex()`. Talvez `Vector2d` pudesse oferecer o
 startref="POhash11")))
 
 [[positional_pattern_implement_sec]]
-=== Suportando o pattern matching posicional
+=== Suportando o casamento de padrões posicionais
 
 Até aqui, instâncias de `Vector2d`((("Pythonic objects", "supporting positional
-patterns")))((("positional patterns"))) são compatíveis com o _pattern matching_
+patterns")))((("positional patterns"))) são compatíveis com o casamento de padrões
 com instâncias de classe—vistos na <<keyword_class_patterns_sec>>.
 
 No <<vector_match_keyword_ex>>, todos aqueles padrões nomeados funcionam como esperado.
@@ -720,7 +720,7 @@ TypeError: Vector2d() accepts 0 positional sub-patterns (1 given)
 
 Para fazer `Vector2d` funcionar com padrões posicionais, precisamos acrescentar
 um atributo de classe chamado `+__match_args__+`, listando os atributos de
-instância na ordem em que eles serão usados no pattern matching posicional.
+instância na ordem em que eles serão usados no casamento de padrões posicionais.
 
 
 [source, python]
@@ -1033,7 +1033,7 @@ include::../code/11-pythonic-obj/vector2d_v3_slots.py[tags=VECTOR2D_V3_SLOTS]
     # methods are the same as previous version
 ----
 ====
-<1> `+__match_args__+` lista os nomes dos atributos públicos, para _pattern matching_ posicional.
+<1> `+__match_args__+` lista os nomes dos atributos públicos, para casamento de padrões posicionais.
 <2> `+__slots__+`, por outro lado, lista os nomes dos atributos de instância, que neste caso são atributos privados.
 
 Para medir a economia de memória, escrevi o script _mem_test.py_. Ele recebe,

online/cap12.adoc

@@ -519,9 +519,9 @@ include::../code/12-seq-hacking/vector_v3.py[tags=VECTOR_V3_GETATTR]
 ----
 ====
 
-<1> Define `+__match_args__+` para permitir _pattern matching_ posicional sobre
+<1> Define `+__match_args__+` para permitir casamento de padrões posicionais sobre
 os atributos dinâmicos suportados por `+__getattr__+`.footnote:[Apesar de
-`+__match_args__+` existir para suportar _pattern matching_ desde o Python 3.10,
+`+__match_args__+` existir para suportar casamento de padrões desde o Python 3.10,
 é inofensivo definir este atributo em versões anteriores da linguagem. Na
 primeira edição chamei este atributo de `shortcut_names`. Com o novo nome, ele
 cumpre dois papéis: suportar padrões posicionais em instruções `case` e guardar

online/cap18.adoc

@@ -24,7 +24,7 @@ mecanismos de controle de fluxo não muito comuns em outras linguagens e que, po
 essa razão, podem ser ignorados ou subutilizados em Python. São eles:
 
 * A instrução `with` e o protocolo de gerenciamento de contexto
-* A instrução `match/case` para _pattern matching_ (casamento de padrões)
+* A instrução `match/case` para casamento de padrões (_pattern matching_)
 * A cláusula `else` nas instruções `for`, `while`, e `try`
 
 A instrução `with` cria um contexto temporário e o destrói com segurança, sob o
@@ -33,7 +33,7 @@ repetitivo, tornando as APIs ao mesmo tempo mais seguras e mais fáceis de usar.
 Programadores Python estão encontrando muitos usos para blocos `with` além do
 fechamento automático de arquivos.
 
-Já estudamos _pattern matching_ em capítulos anteriores, mas aqui veremos como a
+Já estudamos casamento de padrões em capítulos anteriores, mas aqui veremos como a
 gramática de uma linguagem de programação pode ser expressa como padrões de
 sequências.
 Por isso `match/case` é uma ferramenta eficiente para criar processadores de
@@ -562,7 +562,7 @@ do _lis.py_, e também explorar todas as cláusulas `case` de `evaluate`,
 explicando não apenas os padrões mas também o que o interpretador faz em cada
 `case`.
 
-Além de mostrar mais _pattern matching_, escrevi essa seção por três razões:
+Além de mostrar mais casamento de padrões, escrevi essa seção por três razões:
 
 . O _lis.py_ de Norvig é um lindo exemplo de código Python idiomático.
 . A simplicidade do Scheme é uma aula magna de design de linguagens.
@@ -1338,7 +1338,7 @@ Meus objetivos aqui eram compartilhar com vocês a beleza do pequeno interpretad
 explicar melhor como as clausuras funcionam,
 e mostrar como `match/case` foi uma ótima adição ao Python.
 
-Para fechar essa seção estendida sobre _pattern matching_,
+Para fechar essa seção estendida sobre casamento de padrões,
 vamos formalizar o conceito de um OR-pattern (_padrão-OU_).((("", startref="lispyproced18")))
 
 ==== Using padrões-OU
@@ -1562,7 +1562,7 @@ função central de qualquer interpretador. Entender o funcionamenteo de
 `evaluate` exigiu revisar um pouco de Scheme, um parser para expressões-S, um
 REPL simples e a construção de escopos aninhados através de `Environment`, uma
 subclasse de `collection.ChainMap`. No fim, _lys.py_ se tornou um instrumento
-para explorarmos mais que _pattern matching_. Ele mostra como diferentes partes
+para explorarmos mais que casamento de padrões. Ele mostra como diferentes partes
 de um interpretador trabalham juntas, jogando luz sobre recursos fundamentais do
 próprio Python: porque palavras reservadas são necessárias, como as regras de
 escopo funcionam, e como clausuras são criadas e usadas.
@@ -1820,11 +1820,11 @@ Python, que implementa PTC. Aprendi a fazer isso lendo o código de Peter Norvig
 Obrigado por compartilhar, professor!((("", startref="tco18")))((("",
 startref="PTC18")))((("", startref="SStail18")))
 
-*A opinião de Norvig sobre `evaluate()` com _pattern matching_*
+*A opinião de Norvig sobre `evaluate()` com casamento de padrões*
 
 Eu((("Soapbox sidebars", "lis.py and evaluate function")))
 compartilhei o código da versão Python 3.10 de _lis.py_ com Peter Norvig.
-Ele gostou do exemplo usando _pattern matching_, mas sugeriu uma solução diferente:
+Ele gostou do exemplo usando casamento de padrões, mas sugeriu uma solução diferente:
 em vez de usar os guardas que escrevi,
 ele teria exatamente um `case` por palavra reservada,
 e teria testes dentro de cada `case`, para fornecer mensagens de `SyntaxError`
@@ -1838,7 +1838,7 @@ https://fpy.li/18-54[_mylis_].
 Mas a forma como estruturei `evaluate` no <<ex_evaluate_match>>
 tem algumas vantagens didáticas nesse livro:
 o exemplo é paralelo à implementação com `if/elif/…` (<<ex_norvigs_eval>>),
-as cláusulas `case` demonstram mais recursos de _pattern matching_
+as cláusulas `case` demonstram mais recursos de casamento de padrões
 e o código é mais conciso.((("", startref="WMEBsoap18")))
 
 ****