diff --git a/basics/basic-types.md b/basics/basic-types.md
index 496a1ec..5c374e9 100644
--- a/basics/basic-types.md
+++ b/basics/basic-types.md
@@ -1,77 +1,76 @@
-# Basic types
+# Tipos básicos
-D provides a number of basic types which always have the same
-size **regardless** of the platform - the only exception
-is the `real` type which provides the highest possible floating point
-precision. There is no difference
-between the size of an integer regardless whether the application
-is compiled for 32-bit or 64-bit systems.
+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.
-
+| tipo | tamanho
+|---------|--------------------------------------------------
+|`float` | 32-bit
+|`double` | 64-bit
+|`real` | >= 64-bit (geralmente 64-bit, mas 80-bit em Intel x86 32-bit)
-The prefix `u` denotes *unsigned* types. `char` translates to
-UTF-8 characters, `wchar` is used in UTF-16 strings and `dchar`
-in UTF-32 strings.
+O prefixo `u` indica tipos *unsigned*. `char` se traduz em caracteres
+caracteres UTF-8, `wchar` é usado em strings UTF-16 e `dchar`
+em cadeias de caracteres UTF-32.
-A conversion between variables of different types is only
-allowed by the compiler if no precision is lost. A conversion
-between floating point types (e.g `double` to `float`)
-is allowed though.
+Uma conversão entre variáveis de tipos diferentes só é
+permitida pelo compilador se não houver perda de precisão. No entanto,
+uma conversão entre tipos de ponto flutuante
+(por exemplo, `double` para `float`) é permitida.
-A conversion to another type may be forced by using the
-`cast(TYPE) myVar` expression. It needs to be used with great care though,
-as the `cast` expression is allowed to break the type system.
+Uma conversão para outro tipo pode ser forçada com o uso da expressão
+`cast(TYPE) myVar`. No entanto, ela precisa ser usada com muito cuidado,
+pois a expressão `cast` pode quebrar o sistema de tipos.
-The special keyword `auto` creates a variable and infers its
-type from the right hand side of the expression. `auto myVar = 7`
-will deduce the type `int` for `myVar`. Note that the type is still
-set at compile-time and can't be changed - just like with any other
-variable with an explicitly given type.
+A palavra-chave especial `auto` cria uma variável e infere
+seu tipo a partir do lado direito da expressão. `auto myVar = 7`
+deduzirá o tipo `int` para `myVar`. Observe que o tipo ainda é
+definido em tempo de compilação e não pode ser alterado, como em qualquer outra
+variável com um tipo explicitamente fornecido.
-### Type properties
+### Propriedades de tipos
-All data types have a property `.init` to which they are initialized.
-For all integers this is `0` and for floating points it is `nan` (*not a number*).
+Todos os tipos de dados têm uma propriedade `.init` para a qual são inicializados.
+Para todos os números inteiros, essa propriedade é `0` e, para pontos flutuantes, é `nan` (*não é um número*).
-Integral and floating point types have a `.max` property for the highest value
-they can represent. Integral types also have a `.min` property for the lowest value
-they can represent, whereas floating point types have a `.min_normal` property
-which is defined to the smallest representable normalized value that's not 0.
+Os tipos de ponto flutuante e integral têm uma propriedade `.max` para o valor mais alto que podem representar.
+Os tipos integrais também têm uma propriedade `.min` para o valor mais baixo
+que podem representar, enquanto os tipos de ponto flutuante têm uma propriedade `.min_normal`
+que é definida como o menor valor normalizado representável que não é 0.
-Floating point types also have properties `.nan` (NaN-value), `.infinity`
-(infinity value), `.dig` (number of decimal digits of precisions), `.mant_dig`
-(number of bits in mantissa) and more.
+Os tipos de ponto flutuante também têm as propriedades `.nan` (valor NaN), `.infinity`
+(valor infinito), `.dig` (número de dígitos decimais das precisões), `.mant_dig`
+(número de bits na mantissa) e outras.
-Every type also has a `.stringof` property which yields its name as a string.
+Cada tipo também tem uma propriedade `.stringof` que produz seu nome como uma string.
-### Indexes in D
+### Índices em D
-In D, indexes usually have the alias type `size_t`, as it is a type that
-is large enough to represent an offset into all addressible memory - this is
-`uint` for 32-bit and `ulong` for 64-bit architectures.
+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.
-### Asserts
+### Expressão Assert
-`assert` is a compiler built-in which verifies conditions in debug mode and aborts
-with an `AssertionError` if it fails.
+O `assert` é uma expressão que verifica as condições no modo de depuração e aborta com um `AssertionError` se falhar.
+O `assert(0)` é, portanto, usado para marcar código inacessível.
-### In-depth
+### Maiores Detalhes
-#### Basic references
+#### Referências Básicas
- [Assignment](http://ddili.org/ders/d.en/assignment.html)
- [Variables](http://ddili.org/ders/d.en/variables.html)
@@ -79,43 +78,47 @@ with an `AssertionError` if it fails.
- [Floating Point](http://ddili.org/ders/d.en/floating_point.html)
- [Fundamental types in _Programming in D_](http://ddili.org/ders/d.en/types.html)
-#### Advanced references
+#### Referencias Avançadas
- [Overview of all basic data types in D](https://dlang.org/spec/type.html)
- [`auto` and `typeof` in _Programming in D_](http://ddili.org/ders/d.en/auto_and_typeof.html)
- [Type properties](https://dlang.org/spec/property.html)
+- [Assert expression](https://dlang.org/spec/expression.html#AssertExpression)
## {SourceCode}
```d
-import std.stdio;
+import std.stdio : writeln;
void main()
{
- // Big numbers can be separated
- // with an underscore "_"
- // to enhance readability.
+ // Números grandes podem ser separados
+ // utilizando sublinha "_"
+ // melhorando a legibilidade.
int b = 7_000_000;
- short c = cast(short) b; // cast needed
- uint d = b; // fine
+ // necessário cast
+ // para conversão explícita
+ short c = cast(short) b;
+ uint d = b; // conversão implícita
int g;
assert(g == 0);
- auto f = 3.1415f; // f denotes a float
+ // f denota-se ser do tipo float
+ auto f = 3.1415f;
- // typeid(VAR) returns the type information
- // of an expression.
+ // typeid(VAR) retorna a informação
+ // sobre o tipo da expressão.
writeln("type of f is ", typeid(f));
- double pi = f; // fine
- // for floating-point types
- // implicit down-casting is allowed
+ double pi = f; // conversão implícita
+ // para tipos de ponto flutuante
+ // permitindo a redução implícita
float demoted = pi;
- // access to type properties
+ // acessando as propriedades do tipo
assert(int.init == 0);
assert(int.sizeof == 4);
assert(bool.max == 1);
writeln(int.min, " ", int.max);
writeln(int.stringof); // int
}
-```
+```
\ No newline at end of file
diff --git a/basics/imports-and-modules.md b/basics/imports-and-modules.md
index c2cc185..4e85797 100644
--- a/basics/imports-and-modules.md
+++ b/basics/imports-and-modules.md
@@ -1,24 +1,56 @@
-# Imports and modules
+# Imports e modules
-For a simple hello world program in D, `import`s are needed.
-The `import` statement makes all public functions
-and types from the given **module** available.
+{{#img-right}}turtle.svg{{/img-right}}
-The standard library, called [Phobos](https://dlang.org/phobos/),
-is located under the **package** `std`
-and its modules are referenced through `import std.MODULE`.
+Uma das principais decisões de design do D foi ser consistente e evitar casos isolados
+na linguagem.
+Isto é conhecido como [_turtles all the way down_](https://en.wikipedia.org/wiki/Turtles_all_the_way_down). [tradução livre: _Tartarugas até lá embaixo._]
+Um bom exemplo dessa consistência são os `import`s.
-The `import` statement can also be used to selectively
-import certain symbols of a module:
+## Imports
- import std.stdio: writeln, writefln;
+Para um simples programa Olá Mundo em D, são necessários `import`s.
+A instrução `import` torna disponíveis todas as funções públicas
+e tipos públicos do **módulo** fornecido.
-Selective imports can be used to improve readability by making
-it obvious where a symbol comes from, and also as a way to
-prevent clashing of symbols with the same name from different modules.
+### As tartarugas começam a cair
-An `import` statement does not need to appear at the top of a source file.
-It can also be used locally within functions or any other scope.
+Uma instrução `import` não precisa aparecer na parte superior de um arquivo de código-fonte.
+Ela também pode ser usada localmente em funções ou em qualquer outro escopo.
+Nos próximos capítulos, você verá que isso se aplica a quase todos os conceitos em D. A linguagem não impõe restrições arbitrárias a você.
+
+### Imports seletivos
+
+A biblioteca pad~rao, chamado [Phobos](https://dlang.org/phobos/),
+está localizado no **pacote** `std`
+e seus módulos são referenciados por meio do `import std.MODULE`.
+
+A instrução `import` também pode ser usada para importar seletivamente
+determinados símbolos de um módulo:
+
+ import std.stdio : writeln, writefln;
+
+As importações seletivas podem ser usadas para melhorar a legibilidade, tornando
+óbvia a origem de um símbolo e também como uma forma de
+evitar o conflito de símbolos com o mesmo nome de módulos diferentes.
+
+### As importações correspondem a diretórios e arquivos
+
+O sistema de módulos do D, em contraste com outros sistemas, é totalmente baseado em arquivos.
+Por exemplo, `import my.cat` sempre se refere a um arquivo `cat.d` na pasta `my/`.
+A pasta `my` precisa estar no diretório de trabalho atual ou
+em uma das importações de diretório especificadas explicitamente (`-I`).
+Por fim, para facilitar a divisão de módulos grandes em vários arquivos menores,
+em vez de `cat.d`, uma pasta `cat/` também poderia ser usada.
+O compilador D tentaria então carregar `my/cat/package.d` em vez de `my/cat.d`.
+
+A convenção (mas não uma regra rígida) para arquivos `package.d` é importar publicamente
+todos os outros módulos na mesma pasta.
+
+### Maiores detalhes
+
+- [Modules and Libraries in _Programming in D_](http://ddili.org/ders/d.en/modules.html)
+- [Modules specification](https://dlang.org/spec/module.html)
## {SourceCode}
@@ -26,7 +58,7 @@ It can also be used locally within functions or any other scope.
void main()
{
import std.stdio;
- // or import std.stdio: writeln;
- writeln("Hello World!");
+ // ou import std.stdio : writeln;
+ writeln("Olá, Mundo!");
}
-```
+```
\ No newline at end of file