remover [.keep-together]

Author: ramalho

links/FPY.LI.htaccess

@@ -1288,3 +1288,6 @@ RedirectTemp /6r	https://docs.python.org/pt-br/3/library/abc.html
 RedirectTemp /6s	https://docs.python.org/pt-br/dev/library/abc.html#abc.abstractmethod
 RedirectTemp /6t	https://docs.python.org/pt-br/3/library/os.html#os.urandom
 RedirectTemp /6v	https://pt.wikipedia.org/wiki/Princ%C3%ADpio_da_segrega%C3%A7%C3%A3o_de_interface
+
+# cap13: appended 2025-11-13 14:52:00
+RedirectTemp /6v	https://docs.python.org/pt-br/3.14/library/typing.html#protocols

online/cap08.adoc

@@ -272,7 +272,7 @@ def show_count(count: int, word: str) -> str:
 
 [TIP]
 ====
-Em vez de digitar opções de linha de comando como [.keep-together]#`--disallow-incomplete-defs`#,
+Em vez de digitar opções de linha de comando como `--disallow-incomplete-defs`,
 você pode salvar sua configuração favorita da forma descrita na página
 https://fpy.li/8-8[Mypy configuration file] (EN) na documentação do Mypy.
 Você pode incluir configurações globais e configurações específicas para cada módulo.
@@ -1137,7 +1137,7 @@ Podemos resumir esse processo em quatro etapas:
 
 . Tornar aquele comportamento o default a partir de Python 3.9: `list[str]` agora funciona sem que  `future` precise ser importado.
 
-. Descontinuar (_deprecate_) todos os tipos genéricos do módulo `typing`.footnote:[Uma de minhas contribuições para a documentação do módulo `typing` foi acrescentar dúzias de avisos de descontinuação, enquanto eu reorganizava as entradas abaixo de https://fpy.li/4b["Conteúdo do Módulo"] em subseções, sob a supervisão de Guido van [.keep-together]#Rossum#.] Avisos de descontinuação não serão emitidos pelo interpretador Python, porque os checadores de tipos devem sinalizar os tipos descontinuados quando o programa sendo checado tiver como alvo Python 3.9 ou posterior.
+. Descontinuar (_deprecate_) todos os tipos genéricos do módulo `typing`.footnote:[Uma de minhas contribuições para a documentação do módulo `typing` foi acrescentar dúzias de avisos de descontinuação, enquanto eu reorganizava as entradas abaixo de https://fpy.li/4b["Conteúdo do Módulo"] em subseções, sob a supervisão de Guido van Rossum.] Avisos de descontinuação não serão emitidos pelo interpretador Python, porque os checadores de tipos devem sinalizar os tipos descontinuados quando o programa sendo checado tiver como alvo Python 3.9 ou posterior.
 
 . Remover aqueles tipos genéricos redundantes na primeira versão de Python lançada cinco anos após Python 3.9. No ritmo atual, esse deverá ser Python 3.14, também conhecido como Python Pi.
 ****

online/cap13.adoc

@@ -607,7 +607,7 @@ Originalmente, o Django oferecia uma série de funções, chamadas views genéri
 
 Entretanto, as views genéricas originais eram funções, então não eram extensíveis. Se quiséssemos algo algo similar mas não exatamente igual a uma view de lista genérica, era  preciso começar do zero.
 
-O conceito de views baseadas em classes foi introduzido no Django 1.3, juntamente com um conjunto de classes de views genéricas divididas em classes base, mixins e classes concretas prontas para o uso. No Django 3.2, as classes base e as mixins estão no módulo `base` do pacote `django.views.generic`, ilustrado((("UML class diagrams", "django.views.generic.base module"))) na <<django_view_base_uml>>. No topo do diagrama vemos duas classes que se encarregam de responsabilidades muito diferentes: `View` e [.keep-together]#`TemplateResponseMixin`.#
+O conceito de views baseadas em classes foi introduzido no Django 1.3, juntamente com um conjunto de classes de views genéricas divididas em classes base, mixins e classes concretas prontas para o uso. No Django 3.2, as classes base e as mixins estão no módulo `base` do pacote `django.views.generic`, ilustrado((("UML class diagrams", "django.views.generic.base module"))) na <<django_view_base_uml>>. No topo do diagrama vemos duas classes que se encarregam de responsabilidades muito diferentes: `View` e `TemplateResponseMixin`.
 
 [role="width-80"]
 [[django_view_base_uml]]

online/cap14.adoc

@@ -1444,7 +1444,7 @@ de Eric Meijer e Peter Drayton.footnote:[O leitor de notas de rodapé se lembrar
 Aprendi muito lendo as partes relevantes de alguns livros sobre outras linguagens que implementam algumas das mesmas ideias:
 
 * https://fpy.li/15-44[_Atomic Kotlin_] (EN), de Bruce Eckel e Svetlana Isakova
-[.keep-together]#(Mindview)#
+(Mindview)
 * https://fpy.li/15-45[_Effective Java_, 3rd ed.,] (EN), de Joshua Bloch (Addison-Wesley)
 * https://fpy.li/15-46[_Programming with Types: TypeScript Examples_] (EN), de Vlad Riscutia (Manning)
 

online/cap15.adoc

@@ -962,7 +962,7 @@ O primeiro grupo contém funções geradoras de filtragem: elas produzem um subc
 [options="header"]
 |=============================================================================================================================================================================================================================================================
 |Módulo|Função|Descrição
-|[.keep-together]#`itertools`#|[.keep-together]#`compress(it, selector_it)`#|Consome dois iteráveis em paralelo; produz itens de `it` sempre que o item correspondente em `selector_it` é verdadeiro
+|`itertools`|`compress(it, selector_it)`|Consome dois iteráveis em paralelo; produz itens de `it` sempre que o item correspondente em `selector_it` é verdadeiro
 |`itertools`|`dropwhile(predicate, it)`|Consome `it`, pulando itens enquanto `predicate` resultar verdadeiro, e daí produz todos os elementos restantes (nenhuma verificação adicional é realizada)
 |(Embutida)|`filter(predicate, it)`|Aplica `predicate` para cada item de `iterable`, produzindo o item se `predicate(item)` for verdadeiro; se `predicate` for `None`, apenas itens verdadeiros serão produzidos
 |`itertools`|`filterfalse(predicate, it)`|Igual a `filter`, mas negando a lógica de `predicate`: produz itens sempre que `predicate` resultar falso
@@ -1012,7 +1012,7 @@ O((("mappings", "mapping generator functions"))) grupo seguinte contém os gerad
 [options="header"]
 |=============================================================================================================================================================================================================================================================
 |Módulo|Função|Descrição
-|[.keep-together]#`itertools`#|`accumulate(it, [func])`|Produz somas cumulativas; se `func` for fornecida, produz o resultado da aplicação de `func` ao primeiro par de itens, depois ao primeiro resultado e ao próximo item, etc.
+|`itertools`|`accumulate(it, [func])`|Produz somas cumulativas; se `func` for fornecida, produz o resultado da aplicação de `func` ao primeiro par de itens, depois ao primeiro resultado e ao próximo item, etc.
 |(embutida)|`enumerate(iterable, start=0)`|Produz tuplas de dois itens na forma `(index, item)`, onde `index` é contado a partir de `start`, e `item` é obtido do `iterable`
 |(embutida)|`map(func, it1, [it2, …, itN])`|Aplica `func` a cada item de `it`, produzindo o resultado; se forem fornecidos N iteráveis, `func` deve aceitar N argumentos, e os iteráveis serão consumidos em paralelo
 |`itertools`|`starmap(func, it)`|Aplica `func` a cada item de `it`, produzindo o resultado; o iterável de entrada deve produzir itens iteráveis `iit`, e `func` é aplicada na forma `func(*iit)`
@@ -1128,7 +1128,7 @@ O <<demo_merging_genfunc>> demonstra o uso das funções geradoras `itertools.ch
 <5> `itertools.zip_longest` funciona como `zip`, exceto por consumir todos os iteráveis de entrada, preenchendo as tuplas de saída com `None` onde necessário.
 <6> O argumento nomeado `fillvalue` especifica um valor de preenchimento customizado.
 
-A geradora `itertools.product` é uma forma preguiçosa para calcular produtos cartesianos, que criamos usando compreensões de lista com mais de uma instrução `for` na <<cartesian_product_sec>>. Expressões geradoras com múltiplas instruções `for` também podem ser usadas para produzir produtos cartesianos de forma preguiçosa. O <<demo_product_genfunc>> demonstra [.keep-together]#`itertools.product`.#
+A geradora `itertools.product` é uma forma preguiçosa para calcular produtos cartesianos, que criamos usando compreensões de lista com mais de uma instrução `for` na <<cartesian_product_sec>>. Expressões geradoras com múltiplas instruções `for` também podem ser usadas para produzir produtos cartesianos de forma preguiçosa. O <<demo_product_genfunc>> demonstra `itertools.product`.
 
 [[demo_product_genfunc]]
 .Exemplo da função geradora `itertools.product`

online/cap17.adoc

@@ -328,7 +328,7 @@ include::../code/19-concurrency/spinner_proc.py[tags=SPINNER_PROC_SUPER]
 <4> O uso básico da classe `Process` é similar ao da classe `Thread`.
 <5> O objeto `spinner` aparece como <Process name='Process-1' parent=14868 initial>`,
 onde `14868` é o `id` do processo da instância de Python que está executando o
-[.keep-together]#_spinner_proc.py_.#
+_spinner_proc.py_.
 
 As APIs básicas de `threading` e `multiprocessing` são similares,
 mas sua implementação é muito diferente, e `multiprocessing`
@@ -376,7 +376,7 @@ A versão com corrotinas do programa de animação é mais fácil de entender se
 include::../code/19-concurrency/spinner_async.py[tags=SPINNER_ASYNC_START]
 ----
 ====
-<1> `main` é a única função regular definida nesse programa—as outras são [.keep-together]#corrotinas#.
+<1> `main` é a única função regular definida nesse programa—as outras são corrotinas.
 <2> A função`asyncio.run` inicia o loop de eventos para controlar a corrotina que irá em algum momento colocar as outras corrotinas em movimento.
 A função `main` ficará bloqueada até que `supervisor` retorne.
 O valor de retorno de `supervisor` será o valor de retorno de `asyncio.run`.
@@ -554,7 +554,7 @@ Aqui está um resumo das diferenças e semelhanças notáveis entre as duas impl
 ele já esta agendado para rodar, mas uma instância de `Thread` precisa ser iniciada explicitamente através de uma chamada a seu método `start`.
 * Na `supervisor` da versão com threads, `slow` é uma função comum e é invocada diretamente pela thread principal. Na versão assíncrona da `supervisor`, `slow` é uma corrotina guiada por `await`.
 * Não há API para terminar uma thread externamente; em vez disso, é preciso enviar um sinal—como acionar o `done` no objeto `Event`. Para objetos `Task`, há o método de instância `Task.cancel()`, que dispara um `CancelledError` na expressão `await` na qual o corpo da corrotina está suspensa naquele momento.
-* A corrotina `supervisor` deve ser iniciada com `asyncio.run` na [.keep-together]#função# `main`.
+* A corrotina `supervisor` deve ser iniciada com `asyncio.run` na função `main`.
 
 Essa comparação ajuda a entender como a concorrência é orquestrada com _asyncio_,
 em contraste com como isso é feito com o módulo `Threading`, possivelmente mais familiar ao leitor.
@@ -619,7 +619,7 @@ ____
 
 Antes de executar o código ou continuar lendo,
 recomendo chegar as respostas por você mesmo.
-Depois, copie e modifique os exemplos pass:[<em>spinner_*.py</em>]  como [.keep-together]#sugerido#.
+Depois, copie e modifique os exemplos pass:[<em>spinner_*.py</em>]  como sugerido.
 
 Agora as respostas, da mais fácil para a mais difícil.
 
@@ -648,7 +648,7 @@ Mas se você tiver duas ou mais threads disputando por mais tempo da CPU, seu pr
 ===== 3. Resposta para asyncio
 Se((("coroutines", "Global Interpreter Lock impact"))) você chamar `is_prime(5_000_111_000_222_021)` na corrotina `slow` do exemplo _spinner_async.py_,
 a animação nunca vai aparecer.
-O efeito seria o mesmo [.keep-together]#que vimos# no <<spinner_async_time_sleep_ex>>,
+O efeito seria o mesmo que vimos no <<spinner_async_time_sleep_ex>>,
 quando substituímos `await asyncio.sleep(3)` por `time.sleep(3)`:
 nenhuma animação.
 O fluxo de controle vai passar da `supervisor` para `slow`, e então para `is_prime`.
@@ -872,7 +872,7 @@ Agora vamos estudar a função `main` de _procs.py_ no <<primes_procs_main_ex>>.
 include::../code/19-concurrency/primes/procs.py[tags=PRIMES_PROC_MAIN]
 ----
 ====
-<1> Se nenhum argumento é dado na linha de comando, define o número de processos como o número de núcleos na CPU; caso contrário, cria quantos processos forem passados no primeiro  [.keep-together]#argumento.#
+<1> Se nenhum argumento é dado na linha de comando, define o número de processos como o número de núcleos na CPU; caso contrário, cria quantos processos forem passados no primeiro  argumento.
 <2> `jobs` e `results` são as filas descritas no <<primes_procs_top_ex>>.
 <3> Inicia `proc` processos para consumir `jobs` e informar `results`.
 <4> Recupera e exibe os resultados; `report` está definido em pass:[<img src="callouts/6.png" alt="6"/>].
@@ -916,7 +916,7 @@ Você((("process pools", "varying process numbers"))) poderia tentar rodar _proc
 $ python3 procs.py 2
 ----
 
-...vai iniciar dois subprocessos, produzindo os resultados quase duas vezes mais rápido que _sequential.py_—se a sua máquina tiver uma CPU com pelo menos dois núcleos e não estiver ocupada rodando outros [.keep-together]#programas#.
+...vai iniciar dois subprocessos, produzindo os resultados quase duas vezes mais rápido que _sequential.py_—se a sua máquina tiver uma CPU com pelo menos dois núcleos e não estiver ocupada rodando outros programas.
 
 Rodei _procs.py_ 12 vezes, usando de 1 a 20 subprocessos, totalizando 240 execuções. Então calculei a mediana do tempo para todas as execuções com o mesmo número de subprocessos, e desenhei a <<procs_x_time_fig>>.