some fixes applied

README.md

@@ -1,4 +1,4 @@
-Versão em português do Brasil da DLang Tour
+Versão em português do Brasil de DLang Tour
 ===========================================
 
 [![sanitycheck build status](https://github.com/dlang-tour/brazilian-portuguese/actions/workflows/d.yml/badge.svg)](https://github.com/dlang-tour/brazilian-portuguese/actions/workflows/d.yml)

basics/alias-strings.md

@@ -37,7 +37,7 @@ e não em um nível de caractere.
 Ao mesmo tempo, os algoritmos da biblioteca padrão interpretarão `string`s como sequências
 de [pontos de código](http://unicode.org/glossary/#code_point), e há também uma
 opção para tratá-las como sequências de
-[graphemes] (http://unicode.org/glossary/#grapheme) por meio do uso explícito de
+[graphemes](http://unicode.org/glossary/#grapheme) por meio do uso explícito de
 [`std.uni.byGrapheme`](https://dlang.org/library/std/uni/by_grapheme.html).
 
 Este pequeno exemplo ilustra essa diferença de interpretação:
@@ -59,10 +59,9 @@ Aqui, o tamanho atual do array `s` é 3, porque ele contém 3 unidades de códig
 (função da biblioteca padrão para calcular o comprimento de um range arbitrário)
 conta dois pontos de código no total. Por fim, `byGrapheme` realiza cálculos bastante caros
 para reconhecer que esses dois pontos de código se combinam em um único caractere exibido.
-caractere.
 
 O processamento correto do Unicode pode ser muito complicado, mas, na maioria das vezes, os desenvolvedores de D
-podem simplesmente considerar as variáveis `string` como arrays mágicas de bytes e
+podem simplesmente considerar as variáveis `string` como arrays mágicos de bytes e
 e confiar nos algoritmos da biblioteca padrão para fazer o trabalho correto.
 Se a iteração por elemento (unidade de código) for desejada, é possível usar
 [`byCodeUnit`](http://dlang.org/phobos/std_utf.html#.byCodeUnit).

basics/arrays.md

@@ -40,11 +40,11 @@ usando a sintaxe `auto arr = new int[3][3]`.
 Os arrays estáticos e dinâmicos fornecem a propriedade `.length`,
 que é somente leitura para arrays estáticos, mas pode ser usada no caso de
 matrizes dinâmicas para alterar seu tamanho dinamicamente. A propriedade
-propriedade `.dup` cria uma cópia do array.
+`.dup` cria uma cópia do array.
 
 A indexação de um array refere-se a um elemento desse array.
 Ao indexar um array por meio da sintaxe `arr[idx]`, um símbolo especial
-especial `$` indica o comprimento de um array. Por exemplo, `arr[$ - 1]` faz referência
+`$` indica o comprimento de um array. Por exemplo, `arr[$ - 1]` faz referência
 o último elemento e é uma forma abreviada de `arr[arr.length - 1]`.
 
 Os arrays podem ser concatenados usando o operador `~`, que

basics/associative-arrays.md

@@ -1,8 +1,8 @@
 # Arrays Associativos
 
-O D tem *arrays associativos* incorporados, também conhecidos como mapas de hash.
-Um array associativo com um tipo de chave `string` e um tipo de valor
-de `int` é declarado da seguinte forma:
+O D tem *arrays associativos* incorporados, também conhecidos como [HashMap](https://en.wikipedia.org/wiki/Hash_table).
+Um array associativo com um tipo `string` na chave e um tipo `int` no valor
+é declarado da seguinte forma:
 
     int[string] arr;
 

basics/basic-types.md

@@ -2,10 +2,9 @@
 
 O D fornece vários tipos básicos que sempre têm o mesmo
 tamanho **independentemente** da plataforma - a única exceção
-é o tipo `real` que fornece a maior precisão possível de ponto flutuante
-possível. Não há diferença
-entre o tamanho de um número inteiro, independentemente de o aplicativo
-seja compilado para sistemas de 32 ou 64 bits.
+é o tipo `real` que fornece a maior precisão possível de ponto flutuante.
+Não há diferença entre o tamanho de um número inteiro, independentemente
+do aplicativo ser compilado para sistemas de 32 ou 64 bits.
 
 | tipo                          | tamanho
 |-------------------------------|------------
@@ -60,8 +59,8 @@ Cada tipo também tem uma propriedade `.stringof` que produz seu nome como uma s
 ### Índices em D
 
 Em D, os índices geralmente têm o alias do tipo `size_t`, pois é um tipo que
-é grande o suficiente para representar um deslocamento em toda a memória endereçável - isto é
-`uint` para arquiteturas de 32 bits e `ulong` para arquiteturas de 64 bits.
+é grande o suficiente para representar um deslocamento em toda a memória endereçável, 
+isto é, `uint` para arquiteturas de 32 bits e `ulong` para arquiteturas de 64 bits.
 
 ### Expressão Assert
 

basics/classes.md

@@ -5,7 +5,7 @@ O D oferece suporte a classes e interfaces como em Java ou C++.
 Qualquer tipo de `class` herda implicitamente do [`Object`](https://dlang.org/phobos/object.html) (objeto).
 
     class Foo { } // herda de Object
-    class Bar : Foo { } // Bar é imcorporado ao Foo
+    class Bar : Foo { } // Bar é incorporado ao Foo
 
 As classes em D geralmente são instanciadas no heap usando `new`:
 
@@ -22,8 +22,8 @@ quando não houver mais referências a um objeto.
 #### Herança
 
 Se uma função de membro de uma classe base for substituída, a palavra-chave
-`override` deve ser usada para indicar isso. Isso evita a substituição não intencional
-sobreposição não intencional de funções.
+`override` deve ser usada para indicar isso. Isso evita a sobreposição não 
+intencional de funções.
 
     class Bar : Foo {
         override functionFromFoo() {}

basics/controlling-flow.md

@@ -3,11 +3,11 @@
 O fluxo de um aplicativo pode ser controlado condicionalmente com declarações `if` e `else`:
 
     if (a == 5) {
-        writeln("Condition is met");
+        writeln("Condição atendida!");
     } else if (a > 10) {
-        writeln("Another condition is met");
+        writeln("Outra condição atendida!");
     } else {
-        writeln("Nothing is met!");
+        writeln("Nenhuma condição atendida!");
     }
 
 Quando um bloco `if` ou `else` contém apenas uma instrução,

basics/delegates.md

@@ -25,9 +25,9 @@ contexto - ou *enclosure*, portanto também chamado de **closure**
 em outras linguagens. Por exemplo, um `delegate`
 que aponta para uma função membro de uma classe também inclui
 o ponteiro para o objeto da classe. Um `delegate` criado por
-uma função aninhada inclui um link para o contexto
+uma função aninhada inclui um vínculo para o contexto
 em vez disso. No entanto, o compilador D pode fazer automaticamente uma cópia do
-do contexto no heap se isso for necessário para a segurança da memória.
+contexto no heap se isso for necessário para a segurança da memória.
 então um delegate será vinculado a essa área de heap.
 
     void foo() {
@@ -42,10 +42,9 @@ teria a seguinte aparência:
 
     void doSomething(int delegate(int,int) doer);
 
-`delegate` and `function` objects cannot be mixed. But the
-standard function
+Os objetos de `delegate` e `function` não podem ser misturados. Porém, é possível a função
 [`std.functional.toDelegate`](https://dlang.org/phobos/std_functional.html#.toDelegate)
-converts a `function` to a `delegate`.
+converter `function` em `delegate`.
 
 ### Funções anônimas & Lambdas
 

basics/exceptions.md

@@ -80,7 +80,7 @@ automaticamente.
 É importante evitar o `assert` e o que será introduzido em breve
 [contract programming](gems/contract-programming)
 para a entrada do usuário, pois o `assert` e os contratos
-são removidos quando compilados no modo de lançamento. Por conveniência
+são removidos quando compilados no modo de lançamento (release). Por conveniência
 [`std.exception`](https://dlang.org/phobos/std_exception.html) fornece
 [`enforce`](https://dlang.org/phobos/std_exception.html#enforce)
 que pode ser usado como o `assert`, mas lança `Exception`s

basics/foreach.md

@@ -29,8 +29,8 @@ chamado **range**, que será apresentado na [próxima seção](basics/ranges).
 
 Os elementos serão copiados do array ou range durante a iteração.
 Isso é aceitável para tipos básicos, mas pode ser um problema para tipos
-tipos grandes. Para evitar a cópia e permitir a mutabilidade do dado
-pode ser usado o `ref`:
+grandes. Para evitar a cópia e permitir a mutabilidade do dado
+utilizando `ref`:
 
     foreach (ref e; arr) {
         e = 10; // sobrescrevendo o valor
@@ -46,7 +46,7 @@ D nos permite escrever iterações que devem ser executadas
     }
     // 0 1 2
 
-O último número em `a ... b` é excluído do intervalo,
+O último número em `a ... b` é excluído do range,
 portanto, o corpo do loop é executado `3` vezes.
 
 ### Iteração com contador de índice

basics/imports-and-modules.md

@@ -21,7 +21,7 @@ Nos próximos capítulos, você verá que isso se aplica a quase todos os concei
 
 ### Imports seletivos
 
-A biblioteca pad~rao, chamado [Phobos](https://dlang.org/phobos/),
+A biblioteca padrão, chamado [Phobos](https://dlang.org/phobos/),
 está localizado no **pacote** `std`
 e seus módulos são referenciados por meio do `import std.MODULE`.
 

basics/memory.md

@@ -2,7 +2,7 @@
 
 D é uma linguagem de programação de sistema e, portanto, permite o gerenciamento manual da memória.
 Entretanto, o gerenciamento manual de memória está sujeito a erros de segurança de memória
-e, portanto, o D usa um *coletor de lixo* por padrão para gerenciar a alocação de memória.
+e por conta disto, o D usa um *coletor de lixo* (GC) por padrão para gerenciar a alocação de memória.
 
 D fornece tipos de ponteiro `T*` como em C:
 
@@ -11,12 +11,12 @@ D fornece tipos de ponteiro `T*` como em C:
     auto c = &a; // c é int* e contém o endereço de a
 
 Um novo bloco de memória no heap é alocado usando uma expressão
-expressão [`new T`](https://dlang.org/spec/expression.html#new_expressions),
+[`new T`](https://dlang.org/spec/expression.html#new_expressions),
 que retorna um ponteiro para a memória gerenciada (quando T é um tipo de valor):
 
     int* a = new int;
 
-Quando a memória referenciada por `a` não for referenciada em nenhum lugar
+Quando a memória referenciada por `a` não for utilizada em nenhum lugar
 por meio de qualquer variável no programa, o próximo ciclo de coleta de lixo
 liberará sua memória. Por padrão, o coletor de lixo só pode ser
 executado ao alocar memória com o GC - por exemplo, ao utilizar

basics/ranges.md

@@ -81,7 +81,7 @@ interface ForwardRange(E) : InputRange!E
 ```
 
 ```d
-// by value (Structs)
+// por valor (Structs)
 auto r = 5.iota;
 auto r2 = refRange(&r);
 r2.save.drop(5).writeln; // []

basics/structs.md

@@ -54,7 +54,7 @@ Se uma função membro for declarada com `const`, não será permitido
 modificar nenhum de seus membros. Isso é imposto pelo compilador.
 Tornar uma função membro `const` faz com que ela possa ser chamada em qualquer objeto `const`
 ou objeto `immutable`, mas também garante aos chamadores que
-a função de membro nunca alterará o estado do objeto.
+a função membro nunca alterará o estado do objeto.
 
 ### Função membro `static`
 
@@ -63,8 +63,7 @@ sem um objeto instanciado (por exemplo, `Person.myStatic()`), mas ela
 não poderá acessar nenhum membro que não seja `static`.  Ele pode ser usado se um método
 não precisar acessar nenhum dos campos de membro do objeto, mas logicamente
 pertence à mesma classe. Também pode ser usado para fornecer alguma funcionalidade
-sem criar uma instância explícita, por exemplo, algumas implementações do padrão de design Singleton
-usam `static`.
+sem criar uma instância explícita, por exemplo, algumas implementações do padrão de design Singleton usam `static`.
 
 ### Herança
 

basics/type-qualifiers.md

@@ -20,9 +20,7 @@ depois disso, não pode ser alterado.
     // ou: immutable err = 5 e int será inferido.
     err = 5; // não compila
 
-Os objetos `imutáveis` podem, portanto, ser compartilhados com segurança entre diferentes threads sem
-sincronização, pois, por definição, eles nunca mudam. Isso também implica que os objetos
-os objetos `immutable` podem ser armazenados em cache perfeitamente.
+Os objetos `imutáveis` podem, portanto, ser compartilhados com segurança entre diferentes threads sem sincronização, pois, por definição, eles nunca mudam. Isso também implica que os objetos `immutable` podem ser armazenados em cache perfeitamente.
 
 ### `const`
 

multithreading/message-passing.md

@@ -9,8 +9,7 @@ por padrão, o que evita os problemas comuns de
 multi-threading.
 
 Todas as funções que implementam a troca de mensagens em D
-podem ser encontradas no módulo [`std.concurrency`](https://dlang.org/phobos/std_concurrency.html)
-módulo. O `spawn` cria uma nova *thread* com base em uma
+podem ser encontradas no módulo [`std.concurrency`](https://dlang.org/phobos/std_concurrency.html). O `spawn` cria uma nova *thread* com base em uma
 função definida pelo usuário:
 
     auto threadId = spawn(&foo, thisTid);

multithreading/std-parallelism.md

@@ -1,4 +1,4 @@
-# std.parallelism
+# Paralelismo
 
 O módulo `std.parallelism` implementa
 primitivas de alto nível para uma programação simultânea conveniente.