From 642b987b40400f2554044e3067c1f27ebdeebfb6 Mon Sep 17 00:00:00 2001 From: Matheus Catarino Date: Fri, 12 Jul 2024 15:47:42 -0300 Subject: [PATCH] some fixes applied --- README.md | 2 +- basics/alias-strings.md | 5 ++--- basics/arrays.md | 4 ++-- basics/associative-arrays.md | 6 +++--- basics/basic-types.md | 11 +++++------ basics/classes.md | 6 +++--- basics/controlling-flow.md | 6 +++--- basics/delegates.md | 9 ++++----- basics/exceptions.md | 2 +- basics/foreach.md | 6 +++--- basics/imports-and-modules.md | 2 +- basics/memory.md | 6 +++--- basics/ranges.md | 2 +- basics/structs.md | 5 ++--- basics/type-qualifiers.md | 4 +--- multithreading/message-passing.md | 3 +-- multithreading/std-parallelism.md | 2 +- 17 files changed, 37 insertions(+), 44 deletions(-) diff --git a/README.md b/README.md index d8ab339..dbc764d 100644 --- a/README.md +++ b/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) diff --git a/basics/alias-strings.md b/basics/alias-strings.md index eab9ae6..8e53886 100644 --- a/basics/alias-strings.md +++ b/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). diff --git a/basics/arrays.md b/basics/arrays.md index 52a9b12..f082c97 100644 --- a/basics/arrays.md +++ b/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 diff --git a/basics/associative-arrays.md b/basics/associative-arrays.md index fcd900b..e326002 100644 --- a/basics/associative-arrays.md +++ b/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; diff --git a/basics/basic-types.md b/basics/basic-types.md index 5c374e9..78f6ce3 100644 --- a/basics/basic-types.md +++ b/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 diff --git a/basics/classes.md b/basics/classes.md index cdf67df..586d9e2 100644 --- a/basics/classes.md +++ b/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() {} diff --git a/basics/controlling-flow.md b/basics/controlling-flow.md index 9bd53e5..54be53f 100644 --- a/basics/controlling-flow.md +++ b/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, diff --git a/basics/delegates.md b/basics/delegates.md index 1ae753a..248bec2 100644 --- a/basics/delegates.md +++ b/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 diff --git a/basics/exceptions.md b/basics/exceptions.md index c0dfd9a..0588c46 100644 --- a/basics/exceptions.md +++ b/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 diff --git a/basics/foreach.md b/basics/foreach.md index 64b0a35..0b85738 100644 --- a/basics/foreach.md +++ b/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 diff --git a/basics/imports-and-modules.md b/basics/imports-and-modules.md index 4e85797..3fceae1 100644 --- a/basics/imports-and-modules.md +++ b/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`. diff --git a/basics/memory.md b/basics/memory.md index 542d2a7..18b0b68 100644 --- a/basics/memory.md +++ b/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 diff --git a/basics/ranges.md b/basics/ranges.md index c6ee141..114a0fb 100644 --- a/basics/ranges.md +++ b/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; // [] diff --git a/basics/structs.md b/basics/structs.md index 3bc1ce9..a5c311d 100644 --- a/basics/structs.md +++ b/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 diff --git a/basics/type-qualifiers.md b/basics/type-qualifiers.md index 0e242b3..5c37c56 100644 --- a/basics/type-qualifiers.md +++ b/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` diff --git a/multithreading/message-passing.md b/multithreading/message-passing.md index 524bd16..726ca7e 100644 --- a/multithreading/message-passing.md +++ b/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); diff --git a/multithreading/std-parallelism.md b/multithreading/std-parallelism.md index c9932d0..6c72f77 100644 --- a/multithreading/std-parallelism.md +++ b/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.