summaryrefslogtreecommitdiffhomepage
path: root/pt-br
diff options
context:
space:
mode:
Diffstat (limited to 'pt-br')
-rw-r--r--pt-br/d-pt.html.markdown262
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);
+ }
+}
+```