1 files changed, 262 insertions, 0 deletions
diff --git a/pt-br/d-pt.html.markdown b/pt-br/d-pt.html.markdown
new file mode 100644
index 00000000..ae4bab22
--- /dev/null
+++ b/pt-br/d-pt.html.markdown
@@ -0,0 +1,262 @@
+---
+language: D
+filename: learnd-pt.d
+contributors:
+    - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
+translators:
+    - ["Julio Vanzelli", "https://github.com/JulioVanzelli"]
+lang: pt-br
+---
+
+```d
+// Você sabe o que está por vir...
+module hello;
+
+import std.stdio;
+
+// args é opcional
+void main(string[] args) {
+    writeln("Hello, World!");
+}
+```
+
+Se você é como eu e passa muito tempo na Internet, é provável que tenha ouvido
+sobre [D] (http://dlang.org/). A linguagem de programação D é moderna, de uso geral,
+linguagem multiparadigma com suporte para tudo, desde recursos de baixo nível até
+abstrações expressivas de alto nível.
+
+D é desenvolvido ativamente por um grande grupo de pessoas super-inteligentes e é liderado por
+[Walter Bright] (https://en.wikipedia.org/wiki/Walter_Bright) e
+[Andrei Alexandrescu] (https://en.wikipedia.org/wiki/Andrei_Alexandrescu).
+Com tudo isso fora do caminho, vamos dar uma olhada em alguns exemplos!
+
+```d
+import std.stdio;
+
+void main() {
+
+    // Condicionais e loops funcionam como esperado.
+    for(int i = 0; i < 10000; i++) {
+        writeln(i);
+    }
+
+    // 'auto' pode ser usado para inferir tipos.
+    auto n = 1;
+
+    // literais numéricos podem usar '_' como um separador de dígitos para maior clareza.
+    while(n < 10_000) {
+        n += n;
+    }
+
+    do {
+        n -= (n / 2);
+    } while(n > 0);
+
+    // Por e enquanto são bons, mas em D-land preferimos loops 'foreach'.
+    // O '..' cria um intervalo contínuo, incluindo o primeiro valor
+    // mas excluindo o último.
+    foreach(n; 1..1_000_000) {
+        if(n % 2 == 0)
+            writeln(n);
+    }
+
+    // Há também 'foreach_reverse' quando você deseja fazer um loop para trás.
+    foreach_reverse(n; 1..int.max) {
+        if(n % 2 == 1) {
+            writeln(n);
+        } else {
+            writeln("No!");
+        }
+    }
+}
+```
+
+Podemos definir novos tipos com `struct`,` class`, `union` e` enum`. Estruturas e uniões
+são passados para funções por valor(ou seja, copiados) e as classes são passadas por referência. Além disso,
+podemos usar modelos para parametrizar tudo isso em tipos e valores!
+
+```d
+// Aqui, 'T' é um parâmetro de tipo. Pense '<T>' em C++/C#/Java.
+struct LinkedList(T) {
+    T data = null;
+
+    // Usar '!' para instanciar um tipo parametrizado. Mais uma vez, pense '<T>'.
+    LinkedList!(T)* next;
+}
+
+class BinTree(T) {
+    T data = null;
+
+    // Se houver apenas um parâmetro de modelo, podemos omitir os parênteses.
+    BinTree!T left;
+    BinTree!T right;
+}
+
+enum Day {
+    Sunday,
+    Monday,
+    Tuesday,
+    Wednesday,
+    Thursday,
+    Friday,
+    Saturday,
+}
+
+// Use o alias para criar abreviações para tipos.
+alias IntList = LinkedList!int;
+alias NumTree = BinTree!double;
+
+// Também podemos criar modelos de funções!
+T max(T)(T a, T b) {
+    if(a < b)
+        return b;
+
+    return a;
+}
+
+// Use a palavra-chave ref para garantir a passagem por referência. Ou seja, mesmo que 'a' 
+// e 'b' sejam tipos de valor, eles sempre serão passados por referência a 'swap ()'.
+void swap(T)(ref T a, ref T b) {
+    auto temp = a;
+
+    a = b;
+    b = temp;
+}
+
+// Com os modelos, também podemos parametrizar valores, não apenas tipos.
+class Matrix(uint m, uint n, T = int) {
+    T[m] rows;
+    T[n] columns;
+}
+
+auto mat = new Matrix!(3, 3); // O tipo 'T' foi padronizado como 'int'.
+
+```
+
+Falando em aulas, vamos falar sobre propriedades por um segundo. Uma propriedade
+é aproximadamente uma função que pode agir como um valor I, para que possamos
+ter a sintaxe das estruturas POD (`structure.x = 7`) com a semântica de
+métodos getter e setter (`object.setX (7)`)!
+
+```d
+// Considere uma classe parametrizada nos tipos 'T' e 'U'.
+class MyClass(T, U) {
+    T _data;
+    U _other;
+}
+
+// E os métodos "getter" e "setter", assim:
+class MyClass(T, U) {
+    T _data;
+    U _other;
+
+    // Os construtores sempre são chamados de 'this'.
+    this(T t, U u) {
+        // This will call the setter methods below.
+        data = t;
+        other = u;
+    }
+
+    // getters
+    @property T data() {
+        return _data;
+    }
+
+    @property U other() {
+        return _other;
+    }
+
+    // setters
+    @property void data(T t) {
+        _data = t;
+    }
+
+    @property void other(U u) {
+        _other = u;
+    }
+}
+
+// E nós os usamos desta maneira:
+void main() {
+    auto mc = new MyClass!(int, string)(7, "seven");
+
+    // Importe o módulo 'stdio' da biblioteca padrão para gravar no 
+    // console (as importações podem ser locais para um escopo).
+    import std.stdio;
+
+    // Ligue para os getters para buscar os valores.
+    writefln("Earlier: data = %d, str = %s", mc.data, mc.other);
+
+    // Ligue para os setters para atribuir novos valores.
+    mc.data = 8;
+    mc.other = "eight";
+
+    // Ligue para os getters novamente para buscar os novos valores.
+    writefln("Later: data = %d, str = %s", mc.data, mc.other);
+}
+```
+
+Com propriedades, podemos adicionar qualquer quantidade de lógica para
+nossos métodos getter e setter, e mantenha a sintaxe limpa de
+acessando membros diretamente!
+
+Outras guloseimas orientadas a objetos à nossa disposição,
+incluem interfaces, classes abstratas,
+e métodos de substituição. D faz herança como Java:
+Estenda uma classe, implemente quantas interfaces você desejar.
+
+Vimos as instalações OOP de D, mas vamos mudar de marcha. D oferece
+programação funcional com funções de primeira classe, `pura`
+funções e dados imutáveis. Além disso, todos os seus favoritos
+algoritmos funcionais (mapear, filtrar, reduzir e amigos) podem ser
+encontrado no maravilhoso módulo `std.algorithm`!
+
+```d
+import std.algorithm : map, filter, reduce;
+import std.range : iota; // cria uma gama exclusiva de final
+
+void main() {
+    // Queremos imprimir a soma de uma lista de quadrados de ints pares 
+    // de 1 a 100. Fácil!
+
+    // Basta passar expressões lambda como parâmetros de modelo!
+    // Você pode passar qualquer função que desejar, mas as lambdas são convenientes aqui.
+    auto num = iota(1, 101).filter!(x => x % 2 == 0)
+                           .map!(y => y ^^ 2)
+                           .reduce!((a, b) => a + b);
+
+    writeln(num);
+}
+```
+
+Observe como conseguimos construir um bom pipeline haskelliano para calcular num?
+Isso se deve a uma inovação em D, conhecida como Uniform Function Call Syntax (UFCS).
+Com o UFCS, podemos optar por escrever uma chamada de função como método
+ou chamada de função grátis! Walter escreveu um bom artigo sobre isso
+[aqui.] (http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394)
+Em resumo, você pode chamar funções cujo primeiro parâmetro
+é de algum tipo A em qualquer expressão do tipo A como método.
+
+Eu gosto de paralelismo. Alguém mais gosta de paralelismo? Com certeza. Vamos fazer um pouco!
+
+```d
+// Digamos que queremos preencher uma matriz grande com a raiz quadrada de todos 
+// os números inteiros consecutivos começando de 1 (até o tamanho da matriz), e queremos 
+// fazer isso simultaneamente, aproveitando o número de núcleos que temos 
+// disponível.
+
+import std.stdio;
+import std.parallelism : parallel;
+import std.math : sqrt;
+
+void main() {
+    // Crie sua grande variedade
+    auto arr = new double[1_000_000];
+
+    // Use um índice, acesse todos os elementos da matriz por referência (porque vamos 
+    // mudar cada elemento) e apenas chame paralelo na matriz!
+    foreach(i, ref elem; parallel(arr)) {
+        elem = sqrt(i + 1.0);
+    }
+}
+```