Merge pull request #10 from kassane/basic-pt

Basics section full translated

README.md

@@ -10,3 +10,18 @@ não hesite em abrir uma [issue](https://github.com/dlang-tour/brazilian-portugu
 
 Você também pode estar procurando pelo [repositório base](https://github.com/dlang-tour)
 que hospeda o conteúdo.
+
+Executar localmente
+-----------
+
+Você precisará buscar o [repositório base](https://github.com/dlang-tour/core) via DUB uma vez:
+
+```sh
+dub fetch dlang-tour
+```
+
+Agora você pode executar o `dlang-tour` no diretório principal desse repositório:
+
+```sh
+dub run dlang-tour -- --lang-dir .
+```

basics/alias-strings.md

@@ -1,44 +1,46 @@
 # Alias & Strings
 
-Now that we know what arrays are, have gotten in touch with `immutable`,
-and had a quick look at the basic types, it's time to introduce two
-new constructs in one line:
+Agora que sabemos o que são arrays, entramos em contato com `immutable`,
+e demos uma olhada rápida nos tipos básicos, é hora de introduzir duas
+novas construções em uma única linha:
 
     alias string = immutable(char)[];
 
-The term `string` is defined by an `alias` statement which defines it
-as a slice of `immutable(char)`s. This means, once a `string` has been constructed
-its content will never change again. And actually this is the second
-introduction: welcome UTF-8 `string`!
+O termo `string` é definido por uma instrução `alias` que o define
+como uma slice de `immutable(char)`s. Isso significa que, uma vez que uma `string`
+tenha sido construída seu conteúdo nunca mais será alterado. E, na verdade,
+esta é a segunda introdução: bem-vindo ao `string` UTF-8!
 
-Due to their immutablility, `string`s can be shared perfectly among
-different threads. As `string` is a slice, parts can be taken out of it without
-allocating memory. The standard function `std.algorithm.splitter`
-for example, splits a string by newline without any memory allocations.
+Devido à sua imutabilidade, as `string`s podem ser compartilhadas perfeitamente entre
+diferentes threads. Como a `string` é uma slice, partes podem ser retiradas dela sem
+alocar memória. A função padrão
+[`std.algorithm.splitter`](https://dlang.org/phobos/std_algorithm_iteration.html#.splitter)
+por exemplo, divide uma string por nova linha sem nenhuma alocação de memória.
 
-Besides the UTF-8 `string`, there are two more types:
+Além da `string` UTF-8, há mais dois tipos:
 
     alias wstring = immutable(wchar)[]; // UTF-16
     alias dstring = immutable(dchar)[]; // UTF-32
 
-The variants are most easily converted between each other using
-the `to` method from `std.conv`:
+As variantes são mais facilmente convertidas entre si usando
+o método `to` do `std.conv`:
 
     dstring myDstring = to!dstring(myString);
     string myString   = to!string(myDstring);
 
 ### Unicode strings
 
-This means that a plain `string` is defined as an array of 8-bit Unicode [code
-units](http://unicode.org/glossary/#code_unit). All array operations can be
-used on strings, but they will work on code unit level, and not character level. At
-the same time, standard library algorithms will interpret `string`s as sequences
-of [code points](http://unicode.org/glossary/#code_point), and there is also an
-option to treat them as sequence of
-[graphemes](http://unicode.org/glossary/#grapheme) by explicit usage of
+Isso significa que uma `string` simples é definida como um array Unicode de 8 bits.
+Todas as operações do array podem ser usadas em strings, mas elas funcionarão em
+um nível de [unidade de código](http://unicode.org/glossary/#code_unit),
+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
 [`std.uni.byGrapheme`](https://dlang.org/library/std/uni/by_grapheme.html).
 
-This small example illustrates the difference in interpretation:
+Este pequeno exemplo ilustra essa diferença de interpretação:
 
     string s = "\u0041\u0308"; // Ä
 
@@ -50,55 +52,65 @@ This small example illustrates the difference in interpretation:
     import std.uni : byGrapheme;
     writeln(s.byGrapheme.walkLength); // 1
 
-Here the actual array length of `s` is 3, because it contains 3 code units:
-`0x41`, `0x03` and `0x08`. Of those latter two define single code point
-(combining diacritics character) and
+Aqui, o tamanho atual do array `s` é 3, porque ele contém 3 unidades de código:
+`0x41`, `0x03` e `0x08`. Esses dois últimos definem um único ponto de código
+(combinando caracteres diacríticos) e
 [`walkLength`](https://dlang.org/library/std/range/primitives/walk_length.html)
-(standard library function to calculate arbitrary range length) counts two code
-points total. Finally, `byGrapheme` performs rather expensive calculations
-to recognize that these two code points combine into a single displayed
-character.
+(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.
 
-Correct processing of Unicode can be very complicated, but most of the time, D
-developers can simply consider `string` variables as magical byte arrays and
-rely on standard library algorithms to do the right job. Most Unicode
-functionality is provided by the
-[`std.uni`](https://dlang.org/library/std/uni.html) module, with some more basic
-primitives available in [`std.utf`](https://dlang.org/library/std/utf.html).
+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
+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).
 
-### Multi-line strings
+A decodificação automática em D é explicada em mais detalhes
+no capítulo [Unicode gems](gems/unicode).
 
-To create multi-line strings, use the `string str = q{ ... }` syntax.
+### Strings de múltiplas linhas
 
-    string multiline = q{ This
-        may be a
-        long document
-    };
+As strings em D sempre podem se estender por várias linhas:
 
-### Raw strings
+    string multiline = "
+    This
+    may be a
+    long document
+    ";
 
-It is also possible to use raw strings to minimize laborious escaping
-of reserved symbols. Raw strings can be declared using either backticks (`` `
-... ` ``) or the r(aw)-prefix (`r" ... "`).
+Quando as aspas aparecem no documento, as strings Wysiwyg (veja abaixo) ou
+[strings delimitadas](http://dlang.org/spec/lex.html#delimited_strings) podem ser usadas.
+
+### Strings Wysiwyg
+
+Também é possível usar strings brutas para minimizar o trabalho de escapar
+de símbolos reservados. As cadeias de caracteres brutas podem ser declaradas com
+o uso de backticks (`` `... ` ``) ou o prefixo r(aw) (`r" ... "`).
 
     string raw  =  `raw "string"`; // raw "string"
-    string raw2 = r"raw "string""; // raw "string"
+    string raw2 = r"raw `string`"; // raw `string`
+
+O D oferece ainda mais maneiras de representar strings - não hesite em
+em [explorar](https://dlang.org/spec/lex.html#string_literals) essas formas.
 
-### In-depth
+### Maiores detalhes
 
 - [Unicode gem](gems/unicode)
 - [Characters in _Programming in D_](http://ddili.org/ders/d.en/characters.html)
 - [Strings in _Programming in D_](http://ddili.org/ders/d.en/strings.html)
 - [std.utf](http://dlang.org/phobos/std_utf.html) - UTF en-/decoding algorithms
 - [std.uni](http://dlang.org/phobos/std_uni.html) - Unicode algorithms
+- [String Literals in the D spec](http://dlang.org/spec/lex.html#string_literals)
 
 ## {SourceCode}
 
 ```d
-import std.stdio;
-import std.range: walkLength;
+import std.stdio : writeln, writefln;
+import std.range : walkLength;
 import std.uni : byGrapheme;
-import std.string: format;
+import std.string : format;
 
 void main() {
     // format generates a string using a printf
@@ -118,13 +130,13 @@ void main() {
     // Strings are just normal arrays, so any
     // operation that works on arrays works here
     // too!
-    import std.array: replace;
+    import std.array : replace;
     writeln(replace(str, "lö", "lo"));
-    import std.algorithm: endsWith;
+    import std.algorithm : endsWith;
     writefln("Does %s end with 'rld'? %s",
         str, endsWith(str, "rld"));
 
-    import std.conv: to;
+    import std.conv : to;
     // Convert to UTF-32
     dstring dstr = to!dstring(str);
     // .. which of course looks the same!