cap13: ortografia

Author: ramalho

online/cap13.adoc

@@ -19,25 +19,25 @@ Desde o Python 3.8, temos quatro maneiras de definir e usar interfaces.
 Elas estão ilustradas no _Mapa de Sistemas de Tipagem_ (<<type_systems_described>>).
 
 [[type_systems_described]]
-.Na metade superior, checagens de tipo dinâmicas (em tempo de execução) usando só o interpretador Python; a metade inferior requer um checador estático externo como o Mypy, ou um IDE como a PyCharm. Os quadrantes da esquerda se referem a tipagem baseada na estrutura do objeto—isto é, os métodos oferecidos pelo objeto, independente de sua classe ou superclasses; os quadrantes da direita dependem de tipos explicitamente nomeados no código: a classe do objeto, ou suas superclasses.
+.Na metade superior, checagens de tipo dinâmicas (em tempo de execução) usando só o interpretador Python; a metade inferior requer um checador estático externo como o Mypy, ou um IDE como o PyCharm. Os quadrantes da esquerda se referem à tipagem baseada na estrutura do objeto—isto é, os métodos oferecidos pelo objeto, independente de sua classe ou superclasses; os quadrantes da direita dependem de tipos explicitamente nomeados no código: a classe do objeto, ou suas superclasses.
 image::../images/mapa-da-tipagem.png[align="center",pdfwidth=12cm]
 
 Podemos as quatro abordagens assim:
 
 Tipagem pato (_duck typing_)::
-    A((("duck typing"))) tratamento padrão para tipos em Python desde o início.
+    O((("duck typing"))) tratamento padrão para tipos em Python desde o início.
     Estamos estudando tipagem pato desde o primeiro capítulo do volume 1.
 Tipagem ganso (_goose typing_)::
     A((("goose typing", "definition of term"))) abordagem suportada pelas classes base abstratas
     (ABCs, _sigla em inglês para Abstract Base Classes_) desde Python 2.6,
     que depende de checar objetos contra ABCs durante a execução.
-    A tipagem ganso é um dos principais temas desse capítulo.
+    A tipagem ganso é um dos principais temas deste capítulo.
 Tipagem estática::
     A((("static typing"))) abordagem tradicional das linguagens de tipos estáticos como C e Java;
     suportada desde o Python 3.5 pelo módulo `typing`,
     e aplicada por checadores de tipos externos compatíveis com a
     https://fpy.li/pep484[PEP 484—Type Hints].
-    Este não é o foco desse capítulo.
+    Este não é o foco deste capítulo.
     A maior parte do <<ch_type_hints_def>> e do <<ch_more_types>>
     mais adiante são sobre tipagem estática.
 Tipagem pato estática (_static duck typing_)::
@@ -54,7 +54,7 @@ As((("interfaces", "typing map")))((("typing map"))) quatro abordagens retratada
 <<type_systems_described>> são complementares: elas têm diferentes prós e contras.
 Não faz sentido descartar qualquer uma delas.
 
-Cada uma dessas quatro abordagens dependem de interfaces para funcionarem, mas a
+Cada uma dessas quatro abordagens depende de interfaces para funcionar, mas a
 tipagem estática pode ser implementada de forma limitada usando apenas tipos
 concretos em vez de abstrações de interfaces como protocolos e classes base
 abstratas.
@@ -66,14 +66,13 @@ capítulo está dividido em quatro seções principais, tratando de três dos qu
 quadrantes no Mapa de Sistemas de Tipagem. (<<type_systems_described>>):
 
 * A <<two_kinds_protocols_sec>> compara duas formas de tipagem estrutural com
-protocolos +
-—o lado esquerdo do Mapa.
+protocolos—o lado esquerdo do Mapa.
 
-* A <<prog_ducks_sec>> se aprofunda na tipagem pato que já é familiar para
+* A <<prog_ducks_sec>> se aprofunda na tipagem pato, que já é familiar para
 quem programa em Python. Vamos ver como fazê-la mais segura,
 preservando sua melhor qualidade: a flexibilidade.
 
-* A <<goose_typing_sec>> explica o uso de ABCs para um checagem de tipo mais
+* A <<goose_typing_sec>> explica o uso de ABCs para uma checagem de tipo mais
 estrita durante a execução do código. É a seção mais longa, não por ser a mais
 importante, mas porque há mais seções sobre tipagem pato, tipagem pato estática e
 tipagem estática em outras partes do livro.
@@ -100,7 +99,7 @@ conteúdo novo—e de todos os outros capítulos relacionados à tipagem em Pyth
 * A <<two_kinds_protocols_sec>> explica as semelhanças e diferenças entre
 protocolos dinâmicos e estáticos.
 
-* A <<defensive_duck_prog_sec>> praticamente reproduz o conteúdo da primeira
+* A <<defensive_duck_prog_sec>> reproduz praticamente o conteúdo da primeira
 edição, mas foi atualizada e agora tem um título de seção que enfatiza sua
 importância.
 
@@ -112,7 +111,7 @@ para incluir a `Collection` ABC, do Python 3.6.
 
 Na primeira edição de _Python Fluente_ escrevi uma seção encorajando o uso das ABCs
 do módulo `numbers` para tipagem ganso.
-Na <<numbers_abc_proto_sec>> explico porque, atualmente, é melhor usar
+Na <<numbers_abc_proto_sec>> explico por que, atualmente, é melhor usar
 protocolos numéricos estáticos do módulo `typing` como `SupportsFloat` se
 você planeja usar checadores de tipos estáticos, ou checagem durante a execução
 no estilo da tipagem ganso.
@@ -228,7 +227,7 @@ precise de todos eles.
 * Protocolos estáticos podem ser inspecionados por checadores de tipos
 estáticos, protocolos dinâmicos não.
 
-Os dois tipos de protocolo compartilham um característica essencial: uma classe
+Os dois tipos de protocolo compartilham uma característica essencial: uma classe
 nunca precisa declarar que suporta um protocolo pelo nome, isto é, por herança.
 
 Antes dos protocolos estáticos, Python já oferecia outra forma de definir uma
@@ -267,7 +266,7 @@ image::../images/flpy_1302.png[align="center",pdfwidth=10cm]
 
 [TIP]
 ====
-A maior parte das ABCs no módulo `collections.abc` existem para formalizar
+A maior parte das ABCs no módulo `collections.abc` existe para formalizar
 interfaces que já eram implementadas por objetos nativos e implicitamente
 suportadas pelo interpretador, muito antes daquele módulo existir.
 As ABCs são úteis como pontos de partida para novas classes, e
@@ -312,15 +311,15 @@ especial que Python dá a qualquer estrutura vagamente semelhante a uma
 sequência. O protocolo iterável em Python representa uma forma extrema de tipagem pato:
 o interpretador tenta dois métodos diferentes para iterar sobre objetos.
 
-Para deixar mais claro, os comportamentos que que descrevi nessa seção estão
+Para deixar mais claro, os comportamentos que descrevi nessa seção estão
 implementados no próprio interpretador, na maioria dos casos em C. Eles não
 dependem dos métodos da ABC `Sequence`. Por exemplo, os métodos concretos
 `+__iter__+` e `+__contains__+` na classe `Sequence` emulam comportamentos
 internos do interpretador Python. Se tiver curiosidade, veja o código-fonte
 destes métodos em https://fpy.li/13-3[_Lib/_collections_abc.py_].
 
 Agora vamos estudar um exemplo que demonstra por que checadores de tipos
-estáticos não têm lidar com protocolos
+estáticos não têm como lidar com protocolos
 dinâmicos.((("", startref="Pseqit13")))((("", startref="seqpro13")))((("",
 startref="itpro13")))
 
@@ -342,7 +341,7 @@ como módulos, classes e funções.
 Vamos fazer _monkey patch_ na classe `FrenchDeck` do <<ex_pythonic_deck_repeat>>
 para superar uma grande limitação: ela não pode ser embaralhada. Anos atrás,
 quando escrevi pela primeira vez o exemplo `FrenchDeck`, implementei um método
-`shuffle`. Depois tive um insight pythônico: se um `FrenchDeck` funciona como
+`shuffle`. Depois tive uma sacada pythônica: se um `FrenchDeck` funciona como
 uma sequência, não precisa ter um método `shuffle`, pois já existe a função
 `random.shuffle`, que "embaralha a sequência x internamente" conforme a
 https://fpy.li/6m[documentação oficial]. 
@@ -385,10 +384,10 @@ TypeError: 'FrenchDeck' object does not support item assignment
 ----
 ====
 
-A mensagem de erro é clara: `O objeto 'FrenchDeck' não suporta a atribuição de
-itens`. O problema é que +shuffle+ opera _internamente_, trocando os itens de
+A mensagem de erro é clara: "o objeto 'FrenchDeck' não suporta a atribuição de
+itens". O problema é que `shuffle` opera internamente, trocando os itens de
 lugar dentro da coleção, mas `FrenchDeck` só implementa o protocolo de sequência
-_imutável_. Para ser uma sequências mutável, `FrenchDeck` precisa oferecer um
+imutável. Para ser uma sequência mutável, `FrenchDeck` precisa oferecer um
 método `+__setitem__+`.
 
 Como Python é dinâmico, podemos consertar isso durante a execução, até mesmo no
@@ -423,10 +422,14 @@ https://fpy.li/6n[Emulando tipos contêineres].
 Aqui nomeei os argumentos `deck, position, card`&#x2014;e não `self, key, value` como na
 referência da linguagem—para mostrar que todo método Python começa sua vida como
 uma função comum, e nomear o primeiro argumento `self` é só uma convenção.
-Fujir da convenção é OK em uma sessão no console onde o código é descartável,
+Fugir da convenção é OK em uma sessão no console onde o código é descartável,
 mas em um arquivo de código-fonte de Python é muito melhor usar
 `self`, `key`, e `value`, seguindo a documentação.
 
+////
+PAREI
+////
+
 O truque é que `set_card` pressupõe que o `deck` tem um atributo chamado
 `+_cards+`, e seu valor deve ser uma sequência mutável. A função `set_cards` é
 então anexada à classe `FrenchDeck` class como o método especial