From ae16d450781aecd9ff4423deb2cf67317d309080 Mon Sep 17 00:00:00 2001
From: omgee <omgee@programmer.net>
Date: Tue, 3 Jan 2017 09:41:35 +0200
Subject: [c++/en,es,it,br,ru,ch] Fix forgotten namespace std:: (#2619)

---
 pt-br/c++-pt.html.markdown | 52 +++++++++++++++++++++++-----------------------
 1 file changed, 26 insertions(+), 26 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown
index e2e95268..fd392b9e 100644
--- a/pt-br/c++-pt.html.markdown
+++ b/pt-br/c++-pt.html.markdown
@@ -19,9 +19,9 @@ foi concebida para
 - suportar programação genérica
 
 Embora sua sintaxe pode ser mais difícil ou complexa do que as linguagens mais
-recentes, C++ é amplamente utilizado porque compila para instruções nativas que 
-podem ser executadas diretamente pelo processador e oferece um controlo rígido sobre hardware (como C), enquanto oferece recursos de alto nível, como os 
-genéricos, exceções e classes. Esta combinação de velocidade e funcionalidade 
+recentes, C++ é amplamente utilizado porque compila para instruções nativas que
+podem ser executadas diretamente pelo processador e oferece um controlo rígido sobre hardware (como C), enquanto oferece recursos de alto nível, como os
+genéricos, exceções e classes. Esta combinação de velocidade e funcionalidade
 faz C++ uma das linguagens de programação mais utilizadas.
 
 ```c++
@@ -33,7 +33,7 @@ faz C++ uma das linguagens de programação mais utilizadas.
 // declarações de variáveis, tipos primitivos, e funções. No entanto, C++ varia
 // em algumas das seguintes maneiras:
 
-// A função main() em C++ deve retornar um int, embora void main() é aceita 
+// A função main() em C++ deve retornar um int, embora void main() é aceita
 // pela maioria dos compiladores (gcc, bumbum, etc.)
 // Este valor serve como o status de saída do programa.
 // Veja http://en.wikipedia.org/wiki/Exit_status para mais informações.
@@ -105,7 +105,7 @@ int main()
 // Parâmetros padrão de função
 /////////////////////////////
 
-// Você pode fornecer argumentos padrões para uma função se eles não são 
+// Você pode fornecer argumentos padrões para uma função se eles não são
 // fornecidos pelo chamador.
 
 void doSomethingWithInts(int a = 1, int b = 4)
@@ -157,7 +157,7 @@ void foo()
 
 int main()
 {
-    // Assuma que tudo é do namespace "Second" a menos que especificado de 
+    // Assuma que tudo é do namespace "Second" a menos que especificado de
     // outra forma.
     using namespace Second;
 
@@ -222,7 +222,7 @@ cout << myString; // "Hello Dog"
 
 // Além de indicadores como os de C, C++ têm _referências_. Esses são tipos de
 // ponteiro que não pode ser reatribuída uma vez definidos e não pode ser nulo.
-// Eles também têm a mesma sintaxe que a própria variável: Não * é necessário 
+// Eles também têm a mesma sintaxe que a própria variável: Não * é necessário
 // para _dereferencing_ e & (endereço de) não é usado para atribuição.
 
 using namespace std;
@@ -258,7 +258,7 @@ class Dog {
     std::string name;
     int weight;
 
-// Todos os membros a seguir este são públicos até que "private:" ou 
+// Todos os membros a seguir este são públicos até que "private:" ou
 // "protected:" é encontrado.
 public:
 
@@ -274,13 +274,13 @@ public:
 
     void setWeight(int dogsWeight);
 
-    // Funções que não modificam o estado do objecto devem ser marcadas como 
+    // Funções que não modificam o estado do objecto devem ser marcadas como
     // const. Isso permite que você chamá-los se for dada uma referência const
     // para o objeto. Além disso, observe as funções devem ser explicitamente
-    // declarados como _virtual_, a fim de ser substituídas em classes 
-    // derivadas. As funções não são virtuais por padrão por razões de 
+    // declarados como _virtual_, a fim de ser substituídas em classes
+    // derivadas. As funções não são virtuais por padrão por razões de
     // performance.
-    
+
     virtual void print() const;
 
     // As funções também podem ser definidas no interior do corpo da classe.
@@ -291,7 +291,7 @@ public:
     // Estes são chamados quando um objeto é excluído ou fica fora do escopo.
     // Isto permite paradigmas poderosos, como RAII
     // (veja abaixo)
-    // Destruidores devem ser virtual para permitir que as classes de ser 
+    // Destruidores devem ser virtual para permitir que as classes de ser
     // derivada desta.
     virtual ~Dog();
 
@@ -323,7 +323,7 @@ void Dog::print() const
 
 void Dog::~Dog()
 {
-    cout << "Goodbye " << name << "\n";
+    std::cout << "Goodbye " << name << "\n";
 }
 
 int main() {
@@ -343,8 +343,8 @@ class OwnedDog : public Dog {
 
     // Substituir o comportamento da função de impressão de todas OwnedDogs.
     // Ver http://en.wikipedia.org/wiki/Polymorphism_(computer_science)#Subtyping
-    // Para uma introdução mais geral, se você não estiver familiarizado com o 
-    // polimorfismo subtipo. A palavra-chave override é opcional, mas torna-se 
+    // Para uma introdução mais geral, se você não estiver familiarizado com o
+    // polimorfismo subtipo. A palavra-chave override é opcional, mas torna-se
     // na verdade você está substituindo o método em uma classe base.
     void print() const override;
 
@@ -371,8 +371,8 @@ void OwnedDog::print() const
 // Inicialização e Sobrecarga de Operadores
 //////////////////////////////////////////
 
-// Em C ++, você pode sobrecarregar o comportamento dos operadores, tais como 
-// +, -, *, /, etc. Isto é feito através da definição de uma função que é 
+// Em C ++, você pode sobrecarregar o comportamento dos operadores, tais como
+// +, -, *, /, etc. Isto é feito através da definição de uma função que é
 // chamado sempre que o operador é usado.
 
 #include <iostream>
@@ -438,7 +438,7 @@ int main () {
 // mas qualquer tipo pode ser jogado como uma exceção
 #include <exception>
 
-// Todas as exceções lançadas dentro do bloco try pode ser capturado por 
+// Todas as exceções lançadas dentro do bloco try pode ser capturado por
 // manipuladores de captura subseqüentes
 try {
     // Não aloca exceções no heap usando _new_.
@@ -460,7 +460,7 @@ catch (const std::exception& ex)
 ///////
 
 // RAII significa alocação de recursos é de inicialização.
-// Muitas vezes, é considerado o paradigma mais poderoso em C++, e é o 
+// Muitas vezes, é considerado o paradigma mais poderoso em C++, e é o
 // conceito simples que um construtor para um objeto adquire recursos daquele
 // objeto e o destruidor liberá-los.
 
@@ -479,11 +479,11 @@ void doSomethingWithAFile(const char* filename)
 }
 
 // Infelizmente, as coisas são levemente complicadas para tratamento de erros.
-// Suponha que fopen pode falhar, e que doSomethingWithTheFile e 
-// doSomethingElseWithIt retornam códigos de erro se eles falharem. (As 
-// exceções são a forma preferida de lidar com o fracasso, mas alguns 
-// programadores, especialmente aqueles com um conhecimento em C, discordam 
-// sobre a utilidade de exceções). Agora temos que verificar cada chamada para 
+// Suponha que fopen pode falhar, e que doSomethingWithTheFile e
+// doSomethingElseWithIt retornam códigos de erro se eles falharem. (As
+// exceções são a forma preferida de lidar com o fracasso, mas alguns
+// programadores, especialmente aqueles com um conhecimento em C, discordam
+// sobre a utilidade de exceções). Agora temos que verificar cada chamada para
 // o fracasso e fechar o identificador de arquivo se ocorreu um problema.
 
 bool doSomethingWithAFile(const char* filename)
@@ -609,7 +609,7 @@ h=sum<double>(f,g);
 ```
 Leitura Adicional:
 
-Uma referência atualizada da linguagem pode ser encontrada em 
+Uma referência atualizada da linguagem pode ser encontrada em
 <http://cppreference.com/w/cpp>
 
 Uma fonte adicional pode ser encontrada em <http://cplusplus.com>
-- 
cgit v1.2.3


From 99bd27111258428f247d185e11919a5d0299a161 Mon Sep 17 00:00:00 2001
From: Francieli Viane <francielifrv@gmail.com>
Date: Thu, 26 Jan 2017 11:57:30 -0200
Subject: [PT-BR/Scala] Translates Scala file to Brazilian Portuguese  (#2634)

* Translates Scala to brazillian portuguese

* Add lang information to file header

* [Scala/Pt-Br] adds contributor to translation header
---
 pt-br/scala-pt.html.markdown | 668 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 668 insertions(+)
 create mode 100644 pt-br/scala-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/scala-pt.html.markdown b/pt-br/scala-pt.html.markdown
new file mode 100644
index 00000000..3459f567
--- /dev/null
+++ b/pt-br/scala-pt.html.markdown
@@ -0,0 +1,668 @@
+---
+language: Scala
+filename: learnscala-pt.scala
+contributors:
+    - ["George Petrov", "http://github.com/petrovg"]
+    - ["Dominic Bou-Samra", "http://dbousamra.github.com"]
+    - ["Geoff Liu", "http://geoffliu.me"]
+    - ["Ha-Duong Nguyen", "http://reference-error.org"]
+translators:
+    - ["Francieli Viane", "https://github.com/FFrancieli"]
+lang: pt-br
+---
+
+Scala - a linguagem escalável
+
+```scala
+
+/////////////////////////////////////////////////
+// 0. O básico
+/////////////////////////////////////////////////
+/*
+  Configurando o Scala:
+
+  1) Baixe o instalador do Scala - http://www.scala-lang.org/downloads
+  2) Extraia (unzip ou tar) para sua localização favorita e coloque o subdiretório
+  bin na variável de ambiente `PATH`
+*/
+
+/*
+  Tente o REPL
+
+  Scala tem uma ferramenta chamada REPL (Read-Eval-Print Loop) que é análogo a
+  interpretadores de linha de comando de outras linguagens. Você pode digitar
+  qualquer expressão de Scala e o resultado será calculado e impresso.
+
+  O REPL é uma ferramenta muito conveniente para testar e verificar código. Use-o
+  enquanto você lê o tutorial para explorar os conceitos rapidamente por conta própria.
+*/
+
+//Inicialize um REPL de Scala executando o comando scala no terminal. Você deve ver o prompt:
+$ scala
+scala>
+
+//Por padrão, cada expressão que você executa é salva como um novo valor enumerado:
+scala> 2 + 2
+res0: Int = 4
+
+// Valores padrões podem ser reutilizados. Observe o tipo do valor exibido no resultado...
+scala> res0 + 2
+res1: Int = 6
+
+// Scala é uma linguagem fortemente tipada. Você pode usar o REPL para verfificar o tipo
+// sem avaliar uma expressão.
+
+scala> :type (true, 2.0)
+(Boolean, Double)
+
+// As sessões do REPL podem ser salvas
+scala> :save /sites/repl-test.scala
+
+//Arquivos podem ser carregados no REPL
+scala> :load /sites/repl-test.scala
+Loading /sites/repl-test.scala...
+res2: Int = 4
+res3: Int = 6
+
+// Você pode pesquisar em seu histórico recente
+scala> :h?
+1 2 + 2
+2 res0 + 2
+3 :save /sites/repl-test.scala
+4 :load /sites/repl-test.scala
+5 :h?
+
+// Agora que você já sabe brincar, vamos aprender um pouco de Scala...
+
+/////////////////////////////////////////////////
+// 1. Introdução
+/////////////////////////////////////////////////
+
+// Comentários de uma linha começam com duas barras
+
+/*
+  Comentários com múltiplas linhas, como você já pode ver, são assim.
+*/
+
+// Imprimir e forçar uma linha na próxima impressão
+println("Hello world!")
+println(10)
+// Hello world!
+// 10
+
+//Imprimir sem forçar uma nova linha na próxima impressão
+print("Hello world")
+print(10)
+// Hello world10
+
+//A declaração de valores pode ser feita usando tanto o var quanto o val.
+// Declarações feitas com `val` são imutáveis, enquanto que declarações feitas
+// com var são mutáveis. Imutabilidade é uma coisa boa.
+val x = 10 // x is now 10
+x = 20     // error: reassignment to val
+var y = 10
+ = 20     // y agora é 20
+
+/*
+  Scala é uma linguagem estaticamente tipada. Observe ainda que nas declarações
+  acima nós não especificamos um tipo. Isso se deve a um recurso da linguagem
+  chamado de inferência. Na maioria dos casos, o compilador do Scala consegue
+  adivinhar qual tipo é, de forma que você não precisa digitar sempre. Nós
+  podemos declarar o tipo da variável de maneira explícita asim:
+*/
+
+val z: Int = 10
+val a: Double = 1.0
+
+// Note que a conversão automática de Int para Double, o resultado é 10.0, não 10
+val b: Double = 10
+
+//Valores booleanos
+true
+false
+
+//Operações booleanas
+!true         // false
+!false        // true
+true == false // false
+10 > 5        // true
+
+// Matemática é como o de costume
+1 + 1   // 2
+2 - 1   // 1
+5 * 3   // 15
+6 / 2   // 3
+6 / 4   // 1
+6.0 / 4 // 1.5
+6 / 4.0 // 1.5
+
+// Calcular uma expressão no REPL te dá o tipo e o valor do resultado
+1 + 7
+
+/* A linha acima resulta em:
+  scala> 1 + 7
+  res29: Int = 8
+
+  Isso significa que o resultado ao culcular  1 + 7 é um objeto do tipo Int com
+  valor 8.
+
+  Note que "res29" é o nome de uma variável gerada sequencialmente para guardar
+  os resultados das expressões que você executa, logo seu nome pode ser
+  diferente.
+*/
+
+"Strings em Scala são delimitadas por aspas duplas"
+'a' // Um caractere em Scala
+// 'Strings com aspas simples não existem em Scala.' <= isso causa um erro.
+
+// Strings possuem os métodos comuns de Java definidos
+"hello world".length
+"hello world".substring(2, 6)
+"hello world".replace("C", "3")
+
+// Elas também possuem alguns métodos extras do Scala. Veja também:
+scala.collection.immutable.StringOps
+"hello world".take(5)
+"hello world".drop(5)
+
+//Interpolação de string: observe o prefixo "s"
+val n = 45
+s"We have $n apples" // => "We have 45 apples"
+
+// Também é possível ter expressões dentro de interpolação de strings
+val a = Array(11, 9, 6)
+s"My second daughter is ${a(0) - a(2)} years old."    // => "My second daughter is 5 years old."
+s"We have double the amount of ${n / 2.0} in apples." // => "We have double the amount of 22.5 in apples."
+s"Power of 2: ${math.pow(2, 2)}"                      // => "Power of 2: 4"
+
+// Formatação de strings interpoladas com o prefixo "f"
+f"Power of 5: ${math.pow(5, 2)}%1.0f"         // "Power of 5: 25"
+f"Square root of 122: ${math.sqrt(122)}%1.4f" // "Square root of 122: 11.0454"
+
+
+// Strings cruas, ignorando caracteres especiais
+raw"New line feed: \n. Carriage return: \r." // => "New line feed: \n. Carriage return: \r."
+
+//Alguns caracteres precisam ser "escapados", ex. uma aspa dupla dentro de uma string
+
+"They stood outside the \"Rose and Crown\"" // => "They stood outside the "Rose and Crown""
+
+// Aspas triplas permitem strings a abrangerem múltiplas linhas e conter Aspas
+val html = """<form id="daform">
+                <p>Press belo', Joe</p>
+                <input type="submit">
+              </form>"""
+
+
+/////////////////////////////////////////////////
+// 2. Funções
+/////////////////////////////////////////////////
+
+// Funções são definidas da seguinte maneira:
+//
+//   def nomeDaFuncao(args ...): TipoDeRetorno = {body ...}
+//
+// Se você vem de linguagens mais tradicionais, note a omissão da palavra chave
+//return. Em Scala a última expressão no bloco da função é o valor de retorno
+def sumOfSquares(x: Int, y: Int): Int = {
+  val x2 = x * x
+  val y2 = y * y
+  x2 + y2
+}
+
+// As { } podem ser omitidas se o corpo da função possui apenas uma expressão:
+def sumOfSquaresShort(x: Int, y: Int): Int = x * x + y * y
+
+// A sintaxe para chamar funções é familiar:
+sumOfSquares(3, 4)  // => 25
+
+// Você poode usar o nome dos parâmetros para especificá-los numa ordem diferente
+def subtract(x: Int, y: Int): Int = x - y
+
+subtract(10, 3)     // => 7
+subtract(y=10, x=3) // => -7
+
+// Na maioria dos casos (sendo funções recursivas a a exceção mais notável) o
+// tipo de retorno da função pode ser omitido, e o mesmo tipo de inferência que
+// vimos nas variáveis funcionará com o valor de retorno da função:
+def sq(x: Int) = x * x  // O compilador consegue adivinhar que o tipo de retorno é Int
+
+// Funções podem ter parâmetros padrão:
+def addWithDefault(x: Int, y: Int = 5) = x + y
+addWithDefault(1, 2) // => 3
+addWithDefault(1)    // => 6
+
+// Funções anônimas são semelhantes a essa:
+(x: Int) => x * x
+
+// Diferente de defs, até mesmo a entrada de funções anônimas podem ser omitidas
+// se o contexto deixar isso claro. Observe o tipo "Int => Int", que significa
+// uma função que recebe umn Int e retorna um Int.
+val sq: Int => Int = x => x * x
+
+// Se cada argumento na sua função anônima é usado apenas uma vez, Scala te fornece
+// uma maneira ainda mais curta de definí-lo. Estas funções anônimas acabam por
+// ser muito comuns, como será mostrado na sessão de estrutura de dados.
+val addOne: Int => Int = _ + 1
+val weirdSum: (Int, Int) => Int = (_ * 2 + _ * 3)
+
+addOne(5)      // => 6
+weirdSum(2, 4) // => 16
+
+// A palavra chave return existe em Scala, mas só retorna do def mais profundo que o cerca.
+//AVISO: O uso do return em Scala é propenso a erros e deve ser evitado.
+//Não há efeito em funções anônimas. Per exemplo:
+def foo(x: Int): Int = {
+  val anonFunc: Int => Int = { z =>
+    if (z > 5)
+      return z // Esta linha faz Z retornar o valor de foo!
+    else
+      z + 2    // Esta linha retorna o valor de anonFunc
+  }
+  anonFunc(x) // Esta linha retorna o valor de foo
+}
+
+/////////////////////////////////////////////////
+// 3. Controle de Fluxo
+/////////////////////////////////////////////////
+
+1 to 5
+val r = 1 to 5
+r.foreach(println)
+
+r foreach println
+///N.B.: Scala é bem flexível quando se fala de pontos e parêntesis - estude as regras
+//separadamente. Isso ajuda a escrever DSLs e APIs que são lidas como inglês.
+
+(5 to 1 by -1) foreach (println)
+
+// Um loop while
+var i = 0
+while (i < 10) { println("i " + i); i += 1 }
+
+while (i < 10) { println("i " + i); i += 1 }   // Sim, de novo. O que aconteceu? Por quê?
+
+i    // Exibe o valor de i. Note que o while é um loop no senso clássico -
+     // executa sequencialmente enquanto muda a variável do loop. While é muito
+     // rápido, mas usar os combinadores e compreenões acima é mais fácil
+     // para entender e paralizar
+
+// Um loop do-while
+i = 0
+do {
+  println("i ainda é menor que 10")
+  i += 1
+} while (i < 10)
+
+
+// Recursão é a forma mais idiomática de repetir uma ação em Scala (assim como na
+// maioria das linguagens de programação funcional)
+// Funções recursivas precisam de um tipo de retorno explícito, o compilador não
+// consegue inferir;
+// Aqui está o Unit
+def showNumbersInRange(a: Int, b: Int): Unit = {
+  print(a)
+  if (a < b)
+    showNumbersInRange(a + 1, b)
+}
+showNumbersInRange(1, 14)
+
+// Condicionais
+
+al x = 10
+
+if (x == 1) println("yeah")
+if (x == 10) println("yeah")
+if (x == 11) println("yeah")
+if (x == 11) println("yeah") else println("nay")
+
+println(if (x == 10) "yeah" else "nope")
+val text = if (x == 10) "yeah" else "nope"
+
+/////////////////////////////////////////////////
+// 4. Estrutura de Dados
+/////////////////////////////////////////////////
+
+val a = Array(1, 2, 3, 5, 8, 13)
+a(0)     // Int = 1
+a(3)     // Int = 5
+a(21)    // Lança uma exceção
+
+val safeM = m.withDefaultValue("no lo se")
+safeM("bottle")   // java.lang.String = no lo se
+
+val s = Set(1, 3, 7)
+s(0)      // Boolean = false
+s(1)      // Boolean = true
+
+/* Veja a documantação do map aqui -
+ * http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.Map
+ * e garanta que você leia
+ */
+
+ // Tuplas
+
+ (1, 2)
+
+ (4, 3, 2)
+
+ (1, 2, "three")
+
+ (a, 2, "three")
+
+ //Por que ter isso?
+ val divideInts = (x: Int, y: Int) => (x / y, x % y)
+
+//A função divideInts te dá o resultado e o resultado
+divideInts(10, 3)    // (Int, Int) = (3,1)
+
+//Para acessar os elementos de uma tupla, use _._n onde n é o índex do elemento
+
+val d = divideInts(10, 3)    // (Int, Int) = (3,1)
+
+d._1    // Int = 3
+d._2    // Int = 1
+
+// Alternativamente, você pode atribuir múltiplas variáveis para uma tupla, o
+// que é mais conveniente e legível em muitos casos
+val (div, mod) = divideInts(10, 3)
+
+div     // Int = 3
+mod     // Int = 1
+
+/////////////////////////////////////////////////
+// 5. Object Oriented Programming
+/////////////////////////////////////////////////
+
+/*
+    Tudo o que vimos até agora neste tutorial foram expressões simples (valores, funções, etc).
+    Essas expressões são boas para digitar no interpretador da linha de comando para
+    testes rápidos, mas elas não podem existir por si só em um arquivo Scala. Por exemplo,
+    você não pode ter simplesmente "val x = 5" em um arquivo Scala. Ao invés disso, os únicos
+    construtores de alto nível permitidos em Scala são:
+
+    - objects
+    - classes
+    - case classes
+    - traits
+
+    E agora vamos explicar o que é cada um deles.
+*/
+
+//classes são similares a classes em outras linguagens. Os argumentos do construtor
+// são declarados logo depois do nome da classe e a inicialização é feita no corpo da classe.
+
+class Dog(br: String) {
+  // codigo do construtor aqui
+  var breed: String = br
+
+  // Define um método chamado bark que retorna uma String
+  def bark = "Woof, woof!"
+
+  // Assume-se que os métodos e valores são públicos. As palavras chave "protected"
+  // e "private" também estão disponíveis.
+  private def sleep(hours: Int) =
+    println(s"I'm sleeping for $hours hours")
+
+  // Métodos abstratos são simplesmente métodos sem corpo. Se a gente remover o
+  // comentário da próxima linha a classe Dog teria que ser declarada como abstrata
+
+  //   abstract class Dog(...) { ... }
+  // def chaseAfter(what: String): String
+}
+
+// A palavra chave "object" cria um tipo e uma instância singlenton desse tipo.
+// É comum para classes em Scala ter um "companion object" (objeto companheiro),
+// onde, por exemlo, o comportamento é capturado pelas classes em si, mas o comportamento
+// relacionado a toda instância da classe vai em objects. A diferença é semelhante
+// a métodos versus métodos estáticos em outras linguagens. Note que objects e
+// classes podem ter o mesmo nome.
+
+object Dog {
+  def allKnownBreeds = List("pitbull", "shepherd", "retriever")
+  def createDog(breed: String) = new Dog(breed)
+}
+
+// Case classes são classes que possuem uma funcionalidade extra incorporada.
+// Uma dúvida comum para iniciantes em Scala é quando usar classes e quando usar
+// case classes. A linha é bem tênue, mas em geral classes tendem a focar em encapsulamento,
+// polimorfismo e comportamento. Os valores nestas classes tendem a ser privados e
+// apenas métodos ficam expostos. O propósito primário de uma case class é guardar
+// dados imutáveis. Às vezes as case classes possuem alguns poucos métodos, os quais
+// raramente possuem efeitos colaterais (side effects).
+case class Person(name: String, phoneNumber: String)
+
+// Cria uma nova instância. Observe que case classes não precisam de usar "new" ao serem instanciadas
+val george = Person("George", "1234")
+val kate = Person("Kate", "4567")
+
+// Com case classes você ganha algumas regalias, como getters:
+// With case classes, you get a few perks for free, like getters:
+george.phoneNumber  // => "1234"
+
+// Verificação de igualdade por campo (sem a necessidade de sobrescrever o método equals)
+Person("George", "1234") == Person("Kate", "1236")  // => false
+
+// Uma maneira fácil de copiar
+// otherGeorge == Person("george", "9876")
+val otherGeorge = george.copy(phoneNumber = "9876")
+
+// E muitas outras. Case classes também possuem pattern matching de graça. Veja no próximo tópico.
+
+// Traits a caminho.
+
+
+/////////////////////////////////////////////////
+// 6. Pattern Matching
+/////////////////////////////////////////////////
+
+// Pattern matching é um recurso muito poderoso e muito usado em Scala. Aqui
+// mostramos como o seu pattern se adequa a uma case class.
+// NB: Diferente de outras linguagens, Scala não precisa de quebras. Entrar em
+// todas as condições do pattern matching simples não acontece.
+
+def matchPerson(person: Person): String = person match {
+  // Enrão você especifica os padrões
+  case Person("George", number) => "We found George! His number is " + number
+  case Person("Kate", number)   => "We found Kate! Her number is " + number
+  case Person(name, number)     => "We matched someone : " + name + ", phone : " + number
+}
+
+val email = "(.*)@(.*)".r  // Define uma regex para o próximo exemplo.
+
+// Pattern matching pode parecer com o comando switch nas liguagens da família C,
+// mas é muito mais poderoso. Em Scala você pode encontrar mais correpondências:
+
+def matchEverything(obj: Any): String = obj match {
+  // Você pode encontrar valores correspondentes:
+  case "Hello world" => "Got the string Hello world"
+
+  // Você pode fazer correspondência por tipo:
+  case x: Double => "Got a Double: " + x
+
+  // Você pode especificar condições:
+  case x: Int if x > 10000 => "Got a pretty big number!"
+
+  // Você pode encontrar correspondência com case classes, como fizemos antes:
+  case Person(name, number) => s"Got contact info for $name!"
+
+  // Você pode encontrar correspondências por regex:
+  case email(name, domain) => s"Got email address $name@$domain"
+
+  // Você pode encontrar correspondencias por tuplas:
+  case (a: Int, b: Double, c: String) => s"Got a tuple: $a, $b, $c"
+
+  // Você pode encontrar corresponências por estruturas de dados:
+  case List(1, b, c) => s"Got a list with three elements and starts with 1: 1, $b, $c"
+
+  // Você pode aninhar padrões:
+  case List(List((1, 2, "YAY"))) => "Got a list of list of tuple"
+
+  // Retornar qualquer valor (padrão - default) caso nenhuma das possibilidades é correspondente.
+  case _ => "Got unknown object"
+
+  // Na verdade, você pode fazer correspondência de padrão de qualquer objeto que
+  // tenha o método "unnaply". Este recurso é tão poderoso que o Scala te deixa
+  // criar funções inteiras como patterns:
+
+  val patternFunc: Person => String = {
+    case Person("George", number) => s"George's number: $number"
+    case Person(name, number) => s"Random person's number: $number"
+  }
+}
+
+/////////////////////////////////////////////////
+// 7. Programação Funcional
+/////////////////////////////////////////////////
+
+// Scala permite que métodos e funções recebam ou retornem outras funções ou métodos.
+
+val add10: Int => Int = _ + 10 // A function taking an Int and returning an Int
+List(1, 2, 3) map add10 // List(11, 12, 13) - add10 is applied to each element
+
+// Funções anônimas podem ser usadas ao invés de funções com nomes:
+List(1, 2, 3) map (x => x + 10)
+
+// E o símbolo underline ("_") pode ser usado quando há apenas um argumento para a função anônima.
+List(1, 2, 3) map (_ + 10)
+
+// Se tanto o bloco animo quanto a função que você estiver usando receberem apenas
+// um argumento, você pode inclusive omitir o símbolo _
+List(1, 2, 3) map (_ + 10)
+
+// Combinadores
+
+s.map(sq)
+
+val sSquared = s. map(sq)
+
+sSquared.filter(_ < 10)
+
+sSquared.reduce (_+_)
+
+// A função filter recebe um predicado (uma função do tipo A -> Boolean) e seleciona
+// todos os elementos que satisfazem o predicado.
+List(1, 2, 3) filter (_ > 2) // List(3)
+case class Person(name: String, age: Int)
+List(
+  Person(name = "Dom", age = 23),
+  Person(name = "Bob", age = 30)
+).filter(_.age > 25) // List(Person("Bob", 30))
+
+// Scala tem o método foreach definido em algumas collections em específico, o qual
+// recebe um tipo e retorna Unit (um método void)
+val aListOfNumbers = List(1, 2, 3, 4, 10, 20, 100)
+aListOfNumbers foreach (x => println(x))
+aListOfNumbers foreach println
+
+/* NB Ests não são laços for. A semântica dos laços for é 'repetir' enquanto um
+  for-comprehension define um relacionamento entre dois conjuntos de dados */
+
+
+/////////////////////////////////////////////////
+// 8. Implicits
+/////////////////////////////////////////////////
+
+/* ALERTA ALERTA:
+  Implicits são um conjunto de recursos poderosos de Scala e consequentemente é
+  fácil abusar deles. Iniciantes em Scala deveriam resistir a tentação de usá-los
+  até que eles entendam não apenas como eles funcionam mas também as melhores práticas
+  deles. Incluimos uma sessão neste tutorial sobre isso porque implicits são tão
+  corriqueiros em bibliotecas do Scala que é impossível fazer qualqeuer coisa expressiva
+  sem utilizar uma biblioteca que usa implicits. Isto é para você entender e trabalhar
+  com implicits. Não declare seus próprios implicits por conta própria.
+*/
+
+// qualquer valor (val, function, objects, etc) pode ser declarado para ser implícito
+// usando a, você adivinhou, palavra chave "implicit". Usaremos a classe Dog definida
+// na sessão 5 para os próximos exemplos.
+implicit val myImplicitInt = 100
+implicit def myImplicitFunction(breed: String) = new Dog("Golden " + breed)
+
+// A palavra chave implicit não muda o comportamento do valor por si só, então
+// os valores acima podem ser usados como de costume.
+myImplicitInt + 2                   // => 102
+myImplicitFunction("Pitbull").breed // => "Golden Pitbull"
+
+A diferença é que agora esses valores são elegíveis para serem usados quando outra
+// parte do código "precisa" de um valor implícito. Uma situação é uma função
+// com argumentos implícitos:
+def sendGreetings(toWhom: String)(implicit howMany: Int) =
+  s"Hello $toWhom, $howMany blessings to you and yours!"
+
+// Se fornecermos um valor para "howMany" a função se comporta como sempre
+sendGreetings("John")(1000)  // => "Hello John, 1000 blessings to you and yours!"
+
+// Mas se omitirmos o parâmetro implícito um valor implícito de mesmo tipo é usado,
+// neste caso, "myImplicitInt":
+sendGreetings("Jane")  // => "Hello Jane, 100 blessings to you and yours!"
+
+// Parâmetros implícitos de funções nos permitem simular type classes em outras
+//linguagens funcionais. As linhas abaixo são a mesma coisa:
+// def foo[T](implicit c: C[T]) = ...
+// def foo[T : C] = ...
+
+// Outro caso no qual o compilador procura por um implicit é quando você tem obj.method(...)
+// mas "obj" não possui "method" como um método. Neste caso, se houver uma conversão
+// de implicit do tipo A => B, onde A é o tipo do "obj" e B tem um método chamado
+// "method", a conversão é aplicada. Então, tendo myImplicitFunction acima em escopo, podemos dizer:
+"Retriever".breed // => "Golden Retriever"
+"Sheperd".bark    // => "Woof, woof!"
+
+// Aqui, a String é convertida para Dog usando nossa função acima, então o método
+// apropriado é chamado. Isso é um recurso extremamente poderoso, mas de novo, não
+// é para ser usado de maneira leviana. Na verdade, quando você define a função
+// implícita, o seu compilador deve exibir um aviso de que você não deveria fazer isso,
+// a menos que você realmente saiba o que você está fazendo.
+
+/////////////////////////////////////////////////
+// 9. Misc
+/////////////////////////////////////////////////
+
+// Importando coisas
+import scala.collection.immutable.List
+
+// Importando todos os sub pacotes
+import scala.collection.immutable._
+
+// Importando várias classes em um único comando
+import scala.collection.immutable.{List, Map}
+
+// Renomeando um import usando '=>'
+import scala.collection.immutable.{List => ImmutableList}
+
+// Importa todas as classes, com exceção de algumas. O import abaixo importa todas as classes excluindo Map e Set:
+import scala.collection.immutable.{Map => _, Set => _, _}
+
+// Classes Java também podem ser importadas. A syntaxe de Scala pode ser usada:
+import java.swing.{JFrame, JWindow}
+
+// O ponto de entrada do seu programa é definido em um arquivo Scala usando um object com um único método main:
+object Application {
+  def main(args: Array[String]): Unit = {
+    // o código fica aqui
+  }
+}
+
+// Arquivos podem ter múltiplas classes e objects. Compile com scalac
+
+// Entrada e saída
+
+// Para ler um arquivo linha a linha
+import scala.io.Source
+for(line <- Source.fromFile("myfile.txt").getLines())
+  println(line)
+
+// Para escrever um arquivo use o PrintWriter do Javaval writer = new PrintWriter("myfile.txt")
+writer.write("Writing line for line" + util.Properties.lineSeparator)
+writer.write("Another line here" + util.Properties.lineSeparator)
+writer.close()
+
+##  Recursos adicionais
+
+* [Scala for the impatient](http://horstmann.com/scala/)
+* [Twitter Scala school](http://twitter.github.io/scala_school/)
+* [Documentação de Scala](http://docs.scala-lang.org/)
+* [Tente Scala no seu navegador](http://scalatutorials.com/tour/)
+* Junte [Scala user group](https://groups.google.com/forum/#!forum/scala-user)
+```
-- 
cgit v1.2.3


From 2370ece88c454bc6456ba0c98ed79b189662950f Mon Sep 17 00:00:00 2001
From: Yuri Alessandro Martins <yuri.alessandro@hotmail.com>
Date: Thu, 9 Feb 2017 12:22:42 -0300
Subject: Some translation fixes. (#2421)

Improving the consistency of a few sentences.
---
 pt-br/java-pt.html.markdown | 27 ++++++++++++++++-----------
 1 file changed, 16 insertions(+), 11 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/java-pt.html.markdown b/pt-br/java-pt.html.markdown
index db087a5f..d2e07225 100644
--- a/pt-br/java-pt.html.markdown
+++ b/pt-br/java-pt.html.markdown
@@ -7,6 +7,7 @@ contributors:
 translators:
     - ["Victor Kléber Santos L. Melo", "http://victormelo.com.br/blog"]
     - ["Renê Douglas N. de Morais", "mailto:rene.douglas.bsi@gmail.com"]
+    - ["Yuri Alessandro D. T. Martins", "https://github.com/YuriAlessandro"]
 lang: pt-br
 filename: LearnJava-pt.java
 
@@ -407,7 +408,7 @@ class Velocipede extends Bicicleta {
 
 // Interfaces
 // Sintaxe de declaração de Interface
-// <nível de acesso> Interface <nome-da-interface> extends <super-interfaces> {
+// <nível de acesso> interface <nome-da-interface> extends <super-interfaces> {
 // // Constantes
 // // Declarações de método
 //}
@@ -415,11 +416,15 @@ class Velocipede extends Bicicleta {
 // Exemplo - Comida:
 public interface Comestivel {
     public void comer(); // Qualquer classe que implementa essa interface, deve
-                        // Implementar este método.
+                         // implementar este método.
 }
 
 public interface Digestivel {
     public void digerir();
+    // Em Java 8, interfaces podem ter métodos default.
+    // public void digerir() {
+    //     System.out.println("digerindo ...");
+    // }
 }
 
 
@@ -438,7 +443,7 @@ public class Fruta implements Comestivel, Digestivel {
 }
 
 // Em Java, você pode estender somente uma classe, mas você pode implementar muitas
-// Interfaces. Por exemplo:
+// interfaces. Por exemplo:
 public class ClasseExemplo extends ExemploClassePai implements InterfaceUm,
     InterfaceDois {
 
@@ -461,8 +466,8 @@ public class ClasseExemplo extends ExemploClassePai implements InterfaceUm,
 //}
 
 // Marcar uma classe como abstrata significa que ela contém métodos abstratos que devem
-// ser definido em uma classe filha. Semelhante às interfaces, classes abstratas não podem
-// ser instanciadas, ao invés disso devem ser extendidas e os métodos abstratos
+// ser definidos em uma classe filha. Semelhante às interfaces, classes abstratas não podem
+// ser instanciadas, ao invés disso devem ser estendidas e os métodos abstratos
 // definidos. Diferente de interfaces, classes abstratas podem conter uma mistura de
 // métodos concretos e abstratos. Métodos em uma interface não podem ter um corpo,
 // a menos que o método seja estático, e as variáveis sejam finais, por padrão, ao contrário de um
@@ -482,7 +487,7 @@ public abstract class Animal
 
     // Não há necessidade de inicializar, no entanto, em uma interface
     // a variável é implicitamente final e, portanto, tem
-    // de ser inicializado.
+    // de ser inicializada.
     protected int idade;
 
     public void mostrarIdade()
@@ -501,7 +506,7 @@ class Cachorro extends Animal
 {
 
     // Nota: ainda precisamos substituir os métodos abstratos na
-    // classe abstrata
+    // classe abstrata.
     @Override
     public void fazerSom()
     {
@@ -532,13 +537,13 @@ class Cachorro extends Animal
 //}
 
 // Classes finais são classes que não podem ser herdadas e são, portanto, um
-// filha final. De certa forma, as classes finais são o oposto de classes abstratas
-// Porque classes abstratas devem ser estendidas, mas as classes finais não pode ser
+// filho final. De certa forma, as classes finais são o oposto de classes abstratas,
+// porque classes abstratas devem ser estendidas, mas as classes finais não podem ser
 // estendidas.
 public final class TigreDenteDeSabre extends Animal
 {
     // Nota: Ainda precisamos substituir os métodos abstratos na
-     // classe abstrata.
+    // classe abstrata.
     @Override
     public void fazerSom();
     {
@@ -552,7 +557,7 @@ public abstract class Mamifero()
     // Sintaxe de Métodos Finais:
     // <modificador-de-acesso> final <tipo-de-retorno> <nome-do-método>(<argumentos>)
 
-    // Métodos finais, como, classes finais não podem ser substituídas por uma classe filha,
+    // Métodos finais, como classes finais, não podem ser substituídos por uma classe filha,
     // e são, portanto, a implementação final do método.
     public final boolean EImpulsivo()
     {
-- 
cgit v1.2.3


From 7408bd9e43b0847ba438668a75369c3c3820dcef Mon Sep 17 00:00:00 2001
From: ven <vendethiel@hotmail.fr>
Date: Thu, 9 Feb 2017 16:23:02 +0100
Subject: Update java-pt.html.markdown

---
 pt-br/java-pt.html.markdown | 1 -
 1 file changed, 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/java-pt.html.markdown b/pt-br/java-pt.html.markdown
index d2e07225..82989502 100644
--- a/pt-br/java-pt.html.markdown
+++ b/pt-br/java-pt.html.markdown
@@ -7,7 +7,6 @@ contributors:
 translators:
     - ["Victor Kléber Santos L. Melo", "http://victormelo.com.br/blog"]
     - ["Renê Douglas N. de Morais", "mailto:rene.douglas.bsi@gmail.com"]
-    - ["Yuri Alessandro D. T. Martins", "https://github.com/YuriAlessandro"]
 lang: pt-br
 filename: LearnJava-pt.java
 
-- 
cgit v1.2.3


From 63a6eb1182205389388e13b680962199ac9b3ffb Mon Sep 17 00:00:00 2001
From: Andy <andys8@users.noreply.github.com>
Date: Sat, 1 Apr 2017 22:19:58 +0200
Subject: [haskell] Updating second headline (#2695)

* Haskell: Updating second headline

* Haskell: Updating second headline (es)

* Haskell: Updating second headline (fr)

* Haskell: Updating second headline (pl)

* Haskell: Updating second headline (pt)

* Haskell: Updating second headline (ro)

* Haskell: Updating second headline (ru)

* Haskell: Updating second headline (cn)
---
 pt-br/haskell-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/haskell-pt.html.markdown b/pt-br/haskell-pt.html.markdown
index 788dc1d2..181aa471 100644
--- a/pt-br/haskell-pt.html.markdown
+++ b/pt-br/haskell-pt.html.markdown
@@ -93,7 +93,7 @@ not False -- Nega uma falácia
 "AbBbbcAbbcbBbcbcb" !! 2 -- 'B'
 
 ----------------------------------------------------
--- Listas e Túplas
+-- 2. Listas e Túplas
 ----------------------------------------------------
 
 -- A construção de uma lista precisa ser de elementos homogêneos
-- 
cgit v1.2.3


From a2ee84b2010691d7a54a9b335b12e92b366c7eae Mon Sep 17 00:00:00 2001
From: Yan Zhang <Eskibear@users.noreply.github.com>
Date: Thu, 1 Jun 2017 17:31:14 +0800
Subject: fix broken URL for vim (#2744)

---
 pt-br/vim-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/vim-pt.html.markdown b/pt-br/vim-pt.html.markdown
index 4f70079a..51eddb48 100644
--- a/pt-br/vim-pt.html.markdown
+++ b/pt-br/vim-pt.html.markdown
@@ -10,7 +10,7 @@ filename: LearnVim-pt.txt
 ---
 
 
-[Vim](www.vim.org)
+[Vim](http://www.vim.org)
 (Vi IMproved - Vi Melhorado) é um clone do editor vi para Unix. Ele é um
 editor de texto projetado para ter velocidade e produtividade, e está presente
 na maioria dos systemas UNIX. O editor tem um grande número de atalhos de teclado
-- 
cgit v1.2.3


From 025c9d5b2c9b388dc1715ff1e5c8b64b49d1e227 Mon Sep 17 00:00:00 2001
From: marciojrtorres <marciojrtorres@gmail.com>
Date: Mon, 31 Jul 2017 09:49:13 -0300
Subject: pt-br translation and localization of kotlin en tutorial

---
 pt-br/kotlin-pt.html.markdown | 384 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 384 insertions(+)
 create mode 100644 pt-br/kotlin-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/kotlin-pt.html.markdown b/pt-br/kotlin-pt.html.markdown
new file mode 100644
index 00000000..5a038fef
--- /dev/null
+++ b/pt-br/kotlin-pt.html.markdown
@@ -0,0 +1,384 @@
+---
+language: kotlin
+filename: LearnKotlin.kt
+contributors:
+    - ["S Webber", "https://github.com/s-webber"]
+translators:
+    - ["Márcio Torres", "https://github.com/marciojrtorres"]
+lang: pt-br
+---
+
+Kotlin é uma linguagem de programação estaticamente tipada para a JVM, Android e navegadores web. Ela é 100% interoperável com Java.
+[Leia mais aqui.](https://kotlinlang.org/)
+
+```kotlin
+// Comentários de uma linha iniciam com //
+/*
+Comentários multilinha se parecem com este.
+*/
+
+// A palavra-chave "package" funciona do mesmo modo que no Java.
+package com.learnxinyminutes.kotlin
+
+/*
+O ponto de entrada para um programa em Kotlin é uma função chamada "main"
+Esta função recebe um vetor contendo quaisquer argumentos da linha de comando
+*/
+fun main(args: Array<String>) {
+    /*
+    A declaração de valores pode ser feita tanto com "var" como "val"
+    Declarações com "val" não podem ser reatribuídas, enquanto com "var" podem.
+    */
+    val umVal = 10 // não se poderá reatribuir qualquer coisa a umVal
+    var umVar = 10
+    umVar = 20 // umVar pode ser reatribuída, mas respeitando o tipo
+
+    /*
+    Na maioria dos casos Kotlin pode inferir o tipo, então não é preciso sempre
+    especificar o tipo explicitamente, mas quando o fazemos é assim:
+    */
+    val umInteiro: Int = 7
+
+    /*
+    Strings podem ser representadas de forma semelhante a Java.
+    A contrabarra realiza o "escape", da mesma forma.
+    */
+    val umaString = "Minha String está aqui!"
+    val outraString = "Imprimir na outra linha?\nSem problema!"
+    val maisString = "Você quer adicionar um tab?\tSem problema!"
+    println(umaString)
+    println(outraString)
+    println(maisString)
+
+    /*
+    Uma string bruta é delimitada com três aspas (""").
+    Strings brutas podem conter novas linhas e outros caracteres.
+    */
+    val umaStringBruta = """
+fun olaMundo(val nome : String) {
+   println("Olá, mundo!")
+}
+"""
+    println(umaStringBruta)
+
+    /*
+    As strings podem conter expressões modelo (template).
+    Uma expressão modelo começa com um cifrão ($).
+    É semelhante à interpolação de Strings em Ruby.
+    */
+    val umaStringModelo = "$umaString tem ${umaString.length} caracteres"
+    println(umaStringModelo)
+
+    /*
+    Para uma variável receber null deve-se explicitamente declara-la
+    como anulável.
+    A declaração de anulável é realizada incluindo uma "?" ao fim do tipo.
+    Pode-se acessar uma variável anulável usando o operador "?."
+    Usa-se o operador "?:" (também conhecido como operador Elvis) para
+    atribuir um valor alternativo para quando uma variável é nula.
+    */
+    var umaVariavelAnulavel: String? = "abc"
+    println(umaVariavelAnulavel?.length) // => 3
+    println(umaVariavelAnulavel?.length ?: -1) // => 3
+    umaVariavelAnulavel = null
+    println(umaVariavelAnulavel?.length) // => null
+    println(umaVariavelAnulavel?.length ?: -1) // => -1
+
+    /*
+    Funções podem ser declaradas usando a palavra-chave "fun"
+    Os parâmetros da função são declarados entre parênteses logo
+    após o nome da função.
+    Os parâmetros da função podem ter opcionalmente um valor padrão.
+    O tipo de retorno da função, se necessário, é especificado após os argumentos.
+    */
+    fun ola(nome: String = "mundo"): String {
+        return "Olá, $nome!"
+    }
+    println(ola("você")) // => Olá, você!
+    println(ola(nome = "tu")) // => Olá, tu!
+    println(ola()) // => Olá, mundo!
+
+    /*
+    Um parâmetro pode ser declarado com a palavra-chave "vararg" para
+    permitir que seja passado um número variável de argumentos.
+    */
+    fun exemploVarArg(vararg numeros: Int) {
+        println("Foram recebidos ${numeros.size} argumentos")
+    }
+    exemploVarArg() // => Passando nenhum argumento (0 argumentos)
+    exemploVarArg(1) // => Passando 1 argumento
+    exemploVarArg(1, 2, 3) // => Passando 3 argumentos
+
+    /*
+    Quando uma função consiste numa única expressão as chaves
+    podem ser omitidas e o corpo declarado após o símbolo de "="
+    */
+    fun impar(x: Int): Boolean = x % 2 == 1
+    println(impar(6)) // => false
+    println(impar(7)) // => true
+
+    // O tipo de retorno não precisa ser declarado se pode ser inferido.
+    fun impar(x: Int) = x % 2 == 0
+    println(impar(6)) // => true
+    println(impar(7)) // => false
+
+    // Funções podem receber e retornar outras funções
+    fun nao(f: (Int) -> Boolean): (Int) -> Boolean {
+        return {n -> !f.invoke(n)}
+    }
+    // Funções nomeadas podem ser passadas como argumento usando o operador "::"
+    val naoImpar = nao(::impar)
+    val naoPar = nao(::par)
+    // Expressões Lambda podem ser usadas como argumentos
+    val naoZero = nao {n -> n == 0}
+    /*
+    Se uma lambda têm apenas um parâmetro sua declaração pode ser omitida,
+    incluindo o símbolo "->".
+    Neste caso o nome do único parâmetro deve ser "it".
+    */
+    val naoPositivo = nao {it > 0}
+    for (i in 0..4) {
+        println("${naoImpar(i)} ${naoPar(i)} ${naoZero(i)} ${naoPositivo(i)}")
+    }
+
+    // A palavra-chave "class" é usada para declarar classes
+    class ClasseExemplo(val x: Int) {
+        fun funcaoMembro(y: Int): Int { // ou "método"
+            return x + y
+        }
+
+        infix fun funcaoMembroInfixa(y: Int): Int {
+            return x * y
+        }
+    }
+    /*
+    Para criar uma nova instância chama-se o construtor.
+    Note que Kotlin não tem a palavra-chave "new".
+    */
+    val umaInstanciaDaClasseExemplo = ClasseExemplo(7)
+    // Funções membro (métodos) podem ser chamados usando a notação ponto "."
+    println(umaInstanciaDaClasseExemplo.funcaoMembro(4)) // => 11
+    /*
+    Se uma função foi declarada com a palavra-chave "infix" então
+    ela pode ser invocada com a notação infixa.
+    */
+    println(umaInstanciaDaClasseExemplo funcaoMembroInfixa 4) // => 28
+
+    /*
+    Classes de dados são um modo sucinto de criar classes que servem apenas
+    para guardas informações.
+    Os métodos "hashCode", "equals" e "toString" são gerados automaticamente.
+    */
+    data class ExemploClasseDados (val x: Int, val y: Int, val z: Int)
+    val objetoDados = ExemploClasseDados(1, 2, 4)
+    println(objetoDados) // => ExemploClasseDados(x=1, y=2, z=4)
+
+    // Classes de dados têm uma função "copy"
+    val dadosCopia = objetoDados.copy(y = 100)
+    println(dadosCopia) // => ExemploClasseDados(x=1, y=100, z=4)
+
+    // Objetos podem ser desestruturados em múltiplas variáveis.
+    val (a, b, c) = dadosCopia
+    println("$a $b $c") // => 1 100 4
+
+    // desestruturando em um laço "for"
+    for ((a, b, c) in listOf(objetoDados)) {
+        println("$a $b $c") // => 1 100 4
+    }
+
+    val mapaDados = mapOf("a" to 1, "b" to 2)
+    // Map.Entry também é desestruturável
+    for ((chave, valor) in mapaDados) {
+        println("$chave -> $valor")
+    }
+
+    // A função "with" é semelhante à declaração "with" do JavaScript
+    data class ExemploClasseDadosMutaveis (var x: Int, var y: Int, var z: Int)
+    val objDadosMutaveis = ExemploClasseDadosMutaveis(7, 4, 9)
+    with (objDadosMutaveis) {
+        x -= 2
+        y += 2
+        z--
+    }
+    println(objDadosMutaveis) // => ExemploClasseDadosMutaveis(x=5, y=6, z=8)
+
+    /*
+    Pode-se criar uma lista usando a função "listOf".
+    A lista é imutável, isto é, elementos não podem ser adicionados ou removidos.
+    */
+    val umaLista = listOf("a", "b", "c")
+    println(umaLista.size) // => 3
+    println(umaLista.first()) // => a
+    println(umaLista.last()) // => c
+    // Elementos de uma lista podem ser acessados pelo índice
+    println(umaLista[1]) // => b
+
+    // Uma lista mutável pode ser criada com a função "mutableListOf".
+    val umaListaMutavel = mutableListOf("a", "b", "c")
+    umaListaMutavel.add("d")
+    println(umaListaMutavel.last()) // => d
+    println(umaListaMutavel.size) // => 4
+
+    // Similarmente, pode-se criar um conjunto com a função "setOf".
+    val umConjunto = setOf("a", "b", "c")
+    println(umConjunto.contains("a")) // => true
+    println(umConjunto.contains("z")) // => false
+
+    // Da mesma forma que um mapa com a função "mapOf".
+    val umMapa = mapOf("a" to 8, "b" to 7, "c" to 9)
+    // Os valores contidos no mapa podem ser acessados pela sua chave.
+    println(umMapa["a"]) // => 8
+
+    /*
+    Sequências representam coleções avaliadas "preguiçosamente" (sob demanda).
+    Pode-se criar uma sequência usando a função "generateSequence".
+    */
+    val umaSequencia = generateSequence(1, { it + 1 })
+    val x = umaSequencia.take(10).toList()
+    println(x) // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+    // Um exemplo de uma sequência usada para gerar Números de Fibonacci:
+    fun sequenciaFibonacci(): Sequence<Long> {
+        var a = 0L
+        var b = 1L
+
+        fun proximo(): Long {
+            val resultado = a + b
+            a = b
+            b = resultado
+            return a
+        }
+
+        return generateSequence(::proximo)
+    }
+    val y = sequenciaFibonacci().take(10).toList()
+    println(y) // => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+
+    // Kotlin oferece funções de alta-ordem para trabalhar com coleções.
+    val z = (1..9).map {it * 3}
+                  .filter {it < 20}
+                  .groupBy {it % 2 == 0}
+                  .mapKeys {if (it.key) "par" else "impar"}
+    println(z) // => {impar=[3, 9, 15], par=[6, 12, 18]}
+
+    // Um "for" pode ser usado com qualquer coisa que ofereça um "iterator"
+    for (c in "salve") {
+        println(c)
+    }
+
+    // O "while" funciona da mesma forma que em outras linguagens.
+    var contador = 0
+    while (contador < 5) {
+        println(contador)
+        contador++
+    }
+    do {
+        println(contador)
+        contador++
+    } while (contador < 10)
+
+    /*
+    "if" pode ser usado como uma expressão que retorna um valor.
+    Por este motivo o operador ternário "? :" não é necessário em Kotlin.
+    */
+    val numero = 5
+    val mensagem = if (numero % 2 == 0) "par" else "impar"
+    println("$numero é $mensagem") // => 5 é impar
+
+    // "when" pode ser usado como alternativa às correntes de "if-else if".
+    val i = 10
+    when {
+        i < 7 -> println("primeiro block")
+        umaString.startsWith("oi") -> println("segundo block")
+        else -> println("bloco else")
+    }
+
+    // "when" pode ser usado com um argumento.
+    when (i) {
+        0, 21 -> println("0 ou 21")
+        in 1..20 -> println("entre 1 e 20")
+        else -> println("nenhum dos anteriores")
+    }
+
+    // "when" pode ser usada como uma função que retorna um valor.
+    var resultado = when (i) {
+        0, 21 -> "0 ou 21"
+        in 1..20 -> "entre 1 e 20"
+        else -> "nenhum dos anteriores"
+    }
+    println(resultado)
+
+    /*
+    Pode-se verificar se um objeto é de um certo tipo usando o operador "is".
+    Se o objeto passar pela verificação então ele pode ser usado como
+    este tipo, sem a necessidade de uma coerção (cast) explícita (SmartCast).
+    */
+    fun exemploSmartCast(x: Any) : Boolean {
+        if (x is Boolean) {
+            // x é automaticamente coagido para Boolean
+            return x
+        } else if (x is Int) {
+            // x é automaticamente coagido para Int
+            return x > 0
+        } else if (x is String) {
+            // x é automaticamente coagido para String
+            return x.isNotEmpty()
+        } else {
+            return false
+        }
+    }
+    println(exemploSmartCast("Olá, mundo!")) // => true
+    println(exemploSmartCast("")) // => false
+    println(exemploSmartCast(5)) // => true
+    println(exemploSmartCast(0)) // => false
+    println(exemploSmartCast(true)) // => true
+
+    // O Smartcast também funciona com blocos "when"
+    fun exemploSmartCastComWhen(x: Any) = when (x) {
+        is Boolean -> x
+        is Int -> x > 0
+        is String -> x.isNotEmpty()
+        else -> false
+    }
+
+    /*
+    As extensões são uma maneira nova de adicionar funcionalidades a classes.
+    Elas são similares aos "extension methods" da linguagem C#.
+    */
+    fun String.remove(c: Char): String {
+        return this.filter {it != c}
+    }
+    println("olá, mundo!".remove('o')) // => lá, mund!
+
+    println(ExemploEnum.A) // => A
+    println(ExemploObjeto.ola()) // => olá
+}
+
+// Classes Enum são similares aos "enum types" do Java.
+enum class ExemploEnum {
+    A, B, C
+}
+
+/*
+A palavra-chave "object" pode ser usar para criar Singletons.
+Eles não são instanciados, mas podem referenciar sua instância única pelo nome.
+É semelhante aos "singleton objects" da linguagem Scala.
+*/
+object ExemploObjeto {
+    fun ola(): String {
+        return "olá"
+    }
+}
+
+fun usaObjeto() {
+    ExemploObjeto.ola()
+    val algumaReferencia: Any = ExemploObjeto // usa-se o nome diretamente
+}
+
+```
+
+### Leitura Adicional
+
+* [Tutoriais de Kotlin](https://kotlinlang.org/docs/tutorials/)(EN)
+* [Experimente Kotlin no seu navegador](http://try.kotlinlang.org/)(EN)
+* [Uma lista de material sobre Kotlin](http://kotlin.link/)(EN)
-- 
cgit v1.2.3


From 985d23a52b76593a120adff5381c2df3a80fe298 Mon Sep 17 00:00:00 2001
From: HairyFotr <hairyfotr@gmail.com>
Date: Wed, 23 Aug 2017 10:14:39 +0200
Subject: Fix a bunch of typos

---
 pt-br/c-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown
index 0af553c8..6e7aa8c2 100644
--- a/pt-br/c-pt.html.markdown
+++ b/pt-br/c-pt.html.markdown
@@ -647,7 +647,7 @@ Se você tem uma pergunta, leia [compl.lang.c Frequently Asked Questions](http:/
 
 É importante usar espaços e indentação adequadamente e ser consistente com seu estilo de código em geral.
 Código legível é melhor que código 'esperto' e rápido. Para adotar um estilo de código bom e são, veja
-[Linux kernel coding stlye](https://www.kernel.org/doc/Documentation/CodingStyle).
+[Linux kernel coding style](https://www.kernel.org/doc/Documentation/CodingStyle).
 
 Além disso, Google é teu amigo.
 [1] http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member
-- 
cgit v1.2.3


From 9541b8141ee0a72b0d3cb4203cc0dc7269040bd5 Mon Sep 17 00:00:00 2001
From: Pratik Karki <prertik@outlook.com>
Date: Fri, 25 Aug 2017 13:56:15 +0545
Subject: Add language code suffix(#2832)

---
 pt-br/bf.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'pt-br')

diff --git a/pt-br/bf.html.markdown b/pt-br/bf.html.markdown
index d6d7c6e9..e115b726 100644
--- a/pt-br/bf.html.markdown
+++ b/pt-br/bf.html.markdown
@@ -1,5 +1,6 @@
 ---
 language: bf
+filename: learnbf-br.bf
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io/"]
     - ["Mathias Bynens", "http://mathiasbynens.be/"]
-- 
cgit v1.2.3


From 5e5a2935c0fb5c0015d35557f9f2fe57479f47f1 Mon Sep 17 00:00:00 2001
From: Pratik Karki <prertik@outlook.com>
Date: Fri, 25 Aug 2017 13:56:53 +0545
Subject: Add language code suffix(#2832)

---
 pt-br/c++-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown
index fd392b9e..c1cfbbb1 100644
--- a/pt-br/c++-pt.html.markdown
+++ b/pt-br/c++-pt.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: c++
-filename: learncpp.cpp
+filename: learncpp-pt.cpp
 contributors:
     - ["Steven Basart", "http://github.com/xksteven"]
     - ["Matt Kline", "https://github.com/mrkline"]
-- 
cgit v1.2.3


From ca701ab30ca85e980dce19b92d3399a9c1873d1e Mon Sep 17 00:00:00 2001
From: Pratik Karki <prertik@outlook.com>
Date: Fri, 25 Aug 2017 13:57:09 +0545
Subject: Add language code suffix(#2832)

---
 pt-br/bf.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/bf.html.markdown b/pt-br/bf.html.markdown
index e115b726..52a5269e 100644
--- a/pt-br/bf.html.markdown
+++ b/pt-br/bf.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: bf
-filename: learnbf-br.bf
+filename: learnbf-pt.bf
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io/"]
     - ["Mathias Bynens", "http://mathiasbynens.be/"]
-- 
cgit v1.2.3


From 5d67c543bdaa9d76425f748cbb7bd5a9328c9e71 Mon Sep 17 00:00:00 2001
From: Pratik Karki <prertik@outlook.com>
Date: Fri, 25 Aug 2017 13:57:54 +0545
Subject: Add language code suffix(#2832)

---
 pt-br/groovy-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/groovy-pt.html.markdown b/pt-br/groovy-pt.html.markdown
index 2ec7d967..25e123c0 100644
--- a/pt-br/groovy-pt.html.markdown
+++ b/pt-br/groovy-pt.html.markdown
@@ -1,7 +1,7 @@
 ---
 language: Groovy
 category: language
-filename: learngroovy.groovy
+filename: learngroovy-pt.groovy
 contributors:
     - ["Roberto Pérez Alcolea", "http://github.com/rpalcolea"]
 translators:
-- 
cgit v1.2.3


From 34b3dddd1fdd961bbde3e9f7241209a964fdda13 Mon Sep 17 00:00:00 2001
From: Pratik Karki <prertik@outlook.com>
Date: Fri, 25 Aug 2017 13:58:28 +0545
Subject: Add language code suffix(#2832)

---
 pt-br/hy-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/hy-pt.html.markdown b/pt-br/hy-pt.html.markdown
index 5fa4df75..c69ac859 100644
--- a/pt-br/hy-pt.html.markdown
+++ b/pt-br/hy-pt.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: hy
-filename: learnhy.hy
+filename: learnhy-pt.hy
 contributors:
     - ["Abhishek L", "http://twitter.com/abhishekl"]
 translators:
-- 
cgit v1.2.3


From fb8a3308e0a8abdfe1861c7ffd4ff377926dbcef Mon Sep 17 00:00:00 2001
From: Pratik Karki <prertik@outlook.com>
Date: Fri, 25 Aug 2017 13:58:58 +0545
Subject: Add filename(#2832)

---
 pt-br/javascript-pt.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'pt-br')

diff --git a/pt-br/javascript-pt.html.markdown b/pt-br/javascript-pt.html.markdown
index e337f4bc..7b6729ef 100644
--- a/pt-br/javascript-pt.html.markdown
+++ b/pt-br/javascript-pt.html.markdown
@@ -1,5 +1,6 @@
 ---
 language: javascript
+filename: javascript-pt.js
 contributors:
     - ["Adam Brenecki", "http://adam.brenecki.id.au"]
     - ["Ariel Krakowski", "http://www.learneroo.com"]
-- 
cgit v1.2.3


From 892abe4644e9d5b244ce5bb33d1a00ba786b301d Mon Sep 17 00:00:00 2001
From: Pratik Karki <prertik@outlook.com>
Date: Fri, 25 Aug 2017 13:59:30 +0545
Subject: Add language code suffix(#2832)

---
 pt-br/swift-pt.html.markdown | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/swift-pt.html.markdown b/pt-br/swift-pt.html.markdown
index 4ad67a06..ebf74b6f 100644
--- a/pt-br/swift-pt.html.markdown
+++ b/pt-br/swift-pt.html.markdown
@@ -1,12 +1,13 @@
 ---
 language: swift
+filename: learnswift-pt.swift
 contributors:
     - ["Grant Timmerman", "http://github.com/grant"]
     - ["Christopher Bess", "http://github.com/cbess"]
 translators:
     - ["Mariane Siqueira Machado", "https://twitter.com/mariane_sm"]
 lang: pt-br
-filename: learnswift.swift
+
 ---
 
 Swift é uma linguagem de programação para desenvolvimento de aplicações no iOS e OS X criada pela Apple. Criada para
-- 
cgit v1.2.3


From 4cd428b050893ca1f50df6defb5c752c7df3f2a4 Mon Sep 17 00:00:00 2001
From: Pratik Karki <predatoramigo@gmail.com>
Date: Fri, 25 Aug 2017 16:05:03 +0545
Subject: Fix language code suffix

---
 pt-br/kotlin-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/kotlin-pt.html.markdown b/pt-br/kotlin-pt.html.markdown
index 5a038fef..7c3313fc 100644
--- a/pt-br/kotlin-pt.html.markdown
+++ b/pt-br/kotlin-pt.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: kotlin
-filename: LearnKotlin.kt
+filename: LearnKotlin-pt.kt
 contributors:
     - ["S Webber", "https://github.com/s-webber"]
 translators:
-- 
cgit v1.2.3


From f225f0cb31487550bd0fa2f45ecdc1cf64da590b Mon Sep 17 00:00:00 2001
From: JoaoGFarias <jgfd@cin.ufpe.br>
Date: Sun, 3 Sep 2017 13:14:09 -0300
Subject: Solidity - PT/BR Translation

---
 pt-br/solidity-pt.html.markdown | 913 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 913 insertions(+)
 create mode 100644 pt-br/solidity-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/solidity-pt.html.markdown b/pt-br/solidity-pt.html.markdown
new file mode 100644
index 00000000..3e66957f
--- /dev/null
+++ b/pt-br/solidity-pt.html.markdown
@@ -0,0 +1,913 @@
+---
+language: Solidity
+filename: learnSolidity.sol
+contribuidors:
+  - ["Nemil Dalal", "https://www.nemil.com"]
+  - ["Joseph Chow", ""]
+translators:
+    - ["João Farias", "http://thatsabug.com/"]
+---
+
+Solidity permite você programar para a [Ethereum]
+(https://www.ethereum.org/), uma máquina virtual baseada na tecnologia blockhain
+para criação e execução de contratos inteligentes, sem necessidade de partes
+centralizadas ou de confiança.
+
+Solidity é uma linguagem de contratos estaticamente tipaada com similaridade com
+Javascript e C. Como objetos em programação orientada a objetos, cada contrato
+possue variáveis de estado, funções e tipos de dados comuns. Funcionalidades
+particulares de contratados incluem cláusuras modificadoras (guarda), notifica
+dores de eventos para listerners e variáveis globais customizadas.
+
+
+Exemplos de contratos Ethereum incluem crowdfunding, votações e audições cegas.
+
+Erros em código Solidity causam grandes riscos e custos; portanto, você
+deve ser muito cuidado com teste e divulgação. DEVIDO ÀS CONSTANTES MUDANÇAS
+NO ETHEREUM, ESTE DOCUMENTOS PROVAVELMENTE NÃO ESTARÁ ATUALIZADO, VOCÊ DEVE
+ACOMPANHAR A CHATROOM DO SOLIDITY E O BLOG DO ETHEREUM PARA NOTÍCIAS ATUALIZADAS.
+TODO CÓDIGO AQUI É ENTREGUE COMO ESTÁ, COM SUBSTANCIAL RISCO DE ERRROS E PADRÕES
+DE CÓDIGO DEPRECADOS.
+
+Diferentemente de outros tipo de código, você também deve adicionar padrões
+como pausa, deprecação e retração para reduzir riscos. Este documento discute
+sintaxe, então, muito padrões populares são excluídos.
+
+Como Solidity e Ethereum ainda estão sob desenvolvimento, funcionalidades beta
+e experimentais são tipicamente marcadas e sujeitas à mudanças. Pull requests
+são bem-vindos.
+
+```javascript
+// Primeiramente, um contrato de um Banco simples
+// Permite depósitos, retiradas e checagens de saldo
+
+// banco_simples.sol (note a extensão .sol)
+
+/* **** INCICIO DO EXEMPLO **** */
+
+// Declare a versão do compilador.
+pragma solidity ^0.4.2;
+
+// Inicie com comentários Natspec (as três barras)
+// usados para documentação - e como dados descritivos para elementos/ação de UI
+
+/// @title BancoSimples
+/// @author nemild
+
+/* 'contrato' tem similadirades com 'classes' em outras linguagens (variáveis de
+class, herança, etc.) */
+
+contract BancoSimples { // CamelCase
+    // Declare variáveis de estado fora da função, para persistí-la durante a
+    // duração do contrato
+
+    // dicionário que mapeia endereços para saldos
+    // tenha cuidado  sobre ataques de overflow com números
+
+    mapping (address => uint) private saldos;
+
+    // "private" significa que outros contratos não podem acessar saldos
+    // diretamente, mas o dado ainda é visível para outras partes da blockchain
+
+    address public dono;
+
+    // ´public´ é legível (mas sem acesso de escrita) por usuários e contratos
+
+    // Eventos - ações públicas para ouvintes externo
+    event LogRealizacaoDeDeposito(address numeroDaConta, uint quantidade);
+
+    // Construtor, pode receber uma ou várias variáveis; apenas uma opção é
+    // permitidas
+
+    function BancoSimples() {
+        // msg dá detalhes sobre a mensagem mandada pelo contrato
+        // msg.sender é um chamador do contrato (endereço do criador do
+        // contrato)
+
+        dono = msg.sender;
+    }
+
+    /// @notice Deposita ether no banco
+    /// @return O saldo do usuário após o depósito
+
+    function deposito() public returns (uint) {
+        saldos[msg.sender] += msg.value;
+
+        // Sem necessidade de "this." ou "self." para variáveis de estado
+        // todos as variáveis são inciadas com seu valor default
+
+        LogRealizacaoDeDeposito(msg.sender, msg.value); // dispara evento
+
+        return saldos[msg.sender];
+    }
+
+    /// @notice Retira ether do banco
+    /// @dev Isto não retorna nenhum ether excendente
+    /// @param quantidadeDeRetirada quantidade que você quer retirar
+    /// @return O saldo restante do usuário
+    function retirada(uint quantidadeDeRetirada) public returns (uint saldoRestate) {
+        if(saldos[msg.sender] >= quantidadeDeRetirada) {
+
+            // Observe como deduzimos o saldo imediatamente, antes de enviar -
+            // devido ao risco de uma chamada recursiva que permite o chamador
+            // pedir um valor maior que seu saldo
+
+            saldos[msg.sender] -= quantidadeDeRetirada;
+
+            if (!msg.sender.send(quantidadeDeRetirada)) {
+                // incremente de volta só se falhar, como pode estar enviando
+                // para o contrato que substituiu 'enviar' no final
+                // do recebimento
+                saldos[msg.sender] += quantidadeDeRetirada;
+            }
+        }
+
+        return saldos[msg.sender];
+    }
+
+    /// @notice Retorna o saldo
+    /// @return O saldo do usuário
+    // 'constant' evita que a função edite variáveis de estado
+    // permite a função executar localmente/fora da blockchain
+    function saldo() constant returns (uint) {
+        return saldos[msg.sender];
+    }
+
+    // Função de fallback - Chamada se outras funções não forem chamadas ou
+    // se ether sem dados forem enviados
+    // Tipicamente chamada quando dados inválidos são enviados
+    // Adicionada para que ether enviado neste contrato seja revertido se o
+    // contrato falhar. Se não existisse, o dinheiro do enviante é transferido
+    // para o contrato
+    function () {
+        throw; // 'throw' reverte o estao para antes da chamada
+    }
+}
+// ** FIM DO EXEMPLO **
+
+// Agora, o básico de Solidity
+
+
+//1 TIPO DE DADOS E MÉTODOS ASSOCIADOS
+// uint é usado para quantidade de moeda (não existem doubles ou floats)
+// e para datas (no sistema de tempo Unix)
+
+uint x;
+
+// int de 256 bits, não pode ser mudado após sua instanciação
+int constant a = 8;
+int256 constant a = 8; // mesmo efeito, mas aqui os 256 bits são explícitos
+uint constant VERSÃO_ID = 0x123A1; // uma constante hexadecimal
+
+// com 'constant', o compilador substitui cada ocorrência com o valor
+
+// Para int e uint, é possível determinar o espaço explicitamente, em intervalos
+// de 8 a 256, e.g., int8, int16, int24
+uint8 b;
+int64 c;
+uint248 e;
+
+// Cuidado contra overflows, e proteja-se contra esse tipo de ataque
+
+// Não há funções randômicas padrão, use outros contratos para este objetivo
+
+// Casting de tipo
+int x = int(b);
+
+bool b = true; // ou então 'var b = true;' para inferição de tipo
+
+// Endereços - comportam 20 bytes/160 bits endereços Ethereum
+// Não permite operações aritiméticas
+address public dono;
+
+// Tipos de contas:
+// Conta de contrato: endereço criado ao criar (função do endereço do criador,
+// número da transação)
+// Conta externa: (pessoa/entidade externa): endereç criado a partir de chave
+// pública
+
+// Adicione o campo 'public' para indicar visibilidade pública/externa
+// um getter é automaticamente criado, mas NÃO um setter
+
+// Todos os endereços podem enviar ether
+dono.send(ALGUM_SALDO); // returna falso caso falhe
+if (dono.send) {} // LEMBRE-SE: encapsule num 'if', dado que endereços de
+// contrato tem funções executadas no envio e estas podem falhar
+//Também certifique-se que os saldos deduzidos ANTES de tentar enviar, dado que
+// há um risco de chamada recursiva que pode drenar um contrato
+
+// pode sobrescrever seu próprio
+
+// Pode verificar o saldo
+dona.balance; // o saldo do dono (usuário ou contrato)
+
+// Bytes permitidos de 1 a 32
+byte a; // byte é o mesmo que bytes1
+bytes2 b;
+bytes32 c;
+
+// Bytes dinamicamente criados
+
+bytes m; // Um array especial, mesmo que byte[] (mas mais comprimido)
+
+// Mais custoso que byte1-byte32, então, prefira estes quando possível
+
+// mesmo que bytes, mas não permite verificar tamanho ou acesso por indíce (por
+// enquanto)
+
+string n = "oi"; // guardado em UTF8, note as aspas duplas, não simples
+
+// funções de string serão adicionadas no futuro
+// prefira bytes32/bytes, dado que UTF8 usa mais espaço
+
+// Inferência de tipo
+// var não infere tipos baseados na primeira atribuição,
+// não pode ser usado em paramêtros de funções
+
+var a = true;
+
+// use com cuidado, inferência pode resultar em tipos errados
+// e.g., um int8, quando um contador precisa de int16
+
+// var pode ser usado para assinalar uma função a uma variável
+function a(uint x) returns (uint) {
+    return x * 2;
+}
+var f = a;
+f(22); // chamada
+
+// por padrão, todos os valores são inicializados com 0
+
+// Delete pode ser chamada na maioria dos tipos
+// (NÃO destroi o valor, mas retorna para o valor 0, o incial)
+
+uint x = 5;
+
+// Desestruturação/Tuplas
+(x, y) = (2, 7); // assinada/troca múltiplos valores
+
+// 2. ESTRUTURAS DE DADOS
+// Arrays
+
+bytes32[5] apelidos; // array estático
+bytes32[] nomes; // array dinâmico
+uint novoTamanho = nomes.push("João"); // adicionando retorna o novo tamanho do
+
+// Tamanho
+nomes.length; // pega o tamanho
+nomes.length = 1; // tamanhos pode ser alterados (para arrays dinâmicos)
+
+// arrays multidimensionais
+uint x[][5]; // array com 5 arrays dinâmicos como elementos (ordem da maioria
+// das linguagens)
+
+// Dicionários (qualquer tipo para qualquer tipo)
+mapping (string => uint) public saldos;
+saldos["charles"] = 1;
+console.log(saldos["ada"]); // é 0, toda chave não assinalada retorna zero
+// 'public' permite o seguinte contrato
+nomeDoContrato.saldos("charles"); // retorna 1
+// 'public' cria um getter (mas não um setter) como o seguinte
+function saldos(string _conta) returns (uint saldo) {
+    return saldos[_conta];
+}
+
+// Mapeamentos aninhados
+mapping (endereco => mapping (endereco => uint)) public guardioes;
+
+// Para deletar
+delete saldos["John"];
+delete saldos; // assinala zero para todas as chaves
+
+// Diferentemente de outras linguages, NÃO É POSSÍVEL iterar sobre todos os
+// elementos de um mapeamento, sem saber previamente as chaves - é possível
+// construir estruturas de dados personalizadas para fazer isso
+
+// Structs e enums
+struct Banco {
+    address dono;
+    uint saldo;
+}
+Banco b = Banco({
+    dono: msg.sender,
+    saldo: 5
+});
+// ou
+Banco c = Banco(msg.sender, 5);
+
+c.quantidade = 5; // cria novo valor
+delete b;
+// assinala todos os valores do enum para zero, exceto mapeamentos
+
+// Enums
+enum Estado { Criado, Travado, Inativo }; // geralmente usado para máquina de
+// estados
+Estado public estado; // Declara variável para enum
+estado = Estado.Criado;
+// enums podem ser explicitamente convertidas em ints
+uint estadoCriado = uint(Estado.Criado); //  0
+
+// Localização de dados: Memória vs. disco vs. pilha - todos os tipos complexos
+// (arrays, structs) tem uma localização de dados
+// 'memória' não é persistida, 'disco' é
+// Padrão é 'disco' para variáveis locais e de estado; 'memória' para paramêtros
+// de função. Pilha guarda pequena variáveis locais
+
+// a maioria dos tipos podem ter sua localização de dados explicitamente assinalos
+
+// 3. Operações simples
+// Comparações, operadores binários e aritimétricos são providos
+// exponenciação: **
+// ou exclusivo: ^
+// negação binária: ~
+
+// 4. Variáveis Globais de nota
+// ** this **
+this; // endereço do contrato
+// geralmente usado no final do contrato para enviar o saldo restante às partes
+this.balance;
+this.algumFuncao(); // chamada de função externa via call, não via jump interno
+
+// ** msg - Mensagem corrente recebida pelo contrato ** **
+msg.sender; // endereço do enviador
+msg.value; // quantidade de ether provida para este contrato em wei
+msg.data; // bytes, todos os dados da chamada
+msg.gas; // gas restante
+
+// ** tx - Esta transação **
+tx.origin; // endereço do enviador da transação
+tx.gasprice; // valor do gas da transação
+
+// ** block - Informação do bloco corrente **
+now; // tempo corrente (aproxiamdo), substituto para block.timestamp
+//(usa tempo do Unix)
+block.number; // número do bloco corrente
+block.difficulty; // dificuldade do bloco corrente
+block.blockhash(1); // retorna bytes32, só funciona para os 256 blocos mais
+//recentes
+block.gasLimit();
+
+// ** storage - Hash de disco persistente **
+storage['abc'] = 'def'; // mapea palavras de 256 bits em palavras de 256 bits
+
+
+// 4. FUNÇÕES E MAIS
+// A. Funções
+// Funções simples
+function incremento(uint x) returns (uint) {
+    x += 1;
+    return x;
+}
+
+// Funções podem retornar muito argumentos, e podem especificar argumentos
+// retornados sem necessidade de explicitamente usar return
+function incremento(uint x, uint y) returns (uint x, uint y) {
+    x += 1;
+    y += 1;
+}
+// Chamando a função anterior
+uint (a,b) = incremento(1,1);
+
+// 'constant' indica que uam função não altera variáveis persistidas
+// Funções constantes são executadas localmente, não na blockchain
+uint y;
+
+function incremento(uint x) constant returns (uint x) {
+    x += 1;
+    y += 1; // Esta linha deve falhar
+    // y é uma variável de estado e não pode ser alterada por uma função local
+}
+
+// 'Especificadores de visibilidade de funções'
+// Estes podem substituitir 'constante', incluíndo:
+// public - visbilidade externa e interna (padrão)
+// private - apenas visível no contrato corrente
+// internal - apenas visível no contrato corrente e seus derivados
+
+// Functions hosteada - e pode ser assinalada para variável
+function a() {
+    var z = b;
+    b();
+}
+
+function b() {
+
+}
+
+// Prefira loops sobre recursões (pilha de chamada é no máximo 1024)
+
+// B. Eventos
+// Eventos podem notificar partes externas; facilmente buscáveis e acessáveis
+// de fora da blockchain (com clientes leves)
+// tipicamente declarados após os parâmetros do contrato
+
+// Tipicamente, com letra maiúscula - e adicione Log na frente para
+// ser explicito e previnir confusão na chamada da função
+
+// Declaração
+event LogEnvio(address indexed de, address indexed para, uint quantidade);
+// Observe a letra maíscula no início do nome
+
+// Chamada
+Envio(de, para, quantidade);
+
+// Para partes externas (um contrato ou entidade externo), observe:
+Coin.Envio().watch({}, '', function(erro, resultado) {
+    if (!erro) {
+        console.log("Moeda transferida: " + resultado.args.quantidade +
+            " moedas enviadas de " + resultado.args.de +
+            " para " + resultado.args.para + ".");
+        console.log("Saldo atual:\n" +
+            "Enviador: " + Coin.balances.call(resultado.args.de) +
+            "Recebedor: " + Coin.balances.call(resultado.args.para));
+    }
+}
+// Paradigma comum para um contrato depender de outro (e.g., um contrato que
+// depende da taxa de troca provida por outro)
+
+// C. ModifiCadores
+// MOdificadores validam entradas de funções, como saldo mínimo e autorização
+// do usuário; semelhantes a guardas em outras linguagens
+
+// '_' (subtraço) geralmente incluído como última linha do corpo, indica que a
+// função sendo chamada deve ser colocada ali
+modifier apenasDepois(uint _tempo) { if (agora <= _tempo) throw; _ }
+modifier apenasDono { if (msg.sender == dono) _ }
+// geralmente usado para máquina de estado
+modifier apenasSeEmEstado (Estado estadoCorrente)
+{ if (estadoCorrente != Estado.A) _ }
+
+// Concatenado logo após a chamada da função
+function mudeDona(novoDono)
+apenasDepois(algumTempo)
+apenasDono()
+apenasSeEmEstado(Estado.A)
+{
+    dono = novoDono;
+}
+
+// subtração pode ser incluído antes do final do corpo, mas retorno explícitos
+// pode ser ignorado, então, tome cuidado
+modifier chequeValor(uint quantidade) {
+    _
+    if (msg.value > quantidade) {
+        uint quantidadeASerDevolvida = quantidade - msg.value;
+        if (!msg.sender.send(quantidadeASerDevolvida)) {
+            throw;
+        }
+    }
+}
+
+// 6. BRANCHES E LOOPS
+
+// Todas as lógicas básicas de bloco funcionam - incluindo if/else,
+// while, break, continue, return - mas não há switch
+
+// A sintaxe é semelhante a Javascript, mas sem conversão de tipos
+// de não-booleanos para booleanos (operadores de comparação precisam
+// utilizar valores booleanos)
+
+// Loops que dependem o comportamento do usuário exigem cuidado - dado
+// que contratos tem uma quantidade máxima de gas para cada bloco de
+// de código - falhas acontecerão caso ele seja excedido
+// Por exemplo:
+for(uint x = 0; x < listaDeEnderecoDeRefundo.length; x++) {
+    if (!listaDeEnderecoDeRefundo[x].send(ALGUMA_QUANTIDADE)) {
+       throw;
+    }
+}
+
+// Dois erros acima:
+// 1. Uma falha no enviar para o loop completamente, travando dinheiro
+// 2. Este loop pode ser abitrariamente longo (basado na quando que
+// o usuário precisa de refundo), portanto, pode falhar quando exceder
+// a quantidade máxima de gas do bloco
+// Ao invés disso, você deve deixar as pessoas retirarem
+// individualmente de suas subcontas e marcarem a retirada
+
+
+// 7. OBJETOS/CONTRATOS
+
+// A. Chamando um contrato externo
+contract FonteDeInformacoes {
+    function info() returns (uint ret) { return 42; }
+}
+
+contract Consumidor {
+    FonteDeInformacoes fonte; // aponta para um contrato na blockchain
+
+    // Assinala variável para uma instância do contrato
+    function setFonte(address endereco) {
+        // Cast automático, cuidado; construtor não é chamado
+        fonte = FonteDeInformacoes(endereco);
+    }
+
+    // Assinala variável para uma nova instância do contrato
+    function createNewFeed() {
+        fonte = new FonteDeInformacoes(); // nova instância criada
+        // construtor é chamado
+    }
+
+    function chameFonte() {
+        // último parenteses chama o contrato, podendo adicionar
+        // opcionalmente valores ou gas
+        fonte.info.value(10).gas(800)();
+    }
+}
+
+// B. Herança
+
+// Ordem importa, último contrato herdado (i.e., 'def') pode
+// sobrescrever partes de contratos previamente herdados
+contract MeuContratdo is abc, def("um argumento personalizado def") {
+
+// sobrescrevendo função
+    function z() {
+        if (msg.sender == dono) {
+            def.z(); // chama função sobrescrita de def
+            super.z(); // chama função do pai imeadiato
+        }
+    }
+}
+
+// função abstrata
+function umaFuncaoAbstrata(uint x);
+// não pode ser compilada, usada em contratos base/abstratos que
+// então, a implementam
+
+// C. Import
+
+import "filename";
+import "github.com/ethereum/dapp-bin/library/iterable_mapping.sol";
+
+// 'Import' está sobre desenvolvimento
+// Atualmente não pode ser usada na linha de comando
+
+
+// 8.OUTRAS PALAVRAS-CHAVE
+
+// A. Throwing
+// Throwing
+throw; // reverte estado e dinheiro NÃO-USADO é devolvido ao usuários
+// Atualmente não pode ser capturado
+
+// Um padrão de design comum é:
+if (!endereco.send(123)) {
+    throw;
+}
+
+// B. Selfdestruct
+// auto-destroe o contrato corrente, enviando fundos para o endereço
+// (geralmente o criador)
+selfdestruct(ALGUM_ENDERECO);
+
+// remove disco/código dos blocos corrente e futuros
+// ajuda clientes leves, mas dados persistidos continuam no blockchain
+
+// Padrão comum, permite ao dono finalizar o contrato e receber fundos
+// restantes
+function remover() {
+    if(msg.sender == criador) { // Apenas o criador do contrato pode
+                                // fazer isso
+        selfdestruct(criador); // Inativa o contrato e retorna os fundos
+    }
+}
+
+// Talvez queria desativar o contrato manualmente, ao invés de usar
+// selfdestruct (ether enviado para contratos selfdestructed é perdido)
+
+
+// 9. NOTAS SOBRE DESIGN DE CONTRATOS
+
+// A. Obfuscação
+// Todas as variáveis são publicamente visíveis na blockchain, então
+// qualquer coisa privada precisa ser obfuscada (e.g., hash com segredo)
+
+// Passo-a-pass: 1. Comprometa-se com algo, 2. Revele compromisso
+sha3("quantidade_de_lance", "algum segredo"); // compromisso
+
+// chame a função reveal (revelar) do contrato no futuros
+// mostrando o lance mais o segredo para foi hasheado com SHA3
+reveal(100, "meuSegredo");
+
+// B. Otimização de disco
+// Escrever na blockchain pode ser caro, dado que os dados são guardados
+// para sempre. É encorajado que contratos inteligentes usem memória (
+// enventualmente, compilação será melhor, mas por enquanto é benéfico
+// usar estruturas de dados simples - armazenando minimamente na
+// blockchain)
+
+// Custo pode ser alto para item como arrays multidimensionais
+// (custo para guardar os dados - não declarar variáveis)
+
+// C. Acesso de dados da blockchain
+
+// Não pode restringir humanos ou computadores de ler os conteúdos
+// de transações ou estado de transações
+
+// Enquanto 'private' previne outros *contratos* de ler dados ]
+// diretamente - qualquer outra parte ainda pode ler dados da blockchain
+
+// Todos os dados são armazedos na blockchain, para que qualquer um
+// possa observar dados antigos e mudanças
+
+// D. Jobs Cron
+// Contratos deve ser manualmente chamados para lidar com agendamentos
+// baseados em tempo; podendo criar código externo para pingar
+// regularmente ou prover incentivos (ether) para outros fazê-lo
+
+// E. Padrão Observador
+// O Padrão Observador permite que você registre um inscritor e
+// registre uma função a ser chamada pelo Oráculo (nota, Oráculos pagam
+// pela ação executada). Similarmente à subscrição em Pub/sub
+
+// Este é um contrato abstrato, tanto as classes cliente como a
+// servidor importam o cliente que deve ser implementado
+contract AlgumOraculoCallback {
+    function OraculoCallback(int _valor, uint _tempo, bytes32 info) external;
+}
+
+contract AlgumOráculo {
+    AlgumOraculoCallback[] callbacks; // array com todos os inscritos
+
+    // Registra inscrito
+    function addInscrito(AlgumOraculoCallback a) {
+        callbacks.push(a);
+    }
+
+    function notificar(valor, tempo, info) private {
+        for(uint i = 0;i < callbacks.length; i++) {
+            // todos os inscritos precisam implementar AlgumOraculoCallback
+            callbacks[i].OraculoCallback(valor, tempo, info);
+        }
+    }
+
+    function facaAlgo() public {
+        // Código para fazer algo
+
+        // Notifica todos os inscrito
+        notificar(_valor, _tempo, _info);
+    }
+}
+
+// Agora, seu contrato cliente pode addInscrito importando
+// AlgumOraculoCallback e registrando algum Oráculo
+
+// F. Máquinas de estado
+// veja o exemplo abaixo para o enum Estado e o modificador noEstado
+
+// *** EXEMPLO: Um exemplo de crowdfunding example (similar ao
+// Kickstarter) ***
+// ** INCIO DO EXEMPLO **
+
+// FundadorDoCrowdFunding.sol
+
+/// @title FundadorDoCrowdFunding
+/// @author nemild
+contract FundadorDoCrowdFunding {
+    // Variáveis assinaladas na crição pelo criador
+    address public criador;
+    address public recipiente; // criador pode ser diferente do Recipiente
+    uint public minALevantar; // requisito para pagar, pelo contrário
+                              // os doadores recebem o dinheiro de volta
+    string urlDaCampanha;
+    byte constant versao = 1;
+
+    // Estruturas de dados
+    enum Estado {
+        LevantandoFundos,
+        RefundoExpirado,
+        Sucesso
+    }
+    struct Contribuicao {
+        uint quantidade;
+        address contribuidor;
+    }
+
+    // Variáveis de Estado
+    State public estado = Estado.LevantandoFundos; // incializado na criação
+    uint public totalLevantado;
+    uint public levantadoPor;
+    uint public completadoEm;
+    Contribution[] contribuidores;
+
+    event LogRecebimentoDeFundos(address endereco,
+                                 uint quantidade,
+                                 uint totalAtual);
+    event LogFundosPagos(address enderecoDoRecebedor);
+
+    modifier noEstado(Estado _estado) {
+        if (estado != _estado) throw;
+        _
+    }
+
+    modifier eOCriador() {
+        if (msg.sender != criador) throw;
+        _
+    }
+
+    // Aguarda 6 meses após o final do contrato para destruí-lo
+    modifier noFimDoContrato() {
+    if(!((estado == Estado.RefundoExpirado || estado == Estado.Sucesso) &&
+        completadoEm + 6 months < now)) {
+            throw;
+        }
+        _
+    }
+
+    function FundadorDoCrowdFunding(
+        uint tempoEmHorasParaFundraising,
+        string _urlDaCampanha,
+        address _recipiente,
+        uint _minALevantar)
+    {
+        criador = msg.sender;
+        recipiente = _recipiente;
+        urlDaCampanha = _urlDaCampanha;
+        minALevantar = _minALevantar;
+        levantadoPor = now + (tempoEmHorasParaFundraising * 1 hours);
+    }
+
+    function contribuir()
+    public
+    noEstado(Estado.LevantandoFundos)
+    {
+        contribuidores.push(
+            Contribuicao({
+                quantidade: msg.value,
+                contribuidor: msg.sender
+            }) // use array, para podermos iterar
+        );
+        totalLevantado += msg.value;
+
+        LogRecebimentoDeFundos(msg.sender, msg.value, totalRaised);
+
+        verifiqueSeLevantamentoFoiCompletadoOuExpirado();
+        return contribuicoes.length - 1; // retorna id
+    }
+
+    function verifiqueSeLevantamentoFoiCompletadoOuExpirado() {
+        if (totalLevantado > minALevantar) {
+            estado = Estado.Sucesso;
+            pagar();
+
+            // pode incentivar enviador que iniciou a mudanção de estado
+        } else if ( now > levantadoPor )  {
+            estado = Estado.RefundoExpirado; // backers podem coletar
+                                             // o fundo chamando receberRefundo(id)
+        }
+        completadoEm = now;
+    }
+
+    function pagar()
+    public
+    emEstado(Estado.Sucesso)
+    {
+        if(!recipiente.send(this.balance)) {
+            throw;
+        }
+
+
+        LogFundosPagos(fundRecipient);
+    }
+
+    function receberRefundo(id)
+    public
+    emEstado(Estado.RefundoExpirado)
+    {
+        if (contribuicoes.length <= id || id < 0 || contribuicoes[id].amount == 0 ) {
+            throw;
+        }
+
+        uint quantidadeDeRefundo = contribuicoes[id].amount;
+        contribuicoes[id].amount = 0;
+
+        if(!contribuicoes[id].contribuidor.send(quantidadeParaEnviar)) {
+            contribuicoes[id].amount = quantidadeParaEnviar;
+            return false;
+        }
+
+      return true;
+    }
+
+    function removerContrato()
+    public
+    eOCriador()
+    noFimDoContrato()
+    {
+        selfdestruct(msg.sender);
+        // criador recebe todo o dinheiro restante{
+
+    }
+
+    function () { throw; }
+}
+// ** FIM DO EXEMPLO **
+
+// 10. OUTRAS FUNÇÕES NATIVAS
+
+// Unidades monetárias
+// Moeda é definida usando wei, menor quantidade de ether
+uint quantidadeMin = 1 wei;
+uint a = 1 finney; // 1 ether == 1000 finney
+// Para outras unidades, veja: http://ether.fund/tool/converter
+
+// Unidades temporais
+1 == 1 second // segundos
+1 minutes == 60 seconds // Minutos
+
+// Pode multiplicar uma variável de tempo, dado que unidades não são guardadas
+// na variável
+uint x = 5;
+(x * 1 days); // 5 dias
+
+// Cuidado com o salto de segundos / anos com declarações de igualdade para o tempo
+// (em vez disso, prefira maior que / menor que)
+
+// Criptografia
+// Todas as string passadas são concatenadas antes de realizar hashing
+sha3("ab", "cd");
+ripemd160("abc");
+sha256("def");
+
+// 11. Segurança
+
+// Bugs são desastrosos para contratos Ethereum - até padrões Solidity populares
+// podem ser considerados anti-padrões
+
+// Veja links para segurança no final deste documento
+
+// 12. FUNÇÕES DE BAIXO NÍVELS
+// call - baixo nível, geralmente não usada, não tem segurança de tipos
+booleanSucesso = algumEnderecoDeContrato.call('nome_da_funcao', 'arg1', 'arg2');
+
+// callcode - Código no endereço alvo executado no *contexto* do contrato
+// de chamada. Fornece funcionalidade de biblioteca
+algumEnderecoDeContrato.callcode('nome_da_funcao');
+
+
+// 13. NOTAS DE ESTILO
+// Baseado no guia de estilo PEP8 do Python
+
+// Resumo rápido:
+// 4 espaços para identação
+// Duas linhas separam declaração de contratos (e outras declarações de alto nível)
+// Evite espaços estranhos entre parênteses
+// Pode omitir chaves curly para uma declaração de linha(if, for, etc)
+// else deve ser colocado na própria linha
+
+
+// 14. COMENTÁRIOS NATSPEC
+// usado para documentação, comentários e UIs externos
+
+// Contrato natspec - sempre acima da definição do contrato
+/// @title Título do Contrato
+/// @author Nome do autor
+
+// Função natspec
+/// @notice informações sobre o que funciona; mostrado quando a função é executada
+/// @dev Documentação de função para desenvolvedor
+
+// Parâmetro de função / valor de retorno  natspec
+/// @param algumParametro Alguma descrição do que o parametro faz
+/// @return Descrição do valor de retorno
+```
+
+## Recursos adicionais
+- [Documetanção Solidity](https://solidity.readthedocs.org/en/latest/)
+- [Guia de Estilo do Solidity](https://ethereum.github.io/solidity//docs/style-guide/):
+ O guia de estilo Ethereum é derivado do guia de estilo do Python [pep8](https://www.python.org/dev/peps/pep-0008/).
+- [Editor de Browser Solidity](http://chriseth.github.io/browser-solidity/)
+- [Gitter Solidity Chat room](https://gitter.im/ethereum/solidity)
+- [Estratégias de projeto modular para contratos Ethereum](https://docs.erisindustries.com/tutorials/solidity/)
+
+## Contratos de Exemplo
+- [Dapp Bin](https://github.com/ethereum/dapp-bin)
+- [Solidity Baby Step Contracts](https://github.com/fivedogit/solidity-baby-steps/tree/master/contracts)
+- [ConsenSys Contracts](https://github.com/ConsenSys/dapp-store-contracts)
+- [State of Dapps](http://dapps.ethercasts.com/)
+
+## Segurança
+- [Thinking About Smart Contract Security](https://blog.ethereum.org/2016/06/19/thinking-smart-contract-security/)
+- [Smart Contract Security](https://blog.ethereum.org/2016/06/10/smart-contract-security/)
+- [Hacking Distributed Blog](http://hackingdistributed.com/)
+
+## Informação excluída intencionalmente
+- Libraries
+
+## Estilo
+- [PEP8](https://www.python.org/dev/peps/pep-0008/) é usado como guia de estilo,
+ incluindo sua filosofia geral
+
+## Editores
+- [Vim Solidity](https://github.com/tomlion/vim-solidity)
+- Snippets de Editores ([Ultisnips format](https://gist.github.com/nemild/98343ce6b16b747788bc))
+
+## Trabalhos Futuros
+- Novas palavras-chave: protected, inheritable
+- Lista de padrões de design comuns (throttling, RNG, atualização de versão)
+- Padrões anti-segurança comuns
+
+
+Sinta-se a vontade para enviar um pull request com quaisquer edições - ou email
+para nemild - / at- / gmail
-- 
cgit v1.2.3


From 018dc98a7f063169fda2c76b0cf85c92995a8477 Mon Sep 17 00:00:00 2001
From: Pratik Karki <predatoramigo@gmail.com>
Date: Wed, 6 Sep 2017 00:55:49 +0545
Subject: Add lang

---
 pt-br/solidity-pt.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'pt-br')

diff --git a/pt-br/solidity-pt.html.markdown b/pt-br/solidity-pt.html.markdown
index 3e66957f..84d02e50 100644
--- a/pt-br/solidity-pt.html.markdown
+++ b/pt-br/solidity-pt.html.markdown
@@ -6,6 +6,7 @@ contribuidors:
   - ["Joseph Chow", ""]
 translators:
     - ["João Farias", "http://thatsabug.com/"]
+lang: pt-br
 ---
 
 Solidity permite você programar para a [Ethereum]
-- 
cgit v1.2.3


From 3e4f4e4dcd579f3350a5434e424794db9318ca5c Mon Sep 17 00:00:00 2001
From: Pratik Karki <prertik@outlook.com>
Date: Wed, 6 Sep 2017 01:14:56 +0545
Subject: fix typo

---
 pt-br/solidity-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/solidity-pt.html.markdown b/pt-br/solidity-pt.html.markdown
index 84d02e50..37d15bf2 100644
--- a/pt-br/solidity-pt.html.markdown
+++ b/pt-br/solidity-pt.html.markdown
@@ -1,7 +1,7 @@
 ---
 language: Solidity
 filename: learnSolidity.sol
-contribuidors:
+contributors:
   - ["Nemil Dalal", "https://www.nemil.com"]
   - ["Joseph Chow", ""]
 translators:
-- 
cgit v1.2.3


From 3c38bb8197a281f2ea5967e3f807736ba5bb5c50 Mon Sep 17 00:00:00 2001
From: Abel Salgado Romero <abelromero@gmail.com>
Date: Thu, 21 Sep 2017 18:51:50 +0200
Subject: [asciidoc/en][asciidoc/de][asciidoc/is][asciidoc/pt] fixed wrong
 AsciiDoc section levels

---
 pt-br/asciidoc-pt.html.markdown | 4 ----
 1 file changed, 4 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/asciidoc-pt.html.markdown b/pt-br/asciidoc-pt.html.markdown
index 75b3c268..1dee31db 100644
--- a/pt-br/asciidoc-pt.html.markdown
+++ b/pt-br/asciidoc-pt.html.markdown
@@ -87,10 +87,6 @@ Título de seções
 
 ===== Nível 4 <h5>
 
-====== Nível 5 <h6>
-
-======= Nível 6  <h7>
-
 ```
 
 Listas
-- 
cgit v1.2.3


From 9afd4fd1bd7ea9fb32dd3957c07380d3879da753 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Kamil=20=C5=81opusza=C5=84ski?= <kam.wopush314@gmail.com>
Date: Wed, 4 Oct 2017 16:15:38 +0200
Subject: [groovy] small fix in iteration over a map

---
 pt-br/groovy-pt.html.markdown | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/groovy-pt.html.markdown b/pt-br/groovy-pt.html.markdown
index 25e123c0..aed23df1 100644
--- a/pt-br/groovy-pt.html.markdown
+++ b/pt-br/groovy-pt.html.markdown
@@ -226,10 +226,12 @@ for (i in array) {
 
 //Itera sobre um mapa
 def map = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy']
-x = 0
+x = ""
 for ( e in map ) {
     x += e.value
+    x += " "
 }
+assert x.equals("Roberto Grails Groovy ")
 
 /*
   Operadores
-- 
cgit v1.2.3


From 31b9d9b8035ffe8581981e546b724ca6f3fc67d7 Mon Sep 17 00:00:00 2001
From: Lucas Pugliesi <ferreiraplucas@gmail.com>
Date: Wed, 4 Oct 2017 14:35:23 -0300
Subject: [pyqt/pt-br] Translation of PyQt to pt-br.

---
 pt-br/pyqt-pt.html.markdown | 92 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 92 insertions(+)
 create mode 100644 pt-br/pyqt-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/pyqt-pt.html.markdown b/pt-br/pyqt-pt.html.markdown
new file mode 100644
index 00000000..ced107dc
--- /dev/null
+++ b/pt-br/pyqt-pt.html.markdown
@@ -0,0 +1,92 @@
+---
+category: tool
+tool: PyQT
+filename: learnpyqt.py
+contributors:
+    - ["Nathan Hughes", "https://github.com/sirsharpest"]
+translators:
+    - ["Lucas Pugliesi", "https://github.com/fplucas"]
+lang: pt-br
+---
+
+**Qt** é amplamente conhecido como um framework para desenvolvimento de
+software multi-plataforma que pode rodar em vários outras plataformas de
+softwares e hardwares com pouca ou nenhuma alteração no código, enquanto mantém
+o poder e a velocidade de uma aplicação nativa. Embora o **Qt** tenha sido
+originalmente escrito em *C++*.
+
+
+Essa é uma adaptação de uma introdução ao QT em C++ por
+[Aleksey Kholovchuk](https://github.com/vortexxx192), alguns dos exemplos de
+código podem resultar na mesma funcionalidade que essa versão, apenas usando
+o pyqt!
+
+```python
+import sys
+from PyQt4 import QtGui
+	
+def window():
+	# Cria um objeto para a aplicação
+    app = QtGui.QApplication(sys.argv)
+	# Cria um widget onde o nosso label será inserido
+    w = QtGui.QWidget()
+	# Adiciona um label ao widget
+    b = QtGui.QLabel(w)
+	# Informa algum texto ao label
+    b.setText("Hello World!")
+	# Define os tamanhos e posições dos objetos
+    w.setGeometry(100, 100, 200, 50)
+    b.move(50, 20)
+	# Define o título da janela
+    w.setWindowTitle("PyQt")
+	# Exibe a janela
+    w.show()
+	# Executa tudo o que foi pedido, apenas uma vez
+    sys.exit(app.exec_())
+
+if __name__ == '__main__':
+    window()
+
+```
+
+Para utilizar mais funcionalidades no **pyqt** veremos a construção de alguns
+outros elementos.
+Aqui mostraremos como criar uma janela popup, muito útil para perguntar ao
+usuário qual decisão tomar ou exibir alguma informação.
+
+```Python 
+import sys
+from PyQt4.QtGui import *
+from PyQt4.QtCore import *
+
+
+def window():
+    app = QApplication(sys.argv)
+    w = QWidget()
+    # Cria um botão e o anexa ao widget w
+    b = QPushButton(w)
+    b.setText("Press me")
+    b.move(50, 50)
+    # Informa b a chamar essa função quando for clicado
+    # observe que a função chamada não necessita de "()"
+    b.clicked.connect(showdialog)
+    w.setWindowTitle("PyQt Dialog")
+    w.show()
+    sys.exit(app.exec_())
+	
+# Essa função deve criar uma janela de diálogo com um botão,
+# aguarda ser clicado e encerra o programa
+def showdialog():
+    d = QDialog()
+    b1 = QPushButton("ok", d)
+    b1.move(50, 50)
+    d.setWindowTitle("Dialog")
+    # Essa modalidade define que o popup deve bloquear as outras janelas quando ativo
+    d.setWindowModality(Qt.ApplicationModal)
+    # Ao ser clicado deve encerrar o processo
+    b1.clicked.connect(sys.exit)
+    d.exec_()
+
+if __name__ == '__main__':
+    window()
+```
-- 
cgit v1.2.3


From d00c5e67d04d83d647746836872d3c1e1ed74d0b Mon Sep 17 00:00:00 2001
From: fnscoder <felipensouza@live.com>
Date: Wed, 4 Oct 2017 21:53:03 -0300
Subject: fix names in pt-br

---
 pt-br/amd-pt.html.markdown    | 218 ++++++++++
 pt-br/amd.html.markdown       | 218 ----------
 pt-br/bf-pt.html.markdown     |  86 ++++
 pt-br/bf.html.markdown        |  86 ----
 pt-br/csharp-pt.html.markdown | 896 ++++++++++++++++++++++++++++++++++++++++++
 pt-br/csharp.html.markdown    | 896 ------------------------------------------
 pt-br/elixir-pt.html.markdown | 412 +++++++++++++++++++
 pt-br/elixir.html.markdown    | 412 -------------------
 8 files changed, 1612 insertions(+), 1612 deletions(-)
 create mode 100644 pt-br/amd-pt.html.markdown
 delete mode 100644 pt-br/amd.html.markdown
 create mode 100644 pt-br/bf-pt.html.markdown
 delete mode 100644 pt-br/bf.html.markdown
 create mode 100644 pt-br/csharp-pt.html.markdown
 delete mode 100644 pt-br/csharp.html.markdown
 create mode 100644 pt-br/elixir-pt.html.markdown
 delete mode 100644 pt-br/elixir.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/amd-pt.html.markdown b/pt-br/amd-pt.html.markdown
new file mode 100644
index 00000000..38c1f70f
--- /dev/null
+++ b/pt-br/amd-pt.html.markdown
@@ -0,0 +1,218 @@
+---
+category: tool
+tool: amd
+contributors:
+    - ["Frederik Ring", "https://github.com/m90"]
+translators:
+    - ["Felipe Tarijon", "http://nanoincub.com/"]
+lang: pt-br
+filename: learnamd-pt.js
+---
+
+## Começando com AMD
+
+A API de Definição de Módulos Assíncrona **Asynchronous Module Definition** 
+especifica um mecanismo para definição de módulos em JavaScript para os quais o
+módulo e suas dependências podem ser carregados de forma assíncrona. Isso é
+particularmente bem adequado para o ambiente do browser onde o carregamento de
+módulos de forma síncrona fica sujeito a problemas de performance, usabilidade,
+debugging e problemas de acesso em requisições cross-domain.
+
+### Conceito básico
+```javascript
+// O básico da API de AMD consiste de nada mais que dois métodos: `define` e `require`
+// e isso é tudo sobre a definição de módulo e consumo:
+// `define(id?, dependências?, factory)` define um módulo
+// `require(dependências, callback)` importa uma série de dependências e
+// consome elas no callback passado como parâmetro.
+
+// Vamos começar usando o define para definir um novo módulo
+// que não tem dependências. Nós vamos fazer isso passando um nome
+// e uma função factory para definir:
+define('awesomeAMD', function(){
+  var isAMDAwesome = function(){
+    return true;
+  };
+  // O valor retornado da função de factory do módulo é
+  // o que os outros módulos ou chamadas de require irão
+  // receber quando requisitarem nosso módulo `awesomeAMD`.
+  // O valor exportado pode ser qualquer coisa, (construtor) funções,
+  // objetos, primitives, até mesmo undefined (apesar de que não irão ajudar muito).
+  return isAMDAwesome;
+});
+
+// Agora, vamos definir outro módulo que depende do nosso módulo `awesomeAMD`.
+// Perceba que existe um argumento adicional definindo nossas dependências do
+// módulo agora:
+define('loudmouth', ['awesomeAMD'], function(awesomeAMD){
+  // dependências serão passadas como argumentos da factory
+  // na ordem que elas forem especificadas
+  var tellEveryone = function(){
+    if (awesomeAMD()){
+      alert('Isso é tãaaao loko!');
+    } else {
+      alert('Bem estúpido, né não?');
+    }
+  };
+  return tellEveryone;
+});
+
+// Agora que nós sabemos como usar o define, vamos usar o `require` para
+// começar nosso programa. A assinatura do `require` é `(arrayDedependências, callback)`.
+require(['loudmouth'], function(loudmouth){
+  loudmouth();
+});
+
+// Para fazer esse tutorial executável, vamos implementar uma versão muito básica
+// (não-assíncrona) de AMD bem aqui nesse lugar:
+function define(nome, deps, factory){
+  // perceba como os módulos sem dependências são manipulados
+  define[nome] = require(factory ? deps : [], factory || deps);
+}
+
+function require(deps, callback){
+  var args = [];
+  // primeiro vamos recuperar todas as dependências necessárias
+  // pela chamada requerida
+  for (var i = 0; i < deps.length; i++){
+    args[i] = define[deps[i]];
+  }
+  // corresponder todas as dependências da função de callback
+  return callback.apply(null, args);
+}
+// você pode ver esse código em ação aqui: http://jsfiddle.net/qap949pd/
+```
+
+### Uso na vida real com require.js
+
+Em contraste com o exemplo introdutório, `require.js` (a biblioteca mais popular de AMD) na verdade implementa o **A** do **AMD**, permitindo que você carregue os módulos e suas
+dependências via XHR:
+
+```javascript
+/* file: app/main.js */
+require(['modules/algumaClasse'], function(AlgumaClasse){
+  // o callback é deferido até que a dependencia seja carregada
+  var coisa = new AlgumaClasse();
+});
+console.log('Então aqui estamos nós, esperando!'); // isso vai rodar primeiro
+```
+
+Por convenção, você geralmente guarda um módulo em um arquivo. `require.js` pode resolver nome de módulos baseado no caminho das pastas, então você não precisa nomear os seus módulos, mas sim simplesmente referenciar eles usando sua origem. No exemplo `algumaClasse` é adotado a pasta `modules`, relativa a configuração da sua `baseUrl`:
+
+* app/
+  * main.js
+  * modules/
+    * algumaClasse.js
+    * algunsHelpers.js
+    * ...
+  * daos/
+    * coisas.js
+    * ...
+
+Isso significa que nós podemos definir `algumaClasse` sem especificar o id de um módulo:
+
+```javascript
+/* arquivo: app/modules/algumaClasse.js */
+define(['daos/coisas', 'modules/algunsHelpers'], function(coisasDao, helpers){
+  // definição de módulo, claro, irá acontecer também de forma assíncrona
+  function AlgumaClasse(){
+    this.metodo = function(){/**/};
+    // ...
+  }
+  return AlgumaClasse;
+});
+```
+Para alterar o comportamento padrão de mapeamento de caminho de pastas utilize
+`requirejs.config(configObj)` em seu `main.js`:
+
+```javascript
+/* arquivo: main.js */
+requirejs.config({
+  baseUrl : 'app',
+  paths : {
+    // você pode também carregar módulos de outros locais
+    jquery : '//ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min',
+    coolLibFromBower : '../bower_components/cool-lib/coollib'
+  }
+});
+require(['jquery', 'coolLibFromBower', 'modules/algunsHelpers'], function($, coolLib, helpers){
+  // um arquivo `main` precisa chamar o require pelo menos uma vez,
+  // caso contrário, o código jamais rodará
+  coolLib.facaAlgoDoidoCom(helpers.transform($('#foo')));
+});
+```
+Apps baseados em `require.js` geralmente terão u´m único ponto de acesso (`main.js`) que é passado à tag script do `require.js` como um data-attribute. Ele vai ser automaticamente carregado e executado com o carregamento da página:
+
+```html
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Umas 100 tags de script? Nunca mais!</title>
+</head>
+<body>
+  <script src="require.js" data-main="app/main"></script>
+</body>
+</html>
+```
+
+### Otimizando um projeto inteiro utilizando r.js
+
+Muitas pessoas preferem usar AMD para sanar a organização do código durante o desenvolvimento, mas continuam querendo colocar um único arquivo de script em produção ao invés de realizarem centenas de requisições XHRs no carregamento da página.
+
+`require.js` vem com um script chamado `r.js` (que você vai provavelmente rodar em node.js, embora Rhino suporte também) que você pode analisar o gráfico de dependências de seu projeto, e fazer em um único arquivo contendo todos os seus módulos (corretamente nomeados), minificados e prontos para serem consumidos.
+
+Instale-o utilizando `npm`:
+```shell
+$ npm install requirejs -g
+```
+
+Agora você pode alimentá-lo com um arquivo de configuração:
+```shell
+$ r.js -o app.build.js
+```
+
+Para o nosso exemplo acima a configuração pode ser essa:
+```javascript
+/* file : app.build.js */
+({
+  name : 'main', // nome do ponto de acesso
+  out : 'main-built.js', // nome o arquivo para gravar a saída
+  baseUrl : 'app',
+  paths : {
+    // `empty:` fala para o r.js que isso ainda deve ser baixado da CDN, usando
+    // o local especificado no `main.js`
+    jquery : 'empty:',
+    coolLibFromBower : '../bower_components/cool-lib/coollib'
+  }
+})
+```
+
+Para usar o arquivo gerado, em produção, simplesmente troque o `data-main`:
+```html
+<script src="require.js" data-main="app/main-built"></script>
+```
+
+Uma incrível e detalhada visão geral [de build options](https://github.com/jrburke/r.js/blob/master/build/example.build.js) está disponível no repositório do GitHub.
+
+### Tópicos não abordados nesse tutorial
+* [Plugins de carregamento / transforms](http://requirejs.org/docs/plugins.html)
+* [CommonJS style carregamento e exportação](http://requirejs.org/docs/commonjs.html)
+* [Configuração avançada](http://requirejs.org/docs/api.html#config)
+* [Shim configuration (carregando módulos sem AMD)](http://requirejs.org/docs/api.html#config-shim)
+* [Carregando e otimizando CSS com require.js](http://requirejs.org/docs/optimization.html#onecss)
+* [Usando almond.js para builds](https://github.com/jrburke/almond)
+
+### Outras leituras:
+
+* [Especificação oficial](https://github.com/amdjs/amdjs-api/wiki/AMD)
+* [Por quê AMD?](http://requirejs.org/docs/whyamd.html)
+* [Universal Module Definition](https://github.com/umdjs/umd)
+
+### Implementações:
+
+* [require.js](http://requirejs.org)
+* [dojo toolkit](http://dojotoolkit.org/documentation/tutorials/1.9/modules/)
+* [cujo.js](http://cujojs.com/)
+* [curl.js](https://github.com/cujojs/curl)
+* [lsjs](https://github.com/zazl/lsjs)
+* [mmd](https://github.com/alexlawrence/mmd)
diff --git a/pt-br/amd.html.markdown b/pt-br/amd.html.markdown
deleted file mode 100644
index 38c1f70f..00000000
--- a/pt-br/amd.html.markdown
+++ /dev/null
@@ -1,218 +0,0 @@
----
-category: tool
-tool: amd
-contributors:
-    - ["Frederik Ring", "https://github.com/m90"]
-translators:
-    - ["Felipe Tarijon", "http://nanoincub.com/"]
-lang: pt-br
-filename: learnamd-pt.js
----
-
-## Começando com AMD
-
-A API de Definição de Módulos Assíncrona **Asynchronous Module Definition** 
-especifica um mecanismo para definição de módulos em JavaScript para os quais o
-módulo e suas dependências podem ser carregados de forma assíncrona. Isso é
-particularmente bem adequado para o ambiente do browser onde o carregamento de
-módulos de forma síncrona fica sujeito a problemas de performance, usabilidade,
-debugging e problemas de acesso em requisições cross-domain.
-
-### Conceito básico
-```javascript
-// O básico da API de AMD consiste de nada mais que dois métodos: `define` e `require`
-// e isso é tudo sobre a definição de módulo e consumo:
-// `define(id?, dependências?, factory)` define um módulo
-// `require(dependências, callback)` importa uma série de dependências e
-// consome elas no callback passado como parâmetro.
-
-// Vamos começar usando o define para definir um novo módulo
-// que não tem dependências. Nós vamos fazer isso passando um nome
-// e uma função factory para definir:
-define('awesomeAMD', function(){
-  var isAMDAwesome = function(){
-    return true;
-  };
-  // O valor retornado da função de factory do módulo é
-  // o que os outros módulos ou chamadas de require irão
-  // receber quando requisitarem nosso módulo `awesomeAMD`.
-  // O valor exportado pode ser qualquer coisa, (construtor) funções,
-  // objetos, primitives, até mesmo undefined (apesar de que não irão ajudar muito).
-  return isAMDAwesome;
-});
-
-// Agora, vamos definir outro módulo que depende do nosso módulo `awesomeAMD`.
-// Perceba que existe um argumento adicional definindo nossas dependências do
-// módulo agora:
-define('loudmouth', ['awesomeAMD'], function(awesomeAMD){
-  // dependências serão passadas como argumentos da factory
-  // na ordem que elas forem especificadas
-  var tellEveryone = function(){
-    if (awesomeAMD()){
-      alert('Isso é tãaaao loko!');
-    } else {
-      alert('Bem estúpido, né não?');
-    }
-  };
-  return tellEveryone;
-});
-
-// Agora que nós sabemos como usar o define, vamos usar o `require` para
-// começar nosso programa. A assinatura do `require` é `(arrayDedependências, callback)`.
-require(['loudmouth'], function(loudmouth){
-  loudmouth();
-});
-
-// Para fazer esse tutorial executável, vamos implementar uma versão muito básica
-// (não-assíncrona) de AMD bem aqui nesse lugar:
-function define(nome, deps, factory){
-  // perceba como os módulos sem dependências são manipulados
-  define[nome] = require(factory ? deps : [], factory || deps);
-}
-
-function require(deps, callback){
-  var args = [];
-  // primeiro vamos recuperar todas as dependências necessárias
-  // pela chamada requerida
-  for (var i = 0; i < deps.length; i++){
-    args[i] = define[deps[i]];
-  }
-  // corresponder todas as dependências da função de callback
-  return callback.apply(null, args);
-}
-// você pode ver esse código em ação aqui: http://jsfiddle.net/qap949pd/
-```
-
-### Uso na vida real com require.js
-
-Em contraste com o exemplo introdutório, `require.js` (a biblioteca mais popular de AMD) na verdade implementa o **A** do **AMD**, permitindo que você carregue os módulos e suas
-dependências via XHR:
-
-```javascript
-/* file: app/main.js */
-require(['modules/algumaClasse'], function(AlgumaClasse){
-  // o callback é deferido até que a dependencia seja carregada
-  var coisa = new AlgumaClasse();
-});
-console.log('Então aqui estamos nós, esperando!'); // isso vai rodar primeiro
-```
-
-Por convenção, você geralmente guarda um módulo em um arquivo. `require.js` pode resolver nome de módulos baseado no caminho das pastas, então você não precisa nomear os seus módulos, mas sim simplesmente referenciar eles usando sua origem. No exemplo `algumaClasse` é adotado a pasta `modules`, relativa a configuração da sua `baseUrl`:
-
-* app/
-  * main.js
-  * modules/
-    * algumaClasse.js
-    * algunsHelpers.js
-    * ...
-  * daos/
-    * coisas.js
-    * ...
-
-Isso significa que nós podemos definir `algumaClasse` sem especificar o id de um módulo:
-
-```javascript
-/* arquivo: app/modules/algumaClasse.js */
-define(['daos/coisas', 'modules/algunsHelpers'], function(coisasDao, helpers){
-  // definição de módulo, claro, irá acontecer também de forma assíncrona
-  function AlgumaClasse(){
-    this.metodo = function(){/**/};
-    // ...
-  }
-  return AlgumaClasse;
-});
-```
-Para alterar o comportamento padrão de mapeamento de caminho de pastas utilize
-`requirejs.config(configObj)` em seu `main.js`:
-
-```javascript
-/* arquivo: main.js */
-requirejs.config({
-  baseUrl : 'app',
-  paths : {
-    // você pode também carregar módulos de outros locais
-    jquery : '//ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min',
-    coolLibFromBower : '../bower_components/cool-lib/coollib'
-  }
-});
-require(['jquery', 'coolLibFromBower', 'modules/algunsHelpers'], function($, coolLib, helpers){
-  // um arquivo `main` precisa chamar o require pelo menos uma vez,
-  // caso contrário, o código jamais rodará
-  coolLib.facaAlgoDoidoCom(helpers.transform($('#foo')));
-});
-```
-Apps baseados em `require.js` geralmente terão u´m único ponto de acesso (`main.js`) que é passado à tag script do `require.js` como um data-attribute. Ele vai ser automaticamente carregado e executado com o carregamento da página:
-
-```html
-<!DOCTYPE html>
-<html>
-<head>
-  <title>Umas 100 tags de script? Nunca mais!</title>
-</head>
-<body>
-  <script src="require.js" data-main="app/main"></script>
-</body>
-</html>
-```
-
-### Otimizando um projeto inteiro utilizando r.js
-
-Muitas pessoas preferem usar AMD para sanar a organização do código durante o desenvolvimento, mas continuam querendo colocar um único arquivo de script em produção ao invés de realizarem centenas de requisições XHRs no carregamento da página.
-
-`require.js` vem com um script chamado `r.js` (que você vai provavelmente rodar em node.js, embora Rhino suporte também) que você pode analisar o gráfico de dependências de seu projeto, e fazer em um único arquivo contendo todos os seus módulos (corretamente nomeados), minificados e prontos para serem consumidos.
-
-Instale-o utilizando `npm`:
-```shell
-$ npm install requirejs -g
-```
-
-Agora você pode alimentá-lo com um arquivo de configuração:
-```shell
-$ r.js -o app.build.js
-```
-
-Para o nosso exemplo acima a configuração pode ser essa:
-```javascript
-/* file : app.build.js */
-({
-  name : 'main', // nome do ponto de acesso
-  out : 'main-built.js', // nome o arquivo para gravar a saída
-  baseUrl : 'app',
-  paths : {
-    // `empty:` fala para o r.js que isso ainda deve ser baixado da CDN, usando
-    // o local especificado no `main.js`
-    jquery : 'empty:',
-    coolLibFromBower : '../bower_components/cool-lib/coollib'
-  }
-})
-```
-
-Para usar o arquivo gerado, em produção, simplesmente troque o `data-main`:
-```html
-<script src="require.js" data-main="app/main-built"></script>
-```
-
-Uma incrível e detalhada visão geral [de build options](https://github.com/jrburke/r.js/blob/master/build/example.build.js) está disponível no repositório do GitHub.
-
-### Tópicos não abordados nesse tutorial
-* [Plugins de carregamento / transforms](http://requirejs.org/docs/plugins.html)
-* [CommonJS style carregamento e exportação](http://requirejs.org/docs/commonjs.html)
-* [Configuração avançada](http://requirejs.org/docs/api.html#config)
-* [Shim configuration (carregando módulos sem AMD)](http://requirejs.org/docs/api.html#config-shim)
-* [Carregando e otimizando CSS com require.js](http://requirejs.org/docs/optimization.html#onecss)
-* [Usando almond.js para builds](https://github.com/jrburke/almond)
-
-### Outras leituras:
-
-* [Especificação oficial](https://github.com/amdjs/amdjs-api/wiki/AMD)
-* [Por quê AMD?](http://requirejs.org/docs/whyamd.html)
-* [Universal Module Definition](https://github.com/umdjs/umd)
-
-### Implementações:
-
-* [require.js](http://requirejs.org)
-* [dojo toolkit](http://dojotoolkit.org/documentation/tutorials/1.9/modules/)
-* [cujo.js](http://cujojs.com/)
-* [curl.js](https://github.com/cujojs/curl)
-* [lsjs](https://github.com/zazl/lsjs)
-* [mmd](https://github.com/alexlawrence/mmd)
diff --git a/pt-br/bf-pt.html.markdown b/pt-br/bf-pt.html.markdown
new file mode 100644
index 00000000..52a5269e
--- /dev/null
+++ b/pt-br/bf-pt.html.markdown
@@ -0,0 +1,86 @@
+---
+language: bf
+filename: learnbf-pt.bf
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+    - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+    - ["Suzane Sant Ana", "http://github.com/suuuzi"]
+    - ["Rodrigo Muniz", "http://github.com/muniz95"]
+lang: pt-br
+---
+
+Brainfuck (em letras minúsculas, exceto no início de frases) é uma linguagem de
+programação Turing-completa extremamente simples com apenas 8 comandos.
+
+```
+Qualquer caractere exceto "><+-.,[]" (sem contar as aspas) é ignorado.
+
+Brainfuck é representado por um vetor com 30 000 células inicializadas em zero
+e um ponteiro de dados que aponta para a célula atual.
+
+Existem 8 comandos:
++ : Incrementa o valor da célula atual em 1.
+- : Decrementa o valor da célula atual em 1.
+> : Move o ponteiro de dados para a célula seguinte (célula à direita).
+< : Move o ponteiro de dados para a célula anterior (célula à esquerda).
+. : Imprime o valor ASCII da célula atual. (ex. 65 = 'A').
+, : Lê um único caractere para a célula atual.
+[ : Se o valor da célula atual for zero, salta para o ] correspondente.
+    Caso contrário, passa para a instrução seguinte.
+] : Se o valor da célula atual for zero, passa para a instrução seguinte.
+    Caso contrário, volta para a instrução relativa ao [ correspondente.
+
+[ e ] formam um ciclo while. Obviamente, devem ser equilibrados.
+
+Vamos ver alguns exemplos básicos em brainfuck:
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Este programa imprime a letra 'A'. Primeiro incrementa a célula #1 para 6.
+A célula #1 será usada num ciclo. Depois é iniciado o ciclo ([) e move-se
+o ponteiro de dados para a célula #2. O valor da célula #2 é incrementado 10
+vezes, move-se o ponteiro de dados de volta para a célula #1, e decrementa-se
+a célula #1. Este ciclo acontece 6 vezes (são necessários 6 decrementos para
+a célula #1 chegar a 0, momento em que se salta para o ] correspondente,
+continuando com a instrução seguinte).
+
+Nesta altura estamos na célula #1, cujo valor é 0, enquanto a célula #2
+tem o valor 60. Movemos o ponteiro de dados para a célula #2, incrementa-se 5
+vezes para um valor final de 65, e então é impresso o valor da célula #2. O valor
+65 corresponde ao caractere 'A' em ASCII, então 'A' é impresso no terminal.
+
+, [ > + < - ] > .
+
+Este programa lê um caractere e copia o seu valor para a célula #1. Um ciclo é
+iniciado. Movemos o ponteiro de dados para a célula #2, incrementamos o valor na
+célula #2, movemos o ponteiro de dados de volta para a célula #1 e finalmente
+decrementamos o valor na célula #1. Isto continua até o valor na célula #1 ser
+igual a 0 e a célula #2 ter o antigo valor da célula #1. Como o ponteiro de
+dados está apontando para a célula #1 no fim do ciclo, movemos o ponteiro para a
+célula #2 e imprimimos o valor em ASCII.
+
+Os espaços servem apenas para tornar o programa mais legível. Podemos escrever
+o mesmo programa da seguinte maneira:
+
+,[>+<-]>.
+
+Tente descobrir o que este programa faz:
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+Este programa lê dois números e os multiplica.
+
+Basicamente o programa pede dois caracteres ao usuário. Depois é iniciado um
+ciclo exterior controlado pelo valor da célula #1. Movemos o ponteiro de dados
+para a célula #2 e inicia-se o ciclo interior controlado pelo valor da célula
+#2, incrementando o valor da célula #3. Porém existe um problema, no final do
+ciclo interior: a célula #2 tem o valor 0. Para resolver este problema o valor da
+célula #4 é também incrementado e copiado para a célula #2.
+```
+
+E isto é brainfuck. Simples, não? Por divertimento você pode escrever os
+seus próprios programas em brainfuck, ou então escrever um interpretador de
+brainfuck em outra linguagem. O interpretador é relativamente fácil de se
+implementar, mas caso você seja masoquista, tente escrever um interpretador de
+brainfuck… em brainfuck.
diff --git a/pt-br/bf.html.markdown b/pt-br/bf.html.markdown
deleted file mode 100644
index 52a5269e..00000000
--- a/pt-br/bf.html.markdown
+++ /dev/null
@@ -1,86 +0,0 @@
----
-language: bf
-filename: learnbf-pt.bf
-contributors:
-    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
-    - ["Mathias Bynens", "http://mathiasbynens.be/"]
-translators:
-    - ["Suzane Sant Ana", "http://github.com/suuuzi"]
-    - ["Rodrigo Muniz", "http://github.com/muniz95"]
-lang: pt-br
----
-
-Brainfuck (em letras minúsculas, exceto no início de frases) é uma linguagem de
-programação Turing-completa extremamente simples com apenas 8 comandos.
-
-```
-Qualquer caractere exceto "><+-.,[]" (sem contar as aspas) é ignorado.
-
-Brainfuck é representado por um vetor com 30 000 células inicializadas em zero
-e um ponteiro de dados que aponta para a célula atual.
-
-Existem 8 comandos:
-+ : Incrementa o valor da célula atual em 1.
-- : Decrementa o valor da célula atual em 1.
-> : Move o ponteiro de dados para a célula seguinte (célula à direita).
-< : Move o ponteiro de dados para a célula anterior (célula à esquerda).
-. : Imprime o valor ASCII da célula atual. (ex. 65 = 'A').
-, : Lê um único caractere para a célula atual.
-[ : Se o valor da célula atual for zero, salta para o ] correspondente.
-    Caso contrário, passa para a instrução seguinte.
-] : Se o valor da célula atual for zero, passa para a instrução seguinte.
-    Caso contrário, volta para a instrução relativa ao [ correspondente.
-
-[ e ] formam um ciclo while. Obviamente, devem ser equilibrados.
-
-Vamos ver alguns exemplos básicos em brainfuck:
-
-++++++ [ > ++++++++++ < - ] > +++++ .
-
-Este programa imprime a letra 'A'. Primeiro incrementa a célula #1 para 6.
-A célula #1 será usada num ciclo. Depois é iniciado o ciclo ([) e move-se
-o ponteiro de dados para a célula #2. O valor da célula #2 é incrementado 10
-vezes, move-se o ponteiro de dados de volta para a célula #1, e decrementa-se
-a célula #1. Este ciclo acontece 6 vezes (são necessários 6 decrementos para
-a célula #1 chegar a 0, momento em que se salta para o ] correspondente,
-continuando com a instrução seguinte).
-
-Nesta altura estamos na célula #1, cujo valor é 0, enquanto a célula #2
-tem o valor 60. Movemos o ponteiro de dados para a célula #2, incrementa-se 5
-vezes para um valor final de 65, e então é impresso o valor da célula #2. O valor
-65 corresponde ao caractere 'A' em ASCII, então 'A' é impresso no terminal.
-
-, [ > + < - ] > .
-
-Este programa lê um caractere e copia o seu valor para a célula #1. Um ciclo é
-iniciado. Movemos o ponteiro de dados para a célula #2, incrementamos o valor na
-célula #2, movemos o ponteiro de dados de volta para a célula #1 e finalmente
-decrementamos o valor na célula #1. Isto continua até o valor na célula #1 ser
-igual a 0 e a célula #2 ter o antigo valor da célula #1. Como o ponteiro de
-dados está apontando para a célula #1 no fim do ciclo, movemos o ponteiro para a
-célula #2 e imprimimos o valor em ASCII.
-
-Os espaços servem apenas para tornar o programa mais legível. Podemos escrever
-o mesmo programa da seguinte maneira:
-
-,[>+<-]>.
-
-Tente descobrir o que este programa faz:
-
-,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
-
-Este programa lê dois números e os multiplica.
-
-Basicamente o programa pede dois caracteres ao usuário. Depois é iniciado um
-ciclo exterior controlado pelo valor da célula #1. Movemos o ponteiro de dados
-para a célula #2 e inicia-se o ciclo interior controlado pelo valor da célula
-#2, incrementando o valor da célula #3. Porém existe um problema, no final do
-ciclo interior: a célula #2 tem o valor 0. Para resolver este problema o valor da
-célula #4 é também incrementado e copiado para a célula #2.
-```
-
-E isto é brainfuck. Simples, não? Por divertimento você pode escrever os
-seus próprios programas em brainfuck, ou então escrever um interpretador de
-brainfuck em outra linguagem. O interpretador é relativamente fácil de se
-implementar, mas caso você seja masoquista, tente escrever um interpretador de
-brainfuck… em brainfuck.
diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
new file mode 100644
index 00000000..547f4817
--- /dev/null
+++ b/pt-br/csharp-pt.html.markdown
@@ -0,0 +1,896 @@
+---
+language: c#
+filename: csharp-pt.cs
+contributors:
+    - ["Robson Alves", "http://robsonalves.net/"]    
+lang: pt-br
+---
+
+C# é uma linguagem elegante e altamente tipado orientada a objetos que permite aos desenvolvedores criarem uma variedade de aplicações seguras e robustas que são executadas no .NET Framework.
+
+[Read more here.](http://msdn.microsoft.com/pt-br/library/vstudio/z1zx9t92.aspx)
+
+```c#
+// Comentário de linha única começa com //
+/*
+Múltipas linhas é desta forma
+*/
+/// <summary>
+/// Esta é uma documentação comentário XML que pode ser usado para gerar externo
+/// documentação ou fornecer ajuda de contexto dentro de um IDE
+/// </summary>
+//public void MethodOrClassOrOtherWithParsableHelp() {}
+
+// Especificar qual namespace seu código irá usar
+// Os namespaces a seguir são padrões do .NET Framework Class Library 
+using System;
+using System.Collections.Generic;
+using System.Dynamic;
+using System.Linq;
+using System.Net;
+using System.Threading.Tasks;
+using System.IO;
+
+// Mas este aqui não é :
+using System.Data.Entity;
+// Para que consiga utiliza-lo, você precisa adicionar novas referências
+// Isso pode ser feito com o gerenciador de pacotes NuGet : `Install-Package EntityFramework`
+
+// Namespaces são escopos definidos para organizar o códgo em "pacotes" or "módulos"
+// Usando este código a partir de outra arquivo de origem: using Learning.CSharp;
+namespace Learning.CSharp
+{
+    // Cada .cs deve conter  uma classe com o mesmo nome do arquivo
+    // você está autorizado a contrariar isto, mas evite por sua sanidade.
+    public class AprenderCsharp
+    {
+        // Sintaxe Básica - Pule para as CARACTERÍSTICAS INTERESSANTES se você ja usou Java ou C++ antes.
+        public static void Syntax()
+        {
+            // Use Console.WriteLine para apresentar uma linha
+            Console.WriteLine("Hello World");
+            Console.WriteLine(
+                "Integer: " + 10 +
+                " Double: " + 3.14 +
+                " Boolean: " + true);
+
+            // Para apresentar sem incluir uma nova linha, use Console.Write
+            Console.Write("Hello ");
+            Console.Write("World");
+
+            ///////////////////////////////////////////////////
+            // Tpos e Variáveis
+            //
+            // Declare uma variável usando <tipo> <nome>
+            ///////////////////////////////////////////////////
+
+            // Sbyte - Signed 8-bit integer
+            // (-128 <= sbyte <= 127)
+            sbyte fooSbyte = 100;
+
+            // Byte - Unsigned 8-bit integer
+            // (0 <= byte <= 255)
+            byte fooByte = 100;
+
+            // Short - 16-bit integer
+            // Signed - (-32,768 <= short <= 32,767)
+            // Unsigned - (0 <= ushort <= 65,535)
+            short fooShort = 10000;
+            ushort fooUshort = 10000;
+
+            // Integer - 32-bit integer
+            int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647)
+            uint fooUint = 1; // (0 <= uint <= 4,294,967,295)
+
+            // Long - 64-bit integer
+            long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+            ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615)
+            // Numbers default to being int or uint depending on size.
+            // L is used to denote that this variable value is of type long or ulong
+
+            // Double - Double-precision 64-bit IEEE 754 Floating Point
+            double fooDouble = 123.4; // Precision: 15-16 digits
+
+            // Float - Single-precision 32-bit IEEE 754 Floating Point
+            float fooFloat = 234.5f; // Precision: 7 digits
+            // f is used to denote that this variable value is of type float
+
+            // Decimal - a 128-bits data type, with more precision than other floating-point types,
+            // suited for financial and monetary calculations
+            decimal fooDecimal = 150.3m;
+
+            // Boolean - true & false
+            bool fooBoolean = true; // or false
+
+            // Char - A single 16-bit Unicode character
+            char fooChar = 'A';
+
+            // Strings - ao contrário dos anteriores tipos base, que são todos os tipos de valor,
+            // Uma string é um tipo de referência. Ou seja, você pode configurá-lo como nulo
+            string fooString = "\"escape\" quotes and add \n (new lines) and \t (tabs)";
+            Console.WriteLine(fooString);
+
+            //  Você pode acessar todos os caracteres de string com um indexador: 
+            char charFromString = fooString[1]; // => 'e'
+            // Strings são imutáveis: você não pode fazer fooString[1] = 'X';
+
+            // Compare strings com sua atual cultura, ignorando maiúsculas e minúsculas
+            string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase);
+
+            // Formatando, baseado no sprintf
+            string fooFs = string.Format("Check Check, {0} {1}, {0} {1:0.0}", 1, 2);
+
+            // Datas e formatações
+            DateTime fooDate = DateTime.Now;
+            Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));
+
+            // Você pode juntar um string em mais de duas linhas com o símbolo @. Para escapar do " use ""
+            string bazString = @"Here's some stuff
+on a new line! ""Wow!"", the masses cried";
+
+            // Use const ou read-only para fazer uma variável imutável
+            // os valores da const são calculados durante o tempo de compilação
+            const int HoursWorkPerWeek = 9001;
+
+            ///////////////////////////////////////////////////
+            // Estrutura de Dados
+            ///////////////////////////////////////////////////
+
+            // Matrizes - zero indexado
+            // O tamanho do array pode ser decidido ainda na declaração
+            // O formato para declarar uma matriz é o seguinte: 
+            // <tipodado>[] <var nome> = new <tipodado>[<array tamanho>];
+            int[] intArray = new int[10];
+
+            // Outra forma de declarar & inicializar uma matriz
+            int[] y = { 9000, 1000, 1337 };
+
+            // Indexando uma matriz - Acessando um elemento
+            Console.WriteLine("intArray @ 0: " + intArray[0]);
+            // Matriz são alteráveis
+            intArray[1] = 1;
+
+            // Listas
+            // Listas são usadas frequentemente tanto quanto matriz por serem mais flexiveis
+            // O formato de declarar uma lista é o seguinte:
+            // List<tipodado> <var nome> = new List<tipodado>();
+            List<int> intList = new List<int>();
+            List<string> stringList = new List<string>();
+            List<int> z = new List<int> { 9000, 1000, 1337 }; // inicializar
+            // O <> são para genéricos - Confira está interessante seção do material
+
+            // Lista não possuem valores padrão.
+            // Um valor deve ser adicionado antes e depois acessado pelo indexador
+            intList.Add(1);
+            Console.WriteLine("intList @ 0: " + intList[0]);
+
+            // Outras estruturas de dados para conferir:
+            // Pilha/Fila
+            // Dicionário (uma implementação de map de hash)
+            // HashSet
+            // Read-only Coleção
+            // Tuple (.Net 4+)
+
+            ///////////////////////////////////////
+            // Operadores
+            ///////////////////////////////////////
+            Console.WriteLine("\n->Operators");
+
+            int i1 = 1, i2 = 2; // Forma curta para declarar diversas variáveis
+
+            // Aritmética é clara
+            Console.WriteLine(i1 + i2 - i1 * 3 / 7); // => 3
+
+            // Modulo
+            Console.WriteLine("11%3 = " + (11 % 3)); // => 2
+
+            // Comparações de operadores
+            Console.WriteLine("3 == 2? " + (3 == 2)); // => falso
+            Console.WriteLine("3 != 2? " + (3 != 2)); // => verdadeiro
+            Console.WriteLine("3 > 2? " + (3 > 2)); // => verdadeiro
+            Console.WriteLine("3 < 2? " + (3 < 2)); // => falso
+            Console.WriteLine("2 <= 2? " + (2 <= 2)); // => verdadeiro
+            Console.WriteLine("2 >= 2? " + (2 >= 2)); // => verdadeiro
+
+            // Operadores bit a bit (bitwise)
+            /*
+            ~       Unário bitwise complemento
+            <<      Signed left shift
+            >>      Signed right shift
+            &       Bitwise AND
+            ^       Bitwise exclusivo OR
+            |       Bitwise inclusivo OR
+            */
+
+            // Incrementações
+            int i = 0;
+            Console.WriteLine("\n->Inc/Dec-rementation");
+            Console.WriteLine(i++); //i = 1. Post-Incrementation
+            Console.WriteLine(++i); //i = 2. Pre-Incrementation
+            Console.WriteLine(i--); //i = 1. Post-Decrementation
+            Console.WriteLine(--i); //i = 0. Pre-Decrementation
+
+            ///////////////////////////////////////
+            // Estrutura de Controle
+            ///////////////////////////////////////
+            Console.WriteLine("\n->Control Structures");
+
+            // Declaração if é como a linguagem C
+            int j = 10;
+            if (j == 10)
+            {
+                Console.WriteLine("I get printed");
+            }
+            else if (j > 10)
+            {
+                Console.WriteLine("I don't");
+            }
+            else
+            {
+                Console.WriteLine("I also don't");
+            }
+
+            // Operador Ternário
+            // Um simples if/else pode ser escrito da seguinte forma
+            // <condição> ? <verdadeiro> : <falso>
+            int toCompare = 17;
+            string isTrue = toCompare == 17 ? "True" : "False";
+
+            // While loop
+            int fooWhile = 0;
+            while (fooWhile < 100)
+            {
+                //Iterated 100 times, fooWhile 0->99
+                fooWhile++;
+            }
+
+            // Do While Loop
+            int fooDoWhile = 0;
+            do
+            {
+                // Inicia a interação 100 vezes, fooDoWhile 0->99
+                if (false)
+                    continue; // pule a intereção atual para apróxima
+
+                fooDoWhile++;
+
+                if (fooDoWhile == 50)
+                    break; // Interrompe o laço inteiro
+
+            } while (fooDoWhile < 100);
+
+            //estrutura de loop for  => for(<declaração para começar>; <condicional>; <passos>)
+            for (int fooFor = 0; fooFor < 10; fooFor++)
+            {
+                //Iterado 10 vezes, fooFor 0->9
+            }
+
+            // For Each Loop
+            // Estrutura do foreach  => foreach(<Tipo Iterador> <Nome do Iterador> in <enumerable>)
+            // O laço foreach  percorre sobre qualquer objeto que implementa IEnumerable ou IEnumerable<T>
+            // Toda a coleção de tipos  (Array, List, Dictionary...) no .Net framework
+            // implementa uma ou mais destas interfaces.
+            // (O ToCharArray() pode ser removido, por que uma string também implementa IEnumerable)
+            foreach (char character in "Hello World".ToCharArray())
+            {
+                //Iterated over all the characters in the string
+            }
+
+            // Switch Case
+            // Um switch funciona com os tipos de dados byte, short, char, e int.
+            // Isto também funcional com tipos enumeradors (discutidos em Tipos Enum),
+            // A classe String, and a few special classes that wrap
+            // tipos primitívos: Character, Byte, Short, and Integer.
+            int month = 3;
+            string monthString;
+            switch (month)
+            {
+                case 1:
+                    monthString = "January";
+                    break;
+                case 2:
+                    monthString = "February";
+                    break;
+                case 3:
+                    monthString = "March";
+                    break;
+                // You can assign more than one case to an action
+                // But you can't add an action without a break before another case
+                // (if you want to do this, you would have to explicitly add a goto case x
+                case 6:
+                case 7:
+                case 8:
+                    monthString = "Summer time!!";
+                    break;
+                default:
+                    monthString = "Some other month";
+                    break;
+            }
+
+            ///////////////////////////////////////
+            // Converting Data Types And Typecasting
+            ///////////////////////////////////////
+
+            // Converting data
+
+            // Convert String To Integer
+            // this will throw a FormatException on failure
+            int.Parse("123");//returns an integer version of "123"
+
+            // try parse will default to type default on failure
+            // in this case: 0
+            int tryInt;
+            if (int.TryParse("123", out tryInt)) // Function is boolean
+                Console.WriteLine(tryInt);       // 123
+
+            // Convert Integer To String
+            // Convert class has a number of methods to facilitate conversions
+            Convert.ToString(123);
+            // or
+            tryInt.ToString();
+
+            // Casting
+            // Cast decimal 15 to a int
+            // and then implicitly cast to long
+            long x = (int) 15M;
+        }
+
+        ///////////////////////////////////////
+        // CLASSES - see definitions at end of file
+        ///////////////////////////////////////
+        public static void Classes()
+        {
+            // See Declaration of objects at end of file
+
+            // Use new to instantiate a class
+            Bicycle trek = new Bicycle();
+
+            // Call object methods
+            trek.SpeedUp(3); // You should always use setter and getter methods
+            trek.Cadence = 100;
+
+            // ToString is a convention to display the value of this Object.
+            Console.WriteLine("trek info: " + trek.Info());
+
+            // Instantiate a new Penny Farthing
+            PennyFarthing funbike = new PennyFarthing(1, 10);
+            Console.WriteLine("funbike info: " + funbike.Info());
+
+            Console.Read();
+        } // End main method
+
+        // CONSOLE ENTRY A console application must have a main method as an entry point
+        public static void Main(string[] args)
+        {
+            OtherInterestingFeatures();
+        }
+
+        //
+        // INTERESTING FEATURES
+        //
+
+        // DEFAULT METHOD SIGNATURES
+
+        public // Visibility
+        static // Allows for direct call on class without object
+        int // Return Type,
+        MethodSignatures(
+            int maxCount, // First variable, expects an int
+            int count = 0, // will default the value to 0 if not passed in
+            int another = 3,
+            params string[] otherParams // captures all other parameters passed to method
+        )
+        {
+            return -1;
+        }
+
+        // Methods can have the same name, as long as the signature is unique
+        // A method that differs only in return type is not unique
+        public static void MethodSignatures(
+            ref int maxCount, // Pass by reference
+            out int count)
+        {
+            count = 15; // out param must be assigned before control leaves the method
+        }
+
+        // GENERICS
+        // The classes for TKey and TValue is specified by the user calling this function.
+        // This method emulates the SetDefault of Python
+        public static TValue SetDefault<TKey, TValue>(
+            IDictionary<TKey, TValue> dictionary,
+            TKey key,
+            TValue defaultItem)
+        {
+            TValue result;
+            if (!dictionary.TryGetValue(key, out result))
+                return dictionary[key] = defaultItem;
+            return result;
+        }
+
+        // You can narrow down the objects that are passed in
+        public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>
+        {
+            // We can iterate, since T is a IEnumerable
+            foreach (var item in toPrint)
+                // Item is an int
+                Console.WriteLine(item.ToString());
+        }
+
+        public static void OtherInterestingFeatures()
+        {
+            // OPTIONAL PARAMETERS
+            MethodSignatures(3, 1, 3, "Some", "Extra", "Strings");
+            MethodSignatures(3, another: 3); // explicity set a parameter, skipping optional ones
+
+            // BY REF AND OUT PARAMETERS
+            int maxCount = 0, count; // ref params must have value
+            MethodSignatures(ref maxCount, out count);
+
+            // EXTENSION METHODS
+            int i = 3;
+            i.Print(); // Defined below
+
+            // NULLABLE TYPES - great for database interaction / return values
+            // any value type (i.e. not a class) can be made nullable by suffixing a ?
+            // <type>? <var name> = <value>
+            int? nullable = null; // short hand for Nullable<int>
+            Console.WriteLine("Nullable variable: " + nullable);
+            bool hasValue = nullable.HasValue; // true if not null
+
+            // ?? is syntactic sugar for specifying default value (coalesce)
+            // in case variable is null
+            int notNullable = nullable ?? 0; // 0
+
+            // IMPLICITLY TYPED VARIABLES - you can let the compiler work out what the type is:
+            var magic = "magic is a string, at compile time, so you still get type safety";
+            // magic = 9; will not work as magic is a string, not an int
+
+            // GENERICS
+            //
+            var phonebook = new Dictionary<string, string>() {
+                {"Sarah", "212 555 5555"} // Add some entries to the phone book
+            };
+
+            // Calling SETDEFAULT defined as a generic above
+            Console.WriteLine(SetDefault<string,string>(phonebook, "Shaun", "No Phone")); // No Phone
+            // nb, you don't need to specify the TKey and TValue since they can be
+            // derived implicitly
+            Console.WriteLine(SetDefault(phonebook, "Sarah", "No Phone")); // 212 555 5555
+
+            // LAMBDA EXPRESSIONS - allow you to write code in line
+            Func<int, int> square = (x) => x * x; // Last T item is the return value
+            Console.WriteLine(square(3)); // 9
+
+            // ERROR HANDLING - coping with an uncertain world
+            try
+            {
+                var funBike = PennyFarthing.CreateWithGears(6);
+
+                // will no longer execute because CreateWithGears throws an exception
+                string some = "";
+                if (true) some = null;
+                some.ToLower(); // throws a NullReferenceException
+            }
+            catch (NotSupportedException)
+            {
+                Console.WriteLine("Not so much fun now!");
+            }
+            catch (Exception ex) // catch all other exceptions
+            {
+                throw new ApplicationException("It hit the fan", ex);
+                // throw; // A rethrow that preserves the callstack
+            }
+            // catch { } // catch-all without capturing the Exception
+            finally
+            {
+                // executes after try or catch
+            }
+
+            // DISPOSABLE RESOURCES MANAGEMENT - let you handle unmanaged resources easily.
+            // Most of objects that access unmanaged resources (file handle, device contexts, etc.)
+            // implement the IDisposable interface. The using statement takes care of
+            // cleaning those IDisposable objects for you.
+            using (StreamWriter writer = new StreamWriter("log.txt"))
+            {
+                writer.WriteLine("Nothing suspicious here");
+                // At the end of scope, resources will be released.
+                // Even if an exception is thrown.
+            }
+
+            // PARALLEL FRAMEWORK
+            // http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx
+            var websites = new string[] {
+                "http://www.google.com", "http://www.reddit.com",
+                "http://www.shaunmccarthy.com"
+            };
+            var responses = new Dictionary<string, string>();
+
+            // Will spin up separate threads for each request, and join on them
+            // before going to the next step!
+            Parallel.ForEach(websites,
+                new ParallelOptions() {MaxDegreeOfParallelism = 3}, // max of 3 threads
+                website =>
+            {
+                // Do something that takes a long time on the file
+                using (var r = WebRequest.Create(new Uri(website)).GetResponse())
+                {
+                    responses[website] = r.ContentType;
+                }
+            });
+
+            // This won't happen till after all requests have been completed
+            foreach (var key in responses.Keys)
+                Console.WriteLine("{0}:{1}", key, responses[key]);
+
+            // DYNAMIC OBJECTS (great for working with other languages)
+            dynamic student = new ExpandoObject();
+            student.FirstName = "First Name"; // No need to define class first!
+
+            // You can even add methods (returns a string, and takes in a string)
+            student.Introduce = new Func<string, string>(
+                (introduceTo) => string.Format("Hey {0}, this is {1}", student.FirstName, introduceTo));
+            Console.WriteLine(student.Introduce("Beth"));
+
+            // IQUERYABLE<T> - almost all collections implement this, which gives you a lot of
+            // very useful Map / Filter / Reduce style methods
+            var bikes = new List<Bicycle>();
+            bikes.Sort(); // Sorts the array
+            bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels)); // Sorts based on wheels
+            var result = bikes
+                .Where(b => b.Wheels > 3) // Filters - chainable (returns IQueryable of previous type)
+                .Where(b => b.IsBroken && b.HasTassles)
+                .Select(b => b.ToString()); // Map - we only this selects, so result is a IQueryable<string>
+
+            var sum = bikes.Sum(b => b.Wheels); // Reduce - sums all the wheels in the collection
+
+            // Create a list of IMPLICIT objects based on some parameters of the bike
+            var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles });
+            // Hard to show here, but you get type ahead completion since the compiler can implicitly work
+            // out the types above!
+            foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome))
+                Console.WriteLine(bikeSummary.Name);
+
+            // ASPARALLEL
+            // And this is where things get wicked - combines linq and parallel operations
+            var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name);
+            // this will happen in parallel! Threads will automagically be spun up and the
+            // results divvied amongst them! Amazing for large datasets when you have lots of
+            // cores
+
+            // LINQ - maps a store to IQueryable<T> objects, with delayed execution
+            // e.g. LinqToSql - maps to a database, LinqToXml maps to an xml document
+            var db = new BikeRepository();
+
+            // execution is delayed, which is great when querying a database
+            var filter = db.Bikes.Where(b => b.HasTassles); // no query run
+            if (42 > 6) // You can keep adding filters, even conditionally - great for "advanced search" functionality
+                filter = filter.Where(b => b.IsBroken); // no query run
+
+            var query = filter
+                .OrderBy(b => b.Wheels)
+                .ThenBy(b => b.Name)
+                .Select(b => b.Name); // still no query run
+
+            // Now the query runs, but opens a reader, so only populates are you iterate through
+            foreach (string bike in query)
+                Console.WriteLine(result);
+
+
+
+        }
+
+    } // End LearnCSharp class
+
+    // You can include other classes in a .cs file
+
+    public static class Extensions
+    {
+        // EXTENSION FUNCTIONS
+        public static void Print(this object obj)
+        {
+            Console.WriteLine(obj.ToString());
+        }
+    }
+
+    // Class Declaration Syntax:
+    // <public/private/protected/internal> class <class name>{
+    //    //data fields, constructors, functions all inside.
+    //    //functions are called as methods in Java.
+    // }
+
+    public class Bicycle
+    {
+        // Bicycle's Fields/Variables
+        public int Cadence // Public: Can be accessed from anywhere
+        {
+            get // get - define a method to retrieve the property
+            {
+                return _cadence;
+            }
+            set // set - define a method to set a proprety
+            {
+                _cadence = value; // Value is the value passed in to the setter
+            }
+        }
+        private int _cadence;
+
+        protected virtual int Gear // Protected: Accessible from the class and subclasses
+        {
+            get; // creates an auto property so you don't need a member field
+            set;
+        }
+
+        internal int Wheels // Internal: Accessible from within the assembly
+        {
+            get;
+            private set; // You can set modifiers on the get/set methods
+        }
+
+        int _speed; // Everything is private by default: Only accessible from within this class.
+                    // can also use keyword private
+        public string Name { get; set; }
+
+        // Enum is a value type that consists of a set of named constants
+        // It is really just mapping a name to a value (an int, unless specified otherwise).
+        // The approved types for an enum are byte, sbyte, short, ushort, int, uint, long, or ulong.
+        // An enum can't contain the same value twice.
+        public enum BikeBrand
+        {
+            AIST,
+            BMC,
+            Electra = 42, //you can explicitly set a value to a name
+            Gitane // 43
+        }
+        // We defined this type inside a Bicycle class, so it is a nested type
+        // Code outside of this class should reference this type as Bicycle.Brand
+
+        public BikeBrand Brand; // After declaring an enum type, we can declare the field of this type
+
+        // Decorate an enum with the FlagsAttribute to indicate that multiple values can be switched on
+        [Flags] // Any class derived from Attribute can be used to decorate types, methods, parameters etc
+        public enum BikeAccessories
+        {
+            None = 0,
+            Bell = 1,
+            MudGuards = 2, // need to set the values manually!
+            Racks = 4,
+            Lights = 8,
+            FullPackage = Bell | MudGuards | Racks | Lights
+        }
+
+        // Usage: aBike.Accessories.HasFlag(Bicycle.BikeAccessories.Bell)
+        // Before .NET 4: (aBike.Accessories & Bicycle.BikeAccessories.Bell) == Bicycle.BikeAccessories.Bell
+        public BikeAccessories Accessories { get; set; }
+
+        // Static members belong to the type itself rather then specific object.
+        // You can access them without a reference to any object:
+        // Console.WriteLine("Bicycles created: " + Bicycle.bicyclesCreated);
+        public static int BicyclesCreated { get; set; }
+
+        // readonly values are set at run time
+        // they can only be assigned upon declaration or in a constructor
+        readonly bool _hasCardsInSpokes = false; // read-only private
+
+        // Constructors are a way of creating classes
+        // This is a default constructor
+        public Bicycle()
+        {
+            this.Gear = 1; // you can access members of the object with the keyword this
+            Cadence = 50;  // but you don't always need it
+            _speed = 5;
+            Name = "Bontrager";
+            Brand = BikeBrand.AIST;
+            BicyclesCreated++;
+        }
+
+        // This is a specified constructor (it contains arguments)
+        public Bicycle(int startCadence, int startSpeed, int startGear,
+                       string name, bool hasCardsInSpokes, BikeBrand brand)
+            : base() // calls base first
+        {
+            Gear = startGear;
+            Cadence = startCadence;
+            _speed = startSpeed;
+            Name = name;
+            _hasCardsInSpokes = hasCardsInSpokes;
+            Brand = brand;
+        }
+
+        // Constructors can be chained
+        public Bicycle(int startCadence, int startSpeed, BikeBrand brand) :
+            this(startCadence, startSpeed, 0, "big wheels", true, brand)
+        {
+        }
+
+        // Function Syntax:
+        // <public/private/protected> <return type> <function name>(<args>)
+
+        // classes can implement getters and setters for their fields
+        // or they can implement properties (this is the preferred way in C#)
+
+        // Method parameters can have default values.
+        // In this case, methods can be called with these parameters omitted
+        public void SpeedUp(int increment = 1)
+        {
+            _speed += increment;
+        }
+
+        public void SlowDown(int decrement = 1)
+        {
+            _speed -= decrement;
+        }
+
+        // properties get/set values
+        // when only data needs to be accessed, consider using properties.
+        // properties may have either get or set, or both
+        private bool _hasTassles; // private variable
+        public bool HasTassles // public accessor
+        {
+            get { return _hasTassles; }
+            set { _hasTassles = value; }
+        }
+
+        // You can also define an automatic property in one line
+        // this syntax will create a backing field automatically.
+        // You can set an access modifier on either the getter or the setter (or both)
+        // to restrict its access:
+        public bool IsBroken { get; private set; }
+
+        // Properties can be auto-implemented
+        public int FrameSize
+        {
+            get;
+            // you are able to specify access modifiers for either get or set
+            // this means only Bicycle class can call set on Framesize
+            private set;
+        }
+
+        // It's also possible to define custom Indexers on objects.
+        // All though this is not entirely useful in this example, you
+        // could do bicycle[0] which yields "chris" to get the first passenger or
+        // bicycle[1] = "lisa" to set the passenger. (of this apparent quattrocycle)
+        private string[] passengers = { "chris", "phil", "darren", "regina" };
+
+        public string this[int i]
+        {
+            get {
+                return passengers[i];
+            }
+
+            set {
+                return passengers[i] = value;
+            }
+        }
+
+        //Method to display the attribute values of this Object.
+        public virtual string Info()
+        {
+            return "Gear: " + Gear +
+                    " Cadence: " + Cadence +
+                    " Speed: " + _speed +
+                    " Name: " + Name +
+                    " Cards in Spokes: " + (_hasCardsInSpokes ? "yes" : "no") +
+                    "\n------------------------------\n"
+                    ;
+        }
+
+        // Methods can also be static. It can be useful for helper methods
+        public static bool DidWeCreateEnoughBycles()
+        {
+            // Within a static method, we only can reference static class members
+            return BicyclesCreated > 9000;
+        } // If your class only needs static members, consider marking the class itself as static.
+
+
+    } // end class Bicycle
+
+    // PennyFarthing is a subclass of Bicycle
+    class PennyFarthing : Bicycle
+    {
+        // (Penny Farthings are those bicycles with the big front wheel.
+        // They have no gears.)
+
+        // calling parent constructor
+        public PennyFarthing(int startCadence, int startSpeed) :
+            base(startCadence, startSpeed, 0, "PennyFarthing", true, BikeBrand.Electra)
+        {
+        }
+
+        protected override int Gear
+        {
+            get
+            {
+                return 0;
+            }
+            set
+            {
+                throw new InvalidOperationException("You can't change gears on a PennyFarthing");
+            }
+        }
+
+        public static PennyFarthing CreateWithGears(int gears)
+        {
+            var penny = new PennyFarthing(1, 1);
+            penny.Gear = gears; // Oops, can't do this!
+            return penny;
+        }
+
+        public override string Info()
+        {
+            string result = "PennyFarthing bicycle ";
+            result += base.ToString(); // Calling the base version of the method
+            return result;
+        }
+    }
+
+    // Interfaces only contain signatures of the members, without the implementation.
+    interface IJumpable
+    {
+        void Jump(int meters); // all interface members are implicitly public
+    }
+
+    interface IBreakable
+    {
+        bool Broken { get; } // interfaces can contain properties as well as methods & events
+    }
+
+    // Class can inherit only one other class, but can implement any amount of interfaces
+    class MountainBike : Bicycle, IJumpable, IBreakable
+    {
+        int damage = 0;
+
+        public void Jump(int meters)
+        {
+            damage += meters;
+        }
+
+        public bool Broken
+        {
+            get
+            {
+                return damage > 100;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Used to connect to DB for LinqToSql example.
+    /// EntityFramework Code First is awesome (similar to Ruby's ActiveRecord, but bidirectional)
+    /// http://msdn.microsoft.com/en-us/data/jj193542.aspx
+    /// </summary>
+    public class BikeRepository : DbContext
+    {
+        public BikeRepository()
+            : base()
+        {
+        }
+
+        public DbSet<Bicycle> Bikes { get; set; }
+    }
+} // End Namespace
+```
+
+## Topics Not Covered
+
+ * Attributes
+ * async/await, yield, pragma directives
+ * Web Development
+ 	* ASP.NET MVC & WebApi (new)
+ 	* ASP.NET Web Forms (old)
+ 	* WebMatrix (tool)
+ * Desktop Development
+ 	* Windows Presentation Foundation (WPF) (new)
+ 	* Winforms (old)
+
+## Further Reading
+
+ * [DotNetPerls](http://www.dotnetperls.com)
+ * [C# in Depth](http://manning.com/skeet2)
+ * [Programming C#](http://shop.oreilly.com/product/0636920024064.do)
+ * [LINQ](http://shop.oreilly.com/product/9780596519254.do)
+ * [MSDN Library](http://msdn.microsoft.com/en-us/library/618ayhy6.aspx)
+ * [ASP.NET MVC Tutorials](http://www.asp.net/mvc/tutorials)
+ * [ASP.NET Web Matrix Tutorials](http://www.asp.net/web-pages/tutorials)
+ * [ASP.NET Web Forms Tutorials](http://www.asp.net/web-forms/tutorials)
+ * [Windows Forms Programming in C#](http://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208)
+ * [C# Coding Conventions](http://msdn.microsoft.com/en-us/library/vstudio/ff926074.aspx)
diff --git a/pt-br/csharp.html.markdown b/pt-br/csharp.html.markdown
deleted file mode 100644
index 547f4817..00000000
--- a/pt-br/csharp.html.markdown
+++ /dev/null
@@ -1,896 +0,0 @@
----
-language: c#
-filename: csharp-pt.cs
-contributors:
-    - ["Robson Alves", "http://robsonalves.net/"]    
-lang: pt-br
----
-
-C# é uma linguagem elegante e altamente tipado orientada a objetos que permite aos desenvolvedores criarem uma variedade de aplicações seguras e robustas que são executadas no .NET Framework.
-
-[Read more here.](http://msdn.microsoft.com/pt-br/library/vstudio/z1zx9t92.aspx)
-
-```c#
-// Comentário de linha única começa com //
-/*
-Múltipas linhas é desta forma
-*/
-/// <summary>
-/// Esta é uma documentação comentário XML que pode ser usado para gerar externo
-/// documentação ou fornecer ajuda de contexto dentro de um IDE
-/// </summary>
-//public void MethodOrClassOrOtherWithParsableHelp() {}
-
-// Especificar qual namespace seu código irá usar
-// Os namespaces a seguir são padrões do .NET Framework Class Library 
-using System;
-using System.Collections.Generic;
-using System.Dynamic;
-using System.Linq;
-using System.Net;
-using System.Threading.Tasks;
-using System.IO;
-
-// Mas este aqui não é :
-using System.Data.Entity;
-// Para que consiga utiliza-lo, você precisa adicionar novas referências
-// Isso pode ser feito com o gerenciador de pacotes NuGet : `Install-Package EntityFramework`
-
-// Namespaces são escopos definidos para organizar o códgo em "pacotes" or "módulos"
-// Usando este código a partir de outra arquivo de origem: using Learning.CSharp;
-namespace Learning.CSharp
-{
-    // Cada .cs deve conter  uma classe com o mesmo nome do arquivo
-    // você está autorizado a contrariar isto, mas evite por sua sanidade.
-    public class AprenderCsharp
-    {
-        // Sintaxe Básica - Pule para as CARACTERÍSTICAS INTERESSANTES se você ja usou Java ou C++ antes.
-        public static void Syntax()
-        {
-            // Use Console.WriteLine para apresentar uma linha
-            Console.WriteLine("Hello World");
-            Console.WriteLine(
-                "Integer: " + 10 +
-                " Double: " + 3.14 +
-                " Boolean: " + true);
-
-            // Para apresentar sem incluir uma nova linha, use Console.Write
-            Console.Write("Hello ");
-            Console.Write("World");
-
-            ///////////////////////////////////////////////////
-            // Tpos e Variáveis
-            //
-            // Declare uma variável usando <tipo> <nome>
-            ///////////////////////////////////////////////////
-
-            // Sbyte - Signed 8-bit integer
-            // (-128 <= sbyte <= 127)
-            sbyte fooSbyte = 100;
-
-            // Byte - Unsigned 8-bit integer
-            // (0 <= byte <= 255)
-            byte fooByte = 100;
-
-            // Short - 16-bit integer
-            // Signed - (-32,768 <= short <= 32,767)
-            // Unsigned - (0 <= ushort <= 65,535)
-            short fooShort = 10000;
-            ushort fooUshort = 10000;
-
-            // Integer - 32-bit integer
-            int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647)
-            uint fooUint = 1; // (0 <= uint <= 4,294,967,295)
-
-            // Long - 64-bit integer
-            long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
-            ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615)
-            // Numbers default to being int or uint depending on size.
-            // L is used to denote that this variable value is of type long or ulong
-
-            // Double - Double-precision 64-bit IEEE 754 Floating Point
-            double fooDouble = 123.4; // Precision: 15-16 digits
-
-            // Float - Single-precision 32-bit IEEE 754 Floating Point
-            float fooFloat = 234.5f; // Precision: 7 digits
-            // f is used to denote that this variable value is of type float
-
-            // Decimal - a 128-bits data type, with more precision than other floating-point types,
-            // suited for financial and monetary calculations
-            decimal fooDecimal = 150.3m;
-
-            // Boolean - true & false
-            bool fooBoolean = true; // or false
-
-            // Char - A single 16-bit Unicode character
-            char fooChar = 'A';
-
-            // Strings - ao contrário dos anteriores tipos base, que são todos os tipos de valor,
-            // Uma string é um tipo de referência. Ou seja, você pode configurá-lo como nulo
-            string fooString = "\"escape\" quotes and add \n (new lines) and \t (tabs)";
-            Console.WriteLine(fooString);
-
-            //  Você pode acessar todos os caracteres de string com um indexador: 
-            char charFromString = fooString[1]; // => 'e'
-            // Strings são imutáveis: você não pode fazer fooString[1] = 'X';
-
-            // Compare strings com sua atual cultura, ignorando maiúsculas e minúsculas
-            string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase);
-
-            // Formatando, baseado no sprintf
-            string fooFs = string.Format("Check Check, {0} {1}, {0} {1:0.0}", 1, 2);
-
-            // Datas e formatações
-            DateTime fooDate = DateTime.Now;
-            Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));
-
-            // Você pode juntar um string em mais de duas linhas com o símbolo @. Para escapar do " use ""
-            string bazString = @"Here's some stuff
-on a new line! ""Wow!"", the masses cried";
-
-            // Use const ou read-only para fazer uma variável imutável
-            // os valores da const são calculados durante o tempo de compilação
-            const int HoursWorkPerWeek = 9001;
-
-            ///////////////////////////////////////////////////
-            // Estrutura de Dados
-            ///////////////////////////////////////////////////
-
-            // Matrizes - zero indexado
-            // O tamanho do array pode ser decidido ainda na declaração
-            // O formato para declarar uma matriz é o seguinte: 
-            // <tipodado>[] <var nome> = new <tipodado>[<array tamanho>];
-            int[] intArray = new int[10];
-
-            // Outra forma de declarar & inicializar uma matriz
-            int[] y = { 9000, 1000, 1337 };
-
-            // Indexando uma matriz - Acessando um elemento
-            Console.WriteLine("intArray @ 0: " + intArray[0]);
-            // Matriz são alteráveis
-            intArray[1] = 1;
-
-            // Listas
-            // Listas são usadas frequentemente tanto quanto matriz por serem mais flexiveis
-            // O formato de declarar uma lista é o seguinte:
-            // List<tipodado> <var nome> = new List<tipodado>();
-            List<int> intList = new List<int>();
-            List<string> stringList = new List<string>();
-            List<int> z = new List<int> { 9000, 1000, 1337 }; // inicializar
-            // O <> são para genéricos - Confira está interessante seção do material
-
-            // Lista não possuem valores padrão.
-            // Um valor deve ser adicionado antes e depois acessado pelo indexador
-            intList.Add(1);
-            Console.WriteLine("intList @ 0: " + intList[0]);
-
-            // Outras estruturas de dados para conferir:
-            // Pilha/Fila
-            // Dicionário (uma implementação de map de hash)
-            // HashSet
-            // Read-only Coleção
-            // Tuple (.Net 4+)
-
-            ///////////////////////////////////////
-            // Operadores
-            ///////////////////////////////////////
-            Console.WriteLine("\n->Operators");
-
-            int i1 = 1, i2 = 2; // Forma curta para declarar diversas variáveis
-
-            // Aritmética é clara
-            Console.WriteLine(i1 + i2 - i1 * 3 / 7); // => 3
-
-            // Modulo
-            Console.WriteLine("11%3 = " + (11 % 3)); // => 2
-
-            // Comparações de operadores
-            Console.WriteLine("3 == 2? " + (3 == 2)); // => falso
-            Console.WriteLine("3 != 2? " + (3 != 2)); // => verdadeiro
-            Console.WriteLine("3 > 2? " + (3 > 2)); // => verdadeiro
-            Console.WriteLine("3 < 2? " + (3 < 2)); // => falso
-            Console.WriteLine("2 <= 2? " + (2 <= 2)); // => verdadeiro
-            Console.WriteLine("2 >= 2? " + (2 >= 2)); // => verdadeiro
-
-            // Operadores bit a bit (bitwise)
-            /*
-            ~       Unário bitwise complemento
-            <<      Signed left shift
-            >>      Signed right shift
-            &       Bitwise AND
-            ^       Bitwise exclusivo OR
-            |       Bitwise inclusivo OR
-            */
-
-            // Incrementações
-            int i = 0;
-            Console.WriteLine("\n->Inc/Dec-rementation");
-            Console.WriteLine(i++); //i = 1. Post-Incrementation
-            Console.WriteLine(++i); //i = 2. Pre-Incrementation
-            Console.WriteLine(i--); //i = 1. Post-Decrementation
-            Console.WriteLine(--i); //i = 0. Pre-Decrementation
-
-            ///////////////////////////////////////
-            // Estrutura de Controle
-            ///////////////////////////////////////
-            Console.WriteLine("\n->Control Structures");
-
-            // Declaração if é como a linguagem C
-            int j = 10;
-            if (j == 10)
-            {
-                Console.WriteLine("I get printed");
-            }
-            else if (j > 10)
-            {
-                Console.WriteLine("I don't");
-            }
-            else
-            {
-                Console.WriteLine("I also don't");
-            }
-
-            // Operador Ternário
-            // Um simples if/else pode ser escrito da seguinte forma
-            // <condição> ? <verdadeiro> : <falso>
-            int toCompare = 17;
-            string isTrue = toCompare == 17 ? "True" : "False";
-
-            // While loop
-            int fooWhile = 0;
-            while (fooWhile < 100)
-            {
-                //Iterated 100 times, fooWhile 0->99
-                fooWhile++;
-            }
-
-            // Do While Loop
-            int fooDoWhile = 0;
-            do
-            {
-                // Inicia a interação 100 vezes, fooDoWhile 0->99
-                if (false)
-                    continue; // pule a intereção atual para apróxima
-
-                fooDoWhile++;
-
-                if (fooDoWhile == 50)
-                    break; // Interrompe o laço inteiro
-
-            } while (fooDoWhile < 100);
-
-            //estrutura de loop for  => for(<declaração para começar>; <condicional>; <passos>)
-            for (int fooFor = 0; fooFor < 10; fooFor++)
-            {
-                //Iterado 10 vezes, fooFor 0->9
-            }
-
-            // For Each Loop
-            // Estrutura do foreach  => foreach(<Tipo Iterador> <Nome do Iterador> in <enumerable>)
-            // O laço foreach  percorre sobre qualquer objeto que implementa IEnumerable ou IEnumerable<T>
-            // Toda a coleção de tipos  (Array, List, Dictionary...) no .Net framework
-            // implementa uma ou mais destas interfaces.
-            // (O ToCharArray() pode ser removido, por que uma string também implementa IEnumerable)
-            foreach (char character in "Hello World".ToCharArray())
-            {
-                //Iterated over all the characters in the string
-            }
-
-            // Switch Case
-            // Um switch funciona com os tipos de dados byte, short, char, e int.
-            // Isto também funcional com tipos enumeradors (discutidos em Tipos Enum),
-            // A classe String, and a few special classes that wrap
-            // tipos primitívos: Character, Byte, Short, and Integer.
-            int month = 3;
-            string monthString;
-            switch (month)
-            {
-                case 1:
-                    monthString = "January";
-                    break;
-                case 2:
-                    monthString = "February";
-                    break;
-                case 3:
-                    monthString = "March";
-                    break;
-                // You can assign more than one case to an action
-                // But you can't add an action without a break before another case
-                // (if you want to do this, you would have to explicitly add a goto case x
-                case 6:
-                case 7:
-                case 8:
-                    monthString = "Summer time!!";
-                    break;
-                default:
-                    monthString = "Some other month";
-                    break;
-            }
-
-            ///////////////////////////////////////
-            // Converting Data Types And Typecasting
-            ///////////////////////////////////////
-
-            // Converting data
-
-            // Convert String To Integer
-            // this will throw a FormatException on failure
-            int.Parse("123");//returns an integer version of "123"
-
-            // try parse will default to type default on failure
-            // in this case: 0
-            int tryInt;
-            if (int.TryParse("123", out tryInt)) // Function is boolean
-                Console.WriteLine(tryInt);       // 123
-
-            // Convert Integer To String
-            // Convert class has a number of methods to facilitate conversions
-            Convert.ToString(123);
-            // or
-            tryInt.ToString();
-
-            // Casting
-            // Cast decimal 15 to a int
-            // and then implicitly cast to long
-            long x = (int) 15M;
-        }
-
-        ///////////////////////////////////////
-        // CLASSES - see definitions at end of file
-        ///////////////////////////////////////
-        public static void Classes()
-        {
-            // See Declaration of objects at end of file
-
-            // Use new to instantiate a class
-            Bicycle trek = new Bicycle();
-
-            // Call object methods
-            trek.SpeedUp(3); // You should always use setter and getter methods
-            trek.Cadence = 100;
-
-            // ToString is a convention to display the value of this Object.
-            Console.WriteLine("trek info: " + trek.Info());
-
-            // Instantiate a new Penny Farthing
-            PennyFarthing funbike = new PennyFarthing(1, 10);
-            Console.WriteLine("funbike info: " + funbike.Info());
-
-            Console.Read();
-        } // End main method
-
-        // CONSOLE ENTRY A console application must have a main method as an entry point
-        public static void Main(string[] args)
-        {
-            OtherInterestingFeatures();
-        }
-
-        //
-        // INTERESTING FEATURES
-        //
-
-        // DEFAULT METHOD SIGNATURES
-
-        public // Visibility
-        static // Allows for direct call on class without object
-        int // Return Type,
-        MethodSignatures(
-            int maxCount, // First variable, expects an int
-            int count = 0, // will default the value to 0 if not passed in
-            int another = 3,
-            params string[] otherParams // captures all other parameters passed to method
-        )
-        {
-            return -1;
-        }
-
-        // Methods can have the same name, as long as the signature is unique
-        // A method that differs only in return type is not unique
-        public static void MethodSignatures(
-            ref int maxCount, // Pass by reference
-            out int count)
-        {
-            count = 15; // out param must be assigned before control leaves the method
-        }
-
-        // GENERICS
-        // The classes for TKey and TValue is specified by the user calling this function.
-        // This method emulates the SetDefault of Python
-        public static TValue SetDefault<TKey, TValue>(
-            IDictionary<TKey, TValue> dictionary,
-            TKey key,
-            TValue defaultItem)
-        {
-            TValue result;
-            if (!dictionary.TryGetValue(key, out result))
-                return dictionary[key] = defaultItem;
-            return result;
-        }
-
-        // You can narrow down the objects that are passed in
-        public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>
-        {
-            // We can iterate, since T is a IEnumerable
-            foreach (var item in toPrint)
-                // Item is an int
-                Console.WriteLine(item.ToString());
-        }
-
-        public static void OtherInterestingFeatures()
-        {
-            // OPTIONAL PARAMETERS
-            MethodSignatures(3, 1, 3, "Some", "Extra", "Strings");
-            MethodSignatures(3, another: 3); // explicity set a parameter, skipping optional ones
-
-            // BY REF AND OUT PARAMETERS
-            int maxCount = 0, count; // ref params must have value
-            MethodSignatures(ref maxCount, out count);
-
-            // EXTENSION METHODS
-            int i = 3;
-            i.Print(); // Defined below
-
-            // NULLABLE TYPES - great for database interaction / return values
-            // any value type (i.e. not a class) can be made nullable by suffixing a ?
-            // <type>? <var name> = <value>
-            int? nullable = null; // short hand for Nullable<int>
-            Console.WriteLine("Nullable variable: " + nullable);
-            bool hasValue = nullable.HasValue; // true if not null
-
-            // ?? is syntactic sugar for specifying default value (coalesce)
-            // in case variable is null
-            int notNullable = nullable ?? 0; // 0
-
-            // IMPLICITLY TYPED VARIABLES - you can let the compiler work out what the type is:
-            var magic = "magic is a string, at compile time, so you still get type safety";
-            // magic = 9; will not work as magic is a string, not an int
-
-            // GENERICS
-            //
-            var phonebook = new Dictionary<string, string>() {
-                {"Sarah", "212 555 5555"} // Add some entries to the phone book
-            };
-
-            // Calling SETDEFAULT defined as a generic above
-            Console.WriteLine(SetDefault<string,string>(phonebook, "Shaun", "No Phone")); // No Phone
-            // nb, you don't need to specify the TKey and TValue since they can be
-            // derived implicitly
-            Console.WriteLine(SetDefault(phonebook, "Sarah", "No Phone")); // 212 555 5555
-
-            // LAMBDA EXPRESSIONS - allow you to write code in line
-            Func<int, int> square = (x) => x * x; // Last T item is the return value
-            Console.WriteLine(square(3)); // 9
-
-            // ERROR HANDLING - coping with an uncertain world
-            try
-            {
-                var funBike = PennyFarthing.CreateWithGears(6);
-
-                // will no longer execute because CreateWithGears throws an exception
-                string some = "";
-                if (true) some = null;
-                some.ToLower(); // throws a NullReferenceException
-            }
-            catch (NotSupportedException)
-            {
-                Console.WriteLine("Not so much fun now!");
-            }
-            catch (Exception ex) // catch all other exceptions
-            {
-                throw new ApplicationException("It hit the fan", ex);
-                // throw; // A rethrow that preserves the callstack
-            }
-            // catch { } // catch-all without capturing the Exception
-            finally
-            {
-                // executes after try or catch
-            }
-
-            // DISPOSABLE RESOURCES MANAGEMENT - let you handle unmanaged resources easily.
-            // Most of objects that access unmanaged resources (file handle, device contexts, etc.)
-            // implement the IDisposable interface. The using statement takes care of
-            // cleaning those IDisposable objects for you.
-            using (StreamWriter writer = new StreamWriter("log.txt"))
-            {
-                writer.WriteLine("Nothing suspicious here");
-                // At the end of scope, resources will be released.
-                // Even if an exception is thrown.
-            }
-
-            // PARALLEL FRAMEWORK
-            // http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx
-            var websites = new string[] {
-                "http://www.google.com", "http://www.reddit.com",
-                "http://www.shaunmccarthy.com"
-            };
-            var responses = new Dictionary<string, string>();
-
-            // Will spin up separate threads for each request, and join on them
-            // before going to the next step!
-            Parallel.ForEach(websites,
-                new ParallelOptions() {MaxDegreeOfParallelism = 3}, // max of 3 threads
-                website =>
-            {
-                // Do something that takes a long time on the file
-                using (var r = WebRequest.Create(new Uri(website)).GetResponse())
-                {
-                    responses[website] = r.ContentType;
-                }
-            });
-
-            // This won't happen till after all requests have been completed
-            foreach (var key in responses.Keys)
-                Console.WriteLine("{0}:{1}", key, responses[key]);
-
-            // DYNAMIC OBJECTS (great for working with other languages)
-            dynamic student = new ExpandoObject();
-            student.FirstName = "First Name"; // No need to define class first!
-
-            // You can even add methods (returns a string, and takes in a string)
-            student.Introduce = new Func<string, string>(
-                (introduceTo) => string.Format("Hey {0}, this is {1}", student.FirstName, introduceTo));
-            Console.WriteLine(student.Introduce("Beth"));
-
-            // IQUERYABLE<T> - almost all collections implement this, which gives you a lot of
-            // very useful Map / Filter / Reduce style methods
-            var bikes = new List<Bicycle>();
-            bikes.Sort(); // Sorts the array
-            bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels)); // Sorts based on wheels
-            var result = bikes
-                .Where(b => b.Wheels > 3) // Filters - chainable (returns IQueryable of previous type)
-                .Where(b => b.IsBroken && b.HasTassles)
-                .Select(b => b.ToString()); // Map - we only this selects, so result is a IQueryable<string>
-
-            var sum = bikes.Sum(b => b.Wheels); // Reduce - sums all the wheels in the collection
-
-            // Create a list of IMPLICIT objects based on some parameters of the bike
-            var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles });
-            // Hard to show here, but you get type ahead completion since the compiler can implicitly work
-            // out the types above!
-            foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome))
-                Console.WriteLine(bikeSummary.Name);
-
-            // ASPARALLEL
-            // And this is where things get wicked - combines linq and parallel operations
-            var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name);
-            // this will happen in parallel! Threads will automagically be spun up and the
-            // results divvied amongst them! Amazing for large datasets when you have lots of
-            // cores
-
-            // LINQ - maps a store to IQueryable<T> objects, with delayed execution
-            // e.g. LinqToSql - maps to a database, LinqToXml maps to an xml document
-            var db = new BikeRepository();
-
-            // execution is delayed, which is great when querying a database
-            var filter = db.Bikes.Where(b => b.HasTassles); // no query run
-            if (42 > 6) // You can keep adding filters, even conditionally - great for "advanced search" functionality
-                filter = filter.Where(b => b.IsBroken); // no query run
-
-            var query = filter
-                .OrderBy(b => b.Wheels)
-                .ThenBy(b => b.Name)
-                .Select(b => b.Name); // still no query run
-
-            // Now the query runs, but opens a reader, so only populates are you iterate through
-            foreach (string bike in query)
-                Console.WriteLine(result);
-
-
-
-        }
-
-    } // End LearnCSharp class
-
-    // You can include other classes in a .cs file
-
-    public static class Extensions
-    {
-        // EXTENSION FUNCTIONS
-        public static void Print(this object obj)
-        {
-            Console.WriteLine(obj.ToString());
-        }
-    }
-
-    // Class Declaration Syntax:
-    // <public/private/protected/internal> class <class name>{
-    //    //data fields, constructors, functions all inside.
-    //    //functions are called as methods in Java.
-    // }
-
-    public class Bicycle
-    {
-        // Bicycle's Fields/Variables
-        public int Cadence // Public: Can be accessed from anywhere
-        {
-            get // get - define a method to retrieve the property
-            {
-                return _cadence;
-            }
-            set // set - define a method to set a proprety
-            {
-                _cadence = value; // Value is the value passed in to the setter
-            }
-        }
-        private int _cadence;
-
-        protected virtual int Gear // Protected: Accessible from the class and subclasses
-        {
-            get; // creates an auto property so you don't need a member field
-            set;
-        }
-
-        internal int Wheels // Internal: Accessible from within the assembly
-        {
-            get;
-            private set; // You can set modifiers on the get/set methods
-        }
-
-        int _speed; // Everything is private by default: Only accessible from within this class.
-                    // can also use keyword private
-        public string Name { get; set; }
-
-        // Enum is a value type that consists of a set of named constants
-        // It is really just mapping a name to a value (an int, unless specified otherwise).
-        // The approved types for an enum are byte, sbyte, short, ushort, int, uint, long, or ulong.
-        // An enum can't contain the same value twice.
-        public enum BikeBrand
-        {
-            AIST,
-            BMC,
-            Electra = 42, //you can explicitly set a value to a name
-            Gitane // 43
-        }
-        // We defined this type inside a Bicycle class, so it is a nested type
-        // Code outside of this class should reference this type as Bicycle.Brand
-
-        public BikeBrand Brand; // After declaring an enum type, we can declare the field of this type
-
-        // Decorate an enum with the FlagsAttribute to indicate that multiple values can be switched on
-        [Flags] // Any class derived from Attribute can be used to decorate types, methods, parameters etc
-        public enum BikeAccessories
-        {
-            None = 0,
-            Bell = 1,
-            MudGuards = 2, // need to set the values manually!
-            Racks = 4,
-            Lights = 8,
-            FullPackage = Bell | MudGuards | Racks | Lights
-        }
-
-        // Usage: aBike.Accessories.HasFlag(Bicycle.BikeAccessories.Bell)
-        // Before .NET 4: (aBike.Accessories & Bicycle.BikeAccessories.Bell) == Bicycle.BikeAccessories.Bell
-        public BikeAccessories Accessories { get; set; }
-
-        // Static members belong to the type itself rather then specific object.
-        // You can access them without a reference to any object:
-        // Console.WriteLine("Bicycles created: " + Bicycle.bicyclesCreated);
-        public static int BicyclesCreated { get; set; }
-
-        // readonly values are set at run time
-        // they can only be assigned upon declaration or in a constructor
-        readonly bool _hasCardsInSpokes = false; // read-only private
-
-        // Constructors are a way of creating classes
-        // This is a default constructor
-        public Bicycle()
-        {
-            this.Gear = 1; // you can access members of the object with the keyword this
-            Cadence = 50;  // but you don't always need it
-            _speed = 5;
-            Name = "Bontrager";
-            Brand = BikeBrand.AIST;
-            BicyclesCreated++;
-        }
-
-        // This is a specified constructor (it contains arguments)
-        public Bicycle(int startCadence, int startSpeed, int startGear,
-                       string name, bool hasCardsInSpokes, BikeBrand brand)
-            : base() // calls base first
-        {
-            Gear = startGear;
-            Cadence = startCadence;
-            _speed = startSpeed;
-            Name = name;
-            _hasCardsInSpokes = hasCardsInSpokes;
-            Brand = brand;
-        }
-
-        // Constructors can be chained
-        public Bicycle(int startCadence, int startSpeed, BikeBrand brand) :
-            this(startCadence, startSpeed, 0, "big wheels", true, brand)
-        {
-        }
-
-        // Function Syntax:
-        // <public/private/protected> <return type> <function name>(<args>)
-
-        // classes can implement getters and setters for their fields
-        // or they can implement properties (this is the preferred way in C#)
-
-        // Method parameters can have default values.
-        // In this case, methods can be called with these parameters omitted
-        public void SpeedUp(int increment = 1)
-        {
-            _speed += increment;
-        }
-
-        public void SlowDown(int decrement = 1)
-        {
-            _speed -= decrement;
-        }
-
-        // properties get/set values
-        // when only data needs to be accessed, consider using properties.
-        // properties may have either get or set, or both
-        private bool _hasTassles; // private variable
-        public bool HasTassles // public accessor
-        {
-            get { return _hasTassles; }
-            set { _hasTassles = value; }
-        }
-
-        // You can also define an automatic property in one line
-        // this syntax will create a backing field automatically.
-        // You can set an access modifier on either the getter or the setter (or both)
-        // to restrict its access:
-        public bool IsBroken { get; private set; }
-
-        // Properties can be auto-implemented
-        public int FrameSize
-        {
-            get;
-            // you are able to specify access modifiers for either get or set
-            // this means only Bicycle class can call set on Framesize
-            private set;
-        }
-
-        // It's also possible to define custom Indexers on objects.
-        // All though this is not entirely useful in this example, you
-        // could do bicycle[0] which yields "chris" to get the first passenger or
-        // bicycle[1] = "lisa" to set the passenger. (of this apparent quattrocycle)
-        private string[] passengers = { "chris", "phil", "darren", "regina" };
-
-        public string this[int i]
-        {
-            get {
-                return passengers[i];
-            }
-
-            set {
-                return passengers[i] = value;
-            }
-        }
-
-        //Method to display the attribute values of this Object.
-        public virtual string Info()
-        {
-            return "Gear: " + Gear +
-                    " Cadence: " + Cadence +
-                    " Speed: " + _speed +
-                    " Name: " + Name +
-                    " Cards in Spokes: " + (_hasCardsInSpokes ? "yes" : "no") +
-                    "\n------------------------------\n"
-                    ;
-        }
-
-        // Methods can also be static. It can be useful for helper methods
-        public static bool DidWeCreateEnoughBycles()
-        {
-            // Within a static method, we only can reference static class members
-            return BicyclesCreated > 9000;
-        } // If your class only needs static members, consider marking the class itself as static.
-
-
-    } // end class Bicycle
-
-    // PennyFarthing is a subclass of Bicycle
-    class PennyFarthing : Bicycle
-    {
-        // (Penny Farthings are those bicycles with the big front wheel.
-        // They have no gears.)
-
-        // calling parent constructor
-        public PennyFarthing(int startCadence, int startSpeed) :
-            base(startCadence, startSpeed, 0, "PennyFarthing", true, BikeBrand.Electra)
-        {
-        }
-
-        protected override int Gear
-        {
-            get
-            {
-                return 0;
-            }
-            set
-            {
-                throw new InvalidOperationException("You can't change gears on a PennyFarthing");
-            }
-        }
-
-        public static PennyFarthing CreateWithGears(int gears)
-        {
-            var penny = new PennyFarthing(1, 1);
-            penny.Gear = gears; // Oops, can't do this!
-            return penny;
-        }
-
-        public override string Info()
-        {
-            string result = "PennyFarthing bicycle ";
-            result += base.ToString(); // Calling the base version of the method
-            return result;
-        }
-    }
-
-    // Interfaces only contain signatures of the members, without the implementation.
-    interface IJumpable
-    {
-        void Jump(int meters); // all interface members are implicitly public
-    }
-
-    interface IBreakable
-    {
-        bool Broken { get; } // interfaces can contain properties as well as methods & events
-    }
-
-    // Class can inherit only one other class, but can implement any amount of interfaces
-    class MountainBike : Bicycle, IJumpable, IBreakable
-    {
-        int damage = 0;
-
-        public void Jump(int meters)
-        {
-            damage += meters;
-        }
-
-        public bool Broken
-        {
-            get
-            {
-                return damage > 100;
-            }
-        }
-    }
-
-    /// <summary>
-    /// Used to connect to DB for LinqToSql example.
-    /// EntityFramework Code First is awesome (similar to Ruby's ActiveRecord, but bidirectional)
-    /// http://msdn.microsoft.com/en-us/data/jj193542.aspx
-    /// </summary>
-    public class BikeRepository : DbContext
-    {
-        public BikeRepository()
-            : base()
-        {
-        }
-
-        public DbSet<Bicycle> Bikes { get; set; }
-    }
-} // End Namespace
-```
-
-## Topics Not Covered
-
- * Attributes
- * async/await, yield, pragma directives
- * Web Development
- 	* ASP.NET MVC & WebApi (new)
- 	* ASP.NET Web Forms (old)
- 	* WebMatrix (tool)
- * Desktop Development
- 	* Windows Presentation Foundation (WPF) (new)
- 	* Winforms (old)
-
-## Further Reading
-
- * [DotNetPerls](http://www.dotnetperls.com)
- * [C# in Depth](http://manning.com/skeet2)
- * [Programming C#](http://shop.oreilly.com/product/0636920024064.do)
- * [LINQ](http://shop.oreilly.com/product/9780596519254.do)
- * [MSDN Library](http://msdn.microsoft.com/en-us/library/618ayhy6.aspx)
- * [ASP.NET MVC Tutorials](http://www.asp.net/mvc/tutorials)
- * [ASP.NET Web Matrix Tutorials](http://www.asp.net/web-pages/tutorials)
- * [ASP.NET Web Forms Tutorials](http://www.asp.net/web-forms/tutorials)
- * [Windows Forms Programming in C#](http://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208)
- * [C# Coding Conventions](http://msdn.microsoft.com/en-us/library/vstudio/ff926074.aspx)
diff --git a/pt-br/elixir-pt.html.markdown b/pt-br/elixir-pt.html.markdown
new file mode 100644
index 00000000..f8c56101
--- /dev/null
+++ b/pt-br/elixir-pt.html.markdown
@@ -0,0 +1,412 @@
+---
+language: elixir
+contributors:
+    - ["Joao Marques", "http://github.com/mrshankly"]
+    - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+translators:
+    - ["Rodrigo Muniz", "http://github.com/muniz95"]
+lang: pt-br
+filename: learnelixir-pt.ex
+---
+
+Elixir é uma linguagem funcional moderna construída no topo da Erlang VM.
+É totalmente compatível com Erlang, porém conta com uma sintaxe mais padronizada
+e muitos outros recursos.
+
+```elixir
+
+# Comentários de linha única começam com um símbolo de número.
+
+# Não há comentários de múltiplas linhas,
+# mas você pode empilhar os comentários.
+
+# Para usar o shell do elixir use o comando `iex`.
+# Compile seus módulos com o comando `elixirc`.
+
+# Ambos devem estar em seu path se você instalou o Elixir corretamente.
+
+## ---------------------------
+## -- Tipos Básicos
+## ---------------------------
+
+# Há números
+3    # integer
+0x1F # integer
+3.0  # float
+
+# Atoms, que são literais, uma constante com nome. Elas começam com `:`.
+:hello # atom
+
+# Tuplas que são guardadas contiguamente em memória.
+{1,2,3} # tupla
+
+# Podemos acessar um elemento de uma tupla om a função `elem`:
+elem({1, 2, 3}, 0) #=> 1
+
+# Listas que são implementadas como listas ligadas.
+[1,2,3] # lista
+
+# Podemos acessar a primeira posição (head) e o resto (tail) de uma lista como a seguir:
+[head | tail] = [1,2,3]
+head #=> 1
+tail #=> [2,3]
+
+# Em elixir, bem como em Erlang, o sinal `=` denota pattern match,
+# e não uma atribuição.
+#
+# Isto significa que o que estiver à esquerda (pattern) é comparado com o que
+# estiver à direita.
+#
+# É assim que o exemplo acima de acesso à head e tail de uma lista funciona.
+
+# Um pattern match retornará erro quando os lados não conferem, como neste exemplo
+# onde as tuplas tem diferentes tamanhos.
+# {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}
+
+# Também há binários
+<<1,2,3>> # binary
+
+# Strings e char lists
+"hello" # string
+'hello' # char list
+
+# Strings de múltiplas linhas
+"""
+Strings
+de múltiplas
+linhas.
+"""
+#=> "Strings\nde múltiplas\nlinhas"
+
+# Strings são sempre codificadas em UTF-8:
+"héllò" #=> "héllò"
+
+# Strings são de fato apenas binários, e char lists apenas listas.
+<<?a, ?b, ?c>> #=> "abc"
+[?a, ?b, ?c]   #=> 'abc'
+
+# `?a` em elixir retorna o valor ASCII para a letra `a`
+?a #=> 97
+
+# Para concatenar listas use `++`, para binários use `<>`
+[1,2,3] ++ [4,5]     #=> [1,2,3,4,5]
+'hello ' ++ 'world'  #=> 'hello world'
+
+<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>
+"hello " <> "world"  #=> "hello world"
+
+# Ranges são representados como `início..fim` (ambos inclusivos)
+1..10 #=> 1..10
+menor..maior = 1..10 # Pattern matching pode ser usada em ranges também
+[lower, upper] #=> [1, 10]
+
+## ---------------------------
+## -- Operadores
+## ---------------------------
+
+# Matemática básica
+1 + 1  #=> 2
+10 - 5 #=> 5
+5 * 2  #=> 10
+10 / 2 #=> 5.0
+
+# Em elixir o operador `/` sempre retorna um float.
+
+# Para divisão de inteiros use `div`
+div(10, 2) #=> 5
+
+# Para obter o resto da divisão use `rem`
+rem(10, 3) #=> 1
+
+# Há também operadores booleanos: `or`, `and` e `not`.
+# Estes operadores esperam um booleano como primeiro argumento.
+true and true #=> true
+false or true #=> true
+# 1 and true    #=> ** (ArgumentError) argument error
+
+# Elixir também fornece `||`, `&&` e `!` que aceitam argumentos de qualquer tipo.
+# Todos os valores exceto `false` e `nil` serão avaliados como true.
+1 || true  #=> 1
+false && 1 #=> false
+nil && 20  #=> nil
+!true #=> false
+
+# Para comparações temos: `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` e `>`
+1 == 1 #=> true
+1 != 1 #=> false
+1 < 2  #=> true
+
+# `===` e `!==` são mais estritos ao comparar integers e floats:
+1 == 1.0  #=> true
+1 === 1.0 #=> false
+
+# Podemos comparar também dois tipos de dados diferentes:
+1 < :hello #=> true
+
+# A regra de ordenação no geral é definida abaixo:
+# number < atom < reference < functions < port < pid < tuple < list < bit string
+
+# Ao citar Joe Armstrong nisto: "A ordem de fato não é importante,
+# mas que uma ordem total esteja bem definida é importante."
+
+## ---------------------------
+## -- Fluxo de Controle
+## ---------------------------
+
+# expressão `if` 
+if false do
+  "Isso nunca será visto"
+else
+  "Isso será"
+end
+
+# Também há `unless`
+unless true do
+  "Isso nunca será visto"
+else
+  "Isso será"
+end
+
+# Lembra do patter matching? Muitas estruturas de fluxo de controle em elixir contam com ela.
+
+# `case` nos permite comparar um valor com muitos patterns:
+case {:um, :dois} do
+  {:quatro, :cinco} ->
+    "Isso não corresponde"
+  {:um, x} ->
+    "Isso corresponde e vincula `x` a `:dois`"
+  _ ->
+    "Isso corresponde a qualquer valor"
+end
+
+# É comum vincular o valor a `_` se não precisamos dele.
+# Por exemplo, se apenas a head de uma lista nos interessa:
+[head | _] = [1,2,3]
+head #=> 1
+
+# Para melhor legibilidade podemos fazer o seguinte:
+[head | _tail] = [:a, :b, :c]
+head #=> :a
+
+# `cond` nos permite verificar várias condições ao mesmo tempo.
+# Use `cond` em vez de aninhar vários `if`'s.
+cond do
+  1 + 1 == 3 ->
+    "Nunca serei visto"
+  2 * 5 == 12 ->
+    "Nem eu"
+  1 + 2 == 3 ->
+    "Mas eu serei"
+end
+
+# É comum definir a última condição igual a `true`, que sempre irá corresponder.
+cond do
+  1 + 1 == 3 ->
+    "Nunca serei visto"
+  2 * 5 == 12 ->
+    "Nem eu"
+  true ->
+    "Mas eu serei (isso é essencialmente um else)"
+end
+
+# `try/catch` é usado para capturar valores que são lançados, também suporta uma
+# cláusula `after` que é invocada havendo um valor capturado ou não.
+try do
+  throw(:hello)
+catch
+  message -> "Deu #{mensagem}."
+after
+  IO.puts("Sou o after.")
+end
+#=> Sou o after
+# "Deu :hello"
+
+## ---------------------------
+## -- Módulos e Funções
+## ---------------------------
+
+# Funções Anônimas (repare o ponto)
+square = fn(x) -> x * x end
+square.(5) #=> 25
+
+# Elas também aceitam várias cláusulas e guards.
+# Guards permitem ajustes finos de pattern matching,
+# sendo indicados pela palavra `when`:
+f = fn
+  x, y when x > 0 -> x + y
+  x, y -> x * y
+end
+
+f.(1, 3)  #=> 4
+f.(-1, 3) #=> -3
+
+# Elixir também fornece várias funções embutidas.
+# Estas estão disponíveis no escopo atual.
+is_number(10)    #=> true
+is_list("ola") #=> false
+elem({1,2,3}, 0) #=> 1
+
+# Você pode agrupar algumas funções em um módulo. Dentro de um módulo use `def`
+# para definir suas funções.
+defmodule Math do
+  def sum(a, b) do
+    a + b
+  end
+
+  def square(x) do
+    x * x
+  end
+end
+
+Math.sum(1, 2)  #=> 3
+Math.square(3) #=> 9
+
+# Para compilar o módulo Math salve-o como `math.ex` e use `elixirc`
+# em seu terminal: elixirc math.ex
+
+# Dentro de um módulo podemos definir funções com `def` e funções privadas com `defp`.
+# Uma função definida com `def` pode ser invocada por outros módulos,
+# já uma função privada pode ser invocada apenas localmente.
+defmodule PrivateMath do
+  def sum(a, b) do
+    do_sum(a, b)
+  end
+
+  defp do_sum(a, b) do
+    a + b
+  end
+end
+
+PrivateMath.sum(1, 2)    #=> 3
+# PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError)
+
+# Declarações de funções também suportam guards cláusulas múltiplas:
+defmodule Geometry do
+  def area({:rectangle, w, h}) do
+    w * h
+  end
+
+  def area({:circle, r}) when is_number(r) do
+    3.14 * r * r
+  end
+end
+
+Geometry.area({:rectangle, 2, 3}) #=> 6
+Geometry.area({:circle, 3})       #=> 28.25999999999999801048
+# Geometry.area({:circle, "not_a_number"})
+#=> ** (FunctionClauseError) no function clause matching in Geometry.area/1
+
+# Devido à imutabilidade, recursão é uma grande parte do elixir
+defmodule Recursion do
+  def sum_list([head | tail], acc) do
+    sum_list(tail, acc + head)
+  end
+
+  def sum_list([], acc) do
+    acc
+  end
+end
+
+Recursion.sum_list([1,2,3], 0) #=> 6
+
+# Módulos do elixir suportam atributos, hpa atributos embutidos e você
+# pode também adicionar os seus próprios.
+defmodule MyMod do
+  @moduledoc """
+  Este é um atributo embutido em um módulo de exemplo.
+  """
+
+  @my_data 100 # Este é um atributo customizado.
+  IO.inspect(@my_data) #=> 100
+end
+
+## ---------------------------
+## -- Structs e Exceptions
+## ---------------------------
+
+# Structs são extensões no topo de mapas que trazem valores padrão,
+# garantias em tempo de compilação e polimorfismo para o Elixir.
+defmodule Pessoa do
+  defstruct nome: nil, idade: 0, peso: 0
+end
+
+joe_info = %Pessoa{ nome: "Joe", idade: 30, peso: 180 }
+#=> %Pessoa{idade: 30, peso: 180, nome: "Joe"}
+
+# Acessa o valor de nome
+joe_info.name #=> "Joe"
+
+# Atualiza o valor de idade
+older_joe_info = %{ joe_info | idade: 31 }
+#=> %Pessoa{idade: 31, peso: 180, nome: "Joe"}
+
+# O bloco `try` com a palavra `rescue` é usado para manipular exceções
+try do
+  raise "algum erro"
+rescue
+  RuntimeError -> "resgatado um erro em tempo de execução"
+  _error -> "isso resgatará qualquer erro"
+end
+
+# Toda exceção possui uma mensagem
+try do
+  raise "algum erro"
+rescue
+  x in [RuntimeError] ->
+    x.message
+end
+
+## ---------------------------
+## -- Concorrência
+## ---------------------------
+
+# Elixir conta com o modelo de ator para concorrência. Tudo o que precisamos para
+# escrever programas concorrentes em elixir são três primitivos: spawning processes,
+# sending messages e receiving messages.
+
+# Para iniciar um novo processo usamos a função `spawn`, a qual leva uma função
+# como argumento.
+f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
+spawn(f) #=> #PID<0.40.0>
+
+# `spawn` retorna um pid (process identifier), você pode usar esse pid para enviar
+# mensagens ao processo. Para envio de mensagens usamos o operador `send`.
+# Para tudo isso ser útil precisamos estar aptos a receber mensagens. Isto é
+# realizado com o mecanismo `receive`:
+defmodule Geometry do
+  def area_loop do
+    receive do
+      {:rectangle, w, h} ->
+        IO.puts("Area = #{w * h}")
+        area_loop()
+      {:circle, r} ->
+        IO.puts("Area = #{3.14 * r * r}")
+        area_loop()
+    end
+  end
+end
+
+# Compile o módulo e crie um processo que avalie `area_loop` no shell
+pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0>
+
+# Envia uma mensagem ao `pid` correspondente a um pattern na declaração de recebimento
+send pid, {:rectangle, 2, 3}
+#=> Area = 6
+#   {:rectangle,2,3}
+
+send pid, {:circle, 2}
+#=> Area = 12.56000000000000049738
+#   {:circle,2}
+
+# O shell também é um processo, você pode usar `self` para obter o pid atual
+self() #=> #PID<0.27.0>
+```
+
+## Referências
+
+* [Getting started guide](http://elixir-lang.org/getting_started/1.html) da [página do elixir](http://elixir-lang.org)
+* [Elixir Documentation](http://elixir-lang.org/docs/master/)
+* ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) por Dave Thomas
+* [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
+* ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) por Fred Hebert
+* ["Programming Erlang: Software for a Concurrent World"](https://pragprog.com/book/jaerlang2/programming-erlang) por Joe Armstrong
diff --git a/pt-br/elixir.html.markdown b/pt-br/elixir.html.markdown
deleted file mode 100644
index f8c56101..00000000
--- a/pt-br/elixir.html.markdown
+++ /dev/null
@@ -1,412 +0,0 @@
----
-language: elixir
-contributors:
-    - ["Joao Marques", "http://github.com/mrshankly"]
-    - ["Dzianis Dashkevich", "https://github.com/dskecse"]
-translators:
-    - ["Rodrigo Muniz", "http://github.com/muniz95"]
-lang: pt-br
-filename: learnelixir-pt.ex
----
-
-Elixir é uma linguagem funcional moderna construída no topo da Erlang VM.
-É totalmente compatível com Erlang, porém conta com uma sintaxe mais padronizada
-e muitos outros recursos.
-
-```elixir
-
-# Comentários de linha única começam com um símbolo de número.
-
-# Não há comentários de múltiplas linhas,
-# mas você pode empilhar os comentários.
-
-# Para usar o shell do elixir use o comando `iex`.
-# Compile seus módulos com o comando `elixirc`.
-
-# Ambos devem estar em seu path se você instalou o Elixir corretamente.
-
-## ---------------------------
-## -- Tipos Básicos
-## ---------------------------
-
-# Há números
-3    # integer
-0x1F # integer
-3.0  # float
-
-# Atoms, que são literais, uma constante com nome. Elas começam com `:`.
-:hello # atom
-
-# Tuplas que são guardadas contiguamente em memória.
-{1,2,3} # tupla
-
-# Podemos acessar um elemento de uma tupla om a função `elem`:
-elem({1, 2, 3}, 0) #=> 1
-
-# Listas que são implementadas como listas ligadas.
-[1,2,3] # lista
-
-# Podemos acessar a primeira posição (head) e o resto (tail) de uma lista como a seguir:
-[head | tail] = [1,2,3]
-head #=> 1
-tail #=> [2,3]
-
-# Em elixir, bem como em Erlang, o sinal `=` denota pattern match,
-# e não uma atribuição.
-#
-# Isto significa que o que estiver à esquerda (pattern) é comparado com o que
-# estiver à direita.
-#
-# É assim que o exemplo acima de acesso à head e tail de uma lista funciona.
-
-# Um pattern match retornará erro quando os lados não conferem, como neste exemplo
-# onde as tuplas tem diferentes tamanhos.
-# {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}
-
-# Também há binários
-<<1,2,3>> # binary
-
-# Strings e char lists
-"hello" # string
-'hello' # char list
-
-# Strings de múltiplas linhas
-"""
-Strings
-de múltiplas
-linhas.
-"""
-#=> "Strings\nde múltiplas\nlinhas"
-
-# Strings são sempre codificadas em UTF-8:
-"héllò" #=> "héllò"
-
-# Strings são de fato apenas binários, e char lists apenas listas.
-<<?a, ?b, ?c>> #=> "abc"
-[?a, ?b, ?c]   #=> 'abc'
-
-# `?a` em elixir retorna o valor ASCII para a letra `a`
-?a #=> 97
-
-# Para concatenar listas use `++`, para binários use `<>`
-[1,2,3] ++ [4,5]     #=> [1,2,3,4,5]
-'hello ' ++ 'world'  #=> 'hello world'
-
-<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>
-"hello " <> "world"  #=> "hello world"
-
-# Ranges são representados como `início..fim` (ambos inclusivos)
-1..10 #=> 1..10
-menor..maior = 1..10 # Pattern matching pode ser usada em ranges também
-[lower, upper] #=> [1, 10]
-
-## ---------------------------
-## -- Operadores
-## ---------------------------
-
-# Matemática básica
-1 + 1  #=> 2
-10 - 5 #=> 5
-5 * 2  #=> 10
-10 / 2 #=> 5.0
-
-# Em elixir o operador `/` sempre retorna um float.
-
-# Para divisão de inteiros use `div`
-div(10, 2) #=> 5
-
-# Para obter o resto da divisão use `rem`
-rem(10, 3) #=> 1
-
-# Há também operadores booleanos: `or`, `and` e `not`.
-# Estes operadores esperam um booleano como primeiro argumento.
-true and true #=> true
-false or true #=> true
-# 1 and true    #=> ** (ArgumentError) argument error
-
-# Elixir também fornece `||`, `&&` e `!` que aceitam argumentos de qualquer tipo.
-# Todos os valores exceto `false` e `nil` serão avaliados como true.
-1 || true  #=> 1
-false && 1 #=> false
-nil && 20  #=> nil
-!true #=> false
-
-# Para comparações temos: `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` e `>`
-1 == 1 #=> true
-1 != 1 #=> false
-1 < 2  #=> true
-
-# `===` e `!==` são mais estritos ao comparar integers e floats:
-1 == 1.0  #=> true
-1 === 1.0 #=> false
-
-# Podemos comparar também dois tipos de dados diferentes:
-1 < :hello #=> true
-
-# A regra de ordenação no geral é definida abaixo:
-# number < atom < reference < functions < port < pid < tuple < list < bit string
-
-# Ao citar Joe Armstrong nisto: "A ordem de fato não é importante,
-# mas que uma ordem total esteja bem definida é importante."
-
-## ---------------------------
-## -- Fluxo de Controle
-## ---------------------------
-
-# expressão `if` 
-if false do
-  "Isso nunca será visto"
-else
-  "Isso será"
-end
-
-# Também há `unless`
-unless true do
-  "Isso nunca será visto"
-else
-  "Isso será"
-end
-
-# Lembra do patter matching? Muitas estruturas de fluxo de controle em elixir contam com ela.
-
-# `case` nos permite comparar um valor com muitos patterns:
-case {:um, :dois} do
-  {:quatro, :cinco} ->
-    "Isso não corresponde"
-  {:um, x} ->
-    "Isso corresponde e vincula `x` a `:dois`"
-  _ ->
-    "Isso corresponde a qualquer valor"
-end
-
-# É comum vincular o valor a `_` se não precisamos dele.
-# Por exemplo, se apenas a head de uma lista nos interessa:
-[head | _] = [1,2,3]
-head #=> 1
-
-# Para melhor legibilidade podemos fazer o seguinte:
-[head | _tail] = [:a, :b, :c]
-head #=> :a
-
-# `cond` nos permite verificar várias condições ao mesmo tempo.
-# Use `cond` em vez de aninhar vários `if`'s.
-cond do
-  1 + 1 == 3 ->
-    "Nunca serei visto"
-  2 * 5 == 12 ->
-    "Nem eu"
-  1 + 2 == 3 ->
-    "Mas eu serei"
-end
-
-# É comum definir a última condição igual a `true`, que sempre irá corresponder.
-cond do
-  1 + 1 == 3 ->
-    "Nunca serei visto"
-  2 * 5 == 12 ->
-    "Nem eu"
-  true ->
-    "Mas eu serei (isso é essencialmente um else)"
-end
-
-# `try/catch` é usado para capturar valores que são lançados, também suporta uma
-# cláusula `after` que é invocada havendo um valor capturado ou não.
-try do
-  throw(:hello)
-catch
-  message -> "Deu #{mensagem}."
-after
-  IO.puts("Sou o after.")
-end
-#=> Sou o after
-# "Deu :hello"
-
-## ---------------------------
-## -- Módulos e Funções
-## ---------------------------
-
-# Funções Anônimas (repare o ponto)
-square = fn(x) -> x * x end
-square.(5) #=> 25
-
-# Elas também aceitam várias cláusulas e guards.
-# Guards permitem ajustes finos de pattern matching,
-# sendo indicados pela palavra `when`:
-f = fn
-  x, y when x > 0 -> x + y
-  x, y -> x * y
-end
-
-f.(1, 3)  #=> 4
-f.(-1, 3) #=> -3
-
-# Elixir também fornece várias funções embutidas.
-# Estas estão disponíveis no escopo atual.
-is_number(10)    #=> true
-is_list("ola") #=> false
-elem({1,2,3}, 0) #=> 1
-
-# Você pode agrupar algumas funções em um módulo. Dentro de um módulo use `def`
-# para definir suas funções.
-defmodule Math do
-  def sum(a, b) do
-    a + b
-  end
-
-  def square(x) do
-    x * x
-  end
-end
-
-Math.sum(1, 2)  #=> 3
-Math.square(3) #=> 9
-
-# Para compilar o módulo Math salve-o como `math.ex` e use `elixirc`
-# em seu terminal: elixirc math.ex
-
-# Dentro de um módulo podemos definir funções com `def` e funções privadas com `defp`.
-# Uma função definida com `def` pode ser invocada por outros módulos,
-# já uma função privada pode ser invocada apenas localmente.
-defmodule PrivateMath do
-  def sum(a, b) do
-    do_sum(a, b)
-  end
-
-  defp do_sum(a, b) do
-    a + b
-  end
-end
-
-PrivateMath.sum(1, 2)    #=> 3
-# PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError)
-
-# Declarações de funções também suportam guards cláusulas múltiplas:
-defmodule Geometry do
-  def area({:rectangle, w, h}) do
-    w * h
-  end
-
-  def area({:circle, r}) when is_number(r) do
-    3.14 * r * r
-  end
-end
-
-Geometry.area({:rectangle, 2, 3}) #=> 6
-Geometry.area({:circle, 3})       #=> 28.25999999999999801048
-# Geometry.area({:circle, "not_a_number"})
-#=> ** (FunctionClauseError) no function clause matching in Geometry.area/1
-
-# Devido à imutabilidade, recursão é uma grande parte do elixir
-defmodule Recursion do
-  def sum_list([head | tail], acc) do
-    sum_list(tail, acc + head)
-  end
-
-  def sum_list([], acc) do
-    acc
-  end
-end
-
-Recursion.sum_list([1,2,3], 0) #=> 6
-
-# Módulos do elixir suportam atributos, hpa atributos embutidos e você
-# pode também adicionar os seus próprios.
-defmodule MyMod do
-  @moduledoc """
-  Este é um atributo embutido em um módulo de exemplo.
-  """
-
-  @my_data 100 # Este é um atributo customizado.
-  IO.inspect(@my_data) #=> 100
-end
-
-## ---------------------------
-## -- Structs e Exceptions
-## ---------------------------
-
-# Structs são extensões no topo de mapas que trazem valores padrão,
-# garantias em tempo de compilação e polimorfismo para o Elixir.
-defmodule Pessoa do
-  defstruct nome: nil, idade: 0, peso: 0
-end
-
-joe_info = %Pessoa{ nome: "Joe", idade: 30, peso: 180 }
-#=> %Pessoa{idade: 30, peso: 180, nome: "Joe"}
-
-# Acessa o valor de nome
-joe_info.name #=> "Joe"
-
-# Atualiza o valor de idade
-older_joe_info = %{ joe_info | idade: 31 }
-#=> %Pessoa{idade: 31, peso: 180, nome: "Joe"}
-
-# O bloco `try` com a palavra `rescue` é usado para manipular exceções
-try do
-  raise "algum erro"
-rescue
-  RuntimeError -> "resgatado um erro em tempo de execução"
-  _error -> "isso resgatará qualquer erro"
-end
-
-# Toda exceção possui uma mensagem
-try do
-  raise "algum erro"
-rescue
-  x in [RuntimeError] ->
-    x.message
-end
-
-## ---------------------------
-## -- Concorrência
-## ---------------------------
-
-# Elixir conta com o modelo de ator para concorrência. Tudo o que precisamos para
-# escrever programas concorrentes em elixir são três primitivos: spawning processes,
-# sending messages e receiving messages.
-
-# Para iniciar um novo processo usamos a função `spawn`, a qual leva uma função
-# como argumento.
-f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
-spawn(f) #=> #PID<0.40.0>
-
-# `spawn` retorna um pid (process identifier), você pode usar esse pid para enviar
-# mensagens ao processo. Para envio de mensagens usamos o operador `send`.
-# Para tudo isso ser útil precisamos estar aptos a receber mensagens. Isto é
-# realizado com o mecanismo `receive`:
-defmodule Geometry do
-  def area_loop do
-    receive do
-      {:rectangle, w, h} ->
-        IO.puts("Area = #{w * h}")
-        area_loop()
-      {:circle, r} ->
-        IO.puts("Area = #{3.14 * r * r}")
-        area_loop()
-    end
-  end
-end
-
-# Compile o módulo e crie um processo que avalie `area_loop` no shell
-pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0>
-
-# Envia uma mensagem ao `pid` correspondente a um pattern na declaração de recebimento
-send pid, {:rectangle, 2, 3}
-#=> Area = 6
-#   {:rectangle,2,3}
-
-send pid, {:circle, 2}
-#=> Area = 12.56000000000000049738
-#   {:circle,2}
-
-# O shell também é um processo, você pode usar `self` para obter o pid atual
-self() #=> #PID<0.27.0>
-```
-
-## Referências
-
-* [Getting started guide](http://elixir-lang.org/getting_started/1.html) da [página do elixir](http://elixir-lang.org)
-* [Elixir Documentation](http://elixir-lang.org/docs/master/)
-* ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) por Dave Thomas
-* [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
-* ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) por Fred Hebert
-* ["Programming Erlang: Software for a Concurrent World"](https://pragprog.com/book/jaerlang2/programming-erlang) por Joe Armstrong
-- 
cgit v1.2.3


From 11fed862e42ef4dd1dba5da0f27b6f4a1206806a Mon Sep 17 00:00:00 2001
From: Lucas Pugliesi <ferreiraplucas@gmail.com>
Date: Thu, 5 Oct 2017 08:57:17 -0300
Subject: Filename learnpyqt.py to learnpyqt-pt.py

---
 pt-br/pyqt-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/pyqt-pt.html.markdown b/pt-br/pyqt-pt.html.markdown
index ced107dc..10d55784 100644
--- a/pt-br/pyqt-pt.html.markdown
+++ b/pt-br/pyqt-pt.html.markdown
@@ -1,7 +1,7 @@
 ---
 category: tool
 tool: PyQT
-filename: learnpyqt.py
+filename: learnpyqt-pt.py
 contributors:
     - ["Nathan Hughes", "https://github.com/sirsharpest"]
 translators:
-- 
cgit v1.2.3


From c41bfe38377ad5989665c559c437df1f0e3fabcf Mon Sep 17 00:00:00 2001
From: Lucas Pugliesi <ferreiraplucas@gmail.com>
Date: Thu, 5 Oct 2017 11:21:33 -0300
Subject: [qt/pt-br] Translation of Qt to pt-br.

---
 pt-br/qt-pt.html.markdown | 174 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 174 insertions(+)
 create mode 100644 pt-br/qt-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/qt-pt.html.markdown b/pt-br/qt-pt.html.markdown
new file mode 100644
index 00000000..99579c35
--- /dev/null
+++ b/pt-br/qt-pt.html.markdown
@@ -0,0 +1,174 @@
+---
+category: tool
+tool: Qt Framework
+language: c++
+filename: learnqt-pt.cpp
+contributors:
+    - ["Aleksey Kholovchuk", "https://github.com/vortexxx192"]
+translators:
+    - ["Lucas Pugliesi", "https://github.com/fplucas"]
+lang: pt-br
+---
+
+**Qt** é amplamente conhecido como um framework para desenvolvimento de
+software multi-plataforma que pode rodar em vários outras plataformas de
+softwares e hardwares com pouca ou nenhuma alteração no código, enquanto mantém
+o poder e a velocidade de uma aplicação nativa. Embora o **Qt** tenha sido
+originalmente escrito em *C++*, é possível utilizá-lo em outras linguagens:
+*[PyQt](https://learnxinyminutes.com/docs/pyqt/)*, *QtRuby*, *PHP-Qt*, etc.
+
+**Qt** é ótimo para criar aplicações com interface gráfica (GUI). Esse tutorial
+será feito em *C++*.
+
+```c++
+/*
+ * Vamos começar
+ */
+
+// Todos as dependências do framework Qt iniciam com a letra 'Q' maiúscula
+#include <QApplication>
+#include <QLineEdit>
+
+int main(int argc, char *argv[]) {
+	 // Cria um objeto para utilizar todos os recursos da aplicação
+    QApplication app(argc, argv);
+
+    // Cria um widget com linha editável e exibe na tela
+    QLineEdit lineEdit("Hello world!");
+    lineEdit.show();
+
+    // Inicia a aplicação em um evento de loop
+    return app.exec();
+}
+```
+
+A parte gráfica do **Qt** é toda composta de *widgets* e *conexões* entre eles.
+
+[LEIA MAIS SOBRE WIDGETS](http://doc.qt.io/qt-5/qtwidgets-index.html)
+
+```c++
+/*
+ * Vamos criar um label e um botão.
+ * Um label irá aparecer quando o botão for clicado
+ *
+ * O próprio código do Qt é autoexplicativo.
+ */
+
+#include <QApplication>
+#include <QDialog>
+#include <QVBoxLayout>
+#include <QPushButton>
+#include <QLabel>
+
+int main(int argc, char *argv[]) {
+    QApplication app(argc, argv);
+
+    QDialog dialogWindow;
+    dialogWindow.show();
+
+    // Adiciona um layout vertical
+    QVBoxLayout layout;
+    dialogWindow.setLayout(&layout);
+
+    QLabel textLabel("Thanks for pressing that button");
+    layout.addWidget(&textLabel);
+    textLabel.hide();
+
+    QPushButton button("Press me");
+    layout.addWidget(&button);
+
+    // Exibe o label oculto quando o botão é clicado
+    QObject::connect(&button, &QPushButton::pressed,
+                     &textLabel, &QLabel::show);
+
+    return app.exec();
+}
+```
+
+Veja o *QObject::connect*. O método é usado para conectar o *SINAL* de um objeto
+ao *ENCAIXE* outro.
+
+**Sinais** são emitidos quando algo ocorre com o objeto, como quando o sinal de
+*clique* é acionado apertando o QPushButton.
+
+**Encaixes** são *ações* que são executadas em resposta aos sinais recebidos.
+
+[LEIA MAIS SOBRE SINAIS E ENCAIXES](http://doc.qt.io/qt-5/signalsandslots.html)
+
+
+A seguir vamos aprender como usar não somente o comportamento padrão dos
+widgets, mas também extender seus comportamentos usando herança. Vamos criar um
+botão e contar quantas vezes é pressionado. Para esse propósito definiremos
+nossa própria classe *CounterLabel*. Ela deve ser declarada em um arquivo
+diferente devido a estrutura específica do Qt.
+
+```c++
+// counterlabel.hpp
+
+#ifndef COUNTERLABEL
+#define COUNTERLABEL
+
+#include <QLabel>
+
+class CounterLabel : public QLabel {
+    Q_OBJECT  // Define os macros presente em todo objeto Qt
+
+public:
+    CounterLabel() : counter(0) {
+        setText("Counter has not been increased yet");  // método do QLabel
+    }
+
+public slots:
+    // Ação que será chamada em resposta ao clique do botão
+    void increaseCounter() {
+        setText(QString("Counter value: %1").arg(QString::number(++counter)));
+    }
+
+private:
+    int counter;
+};
+
+#endif // COUNTERLABEL
+```
+
+```c++
+// main.cpp
+// Quase igual ao exemplo anterior
+
+#include <QApplication>
+#include <QDialog>
+#include <QVBoxLayout>
+#include <QPushButton>
+#include <QString>
+#include "counterlabel.hpp"
+
+int main(int argc, char *argv[]) {
+    QApplication app(argc, argv);
+
+    QDialog dialogWindow;
+    dialogWindow.show();
+
+    QVBoxLayout layout;
+    dialogWindow.setLayout(&layout);
+
+    CounterLabel counterLabel;
+    layout.addWidget(&counterLabel);
+
+    QPushButton button("Push me once more");
+    layout.addWidget(&button);
+    QObject::connect(&button, &QPushButton::pressed,
+                     &counterLabel, &CounterLabel::increaseCounter);
+
+    return app.exec();
+}
+```
+
+É isso! Claro, o framework Qt é muito maior do que exemplificamos no tutorial,
+então esteja preparado para ler e praticar mais.
+
+## Leitura complementar
+
+- [Tutoriais Qt 4.8](http://doc.qt.io/qt-4.8/tutorials.html)
+- [Tutoriais Qt 5](http://doc.qt.io/qt-5/qtexamplesandtutorials.html)
+
+Boa sorte e divirta-se!
-- 
cgit v1.2.3


From d01e5242e16c522becc1b04f9692d2556f94c4f1 Mon Sep 17 00:00:00 2001
From: Damian Rzeszot <damian.rzeszot@gmail.com>
Date: Mon, 9 Oct 2017 12:01:15 +0200
Subject: swift | fix style guidelines

---
 pt-br/swift-pt.html.markdown | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/swift-pt.html.markdown b/pt-br/swift-pt.html.markdown
index ebf74b6f..bf410352 100644
--- a/pt-br/swift-pt.html.markdown
+++ b/pt-br/swift-pt.html.markdown
@@ -389,13 +389,13 @@ if mySquare === mySquare {
 // Podem conter métodos do mesmo jeito que classes.
 
 enum Suit {
-    case Spades, Hearts, Diamonds, Clubs
+    case spades, hearts, diamonds, clubs
     func getIcon() -> String {
         switch self {
-        case .Spades: return "♤"
-        case .Hearts: return "♡"
-        case .Diamonds: return "♢"
-        case .Clubs: return "♧"
+        case .spades: return "♤"
+        case .hearts: return "♡"
+        case .diamonds: return "♢"
+        case .clubs: return "♧"
         }
     }
 }
-- 
cgit v1.2.3


From 13ab5a04aaabe94caff98ffb958a9ecf0e25fe3f Mon Sep 17 00:00:00 2001
From: Lucas Pugliesi <ferreiraplucas@gmail.com>
Date: Mon, 9 Oct 2017 09:17:46 -0300
Subject: rust-pt.html.markdown to pt-br folder

---
 pt-br/rust-pt.html.markdown | 332 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 332 insertions(+)
 create mode 100644 pt-br/rust-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/rust-pt.html.markdown b/pt-br/rust-pt.html.markdown
new file mode 100644
index 00000000..8134d3c5
--- /dev/null
+++ b/pt-br/rust-pt.html.markdown
@@ -0,0 +1,332 @@
+---
+language: rust
+filename: rust-pt.rs
+contributors:
+    - ["Paulo Henrique Rodrigues Pinheiro", "https://about.me/paulohrpinheiro"]
+lang: pt-br
+
+---
+
+Rust é uma linguagem de programação desenvolvida pelo Mozilla Research. Rust
+combina controle de baixo nível sobre o desempenho com facilidades de alto
+nível e garantias de segurança.
+
+Ele atinge esse objetico sem necessitar de um coletor de lixo ou um processo
+*runtime*, permitindo que se use bibliotecas Rust em substituição a bibliotecas 
+em C.
+
+A primeira versão de Rust, 0.1, apareceu em janeiro de 2012, e por três anos o
+desenvolvimento correu tão rapidamente que que até recentemente o uso de
+versões estáveis foi desencorajado e em vez disso a recomendação era usar as
+versões empacotadas toda noite.
+
+Em 15 de maio de 2015, a versão 1.0 de Rust foi liberada com a garantia total
+de compatibilidade reversa. Melhorias no tempo de compilação e em outros
+aspectos do compilador estão disponíveis atualmente nas versões empacotadas à
+noite. Rust adotou um modelo de versões *train-based* com novas versões
+regularmente liberadas a cada seis semanas. A versão 1.1 beta de Rust foi
+disponibilizada ao mesmo tempo que a versão 1.0.
+
+Apesar de Rust ser uma linguagem mais e baixo nível, Rust tem alguns conceitos
+funcionais geralmente encontradas em linguagens de alto nível. Isso faz Rust
+não apenas rápido, mas também fácil e eficiente para programar.
+
+```rust
+// Isso é um comentário. Linhas de comentários são assim...
+// e múltiplas linhas se parecem assim.
+
+/// Comentários para documentação são assim e permitem notação em markdown.
+/// # Exemplos
+///
+/// ```
+/// let five = 5
+/// ```
+
+///////////////
+// 1. Básico //
+///////////////
+
+// Funções
+// `i32` é o tipo para inteiros com sinal de 32 bits
+fn add2(x: i32, y: i32) -> i32 {
+    // Implicit return (no semicolon)
+    x + y
+}
+
+// Função main
+fn main() {
+    // Números //
+
+    // Immutable bindings
+    let x: i32 = 1;
+
+    // Inteiros/Sufixos para ponto flutuante
+    let y: i32 = 13i32;
+    let f: f64 = 1.3f64;
+
+    // Inferência de tipos
+    // Em geral, o compilador Rust consegue inferir qual o tipo de uma 
+    // variável, então você não tem que escrever uma anotação explícita de tipo.
+    // Ao longo desse tutorial, os tipos serão explicitamente anotados em 
+    // muitos lugares, mas apenas com propóstico demonstrativo. A inferência de 
+    // tipos pode gerenciar isso na maioria das vezes.
+    let implicit_x = 1;
+    let implicit_f = 1.3;
+
+    // Aritmética
+    let sum = x + y + 13;
+
+    // Variáveis mutáveis
+    let mut mutable = 1;
+    mutable = 4;
+    mutable += 2;
+
+    // Strings //
+
+    // String literais
+    let x: &str = "hello world!";
+
+    // Imprimindo
+    println!("{} {}", f, x); // 1.3 hello world
+
+    // Uma `String` – uma String alocada no heap
+    let s: String = "hello world".to_string();
+
+    // Uma String slice - uma visão imutável em outra string.
+    // Basicamente, isso é um par imutável de ponteiros para uma string - ele
+    // não contém o conteúdo de uma strinf, apenas um ponteiro para o começo e 
+    // um ponteiro para o fim da área de memória para a string, estaticamente
+    // alocada ou contida em outro objeto (nesse caso, `s`)
+    let s_slice: &str = &s;
+
+    println!("{} {}", s, s_slice); // hello world hello world
+
+    // Vetores/arrays //
+
+    // Um array de tamanho fixo
+    let four_ints: [i32; 4] = [1, 2, 3, 4];
+
+    // Um array dinâmico (vetor)
+    let mut vector: Vec<i32> = vec![1, 2, 3, 4];
+    vector.push(5);
+
+    // Uma fatia – uma visão imutável em um vetor ou array
+    // Isso é como um string slice, mas para vetores
+    let slice: &[i32] = &vector;
+
+    // Use `{:?}` para imprimir alguma coisa no estilo de depuração
+    println!("{:?} {:?}", vector, slice); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
+
+    // Tuplas //
+
+    // Uma tupla é um conjunto de tamanho fixo de valores de tipos
+    // possivelmente diferentes
+    let x: (i32, &str, f64) = (1, "hello", 3.4);
+
+    // Desestruturando `let`
+    let (a, b, c) = x;
+    println!("{} {} {}", a, b, c); // 1 hello 3.4
+
+    // Indexando
+    println!("{}", x.1); // hello
+
+    //////////////
+    // 2. Tipos //
+    //////////////
+
+    // Struct
+    struct Point {
+        x: i32,
+        y: i32,
+    }
+
+    let origin: Point = Point { x: 0, y: 0 };
+
+    // Uma estrutura com campos sem nome, chamada 'estrutura em tupla'
+    struct Point2(i32, i32);
+
+    let origin2 = Point2(0, 0);
+
+    // enum básico com na linguagem C
+    enum Direction {
+        Left,
+        Right,
+        Up,
+        Down,
+    }
+
+    let up = Direction::Up;
+
+    // Enum com campos
+    enum OptionalI32 {
+        AnI32(i32),
+        Nothing,
+    }
+
+    let two: OptionalI32 = OptionalI32::AnI32(2);
+    let nothing = OptionalI32::Nothing;
+
+    // Generics //
+
+    struct Foo<T> { bar: T }
+
+    // Isso é definido na biblioteca padrão como um `Option`
+    enum Optional<T> {
+        SomeVal(T),
+        NoVal,
+    }
+
+    // Methods //
+
+    impl<T> Foo<T> {
+        // Métodos recebem um parâmetro `self` explícito
+        fn get_bar(self) -> T {
+            self.bar
+        }
+    }
+
+    let a_foo = Foo { bar: 1 };
+    println!("{}", a_foo.get_bar()); // 1
+
+    // Traits (conhecidos como interfaces ou typeclasses em outras linguagens)//
+
+    trait Frobnicate<T> {
+        fn frobnicate(self) -> Option<T>;
+    }
+
+    impl<T> Frobnicate<T> for Foo<T> {
+        fn frobnicate(self) -> Option<T> {
+            Some(self.bar)
+        }
+    }
+
+    let another_foo = Foo { bar: 1 };
+    println!("{:?}", another_foo.frobnicate()); // Some(1)
+
+    //////////////////////////////////
+    // 3. Reconhecimento de padrões //
+    //////////////////////////////////
+
+    let foo = OptionalI32::AnI32(1);
+    match foo {
+        OptionalI32::AnI32(n) => println!("it’s an i32: {}", n),
+        OptionalI32::Nothing  => println!("it’s nothing!"),
+    }
+
+    // Reconhecimento avançado de padrões
+    struct FooBar { x: i32, y: OptionalI32 }
+    let bar = FooBar { x: 15, y: OptionalI32::AnI32(32) };
+
+    match bar {
+        FooBar { x: 0, y: OptionalI32::AnI32(0) } =>
+            println!("The numbers are zero!"),
+        FooBar { x: n, y: OptionalI32::AnI32(m) } if n == m =>
+            println!("The numbers are the same"),
+        FooBar { x: n, y: OptionalI32::AnI32(m) } =>
+            println!("Different numbers: {} {}", n, m),
+        FooBar { x: _, y: OptionalI32::Nothing } =>
+            println!("The second number is Nothing!"),
+    }
+
+    //////////////////////////
+    // 4. Controle de fluxo //
+    //////////////////////////
+
+    // `for` laços de repetição/iteração
+    let array = [1, 2, 3];
+    for i in array.iter() {
+        println!("{}", i);
+    }
+
+    // Ranges
+    for i in 0u32..10 {
+        print!("{} ", i);
+    }
+    println!("");
+    // prints `0 1 2 3 4 5 6 7 8 9 `
+
+    // `if`
+    if 1 == 1 {
+        println!("Maths is working!");
+    } else {
+        println!("Oh no...");
+    }
+
+    // `if` como expressão
+    let value = if true {
+        "good"
+    } else {
+        "bad"
+    };
+
+    // laço `while` de repetição
+    while 1 == 1 {
+        println!("The universe is operating normally.");
+    }
+
+    // Repetição infinita
+    loop {
+        println!("Hello!");
+    }
+
+    ////////////////////////////////////////
+    // 5. Proteção de memória & ponteiros //
+    ////////////////////////////////////////
+
+    // Ponteiro com dono - somente uma coisa pode 'possuir' esse ponteiro por
+    // vez.
+    // Isso significa que quando `Box` perde seu escopo, ele pode ser
+    // automaticamente desalocado com segurança.
+    let mut mine: Box<i32> = Box::new(3);
+    *mine = 5; // dereference
+    // Aqui, `now_its_mine` possui o controle exclusivo de `mine`. Em outras 
+    // palavras, `mine` tem o controle transferido.
+    let mut now_its_mine = mine;
+    *now_its_mine += 2;
+
+    println!("{}", now_its_mine); // 7
+    // println!("{}", mine); // não compila porque `now_its_mine` é o dono
+
+    // Referência - um ponteiro imutável que referencia outro dado
+    // Quando uma referência é dada a um valor, nós dizemos que o valor foi
+    // emprestado 'borrowed'.
+    // Quando um valor é emprestado sem ser mutável, ele não pode ser alterado
+    // ou ter a sua propriedade transferida.
+    // Um empréstimo finaliza quando o escopo em que ele foi criado termina.
+
+    let mut var = 4;
+    var = 3;
+    let ref_var: &i32 = &var;
+
+    println!("{}", var); // AO contrário de `mine`, `var` ainda pode ser usado
+    println!("{}", *ref_var);
+    // var = 5; // não compila porque `var` é emprestado
+    // *ref_var = 6; // não compila, porque `ref_var` é uma referência imutável
+
+    // Referência mutável
+    // Quando um valor mutável é emprestado, ele não pode ser acessado.
+    let mut var2 = 4;
+    let ref_var2: &mut i32 = &mut var2;
+    *ref_var2 += 2;         // '*' aponta para var2, que é mutável e emprestada
+
+    println!("{}", *ref_var2); // 6 , // var2 não compila.
+    // ref_var2 é do tipo &mut i32, que guarda uma referência i32, não o valor.
+    // var2 = 2; // não compila porque `var2` é empretada.
+}
+```
+
+## Outras leituras
+
+Existe muita coisa sobre Rust - isto aqui é apenas o básico para que você possa 
+entender as coisas mais importantes. Para aprender mais sobre Rust, leia [The 
+Rust Programming Language](http://doc.rust-lang.org/book/index.html) e 
+acompanhe [/r/rust](http://reddit.com/r/rust). A galera no canal #rust do
+irc.mozilla.org também estão sempre dispostos a ajudar os novatos.
+
+Você pode brincar com outras característica de Rust com um compilador online
+no portal oficial do projeto [Rust playpen](http://play.rust-lang.org), or ler 
+mais na página oficial [Rust website](http://rust-lang.org).
+
+No Brasil acompanhe os encontros do [Meetup Rust São Paulo]
+(http://www.meetup.com/pt-BR/Rust-Sao-Paulo-Meetup/).
+
-- 
cgit v1.2.3


From 8c2c5091b92da3d283bff279fb733b8f5d9212be Mon Sep 17 00:00:00 2001
From: fnscoder <felipensouza@live.com>
Date: Mon, 9 Oct 2017 15:49:51 -0300
Subject: delete duble file asymptoticnotation in pt-br

---
 pt-br/asymptoticnotation-pt.html.markdown | 161 ------------------------------
 1 file changed, 161 deletions(-)
 delete mode 100644 pt-br/asymptoticnotation-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/asymptoticnotation-pt.html.markdown b/pt-br/asymptoticnotation-pt.html.markdown
deleted file mode 100644
index c5299a11..00000000
--- a/pt-br/asymptoticnotation-pt.html.markdown
+++ /dev/null
@@ -1,161 +0,0 @@
----
-category: Algorithms & Data Structures
-name: Asymptotic Notation
-contributors:
-    - ["Jake Prather", "http://github.com/JakeHP"]
-translators: 
-    - ["Carolina Knoll", "http://github.com/carolinaknoll"]
-lang: pt-br
----
-
-# Aprenda X em Y minutos
-## Onde X=Notação Assintótica
-
-# Notações Assintóticas
-## O que são?
-
-Notações assintóticas são notações matemáticas que nos permitem analisar tempo de execução  
-de um algoritmo, identificando o seu comportamento de acordo como o tamanho de entrada para  
-o algoritmo aumenta. Também é conhecido como taxa de "crescimento" de um algoritmo. O algoritmo  
-simplesmente se torna incrivelmente lento conforme o seu tamanho aumenta? Será que pode-se na  
-maior parte manter o seu tempo de execução rápido mesmo quando o tamanho de entrada aumenta?  
-A notação assintótica nos dá a capacidade de responder a essas perguntas. 
-
-## Além desta, existem outras alternativas para responder a essas perguntas?
-
-Uma forma seria a de contar o número de operações primitivas em diferentes tamanhos de entrada. 
-Embora esta seja uma solução válida, a quantidade de trabalho necessário, mesmo para algoritmos 
-simples, não justifica a sua utilização.
-
-Outra maneira é a de medir fisicamente a quantidade de tempo que leva para se executar um algoritmo 
-de diferentes tamanhos. No entanto, a precisão e a relatividade (já que tempos obtidos só teriam 
-relação à máquina em que eles foram testados) deste método estão ligadas a variáveis ambientais, 
-tais como especificações de hardware, poder de processamento, etc.
-
-## Tipos de Notação Assintótica
-
-Na primeira seção deste documento nós descrevemos como uma notação assintótica identifica o comportamento  
-de um algoritmo como as alterações de tamanho de entrada (input). Imaginemos um algoritmo como uma função  
-f, n como o tamanho da entrada, e f (n) sendo o tempo de execução. Assim, para um determinado algoritmo f,  
-com tamanho de entrada n você obtenha algum tempo de execução resultante f (n). Isto resulta num gráfico,  
-em que o eixo Y representa o tempo de execução, o eixo X é o tamanho da entrada, e os pontos marcados são  
-os resultantes da quantidade de tempo para um dado tamanho de entrada.
-
-Pode-se rotular uma função ou algoritmo com uma notação assintótica de diversas maneiras diferentes.  
-Dentre seus exemplos, está descrever um algoritmo pelo seu melhor caso, pior caso, ou caso equivalente.  
-O mais comum é o de analisar um algoritmo pelo seu pior caso. Isso porque você normalmente não avaliaria  
-pelo melhor caso, já que essas condições não são as que você está planejando. Um bom exemplo disto é o de  
-algoritmos de ordenação; especificamente, a adição de elementos a uma estrutura de tipo árvore. O melhor  
-caso para a maioria dos algoritmos pode ser tão simples como uma única operação. No entanto, na maioria   
-dos casos, o elemento que você está adicionando terá de ser ordenado de forma adequada através da árvore,  
-o que poderia significar a análise de um ramo inteiro. Este é o pior caso, e é por ele que precisamos seguir.  
-
-### Tipos de funções, limites, e simplificação
-
-```
-Função Logaritmica - log n  
-Função Linear - an + b  
-Função Quadrática - an^2 + bn + c  
-Função Polinomial - an^z + . . . + an^2 + a*n^1 + a*n^0, onde z é uma constante  
-Função Exponencial - a^n, onde a é uma constante  
-```
-
-Estas são algumas classificações básicas de crescimento de função usados em várias notações. A lista  
-começa com a função crescimento mais lento (logarítmica, com tempo de execução mais rápido) e vai até  
-a mais rápida (exponencial, com tempo de execução mais lento). Observe que 'n', ou nossa entrada,  
-cresce em cada uma dessas funções, e o resultado claramente aumenta muito mais rapidamente em função  
-quadrática, polinomial e exponencial, em comparação com a logarítmica e a linear.
-
-Uma observação de boa importância é que, para as notações a serem discutidas, deve-se fazer o melhor  
-para utilizar termos mais simples. Isto significa desrespeitar constantes, e simplificar termos de  
-ordem, porque, como o tamanho da entrada (ou n no nosso f (n) exemplo) aumenta infinitamente (limites  
-matemáticos), os termos em ordens mais baixas e constantes são de pouca ou nenhuma importância. Dito  
-isto, se você possui constantes com valor 2^9001, ou alguma outra quantidade ridícula, inimaginável,  
-perceberá que a simplificação distorcerá a precisão de sua notação.
-
-Já que nós queremos a forma mais simples, vamos modificar nossas funções um pouco.
-
-```
-Logaritmica - log n  
-Linear - n  
-Quadrática - n^2  
-Polinomial - n^z, onde z é uma constante  
-Exponencial - a^n, onde a é uma constante
-```
-
-### O Grande-O
-
-Grande-O, geralmente escrita como O, é uma Notação Assintótica para o pior caso para uma dada função. Digamos  
-que `f(n)` é o tempo de execução de seu algoritmo, e `g(n)` é uma complexidade de tempo arbitrário que você está  
-tentando se relacionar com o seu algoritmo. `f(n)` será O(g(n)), se, por qualquer constante real c (c > 0),  
-`f(n)` <= `c g(n)` para cada tamanho de entrada n (n > 0).  
-
-*Exemplo 1*
-
-```
-f(n) = 3log n + 100  
-g(n) = log n
-```
-
-É `f(n)` um O(g(n))?  
-É 3 `log n + 100` igual a O(log n)?  
-Vamos checar na definição de Grande-O.  
-
-```
-3log n + 100 <= c * log n
-```
-
-Existe alguma constante c que satisfaça isso para todo n?
-
-```
-3log n + 100 <= 150 * log n, n > 2 (indefinido em n = 1)
-```
-
-Sim! A definição de Grande-O foi satisfeita. Sendo assim, `f(n)` é O(g(n)).
-
-*Exemplo 2*
-
-```
-f(n) = 3 * n^2
-g(n) = n
-```
-
-É `f(n)` um O(g(n))? 
-É `3 * n^2` um O(n)? 
-Vamos ver na definição de Grande-O.
-
-```
-3 * n^2 <= c * n
-```
-
-Existe alguma constante que satisfaça isso para todo n? 
-Não, não existe. `f(n)` NÃO É O(g(n)).
-
-### Grande-Omega
-
-Grande-Omega, comumente escrito como Ω, é uma Notação Assintótica para o melhor caso, ou  
-uma taxa de crescimento padrão para uma determinada função.
-
-`f(n)` é Ω(g(n)), se, por qualquer constante c real (c > 0), `f(n)` é >= `c g(n)` para cada  
-tamanho de entrada n (n > 0).
-
-Sinta-se livre para pesquisar recursos adicionais e obter mais exemplos sobre este assunto!  
-Grande-O é a notação primária utilizada para tempo de execução de algoritmos, de modo geral.  
-
-### Notas de Finalização
-
-É complicado exibir este tipo de assunto de forma tão curta, então é definitivamente recomendado  
-pesquisar além dos livros e recursos on-line listados. Eles serão capazes de analisar o assunto com  
-uma profundidade muito maior, além de ter definições e exemplos. Mais sobre onde X="Algoritmos e  
-Estruturas de Dados" está a caminho: Haverá conteúdo focado na análise de exemplos de códigos reais  
-em breve. 
-
-## Livros
-
-* [Algorithms] (http://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X)  
-* [Algorithm Design] (http://www.amazon.com/Algorithm-Design-Foundations-Analysis-Internet/dp/0471383651)
-
-## Recursos Online
-
-* [MIT] (http://web.mit.edu/16.070/www/lecture/big_o.pdf)  
-* [KhanAcademy] (https://www.khanacademy.org/computing/computer-science/algorithms/asymptotic-notation/a/asymptotic-notation)
-- 
cgit v1.2.3


From 42d9ae2dd37845b4c385980f872e09ac056a93a6 Mon Sep 17 00:00:00 2001
From: Paulo Henrique Rodrigues Pinheiro <paulo.pinheiro@aceita.com>
Date: Tue, 17 Oct 2017 17:59:45 -0200
Subject: Translate awk to pt_BR

---
 pt-br/awk-pt.html.markdown | 376 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 376 insertions(+)
 create mode 100644 pt-br/awk-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/awk-pt.html.markdown b/pt-br/awk-pt.html.markdown
new file mode 100644
index 00000000..75b73abe
--- /dev/null
+++ b/pt-br/awk-pt.html.markdown
@@ -0,0 +1,376 @@
+---
+language: awk
+filename: learnawk-pt.awk
+contributors:
+    - ["Marshall Mason", "http://github.com/marshallmason"]
+translators:
+    - ["Paulo Henrique Rodrigues Pinheiro", "https://github.com/paulohrpinheiro"]
+lang: pt-br
+
+---
+
+AWK é uma ferramenta padrão em todos os sistemas UNIX compatíveis com POSIX. É
+como um Perl despojado, perfeito para tarefas de processamento de texto e
+outras tarefas de script.  Possui uma sintaxe C-like, mas sem ponto e vírgula,
+gerenciamento manual de memória, ou tipagem estática. Destaca-se no
+processamento de texto. Você pode chamá-lo a partir de um shell-script, ou você
+pode usá-lo como uma linguagem de script autônomo.
+
+Por que usar AWK ao invés de Perl? Principalmente porque AWK faz parte do UNIX.
+Você pode sempre contar com ele, enquanto o futuro do Perl é indefinido. AWK é
+também mais fácil de ler que Perl. Para scripts simples de processamento de
+texto, particularmente aqueles que leem arquivos linha por linha e fatiam texto
+por delimitadores, AWK é provavelmente a ferramenta certa para a tarefa.
+
+```awk
+#!/usr/bin/awk -f
+
+# Comentários são assim
+
+# Programas AWK consistem de uma coleção de padrões e ações. O mais
+# importante padrão é chamado BEGIN. Ações estão dentro de blocos
+# entre chaves.
+
+BEGIN {
+
+    # O bloco BEGIN será executado no começo do programa. É onde você coloca
+    # todo código que prepara a execução, antes que você processe qualquer
+    # arquivo de texto. Se você não tem arquivos de texto, então pense no
+    # BEGIN como o ponto principal de entrada.
+
+    # Variáveis são globais. Simplesmente atribua valores ou as use, sem
+    # necessidade de declarar.
+
+    # Operadores são como em C e similares
+    a = count + 1
+    b = count - 1
+    c = count * 1
+    d = count / 1 # divisão inteira
+    e = count % 1 # módulo
+    f = count ^ 1 # exponenciação
+
+    a += 1
+    b -= 1
+    c *= 1
+    d /= 1
+    e %= 1
+    f ^= 1
+
+    # Incrementando e decrementando por um
+    a++
+    b--
+
+    # Como um operador pré-fixado, retorna o valor incrementado
+    ++a
+    --b
+
+    # Perceba, não há pontuação, como ponto-e-vírgula, ao final das declarações
+
+    # Declarações de controle
+    if (count == 0)
+        print "Começando com count em 0"
+    else
+        print "Como é que é?"
+
+    # Ou você pode usar o operador ternário
+    print (count == 0) ? "Começando com count em 0" : "Como é que é?"
+
+    # Blocos multilinhas devem usar chaves
+    while (a < 10) {
+        print "Concatenação de texto é feita" " com uma série" " de"
+            " textos separados por espaço"
+        print a
+
+        a++
+    }
+
+    for (i = 0; i < 10; i++)
+        print "Uma boa opção para um loop de uma linha"
+
+    # Quanto a comparações, eis os padrões:
+    a < b   # Menor que
+    a <= b  # Menor ou igual a
+    a != b  # Não igual
+    a == b  # Igual
+    a > b   # Maior que
+    a >= b  # Maior ou igual a
+
+    # Bem como operadores lógicos
+    a && b  # E
+    a || b  # OU (inclusivo)
+
+    # Em adição, há o utilíssimo operador para expressões regulares
+    if ("foo" ~ "^fo+$")
+        print "Fooey!"
+    if ("boo" !~ "^fo+$")
+        print "Boo!"
+
+    # Matrizes
+    arr[0] = "foo"
+    arr[1] = "bar"
+    # Infelizmente, não há outra forma para inicializar uma matriz. Apenas
+    # coloque cada valor em uma linha, como mostrado acima.
+
+    # Você também pode ter matrizes associativas
+    assoc["foo"] = "bar"
+    assoc["bar"] = "baz"
+
+    # E matrizes multidimensionais, com algumas limitações que não mencionarei
+    multidim[0,0] = "foo"
+    multidim[0,1] = "bar"
+    multidim[1,0] = "baz"
+    multidim[1,1] = "boo"
+
+    # Você pode testar a pertinência de um elemento em uma matriz
+    if ("foo" in assoc)
+        print "Fooey!"
+
+    # Você pode também usar o operador 'in' para percorrer as chaves de uma
+    # matriz associativa
+    for (key in assoc)
+        print assoc[key]
+
+    # Os argumentos da linha de comando estão em uma matriz especial ARGV
+    for (argnum in ARGV)
+        print ARGV[argnum]
+
+    # Você pode remover elementos de uma matriz
+    # Isso é muito útil para prevenir que o AWK assuma que os argumentos são
+    # arquivo para ele processar
+    delete ARGV[1]
+
+    # A quantidade de argumentos passados está na variável ARGC
+    print ARGC
+
+    # O AWK tem várias funções nativas. Elas estão separadas em três categorias.
+    # Demonstrarei cada uma delas logo mais abaixo.
+
+    return_value = arithmetic_functions(a, b, c)
+    string_functions()
+    io_functions()
+}
+
+# Eis como você deve definir uma função
+function arithmetic_functions(a, b, c,    d) {
+
+    # Provavelmente a parte mais irritante do AWK é ele não possuir variáveis
+    # locais. Tudo é global. Para pequenos scripts, isso não é problema, e
+    # pode até mesmo ser considerado útil, mas para grandes scripts, isso pode
+    # ser um problema.
+
+    # Mas há como contornar isso (um hack). Os argumentos de função são locais
+    # para a função e o AWK permite que você defina mais argumentos de função
+    # do que ele precise. Então, coloque a variável local na declaração de
+    # função, como eu fiz acima. Como uma convenção, adicione alguns espaços
+    # extras para distinguir entre parâmetros de função reais e variáveis
+    # locais. Neste exemplo, a, b e c são parâmetros reais, enquanto d é
+    # meramente uma variável local.
+
+    # Agora, serão demonstradas as funções aritméticas
+
+    # Muitas implementações AWK possuem algumas funções trigonométricas padrão
+    localvar = sin(a)
+    localvar = cos(a)
+    localvar = atan2(a, b) # arco-tangente de b / a
+
+    # E conteúdo logarítmico
+    localvar = exp(a)
+    localvar = log(a)
+
+    # Raiz quadrada
+    localvar = sqrt(a)
+
+    # Descartando a parte não inteira de um número em ponto flutuante.
+    localvar = int(5.34) # localvar => 5
+
+    # Números aleatórios
+    srand() # Forneça uma semente como argumento. Por padrão, ele usa a hora atual
+    localvar = rand() # Número aleatório entre 0 e 1.
+
+    # Aqui mostramos como retornar um valor
+    return localvar
+}
+
+function string_functions(    localvar, arr) {
+
+    # Sendo o AWK uma linguagem para processamento de texto, ele possui
+    # várias funções para manipulação de texto, muitas das quais
+    # fortemente dependentes de expressões regulares.
+
+    # Procurar e substituir, primeira instância (sub), ou todas (gsub)
+    # Ambas retornam o número de instâncias substituídas
+    localvar = "fooooobar"
+    sub("fo+", "Meet me at the ", localvar) # localvar => "Meet me at the bar"
+    gsub("e+", ".", localvar) # localvar => "m..t m. at th. bar"
+
+    # Localiza um texto que casa com uma expressão regular
+    # index() faz a mesma coisa, mas não permite uma expressão regular
+    match(localvar, "t") # => 4, pois 't' é o quarto carácter
+
+    # Separa por delimitador
+    split("foo-bar-baz", arr, "-") # a => ["foo", "bar", "baz"]
+
+    # Outras coisas úteis
+    sprintf("%s %d %d %d", "Testing", 1, 2, 3) # => "Testing 1 2 3"
+    substr("foobar", 2, 3) # => "oob"
+    substr("foobar", 4) # => "bar"
+    length("foo") # => 3
+    tolower("FOO") # => "foo"
+    toupper("foo") # => "FOO"
+}
+
+function io_functions(    localvar) {
+
+    # Você já viu como imprimir
+    print "Hello world"
+
+    # Também há o printf
+    printf("%s %d %d %d\n", "Testing", 1, 2, 3)
+
+    # O AWK não disponibiliza manipuladores de arquivo. Ele irá automaticamente
+    # manipular um arquivo quando você fizer algo que precise disso. O texto
+    # que você usou para isso pode ser usado como um manipulador de arquivo,
+    # para propósitos de E/S. Isso faz ele parecer com um shell script:
+
+    print "foobar" >"/tmp/foobar.txt"
+
+    # Agora a string "/tmp/foobar.txt" é um manipulador de arquivos. Você pode
+    # fechá-lo:
+    close("/tmp/foobar.txt")
+
+    # Aqui está como você pode executar alguma coisa no shell
+    system("echo foobar") # => prints foobar
+
+    # Lê uma linha da entrada padrão e armazena em localvar
+    getline localvar
+
+    # Lê uma linha de um pipe
+    "echo foobar" | getline localvar # localvar => "foobar"
+    close("echo foobar")
+
+    # Lê uma linha de um arquivo e armazena em localvar
+    getline localvar <"/tmp/foobar.txt"
+    close("/tmp/foobar.txt")
+}
+
+# Como dito no início, os programas AWK consistem de uma coleção de padrões
+# e ações. Você já viu o padrão BEGIN, o mais importante. Outros padrões são
+# usados apenas se você estiver processando linhas de arquivos ou a entrada
+# padrão.
+
+# Quando você passa argumentos para o AWK, eles são tratados como nomes de
+# arquivos para processar. Todos serão processados, em ordem. Pense nisso como
+# um implícito para loop, iterando sobre as linhas nesses arquivos. Esses
+# padrões e ações são como instruções de mudança dentro do loop.
+
+/^fo+bar$/ {
+
+    # Esta ação será executada para cada linha que corresponda à expressão
+    # regular, / ^ fo + bar $ /, e será ignorada para qualquer linha que não
+    # corresponda. Vamos apenas imprimir a linha:
+
+    print
+
+    # Opa, sem argumento! Isso ocorre pois print tem um argumento padrão: $0.
+    # $0 é o nome da linha atual que está sendo processada. Essa variável é
+    # criada automaticamente para você.
+
+    # Você provavelmente pode adivinhar que existem outras variáveis $. Toda
+    # linha é implicitamente dividida antes de cada ação ser chamada, como
+    # o shell faz. E, como o shell, cada campo pode ser acessado com um sinal
+    # de cifrão
+
+    # Isso irá imprimir o segundo e quarto campos da linha
+    print $2, $4
+
+    # O AWK automaticamente define muitas outras variáveis para ajudar você
+    # a inspecionar processar cada linha. A mais importante delas é NF.
+
+    # Imprime o número de campos da linha atual
+    print NF
+
+    # Imprime o último campo da linha atual
+    print $NF
+}
+
+# Todo padrão é na verdade um teste verdadeiro/falso. A expressão regular no
+# último padrão também é um teste verdadeiro/falso, mas parte dele estava
+# escondido. Se você não informar um texto para testar, AWK assumirá $0,
+# a linha que está atualmente sendo processada. Assim, a versão completa
+# é a seguinte:
+
+$0 ~ /^fo+bar$/ {
+    print "Equivalente ao último padrão"
+}
+
+a > 0 {
+    # Isso será executado uma vez para cada linha, quando a for positivo
+}
+
+# Você entendeu. Processar arquivos de texto, ler uma linha de cada vez, e
+# fazer algo com ela, particularmente dividir com base em um delimitador, é
+# tão comum no UNIX que AWK é uma linguagem de script que faz tudo por você,
+# sem você precisa perguntar. Tudo o que você precisa fazer é escrever os
+# padrões e ações com base no que você espera da entrada, e o que você quer
+# fazer com isso.
+
+# Aqui está um exemplo rápido de um script simples, o tipo de coisa que o AWK
+# é perfeito para fazer. Ele irá ler um nome da entrada padrão e depois
+imprimirá a média de idade de todos com esse primeiro nome. Digamos que você
+forneça como argumento o nome de um arquivo com esses dados:
+
+# Bob Jones 32
+# Jane Doe 22
+# Steve Stevens 83
+# Bob Smith 29
+# Bob Barker 72
+#
+# Eis o script:
+
+BEGIN {
+
+    # Primeiro, pergunte o nome do usuário
+    print "Para qual nome você quer calcular a média de idade?"
+
+    # Pega uma linha da entrada padrão, não dos arquivos indicados na
+    # linha de comando
+    getline name <"/dev/stdin"
+}
+
+# Agora, processa cada linha em que o primeiro nome é o nome informado
+$1 == name {
+
+    # Dentro desse bloco, nós temos acesso a algumas variáveis uteis, que
+    # foram pré-carregadas para nós:
+    # $0  é a linha corrente completa
+    # $3 é o terceiro campo, que é o que nos interessa aqui
+    # NF é a quantidade de campos, que deve ser 3
+    # NR é o número de registros (linhas) lidas até agora
+    # FILENAME é o nome do arquivo sendo processado
+    # FS é o delimitador em uso, que é " " aqui
+    # ...etc. Há muito mais, documentadas no manual.
+
+    # Mantenha um registro do total e da quantidade de linhas encontradas
+    sum += $3
+    nlines++
+}
+
+# Outro padrão especial é chamado END. Ele será executado após o processamento
+# de todos os arquivos de texto. Ao contrário de BEGIN, ele só será executado
+# se você tiver dado a ele dados para processar. Ele será executado depois de
+# todos os arquivos terem sido lidos e processados de acordo com as regras e
+# ações que você forneceu. O objetivo disso em geral é produzir algum tipo de
+# relatório final, ou fazer algo com o agregado dos dados acumulados ao longo
+# do script.
+
+END {
+    if (nlines)
+        print "A média da idade para " name " é " sum / nlines
+}
+
+```
+Leituras adicionais (em inglês):
+
+* [Awk tutorial](http://www.grymoire.com/Unix/Awk.html)
+* [Awk man page](https://linux.die.net/man/1/awk)
+* [The GNU Awk User's Guide](https://www.gnu.org/software/gawk/manual/gawk.html) GNU AWK é encontrado na maioria dos sistemas GNU/Linux.
-- 
cgit v1.2.3


From 5c8c0186dcb8629396e5c82335cb7e9695ed8eec Mon Sep 17 00:00:00 2001
From: Paulo Henrique Rodrigues Pinheiro <paulo.pinheiro@aceita.com>
Date: Thu, 19 Oct 2017 18:31:21 -0200
Subject: Translate latex to pt_BR

---
 pt-br/latex-pt.html.markdown | 291 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 291 insertions(+)
 create mode 100644 pt-br/latex-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/latex-pt.html.markdown b/pt-br/latex-pt.html.markdown
new file mode 100644
index 00000000..a9ed566e
--- /dev/null
+++ b/pt-br/latex-pt.html.markdown
@@ -0,0 +1,291 @@
+---
+language: latex
+contributors:
+    - ["Chaitanya Krishna Ande", "http://icymist.github.io"]
+    - ["Colton Kohnke", "http://github.com/voltnor"]
+    - ["Sricharan Chiruvolu", "http://sricharan.xyz"]
+    - ["Ramanan Balakrishnan", "https://github.com/ramananbalakrishnan"]
+    - ["Svetlana Golubeva", "https://attillax.github.io/"]
+translators:
+    - ["Paulo Henrique Rodrigues Pinheiro", "https://github.com/paulohrpinheiro"]
+lang: pt-br
+filename: learn-latex-pt.tex
+---
+
+```tex
+% Todas as linhas de comentários começam com %
+% Não existem comentários multilinhas
+
+$ LaTeX não é um programa processador de textos "Visual" como
+% MS Word ou OpenOffice Writer
+
+$ Todo comando LaTeX começa com uma barra invertida (\)
+
+% Documentos LaTeX começam com a definição do tipo que será % compilado
+% Os tipos de documento podem ser livro, relatório, apresentação, etc.
+% As opções para um documento aparecem entre [] chaves. Nesse caso
+% está especificado que queremos o tamanho da fonte em 12pt.
+\documentclass[12pt]{article}
+
+% Em seguida definimos os pacotes que o documento usa.
+% Se você quiser incluir gráficos, texto colorido, ou código fonte de outra
+% linguagem em outro arquivo em seu documento, você precisa ampliar as
+% capacidade do LaTeX. Isso é feito adicionando-se pacotes.
+% Serão incluídos os pacotes float e caption para imagens e hyperref
+% para links.
+\usepackage{caption}
+\usepackage{float}
+\usepackage{hyperref}
+
+% Para poder usar caracteres acentuados, use o seguinte pacote:
+\usepackage[utf8]{inputenc}
+
+% Podemos definir algumas outras propriedades do documento também!
+\author{Chaitanya Krishna Ande, Colton Kohnke, Sricharan Chiruvolu \& \\
+Svetlana Golubeva}
+\date{\today}
+\title{Aprenda \LaTeX \hspace{1pt} em Y Minutos!}
+
+% Agora estamos pronto para começar o documento
+% Tudo antes dessa linha é chamado "preâmbulo".
+\begin{document}
+% Se informarmos os campos author (autores), date (data), "title" (título),
+% LaTeX poderá cria uma página inicial para nós.
+\maketitle
+% Se tivermos seções, poderemos criar uma tabela de conteúdo. Para isso,
+% o documento deve ser compilado duas vezes, para que tudo apareça na ordem
+% correta.
+% É uma voa prática separar a tabela de conteúdo do corpo do documento. Para
+% isso usa-se o comando \newpage
+\newpage
+\tableofcontents
+
+\newpage
+
+% Muitos artigos de pesquisa possuem um resumo, e pode-se isar comandos
+% predefinidos para isso.
+% Isso deve aparecer em sua ordem lógica, portanto, após o topo,
+% mas antes das seções principais do corpo.
+% Esse comando está disponível para os documentos do tipo artigo (article)
+% e relatório (report).
+\begin{abstract}
+ Documentação do \LaTeX \hspace{1pt} escrita em \LaTeX! Nada original!
+\end{abstract}
+
+% Comandos para seções são intuitivos. 
+% Todos os títulos de seção são adicionados automaticamente à tabela de conteúdo.
+\section{Introdução}
+Olá, meu nome é Colton e juntos estamos explorando o mundo do \LaTeX!
+
+\section{Outra seção}
+Esse é o texto para outra seção. Penso que precisamos de uma subseção.
+
+\subsection{Isso é uma subseção} % Subseções também são intuitivas.
+Penso que precisamos de mais uma
+
+\subsubsection{Pythagoras}
+Muito melhor agora.
+\label{subsec:pythagoras}
+
+% Ao usar o asterisco nós impedimos a numeração automática.
+% Isso funciona para outros comandos \LaTeX também.
+\section*{Essa é uma seção não numerada} 
+Afinal nem todas as seções precisam ser numeradas!
+
+\section{Algumas notas sobre texto}
+%\section{Espaçamento % É necessário mais informação sobre intervalos de espaço.
+\LaTeX \hspace{1pt} geralmente é muito bom sobre colocar texto onde ele deve
+ser posto. Se 
+uma linha \\ deve \\ ser \\ quebrada \\ adicione \textbackslash\textbackslash
+\hspace{1pt} ao código de seu documento. \\ 
+
+\section{Listas}
+Listas são uma das coisas mais fáceis de criar no \LaTeX! Preciso fazer compras
+amanhã, então façamos uma lista de compras.
+\begin{enumerate} % Isso cria o bloco "enumerate".
+  % \item faz com que o enumerate incremente
+  \item Salada.
+  \item 27 melancias.
+  \item Uma lebre.
+  % pode-se também sobrescrever o número do item usando []
+  \item[quantas?] Pistolas de água médias.
+
+  Não é um item da lista, mas faz parte do bloco enumerate.
+
+  \end{enumerate} % Todos os blocos devem ter um final (end{}).
+
+\section{Matemática}
+
+Um dos usos iniciais para \LaTeX \hspace{1pt} foi a produção de artigos
+acadêmicos e técnicos. Usualmente nos campos da matemática e ciência. Assim, é
+necessários que consigamos incluir alguns símbolos especiais em nosso texto! \\
+
+A matemática tem muitos símbolos, além dos quais se pode encontrar no teclado;
+símbolos para relações e conjuntos, setas, operadores, e letras gregas, apenas
+para mencionar alguns.\\
+
+Conjuntos e relações são essenciais em muitos textos de pesquisa em matemática.
+Aqui está como você pode indicar como todo x que pertence
+a X, $\forall$ x $\in$ X. \\
+% Perceba que é necessário adicionar os sinais $ antes e depois dos símbolos.
+% Isso é porque quando escrevendo, estamos em modo texto.
+% Mas os símbolos de matemática só existem no modo matemática.
+% Podemos entrar no modo matemática a partir do modo texto com os símbolos $.
+% O oposto também pode ocorrer. Variáveis podem ser renderizadas no modo
+% matemática.
+% Também podemos entrar no modo matemática com \[\]
+
+\[a^2 + b^2 = c^2 \]
+
+Minha letra grega favorita é $\xi$. Eu também gosto da $\beta$, $\gamma$ e $\sigma$.
+Eu ainda não encontrei uma letra grega que o \LaTeX \hspace{1pt} não tenha!\\
+
+Operadores são parte essencial de um documento sobre matemática:
+funções trigonométricas ($\sin$, $\cos$, $\tan$),
+logaritmo e exponencial ($\log$, $\exp$), 
+limites ($\lim$), etc. 
+possuem comandos pré-definidos em LaTex. 
+Vamos escrever uma equação para ver como se faz:
+$\cos(2\theta) = \cos^{2}(\theta) - \sin^{2}(\theta)$ \\
+
+Frações (numerador/denominador) podem ser escritas dessa forma:
+
+% 10 / 7
+$$ ^{10}/_{7} $$
+
+% Frações relativamente complexas podem ser escritas como
+% \frac{numerator}{denominator}
+$$ \frac{n!}{k!(n - k)!} $$ \\
+
+Também podemos escrever equações em um ``bloco de equação''.
+
+% Apresenta matemática com o 'bloco' equação
+\begin{equation} % entra no modo matemática
+    c^2 = a^2 + b^2.
+    \label{eq:pythagoras} % para referência
+    \end{equation} % toda declaração \begin precisa de uma declaração end
+
+Podemos então referenciar nossa nova equação!
+A equação~\ref{eq:pythagoras} é também conhecida como Teorema de Pitágoras que é
+também assunto da Seção~\ref{subsec:pythagoras}. Muitas coisas podem ser
+rotuladas: figuras, equações, seções, etc.
+
+Somatórios e Integrais são escritas com os comandos sum e int:
+
+% Alguns compiladores LaTeX irão reclamar se existirem linhas em branco
+% em um bloco de equação.
+\begin{equation} 
+  \sum_{i=0}^{5} f_{i}
+\end{equation} 
+\begin{equation} 
+  \int_{0}^{\infty} \mathrm{e}^{-x} \mathrm{d}x
+\end{equation} 
+
+\section{Figuras}
+
+Insiramos uma Figura. O local para colocar a figura pode ser difícil
+de determinar. Eu tenho sempre que verificar as opções toda vez.
+
+\begin{figure}[H] % H aqui é uma opção para o local da figura. 
+    \centering % centra a figura na página
+    % Inclui uma figura com escala de 0.8 do tamanho da página.
+    %\includegraphics[width=0.8\linewidth]{right-triangle.png} 
+    % Comentado para propósitos de compilação. Por favor, use sua imaginação.
+    \caption{Triângulo retângulo com lados $a$, $b$, $c$}
+    \label{fig:right-triangle}
+\end{figure}
+
+\subsection{Tabelas}
+Também podemos incluir tabelas da mesma forma que figuras.
+
+\begin{table}[H]
+  \caption{Título para a Tabela.}
+  % os argumentos {} abaixo descrevem como cada linha da tabela é desenhada.
+  % Aqui também, Preciso ver isso. Toda. E. Cada. Vez.
+  \begin{tabular}{c|cc} 
+    Número &  Sobrenome & Primeiro Nome \\ % Colunas são separadas por &
+    \hline % uma linha horizontal
+    1 & Biggus & Dickus \\
+    2 & Monty & Python
+  \end{tabular}
+\end{table}
+
+\section{Fazendo o \LaTeX \hspace{1pt} não compilar algo (o código fonte)}
+Digamos que precisamos incluir algum código dentro do nosso
+documento \LaTeX \hspace{1pt}, para isso precisamos com o \LaTeX \hspace{1pt}
+não tente interpretar esse texto e que apenas inclua ele no documento. Fazemos
+isso com o bloco verbatim.
+
+% Existem outros pacotes (por exemplo, minty, lstlisting, etc.)
+% mas verbatim é o básico
+\begin{verbatim} 
+  print("Hello World!")
+  a%b; % olha só! Podemos usar os sinais % no bloco verbatim. 
+  random = 4; #decided by fair random dice roll
+\end{verbatim}
+
+\section{Compilando} 
+
+Imagino que agora você esteja pensando como compilar esse fantástico documento
+e visualizar a gloriosa glória que é um pdf gerado por \LaTeX \hspace{1pt} pdf.
+(sim, esse documento é compilável). \\
+
+Finalizando o documento usando \LaTeX \hspace{1pt} consiste nos seguintes passos:
+  \begin{enumerate}
+    \item Escrever o documento em texto puro (o ``código fonte'').
+    \item Compilar o código fonte para gerar um pdf. 
+     Os passos para compilar se parecem (em Linux) com: \\
+     \begin{verbatim} 
+        > pdflatex learn-latex.tex
+     \end{verbatim}
+  \end{enumerate}
+
+Existem editores de \LaTeX \hspace{1pt} que combinam os passos 1 e 2 no mesmo
+sistema de software. Assim, você pode ver o passo 1, mas não o passo 2 por
+completo. Passo 2 estará acontecendo escondido\footnote{Por exemplo, quando usar
+referências (como Equação~\ref{eq:pythagoras}), pode ser necessário executar o
+passo 2 várias vezes, para gerar arquivos *.aux intermediários.}.
+% É assim que você adiciona notas de rodapé em seus documentos!
+
+Você escreve toda a informação de formatação em texto puro, no passo 1. O
+momento da compilação no passo 2 é responsável por produzir o documento no
+formato que você definiu no passo 1.
+
+\section{Links}
+Nós podemos inserir links em nosso documento. Para isso nós necessitamos incluir
+o pacote hyperref no preâmbulo com o comando:
+\begin{verbatim} 
+    \usepackage{hyperref}
+\end{verbatim}
+
+Existem dois tipos principais de links: URL visíveis \\
+\url{https://learnxinyminutes.com/docs/latex/}, ou
+\href{https://learnxinyminutes.com/docs/latex/}{um texto alternativo}
+% Você não pode adicionar espaços extras ou símbolos especiais no texto
+% alternativo, pois isso causará problemas na compilação.
+
+Esse pacote também produz uma lista de thumbnails no documento pdf gerado e
+ativa os links na tabela de conteúdo.
+
+\section{End}
+
+Por enquanto é isso!
+
+% Frequentemente você precisa de uma seção de referências em seu documento.
+% A forma mais fácil de configurá-la é usando uma seção de bibliografia
+\begin{thebibliography}{1}
+  % como em outras listas, o comando \bibitem pode ser usado para itens da lista
+  % cada entrada pode ser citada diretamente no corpo do texto
+  \bibitem{latexwiki} The amazing \LaTeX \hspace{1pt} wikibook: {\em 
+https://en.wikibooks.org/wiki/LaTeX}
+  \bibitem{latextutorial} An actual tutorial: {\em http://www.latex-tutorial.com}
+\end{thebibliography}
+
+% end the document
+\end{document}
+```
+
+## Mais sobre LaTeX
+
+* The amazing LaTeX wikibook: [https://en.wikibooks.org/wiki/LaTeX](https://en.wikibooks.org/wiki/LaTeX)
+* An actual tutorial: [http://www.latex-tutorial.com/](http://www.latex-tutorial.com/)
-- 
cgit v1.2.3


From d7326e1b260dc97a20c7303ce90bd354caab0e14 Mon Sep 17 00:00:00 2001
From: Victor Bastos <victorwpbastos@gmail.com>
Date: Mon, 23 Oct 2017 13:07:42 -0200
Subject: small typo

---
 pt-br/amd-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/amd-pt.html.markdown b/pt-br/amd-pt.html.markdown
index 38c1f70f..40c7cd09 100644
--- a/pt-br/amd-pt.html.markdown
+++ b/pt-br/amd-pt.html.markdown
@@ -141,7 +141,7 @@ require(['jquery', 'coolLibFromBower', 'modules/algunsHelpers'], function($, coo
   coolLib.facaAlgoDoidoCom(helpers.transform($('#foo')));
 });
 ```
-Apps baseados em `require.js` geralmente terão u´m único ponto de acesso (`main.js`) que é passado à tag script do `require.js` como um data-attribute. Ele vai ser automaticamente carregado e executado com o carregamento da página:
+Apps baseados em `require.js` geralmente terão um único ponto de acesso (`main.js`) que é passado à tag script do `require.js` como um data-attribute. Ele vai ser automaticamente carregado e executado com o carregamento da página:
 
 ```html
 <!DOCTYPE html>
-- 
cgit v1.2.3


From 62892f4ca1a838eb556b3cbd4122d89a8b9f87b7 Mon Sep 17 00:00:00 2001
From: Victor Bastos <victorwpbastos@gmail.com>
Date: Mon, 23 Oct 2017 13:14:03 -0200
Subject: [asciidoc/pt-br] Small typo

---
 pt-br/asciidoc-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/asciidoc-pt.html.markdown b/pt-br/asciidoc-pt.html.markdown
index 1dee31db..b12c0693 100644
--- a/pt-br/asciidoc-pt.html.markdown
+++ b/pt-br/asciidoc-pt.html.markdown
@@ -99,7 +99,7 @@ Para criar uma lista com marcadores use asteriscos.
 * baz
 ```
 
-Para criar uma lista númerada use pontos.
+Para criar uma lista numerada use pontos.
 
 ```
 . item 1
-- 
cgit v1.2.3


From b485624a93bc10f22753d81726ec3481652ee5bc Mon Sep 17 00:00:00 2001
From: Victor Bastos <victorwpbastos@gmail.com>
Date: Mon, 23 Oct 2017 13:19:59 -0200
Subject: [asymptotic-notation/pt-br] Small typo

---
 pt-br/asymptotic-notation-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/asymptotic-notation-pt.html.markdown b/pt-br/asymptotic-notation-pt.html.markdown
index 2e299d09..aecc2194 100644
--- a/pt-br/asymptotic-notation-pt.html.markdown
+++ b/pt-br/asymptotic-notation-pt.html.markdown
@@ -38,7 +38,7 @@ Na primeira seção desse documento, descrevemos como Notação Assintótica ide
  *f*, *n* como o tamanho da entrada e *f(n)* sendo o tempo de execução. Então,
  para dado algoritmo *f*, com entrada de tamanho *n*, você terá tempo de execução
  *f(n)*. Isto resulta em um gráfico onde a coordernada Y é o tempo de execução
-, a coordernada X representa o tamanho da entrada e os pontos representao o tempo
+, a coordernada X representa o tamanho da entrada e os pontos representam o tempo
 de execução para dado tamanho de entrada.
 
 Você pode representar a função, ou o algoritmo, com Notação Assintótica de várias
-- 
cgit v1.2.3


From 0f3b319d66cbf0193d017fc6e18facbbc96469c9 Mon Sep 17 00:00:00 2001
From: Victor Bastos <victorwpbastos@gmail.com>
Date: Mon, 23 Oct 2017 13:30:25 -0200
Subject: [c++/pt-br] Small typos

---
 pt-br/c++-pt.html.markdown | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown
index c1cfbbb1..09bfc825 100644
--- a/pt-br/c++-pt.html.markdown
+++ b/pt-br/c++-pt.html.markdown
@@ -20,7 +20,7 @@ foi concebida para
 
 Embora sua sintaxe pode ser mais difícil ou complexa do que as linguagens mais
 recentes, C++ é amplamente utilizado porque compila para instruções nativas que
-podem ser executadas diretamente pelo processador e oferece um controlo rígido sobre hardware (como C), enquanto oferece recursos de alto nível, como os
+podem ser executadas diretamente pelo processador e oferece um controle rígido sobre hardware (como C), enquanto oferece recursos de alto nível, como os
 genéricos, exceções e classes. Esta combinação de velocidade e funcionalidade
 faz C++ uma das linguagens de programação mais utilizadas.
 
@@ -40,10 +40,10 @@ faz C++ uma das linguagens de programação mais utilizadas.
 
 int main(int argc, char** argv)
 {
-    // Argumentos de linha de comando são passados em pelo argc e argv da mesma
+    // Argumentos de linha de comando são passados para argc e argv da mesma
     // forma que eles estão em C.
     // argc indica o número de argumentos,
-    // e argv é um array de strings, feito C (char*) representado os argumentos
+    // e argv é um array de strings, feito C (char*) representando os argumentos
     // O primeiro argumento é o nome pelo qual o programa foi chamado.
     // argc e argv pode ser omitido se você não se importa com argumentos,
     // dando a assinatura da função de int main()
@@ -274,7 +274,7 @@ public:
 
     void setWeight(int dogsWeight);
 
-    // Funções que não modificam o estado do objecto devem ser marcadas como
+    // Funções que não modificam o estado do objeto devem ser marcadas como
     // const. Isso permite que você chamá-los se for dada uma referência const
     // para o objeto. Além disso, observe as funções devem ser explicitamente
     // declarados como _virtual_, a fim de ser substituídas em classes
-- 
cgit v1.2.3


From b057f5f2bd43368043c1b8ed19e5335e66d18cc0 Mon Sep 17 00:00:00 2001
From: Thiago Ribeiro <thiagofribeiro@gmail.com>
Date: Mon, 23 Oct 2017 13:44:26 -0200
Subject: [c/pt-br] small typo

---
 pt-br/c-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown
index 6e7aa8c2..c0cfb0ba 100644
--- a/pt-br/c-pt.html.markdown
+++ b/pt-br/c-pt.html.markdown
@@ -191,7 +191,7 @@ int main() {
     f1 / f2; // => 0.5, mais ou menos epsilon
     // Números e cálculos de ponto flutuante não são exatos
 
-    // Modulo também existe
+    // Módulo também existe
     11 % 3; // => 2
 
 	// Operadores de comparação provavelmente são familiares,
-- 
cgit v1.2.3


From fc57b35478e2ba624005fdb0138c98bb4916fbf4 Mon Sep 17 00:00:00 2001
From: Paulo Henrique Rodrigues Pinheiro <paulohrpinheiro@gmail.com>
Date: Mon, 23 Oct 2017 16:16:44 -0200
Subject: Translate whip to pt_BR

---
 pt-br/whip-pt.html.markdown | 247 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 247 insertions(+)
 create mode 100644 pt-br/whip-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/whip-pt.html.markdown b/pt-br/whip-pt.html.markdown
new file mode 100644
index 00000000..989bae05
--- /dev/null
+++ b/pt-br/whip-pt.html.markdown
@@ -0,0 +1,247 @@
+---
+language: whip
+contributors:
+  - ["Tenor Biel", "http://github.com/L8D"]
+  - ["Saurabh Sandav", "http://github.com/SaurabhSandav"]
+author: Tenor Biel
+author_url: http://github.com/L8D
+translators:
+  - ["Paulo Henrique Rodrigues Pinheiro", "https://github.com/paulohrpinheiro"]
+lang: pt-br
+filename: whip-pt.lisp
+---
+
+Whip é um dialeto de Lisp feito para construir scripts e trabalhar com
+conceitos mais simples.
+Ele também copia muitas funções e sintaxe de Haskell (uma linguagem não correlata)
+
+Esse documento foi escrito pelo próprio  autor da linguagem. Então é isso.
+
+```scheme
+; Comentário são como em Lisp. Pontos-e-vírgulas...
+
+; A maioria das declarações de primeiro nível estão dentro de "listas"
+; que nada mais são que coisas entre parêntesis separadas por espaços em branco
+nao_é_uma_lista
+(uma lista)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; 1. Números, texto e operadores
+
+; Whip tem um tipo numérico (que é um double de 64 bits IEE 754, do JavaScript)
+3 ; => 3
+1.5 ; => 1.5
+
+; Funções são chamadas se elas são o primeiro elemento em uma lista
+(funcao_chamada argumentos)
+
+; A maioria das operações são feitas com funções
+; Todas as funções aritméticas básicas são bem diretas
+(+ 1 1) ; => 2
+(- 2 1) ; => 1
+(* 1 2) ; => 2
+(/ 2 1) ; => 2
+; até mesmo o módulo
+(% 9 4) ; => 1
+; Divisão não inteira ao estilo JavaScript.
+(/ 5 2) ; => 2.5
+
+; Aninhamento de listas funciona como esperado.
+(* 2 (+ 1 3)) ; => 8
+
+; Há um tipo boleano.
+true
+false
+
+; Textos são criados com ".
+"Hello, world"
+
+; Caracteres são criados com '.
+'a'
+
+; Para negação usa-se a função 'not'.
+(not true) ; => false
+(not false) ; => true
+
+; Mas a maioria das funções não-haskell tem atalhos
+; o não atalho é um '!'.
+(! (! true)) ; => true
+
+; Igualdade é `equal` ou `=`.
+(= 1 1) ; => true
+(equal 2 1) ; => false
+
+; Por exemplo, inigualdade pode ser verificada combinando as funções
+;`not` e `equal`.
+(! (= 2 1)) ; => true
+
+; Mais comparações
+(< 1 10) ; => true
+(> 1 10) ; => false
+; e suas contra partes para texto.
+(lesser 1 10) ; => true
+(greater 1 10) ; => false
+
+; Texto pode ser concatenado com +.
+(+ "Hello " "world!") ; => "Hello world!"
+
+; Você pode usar as características comparativas do JavaScript.
+(< 'a' 'b') ; => true
+; ... e coerção de tipos
+(= '5' 5)
+
+; As funções `at` ou `@` acessarão caracteres de um texto, começando em 0.
+(at 0 'a') ; => 'a'
+(@ 3 "foobar") ; => 'b'
+
+; Também existem as variáveis `null` e `undefined`.
+null ; usada para indicar a ausência de algum valor
+undefined ; usada para indicar que um valor não foi informado
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; 2. Variáveis, matrizes e dicionários
+
+; Variáveis são declaradas com as funções `def` ou `let`.
+; Variáveis que não tiveram valor atribuído serão `undefined`.
+(def some_var 5)
+; `def` deixará a variável no contexto global.
+; `let` deixará a variável no contexto local, e tem uma sintaxe estranha.
+(let ((a_var 5)) (+ a_var 5)) ; => 10
+(+ a_var 5) ; = undefined + 5 => undefined
+
+; Matrizes são listas de valores de qualquer tipo.
+; Elas basicamente são listas sem funções no início
+(1 2 3) ; => [1, 2, 3] (sintaxe JavaScript)
+
+; Dicionários em Whip são o equivalente a 'object' em JavaScript ou
+; 'dict' em python ou 'hash' em Ruby: eles s]ão uma coleção desordenada
+de pares chave-valor.
+{"key1" "value1" "key2" 2 3 3}
+
+; Chaves podem ser apenas identificadores, números ou texto.
+(def my_dict {my_key "my_value" "my other key" 4})
+; Mas em Whip, dicionários são parceados como: valor, espaço, valor;
+; com mais espaço entre cada. Então isso significa que
+{"key" "value"
+"another key"
+1234
+}
+é avaliado da mesma forma que
+{"key" "value" "another key" 1234}
+
+; Dicionários podem ser acessados usando a função `at`
+; (como em texto e listas)
+(@ "my other key" my_dict) ; => 4
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; 3. Lógica e controle de fluxo
+
+; A função `if` é muito simples, ainda que muito diferente do que em muitas
+linguagens imperativas.
+(if true "returned if first arg is true" "returned if first arg is false")
+; => "returned if first arg is true"
+
+; E por conta do legado operador ternário
+; `?` é o atalho não utilizado para `if`.
+(? false true false) ; => false
+
+; `both` é uma declaração lógica `and`, e `either` é o `or` lógico.
+(both true true) ; => true
+(both true false) ; => false
+(either true false) ; => true
+(either false false) ; => false
+; E seus atalhos são
+; & => both
+; ^ => either
+(& true true) ; => true
+(^ false true) ; => true
+
+;;;;;;;;;
+; Lambdas
+
+; Lambdas em Whip são declaradas com as funções `lambda` ou `->`.
+; E funções são na verdade lambdas com nomes.
+(def my_function (-> (x y) (+ (+ x y) 10)))
+;         |       |    |          |
+;         |       |    |    valor retornado (com escopo contento argumentos)
+;         |       | argumentos
+;         | declaração de funções lambda
+;         |
+;   nome do lambda a ser declarado
+
+(my_function 10 10) ; = (+ (+ 10 10) 10) => 30
+
+; Obviamente, todos os lambdas por definição são anônimos e
+; tecnicamente sempre usados anonimamente. Redundância.
+((lambda (x) x) 10) ; => 10
+
+;;;;;;;;;;;;;;;;
+; Comprehensions
+
+; `range` or `..` geram uma lista dos números para
+; cada número entre seus dois argumentos.
+(range 1 5) ; => (1 2 3 4 5)
+(.. 0 2)    ; => (0 1 2)
+
+; `map` aplica seu primeiro argumento (que deve ser um lambda/função)
+; a cada item dos argumentos seguintes (que precisa ser uma lista)
+(map (-> (x) (+ x 1)) (1 2 3)) ; => (2 3 4)
+
+; Reduce
+(reduce + (.. 1 5))
+; equivalente a
+((+ (+ (+ 1 2) 3) 4) 5)
+
+; Nota: map e reduce não possuem atalhos
+
+; `slice` ou `\` é similar ao .slice() do JavaScript
+; mas veja que ele pega uma lista como primeiro argumento, não o último.
+(slice (.. 1 5) 2) ; => (3 4 5)
+(\ (.. 0 100) -5) ; => (96 97 98 99 100)
+
+; `append` ou `<<` são auto explicativos
+(append 4 (1 2 3)) ; => (1 2 3 4)
+(<< "bar" ("foo")) ; => ("foo" "bar")
+
+; Length é auto explicativo.
+(length (1 2 3)) ; => 3
+(_ "foobar") ; => 6
+
+;;;;;;;;;;;;;;;
+; Delicadezas Haskell
+
+; Primeiro item de uma lista
+(head (1 2 3)) ; => 1
+; Pega do segundo ao último elemento de uma lista
+(tail (1 2 3)) ; => (2 3)
+; Último item de uma lista
+(last (1 2 3)) ; => 3
+; Contrário de `tail`
+(init (1 2 3)) ; => (1 2)
+; Pega do primeiro até o elemento especificado da lista
+(take 1 (1 2 3 4)) ; (1 2)
+; Contrário de `take`
+(drop 1 (1 2 3 4)) ; (3 4)
+; Menos valor em uma lista
+(min (1 2 3 4)) ; 1
+; Maior valor em uma lista
+(max (1 2 3 4)) ; 4
+; Verifica se o valor está em uma lista ou objeto
+(elem 1 (1 2 3)) ; true
+(elem "foo" {"foo" "bar"}) ; true
+(elem "bar" {"foo" "bar"}) ; false
+; Inverte a ordem de uma lista
+(reverse (1 2 3 4)) ; => (4 3 2 1)
+; Verifica se o valor é par ou ímpar
+(even 1) ; => false
+(odd 1) ; => true
+; Separa um texto cortando por espaço em branco
+(words "foobar nachos cheese") ; => ("foobar" "nachos" "cheese")
+; Junta lista de textos
+(unwords ("foo" "bar")) ; => "foobar"
+; Sucessor e predecessor
+(pred 21) ; => 20
+(succ 20) ; => 21
+```
+
+Para mais informação, verifique o [repositório](http://github.com/L8D/whip)
-- 
cgit v1.2.3


From ab84fe8cf57d42b78b4a6d441ebd47acc65bd520 Mon Sep 17 00:00:00 2001
From: Antonio Roberto Furlaneto <arfurlaneto@gmail.com>
Date: Wed, 25 Oct 2017 23:27:36 -0200
Subject: [c#/pt-br] Small typos

---
 pt-br/csharp-pt.html.markdown | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index 547f4817..377ac984 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -6,23 +6,23 @@ contributors:
 lang: pt-br
 ---
 
-C# é uma linguagem elegante e altamente tipado orientada a objetos que permite aos desenvolvedores criarem uma variedade de aplicações seguras e robustas que são executadas no .NET Framework.
+C# é uma linguagem elegante, altamente tipada e orientada a objetos que permite aos desenvolvedores criar uma variedade de aplicações seguras e robustas que são executadas no .NET Framework.
 
-[Read more here.](http://msdn.microsoft.com/pt-br/library/vstudio/z1zx9t92.aspx)
+[Leia mais aqui.](http://msdn.microsoft.com/pt-br/library/vstudio/z1zx9t92.aspx)
 
 ```c#
-// Comentário de linha única começa com //
+// Comentários de linha única começam com //
 /*
-Múltipas linhas é desta forma
+Comentários de múltiplas linhas são desta forma
 */
 /// <summary>
-/// Esta é uma documentação comentário XML que pode ser usado para gerar externo
-/// documentação ou fornecer ajuda de contexto dentro de um IDE
+/// Este é um comentário de documentação XML que pode ser usado para gerar documentação
+/// externa ou para fornecer ajuda de contexto dentro de uma IDE
 /// </summary>
 //public void MethodOrClassOrOtherWithParsableHelp() {}
 
-// Especificar qual namespace seu código irá usar
-// Os namespaces a seguir são padrões do .NET Framework Class Library 
+// Especifica os namespaces que o código irá usar
+// Os namespaces a seguir são padrões da biblioteca de classes do .NET Framework
 using System;
 using System.Collections.Generic;
 using System.Dynamic;
@@ -33,11 +33,11 @@ using System.IO;
 
 // Mas este aqui não é :
 using System.Data.Entity;
-// Para que consiga utiliza-lo, você precisa adicionar novas referências
+// Para que consiga utilizá-lo, você precisa adicionar novas referências
 // Isso pode ser feito com o gerenciador de pacotes NuGet : `Install-Package EntityFramework`
 
-// Namespaces são escopos definidos para organizar o códgo em "pacotes" or "módulos"
-// Usando este código a partir de outra arquivo de origem: using Learning.CSharp;
+// Namespaces são escopos definidos para organizar o código em "pacotes" ou "módulos"
+// Usando este código a partir de outro arquivo de origem: using Learning.CSharp;
 namespace Learning.CSharp
 {
     // Cada .cs deve conter  uma classe com o mesmo nome do arquivo
-- 
cgit v1.2.3


From d1b6dda7bd074ba76c0d136d4176f358b0a94adb Mon Sep 17 00:00:00 2001
From: Antonio Roberto Furlaneto <arfurlaneto@gmail.com>
Date: Wed, 25 Oct 2017 23:38:59 -0200
Subject: [java/pt-br] Small typo

---
 pt-br/java-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/java-pt.html.markdown b/pt-br/java-pt.html.markdown
index 82989502..1b9d7fc6 100644
--- a/pt-br/java-pt.html.markdown
+++ b/pt-br/java-pt.html.markdown
@@ -42,7 +42,7 @@ public class LearnJava {
             " Double: " + 3.14 +
             " Boolean: " + true);
 
-        // Para imprimir sem inserir uma nova lina, use o System.out.print
+        // Para imprimir sem inserir uma nova linha, use o System.out.print
         System.out.print("Olá ");
         System.out.print("Mundo");
 
-- 
cgit v1.2.3


From a246fb409059fce98b5f4ebf6ae17036112ce750 Mon Sep 17 00:00:00 2001
From: Antonio Roberto Furlaneto <arfurlaneto@gmail.com>
Date: Wed, 25 Oct 2017 23:42:06 -0200
Subject: [json/pt-br] Small typo

---
 pt-br/json-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/json-pt.html.markdown b/pt-br/json-pt.html.markdown
index fd822c03..62d9ccad 100644
--- a/pt-br/json-pt.html.markdown
+++ b/pt-br/json-pt.html.markdown
@@ -16,7 +16,7 @@ Como JSON é um formato de intercâmbio de dados, este será, muito provavelment
 JSON na sua forma mais pura não tem comentários, mas a maioria dos analisadores 
 aceitarão comentários no estilo C (//, /\* \*/). No entanto estes devem ser evitados para otimizar a compatibilidade.
 
-Um valor JSON pode ser um numero, uma string, um array, um objeto, um booleano (true, false) ou null.
+Um valor JSON pode ser um número, uma string, um array, um objeto, um booleano (true, false) ou null.
 
 Os browsers suportados são: Firefox 3.5+, Internet Explorer 8.0+, Chrome 1.0+, Opera 10.0+, e Safari 4.0+.
 
-- 
cgit v1.2.3


From 5a4785cac438809a714a700ad15e09518052c014 Mon Sep 17 00:00:00 2001
From: Antonio Roberto Furlaneto <arfurlaneto@gmail.com>
Date: Wed, 25 Oct 2017 23:46:29 -0200
Subject: [javascript/pt-br] Small typo

---
 pt-br/javascript-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/javascript-pt.html.markdown b/pt-br/javascript-pt.html.markdown
index 7b6729ef..ed4a6ff3 100644
--- a/pt-br/javascript-pt.html.markdown
+++ b/pt-br/javascript-pt.html.markdown
@@ -25,7 +25,7 @@ Feedback são muito apreciados! Você me encontrar em
 
 ```js
 // Comentários são como em C. Comentários de uma linha começam com duas barras,
-/* e comentários de múltplas linhas começam com barra-asterisco
+/* e comentários de múltiplas linhas começam com barra-asterisco
    e fecham com asterisco-barra */
 
 // comandos podem ser terminados com  ;
-- 
cgit v1.2.3


From 5670c7381dbffa12b3d2b5e51ac9b8b1c4d9dca1 Mon Sep 17 00:00:00 2001
From: Fer <nanda.fer@gmail.com>
Date: Thu, 26 Oct 2017 11:22:40 -0200
Subject: [csharp/pt-br] Missing translation

---
 pt-br/csharp-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index 547f4817..800e3097 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -823,7 +823,7 @@ on a new line! ""Wow!"", the masses cried";
         }
     }
 
-    // Interfaces only contain signatures of the members, without the implementation.
+    // Interfaces contêm apenas as assinaturas dos membros, sem a implementação.
     interface IJumpable
     {
         void Jump(int meters); // all interface members are implicitly public
-- 
cgit v1.2.3


From 9f7322b6208a693a013df81da6b1aadd095b78fd Mon Sep 17 00:00:00 2001
From: Fer <nanda.fer@gmail.com>
Date: Thu, 26 Oct 2017 12:39:25 -0200
Subject: [csharp/pt-br] Missing translation

---
 pt-br/csharp-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index 547f4817..3f13f1aa 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -784,7 +784,7 @@ on a new line! ""Wow!"", the masses cried";
 
     } // end class Bicycle
 
-    // PennyFarthing is a subclass of Bicycle
+    // PennyFarthing é uma subclasse de Bicycle
     class PennyFarthing : Bicycle
     {
         // (Penny Farthings are those bicycles with the big front wheel.
-- 
cgit v1.2.3


From b5cac96eff8d92f9fb736d6e3e61d21d771f1e2a Mon Sep 17 00:00:00 2001
From: Fer <nanda.fer@gmail.com>
Date: Thu, 26 Oct 2017 12:44:09 -0200
Subject: [csharp/pt-br] Missing translation

---
 pt-br/csharp-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index 547f4817..cc3885d2 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -790,7 +790,7 @@ on a new line! ""Wow!"", the masses cried";
         // (Penny Farthings are those bicycles with the big front wheel.
         // They have no gears.)
 
-        // calling parent constructor
+        // chamando construtor pai
         public PennyFarthing(int startCadence, int startSpeed) :
             base(startCadence, startSpeed, 0, "PennyFarthing", true, BikeBrand.Electra)
         {
-- 
cgit v1.2.3


From ee3f34379abd8bea7274d024571b8596c6c759d4 Mon Sep 17 00:00:00 2001
From: Fer <nanda.fer@gmail.com>
Date: Thu, 26 Oct 2017 12:47:42 -0200
Subject: [csharp/pt-br] Missing translation

---
 pt-br/csharp-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index 547f4817..a1bd980b 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -762,7 +762,7 @@ on a new line! ""Wow!"", the masses cried";
             }
         }
 
-        //Method to display the attribute values of this Object.
+        //Método para exibir os valores dos atributos deste objeto.
         public virtual string Info()
         {
             return "Gear: " + Gear +
-- 
cgit v1.2.3


From 18eb083fb64c77b6cf4aec36686a7058f2b03fdc Mon Sep 17 00:00:00 2001
From: lbertolazzi <33129418+lbertolazzi@users.noreply.github.com>
Date: Thu, 26 Oct 2017 13:42:44 -0200
Subject: [css/pt-br] Missing translation

---
 pt-br/css-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/css-pt.html.markdown b/pt-br/css-pt.html.markdown
index b1fbd961..956b3614 100644
--- a/pt-br/css-pt.html.markdown
+++ b/pt-br/css-pt.html.markdown
@@ -25,7 +25,7 @@ O foco principal deste artigo é sobre a sintaxe e algumas dicas gerais.
 
 ```css
 /* Comentários aparecem dentro do slash-asterisk, tal como esta linha!
-   não há "comentários de uma linha"; este é o único estilo de comentário * /
+   Não há "comentários de uma linha"; este é o único estilo de comentário * /
 
 /* ####################
    ## SELETORES
-- 
cgit v1.2.3


From 12d4277200728b24c11da63d069c30ba555ac49c Mon Sep 17 00:00:00 2001
From: daniloyamauti <33129352+daniloyamauti@users.noreply.github.com>
Date: Thu, 26 Oct 2017 13:48:09 -0200
Subject: [c++/pt-br] Small typos

---
 pt-br/c++-pt.html.markdown | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown
index 09bfc825..cd4adde7 100644
--- a/pt-br/c++-pt.html.markdown
+++ b/pt-br/c++-pt.html.markdown
@@ -18,9 +18,9 @@ foi concebida para
 - suportar programação orientada a objetos
 - suportar programação genérica
 
-Embora sua sintaxe pode ser mais difícil ou complexa do que as linguagens mais
-recentes, C++ é amplamente utilizado porque compila para instruções nativas que
-podem ser executadas diretamente pelo processador e oferece um controle rígido sobre hardware (como C), enquanto oferece recursos de alto nível, como os
+Embora sua sintaxe possa ser mais difícil ou complexa do que as linguagens mais
+recentes, C++ é amplamente utilizada porque compila para instruções nativas que
+podem ser executadas diretamente pelo processador e oferece um controle rígido sobre o hardware (como C), enquanto oferece recursos de alto nível, como os
 genéricos, exceções e classes. Esta combinação de velocidade e funcionalidade
 faz C++ uma das linguagens de programação mais utilizadas.
 
-- 
cgit v1.2.3


From 469740c35f4059ece40887f881d27705a536e35f Mon Sep 17 00:00:00 2001
From: lbertolazzi <33129418+lbertolazzi@users.noreply.github.com>
Date: Thu, 26 Oct 2017 13:51:16 -0200
Subject: [perl/pt-br] Missing translation

---
 pt-br/perl-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/perl-pt.html.markdown b/pt-br/perl-pt.html.markdown
index cc07a2ec..ff01c31a 100644
--- a/pt-br/perl-pt.html.markdown
+++ b/pt-br/perl-pt.html.markdown
@@ -52,7 +52,7 @@ my %fruta_cor = (
   banana => "amarelo",
 );
 
-# Scalars, arrays and hashes são documentados mais profundamentes em perldata.
+# Scalars, arrays and hashes são documentados mais profundamente em perldata.
 # (perldoc perldata).
 
 # Mais tipos de dados complexos podem ser construídas utilizando referências,
-- 
cgit v1.2.3


From e787065d76fdf9eeba2747e3b5baaadd532156da Mon Sep 17 00:00:00 2001
From: lbertolazzi <33129418+lbertolazzi@users.noreply.github.com>
Date: Thu, 26 Oct 2017 13:52:52 -0200
Subject: [perl/pt-br] Missing translation

---
 pt-br/perl-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/perl-pt.html.markdown b/pt-br/perl-pt.html.markdown
index cc07a2ec..19a72635 100644
--- a/pt-br/perl-pt.html.markdown
+++ b/pt-br/perl-pt.html.markdown
@@ -55,7 +55,7 @@ my %fruta_cor = (
 # Scalars, arrays and hashes são documentados mais profundamentes em perldata.
 # (perldoc perldata).
 
-# Mais tipos de dados complexos podem ser construídas utilizando referências,
+# Mais tipos de dados complexos podem ser construídos utilizando referências,
 # o que permite que você crie listas e hashes dentro de listas e hashes.
 
 #### Condicionais e construtores de iteração
-- 
cgit v1.2.3


From adb4fb69ad4554665d9708ca3e82b22464dbb98f Mon Sep 17 00:00:00 2001
From: lbertolazzi <33129418+lbertolazzi@users.noreply.github.com>
Date: Thu, 26 Oct 2017 13:55:43 -0200
Subject: [perl/pt-br] Missing translation

---
 pt-br/perl-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/perl-pt.html.markdown b/pt-br/perl-pt.html.markdown
index cc07a2ec..c1e6e76f 100644
--- a/pt-br/perl-pt.html.markdown
+++ b/pt-br/perl-pt.html.markdown
@@ -21,7 +21,7 @@ Perl 5 roda em mais de 100 plataformas, de portáteis a mainframes e é adequada
 
 # Variáveis iniciam com um sigilo, que é um símbolo que mostra o tipo.
 # Um nome de variável válido começa com uma letra ou sublinhado,
-# seguido por qualquer número de letras, números ou sublinhados.
+# seguido por qualquer quantidade de letras, números ou sublinhados.
 
 ### Perl has three main variable types: $scalar, @array, e %hash.
 
-- 
cgit v1.2.3


From 1569318bdcfea0c486cd2fa6a374446fe6ae02c0 Mon Sep 17 00:00:00 2001
From: daniloyamauti <33129352+daniloyamauti@users.noreply.github.com>
Date: Thu, 26 Oct 2017 14:11:13 -0200
Subject: [c++/pt-br] Small typos

---
 pt-br/c-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown
index c0cfb0ba..0dca7ab0 100644
--- a/pt-br/c-pt.html.markdown
+++ b/pt-br/c-pt.html.markdown
@@ -182,7 +182,7 @@ int main() {
     int a, b, c;
     a = b = c = 0;
 
-    // Aritimética é óbvia
+    // Aritmética é óbvia
     i1 + i2; // => 3
     i2 - i1; // => 1
     i2 * i1; // => 2
-- 
cgit v1.2.3


From 189336c674856a036112b9b32a6254b07aa6aa75 Mon Sep 17 00:00:00 2001
From: daniloyamauti <33129352+daniloyamauti@users.noreply.github.com>
Date: Thu, 26 Oct 2017 14:21:20 -0200
Subject: [visualbasic/pt-br] Small typos

---
 pt-br/visualbasic-pt.html.markdown | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/visualbasic-pt.html.markdown b/pt-br/visualbasic-pt.html.markdown
index 76cca567..b94ab609 100644
--- a/pt-br/visualbasic-pt.html.markdown
+++ b/pt-br/visualbasic-pt.html.markdown
@@ -15,9 +15,9 @@ module Module1
 
     Sub Main ()
         ' Uma visão geral de console de aplicativos do Visual Basic antes de 
-        ' mergulharmos mais profundamente na linguagem
+        ' mergulharmos mais profundamente na linguagem.
         ' Aspas simples começam comentários.
-        ' Para Navegar este tutorial dentro do compilador do Visual Basic, 
+        ' Para navegar neste tutorial dentro do compilador do Visual Basic, 
         ' eu criei um sistema de navegação.
         ' Este sistema de navegação vai ser explicado conforme avançarmos no
         ' tutorial, e você vai entender o que isso significa.
@@ -93,16 +93,16 @@ module Module1
     Private Sub HelloWorldInput ()
         Console.Title = " Olá Mundo YourName | Saiba X em Y Minutes"
         ' Variáveis
-        'Os dados inseridos por um usuário precisa ser armazenada .
+        'Os dados inseridos por um usuário precisam ser armazenados.
         ' As variáveis ​​também começar com um Dim e terminar com um Como VariableType .
 
-        ' Neste tutorial, nós queremos saber o que o seu nome, e faça o programa
+        ' Neste tutorial, nós queremos saber qual é o seu nome, e faça o programa
         ' Responder ao que é dito.
         Nome de usuário Dim As String
         " Nós usamos string como string é uma variável de texto baseado .
         Console.WriteLine (" Olá, Qual é o seu nome? ") ' Peça ao usuário seu nome.
-        username = Console.ReadLine () ' armazena o nome usuários.
-        Console.WriteLine (" Olá " + nome do usuário) " A saída é Olá ' Seu nome '
+        username = Console.ReadLine () ' armazena o nome do usuário.
+        Console.WriteLine (" Olá " + username) ' A saída é "Olá < seu nome >".
         Console.ReadLine () ' Outsputs acima.
         ' O código acima irá lhe fazer uma pergunta seguiu imprimindo sua resposta.
         " Outras variáveis ​​incluem Integer e usamos inteiro para números inteiros.
-- 
cgit v1.2.3


From c14dc8fd1d0f04b90c9e5195bb21acc88f90e05b Mon Sep 17 00:00:00 2001
From: Fer <nanda.fer@gmail.com>
Date: Fri, 27 Oct 2017 07:55:22 -0200
Subject: Update csharp-pt.html.markdown

---
 pt-br/csharp-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index 800e3097..a6e82211 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -826,7 +826,7 @@ on a new line! ""Wow!"", the masses cried";
     // Interfaces contêm apenas as assinaturas dos membros, sem a implementação.
     interface IJumpable
     {
-        void Jump(int meters); // all interface members are implicitly public
+        void Jump(int meters); // todos os membros da interface são implicitamente públicos
     }
 
     interface IBreakable
-- 
cgit v1.2.3


From e063c7ef3556cc3b8fc2515a8175474461c83a2d Mon Sep 17 00:00:00 2001
From: Fer <nanda.fer@gmail.com>
Date: Fri, 27 Oct 2017 08:03:05 -0200
Subject: Update csharp-pt.html.markdown

---
 pt-br/csharp-pt.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index 3f13f1aa..8d34d772 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -787,8 +787,8 @@ on a new line! ""Wow!"", the masses cried";
     // PennyFarthing é uma subclasse de Bicycle
     class PennyFarthing : Bicycle
     {
-        // (Penny Farthings are those bicycles with the big front wheel.
-        // They have no gears.)
+        // (Penny Farthings são aquelas bicicletas com uma grande roda frontal.
+        // Elas não tem correias.)
 
         // calling parent constructor
         public PennyFarthing(int startCadence, int startSpeed) :
-- 
cgit v1.2.3


From 46fab3c0be2852661fb972555a20c9f7083ad17d Mon Sep 17 00:00:00 2001
From: milenaduo <33162200+milenaduo@users.noreply.github.com>
Date: Fri, 27 Oct 2017 16:20:32 -0200
Subject: [dynamic-programming/pt-br] - Small typos

---
 pt-br/dynamic-programming-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/dynamic-programming-pt.html.markdown b/pt-br/dynamic-programming-pt.html.markdown
index 8de9bee6..b4ace9a4 100644
--- a/pt-br/dynamic-programming-pt.html.markdown
+++ b/pt-br/dynamic-programming-pt.html.markdown
@@ -22,7 +22,7 @@ Sempre se lembre!!
 
 ## Maneiras de Solucionar tais Problemas
 
-1. Top-Down (De cima para baixo): Começe solucionando o problema quebrando-o em 
+1. Top-Down (De cima para baixo): Comece solucionando o problema quebrando-o em 
 partes. Se você perceber que o problema já foi resolvido, então simplemente 
 pegue a resposta salva. Se ainda não foi resolvido, solucione-o e salve a 
 resposta. Isso é geralmente fácil de pensar e muito intuitivo. É geralmente 
-- 
cgit v1.2.3


From 1504f4af99ef6811158c270143e035bc6ac3eed4 Mon Sep 17 00:00:00 2001
From: milenaduo <33162200+milenaduo@users.noreply.github.com>
Date: Fri, 27 Oct 2017 16:21:48 -0200
Subject: [dynamic-programming/pt-br] - Small typos

---
 pt-br/dynamic-programming-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/dynamic-programming-pt.html.markdown b/pt-br/dynamic-programming-pt.html.markdown
index 8de9bee6..a90b11ec 100644
--- a/pt-br/dynamic-programming-pt.html.markdown
+++ b/pt-br/dynamic-programming-pt.html.markdown
@@ -29,7 +29,7 @@ resposta. Isso é geralmente fácil de pensar e muito intuitivo. É geralmente
 referenciado como Memorização.
 
 2. Bottom-Up (De baixo para cima): Analise o problema e veja a ordem em que os 
-subproblemas são resolvidos e começe a solucionar dos problemas mais triviais, 
+subproblemas são resolvidos e comece a solucionar dos problemas mais triviais, 
 até o problema dado. Neste processo, é garantido que os subproblemas são 
 resolvidos antes de resoler o problema. Isto é referenciado como Programação Dinâmica.
 
-- 
cgit v1.2.3


From 01bcf645997fbea7b5b6d8e5ffb01b9d9c5fc7a6 Mon Sep 17 00:00:00 2001
From: milenaduo <33162200+milenaduo@users.noreply.github.com>
Date: Fri, 27 Oct 2017 16:22:50 -0200
Subject: [dynamic-programming/pt-br] - Small typos

---
 pt-br/dynamic-programming-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/dynamic-programming-pt.html.markdown b/pt-br/dynamic-programming-pt.html.markdown
index 8de9bee6..40e6fda2 100644
--- a/pt-br/dynamic-programming-pt.html.markdown
+++ b/pt-br/dynamic-programming-pt.html.markdown
@@ -31,7 +31,7 @@ referenciado como Memorização.
 2. Bottom-Up (De baixo para cima): Analise o problema e veja a ordem em que os 
 subproblemas são resolvidos e começe a solucionar dos problemas mais triviais, 
 até o problema dado. Neste processo, é garantido que os subproblemas são 
-resolvidos antes de resoler o problema. Isto é referenciado como Programação Dinâmica.
+resolvidos antes de resolver o problema. Isto é referenciado como Programação Dinâmica.
 
 ## Exemplo de Programação Dinâmica
 
-- 
cgit v1.2.3


From 5f5dd74260efd76af39262c1608cd3c3e14f5576 Mon Sep 17 00:00:00 2001
From: milenaduo <33162200+milenaduo@users.noreply.github.com>
Date: Fri, 27 Oct 2017 16:29:00 -0200
Subject: [dynamic-programming/pt-br] - Better reading

---
 pt-br/dynamic-programming-pt.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/dynamic-programming-pt.html.markdown b/pt-br/dynamic-programming-pt.html.markdown
index 8de9bee6..45b52790 100644
--- a/pt-br/dynamic-programming-pt.html.markdown
+++ b/pt-br/dynamic-programming-pt.html.markdown
@@ -51,7 +51,7 @@ array antecedente e uma variável como maiorSequenciasAteAgora e seu índice
 ajudariam a poupar muito tempo.
 Um conceito similar poderia ser aplicado ao procurar o maior caminho em um 
 grafo acíclico dirigido.
----------------------------------------------------------------------------
+
 ```
  for i=0 to n-1
             LS[i]=1
@@ -62,7 +62,7 @@ grafo acíclico dirigido.
             if (largest < LS[i])
 ```
 
-### Alguns Problemas Famosos de Programação Dinâmica
+## Alguns Problemas Famosos de Programação Dinâmica
 ```
 Floyd Warshall Algorithm - Tutorial and C Program source code:http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code 
 
-- 
cgit v1.2.3


From c52ae61127b9b50f39e45876c672ed73ce4e2125 Mon Sep 17 00:00:00 2001
From: andys8 <andys8@users.noreply.github.com>
Date: Sat, 23 Dec 2017 11:57:45 +0100
Subject: [elm] Update code to access tuples

---
 pt-br/elm-pt.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/elm-pt.html.markdown b/pt-br/elm-pt.html.markdown
index 78a4f1b7..d2469a93 100644
--- a/pt-br/elm-pt.html.markdown
+++ b/pt-br/elm-pt.html.markdown
@@ -76,8 +76,8 @@ List.head [] -- Nothing
 
 -- Acesse os elementos de um par com as funções first e second.
 -- (Este é um atalho; nós iremos para o "caminho real" em breve.)
-fst ("elm", 42) -- "elm"
-snd ("elm", 42) -- 42
+Tuple.first ("elm", 42) -- "elm"
+Tuple.second ("elm", 42) -- 42
 
 -- Uma tupla vazia ou "unidade" às vezes é utilizada como um placeholder.
 -- É o único valor de seu tipo, também chamado de "Unit".
-- 
cgit v1.2.3


From d28abc39451bf1b075945d46ab372bb30f8b59fa Mon Sep 17 00:00:00 2001
From: suuuzi <tetestonaldo@gmail.com>
Date: Sun, 31 Dec 2017 14:35:07 -0200
Subject: updating BF translation

---
 pt-br/bf-pt.html.markdown | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/bf-pt.html.markdown b/pt-br/bf-pt.html.markdown
index 52a5269e..53baa9a2 100644
--- a/pt-br/bf-pt.html.markdown
+++ b/pt-br/bf-pt.html.markdown
@@ -13,7 +13,9 @@ lang: pt-br
 Brainfuck (em letras minúsculas, exceto no início de frases) é uma linguagem de
 programação Turing-completa extremamente simples com apenas 8 comandos.
 
-```
+Você pode experimentar brainfuck pelo seu browser com [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
+
+```bf
 Qualquer caractere exceto "><+-.,[]" (sem contar as aspas) é ignorado.
 
 Brainfuck é representado por um vetor com 30 000 células inicializadas em zero
-- 
cgit v1.2.3


From a26d106ed72e7d4a391e73496cc65e0f7b559111 Mon Sep 17 00:00:00 2001
From: Pratik Karki <predatoramigo@gmail.com>
Date: Wed, 28 Feb 2018 16:12:00 +0545
Subject: Fix language name

---
 pt-br/bf-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/bf-pt.html.markdown b/pt-br/bf-pt.html.markdown
index 53baa9a2..c69995ab 100644
--- a/pt-br/bf-pt.html.markdown
+++ b/pt-br/bf-pt.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: bf
+language: Brainfuck
 filename: learnbf-pt.bf
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io/"]
-- 
cgit v1.2.3


From 5ae8ac9988522f290460e7341c303964fb4581bc Mon Sep 17 00:00:00 2001
From: Junior Damacena <juniordamacena980@gmail.com>
Date: Wed, 28 Feb 2018 11:21:47 -0300
Subject: [Dart/pt-br] Translated Dart to pt-BR (#3071)

* Added PT-BR translation to  Dart

* Translation in progress

* Translation in progress

* Moving the file to the correct language folder

* Translation in progress

* Translation finished

* Small adjustments

* File renamed to follow the naming convention

* Adjustments according to suggestions on the pull request
---
 pt-br/dart-pt.html.markdown | 508 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 508 insertions(+)
 create mode 100644 pt-br/dart-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/dart-pt.html.markdown b/pt-br/dart-pt.html.markdown
new file mode 100644
index 00000000..c127034c
--- /dev/null
+++ b/pt-br/dart-pt.html.markdown
@@ -0,0 +1,508 @@
+---
+language: dart
+filename: learndart-pt.dart
+contributors:
+    - ["Joao Pedrosa", "https://github.com/jpedrosa/"]
+translators:
+    - ["Junior Damacena", "https://github.com/jdamacena/"]
+lang: pt-br
+---
+
+Dart é uma novata no reino das linguagens de programação.
+Ela empresta muito de outras linguagens mais conhecidas, e tem a meta de não se diferenciar muito de seu irmão, JavaScript. Assim como JavaScript, Dart foi pensada para oferecer grande integração com o Browser.
+
+A característica mais controversa da Dart é a sua Tipagem Opcional, ou seja, não é obrigatório declarar tipos.
+
+```dart
+import "dart:collection";
+import "dart:math" as DM;
+
+// Bem vindo ao Aprenda Dart em 15 minutos. http://www.dartlang.org/
+// Este é um tutorial executável. Você pode rodar esse tutorial com Dart ou no
+// site Try Dart!, é só copiar e colar este código lá. http://try.dartlang.org/
+
+// Declarações de funções e métodos são iguais. Declarações de funções 
+// podem ser aninhadas. A declaração é feita das seguintes formas
+// nome() {} ou nome() => expressaoDeUmaLinhaSo;
+// A declaração feita com a seta tem um return implícito para o resultado da
+// expressão.
+example1() {
+  example1nested1() {
+    example1nested2() => print("Example1 nested 1 nested 2");
+    example1nested2();
+  }
+  example1nested1();
+}
+
+// Funções anônimas são criadas sem um nome.
+example2() {
+  example2nested1(fn) {
+    fn();
+  }
+  example2nested1(() => print("Example2 nested 1"));
+}
+
+// Quando uma função é declarada como parâmetro, a declaração pode incluir o número
+// de parâmetros que a função recebe, isso é feito especificando o nome de cada um dos 
+// parâmetros que serão recebidos pela função.
+example3() {
+  example3nested1(fn(informSomething)) {
+    fn("Example3 nested 1");
+  }
+  example3planB(fn) { // Ou não declare o número de parâmetros.
+    fn("Example3 plan B");
+  }
+  example3nested1((s) => print(s));
+  example3planB((s) => print(s));
+}
+
+// Funções têm acesso à variáveis fora de seu escopo
+var example4Something = "Example4 nested 1";
+example4() {
+  example4nested1(fn(informSomething)) {
+    fn(example4Something);
+  }
+  example4nested1((s) => print(s));
+}
+
+// Declaração de classe com um método chamado sayIt, que também tem acesso 
+// à variável externa, como se fosse uma função como se viu antes.
+var example5method = "Example5 sayIt";
+class Example5Class {
+  sayIt() {
+    print(example5method);
+  }
+}
+example5() {
+  // Criar uma instância anônima de Example5Class e chamar o método sayIt
+  // nela.
+  new Example5Class().sayIt();
+}
+
+// A declaração de uma classe é feita da seguinte maneira: class name { [classBody] }.
+// onde classBody pode incluir métodos e variáveis de instância, assim como
+// métodos e variáveis de classe.
+class Example6Class {
+  var example6InstanceVariable = "Example6 instance variable";
+  sayIt() {
+    print(example6InstanceVariable);
+  }
+}
+example6() {
+  new Example6Class().sayIt();
+}
+
+// Métodos e variáveis de classe são declarados como "static".
+class Example7Class {
+  static var example7ClassVariable = "Example7 class variable";
+  static sayItFromClass() {
+    print(example7ClassVariable);
+  }
+  sayItFromInstance() {
+    print(example7ClassVariable);
+  }
+}
+example7() {
+  Example7Class.sayItFromClass();
+  new Example7Class().sayItFromInstance();
+}
+
+// Literais são ótimos, mas há uma limitação para o que eles podem ser
+// quando estão fora do corpo de uma função/método. Literais fora do escopo da classe
+// ou fora da classe têm que ser constantes. Strings e números são constantes
+// por padrão. Mas arrays e mapas não. Eles podem ser declarados como constantes
+// usando o comando "const".
+var example8A = const ["Example8 const array"],
+  example8M = const {"someKey": "Example8 const map"};
+example8() {
+  print(example8A[0]);
+  print(example8M["someKey"]);
+}
+
+// Loops em Dart são criados com  for () {} ou while () {},
+// um pouco mais moderno temos for (.. in ..) {}, ou funções de callbacks com muitas
+// funcionalidades, começando com o forEach.
+var example9A = const ["a", "b"];
+example9() {
+  for (var i = 0; i < example9A.length; i++) {
+    print("Example9 for loop '${example9A[i]}'");
+  }
+  var i = 0;
+  while (i < example9A.length) {
+    print("Example9 while loop '${example9A[i]}'");
+    i++;
+  }
+  for (var e in example9A) {
+    print("Example9 for-in loop '${e}'");
+  }
+  example9A.forEach((e) => print("Example9 forEach loop '${e}'"));
+}
+
+// Para percorrer os caracteres de uma string ou extrair uma substring.
+var example10S = "ab";
+example10() {
+  for (var i = 0; i < example10S.length; i++) {
+    print("Example10 String character loop '${example10S[i]}'");
+  }
+  for (var i = 0; i < example10S.length; i++) {
+    print("Example10 substring loop '${example10S.substring(i, i + 1)}'");
+  }
+}
+
+// Int e double são os dois formatos de número suportados.
+example11() {
+  var i = 1 + 320, d = 3.2 + 0.01;
+  print("Example11 int ${i}");
+  print("Example11 double ${d}");
+}
+
+// DateTime traz operações com data/hora.
+example12() {
+  var now = new DateTime.now();
+  print("Example12 now '${now}'");
+  now = now.add(new Duration(days: 1));
+  print("Example12 tomorrow '${now}'");
+}
+
+// Expressões regulares são suportadas.
+example13() {
+  var s1 = "some string", s2 = "some", re = new RegExp("^s.+?g\$");
+  match(s) {
+    if (re.hasMatch(s)) {
+      print("Example13 regexp matches '${s}'");
+    } else {
+      print("Example13 regexp doesn't match '${s}'");
+    }
+  }
+  match(s1);
+  match(s2);
+}
+
+// Expressões booleanas precisam retornar ou true ou false, já que
+// Dart não faz a conversão implicitamente.
+example14() {
+  var v = true;
+  if (v) {
+    print("Example14 value is true");
+  }
+  v = null;
+  try {
+    if (v) {
+      // Nunca seria executada
+    } else {
+      // Nunca seria executada
+    }
+  } catch (e) {
+    print("Example14 null value causes an exception: '${e}'");
+  }
+}
+
+// try/catch/finally e throw são usados para tratamento de exceções.
+// throw aceita qualquer objeto como parâmetro;
+example15() {
+  try {
+    try {
+      throw "Some unexpected error.";
+    } catch (e) {
+      print("Example15 an exception: '${e}'");
+      throw e; // Re-throw
+    }
+  } catch (e) {
+    print("Example15 catch exception being re-thrown: '${e}'");
+  } finally {
+    print("Example15 Still run finally");
+  }
+}
+
+// Para mais eficiência ao criar strings longas dinamicamente, use o
+// StringBuffer. Ou você pode também concatenar um array de strings.
+example16() {
+  var sb = new StringBuffer(), a = ["a", "b", "c", "d"], e;
+  for (e in a) { sb.write(e); }
+  print("Example16 dynamic string created with "
+    "StringBuffer '${sb.toString()}'");
+  print("Example16 join string array '${a.join()}'");
+}
+
+// Strings podem ser concatenadas apenas colocando strings literais uma perto
+// da outra, sem necessidade de nenhum outro operador.
+example17() {
+  print("Example17 "
+      "concatenar "
+      "strings "
+      "é simples assim");
+}
+
+// Strings podem ser delimitadas por apóstrofos ou aspas e não há
+// diferença entre os dois. Essa flexibilidade pode ser boa para
+// evitar a necessidade de escapar conteúdos que contenham o delimitador da string.
+// Por exemplo, aspas dos atributos HTMLse a string conter HTML.
+example18() {
+  print('Example18 <a href="etc">'
+      "Don't can't I'm Etc"
+      '</a>');
+}
+
+// Strings com três apóstrofos ou aspas podem
+// ter muitas linhas e incluem os delimitadores de linha (ou seja, os enter).
+example19() {
+  print('''Example19 <a href="etc">
+Example19 Don't can't I'm Etc
+Example19 </a>''');
+}
+
+// Strings têm a função de interpolação que é chamada com o caractere $.
+// Com $ { [expression] }, o retorno da expressão é interpolado.
+// $ seguido pelo nome de uma variável interpola o conteúdo dessa variável.
+// $ pode ser escapedo assim \$.
+example20() {
+  var s1 = "'\${s}'", s2 = "'\$s'";
+  print("Example20 \$ interpolation ${s1} or $s2 works.");
+}
+
+// A tipagem opcional permite que APIs usem anotações e também ajuda os
+// IDEs na hora das refatorações, auto-complete e checagem de
+// erros. Note que até agora não declaramos nenhum tipo e o programa está
+// funcionando normalmente. De fato, os tipos são ignorados em tempo de execução.
+// Os tipos podem até mesmo estarem errados e o programa ainda vai dar o
+// benefício da dúvida e rodar, visto que os tipos não importam.
+// Existe um parâmetro que checa erros de tipagem que é o
+// checked mode, dizem que é útil enquanto se está desenvolvendo,
+// mas também é mais lento devido às checagens extras e por isso
+// é evitado em ambiente de produção.
+class Example21 {
+  List<String> _names;
+  Example21() {
+    _names = ["a", "b"];
+  }
+  List<String> get names => _names;
+  set names(List<String> list) {
+    _names = list;
+  }
+  int get length => _names.length;
+  void add(String name) {
+    _names.add(name);
+  }
+}
+void example21() {
+  Example21 o = new Example21();
+  o.add("c");
+  print("Example21 names '${o.names}' and length '${o.length}'");
+  o.names = ["d", "e"];
+  print("Example21 names '${o.names}' and length '${o.length}'");
+}
+
+// Herança em classes é feito assim: class name extends AnotherClassName {}.
+class Example22A {
+  var _name = "Some Name!";
+  get name => _name;
+}
+class Example22B extends Example22A {}
+example22() {
+  var o = new Example22B();
+  print("Example22 class inheritance '${o.name}'");
+}
+
+// Mistura de classes também é possível, e é feito assim:
+// class name extends SomeClass with AnotherClassName {}
+// É necessário extender uma classe para poder misturar com outra.
+// No momento, classes misturadas não podem ter construtor.
+// Mistura de classes é mais usado para compartilhar métodos com classes distantes, então
+// a herança comum não fica no caminho do reuso de código.
+// As misturas aparecem após o comando "with" na declaração da classe.
+class Example23A {}
+class Example23Utils {
+  addTwo(n1, n2) {
+    return n1 + n2;
+  }
+}
+class Example23B extends Example23A with Example23Utils {
+  addThree(n1, n2, n3) {
+    return addTwo(n1, n2) + n3;
+  }
+}
+example23() {
+  var o = new Example23B(), r1 = o.addThree(1, 2, 3),
+    r2 = o.addTwo(1, 2);
+  print("Example23 addThree(1, 2, 3) results in '${r1}'");
+  print("Example23 addTwo(1, 2) results in '${r2}'");
+}
+
+// O método construtor da classe usa o mesmo nome da classe e
+// é feito assim SomeClass() : super() {}, onde a parte ": super()"
+// é opcional e é usada para passar parâmetros estáticos para o
+// construtor da classe pai.
+class Example24A {
+  var _value;
+  Example24A({value: "someValue"}) {
+    _value = value;
+  }
+  get value => _value;
+}
+class Example24B extends Example24A {
+  Example24B({value: "someOtherValue"}) : super(value: value);
+}
+example24() {
+  var o1 = new Example24B(),
+    o2 = new Example24B(value: "evenMore");
+  print("Example24 calling super during constructor '${o1.value}'");
+  print("Example24 calling super during constructor '${o2.value}'");
+}
+
+// Há um atalho para passar parâmetros para o construtor no caso de classes mais simples.
+// Simplesmente use o prefixo this.nomeDoParametro e isso irá passar o parâmetro para uma
+// instância de variável de mesmo nome.
+class Example25 {
+  var value, anotherValue;
+  Example25({this.value, this.anotherValue});
+}
+example25() {
+  var o = new Example25(value: "a", anotherValue: "b");
+  print("Example25 shortcut for constructor '${o.value}' and "
+    "'${o.anotherValue}'");
+}
+
+// Parâmetros com nome estão disponíveis quando declarados entre {}.
+// Quando os parâmetros têm nomes, eles podem ser passados em qualquer ordem.
+// Parâmetros declarados entre [] são opcionais.
+example26() {
+  var _name, _surname, _email;
+  setConfig1({name, surname}) {
+    _name = name;
+    _surname = surname;
+  }
+  setConfig2(name, [surname, email]) {
+    _name = name;
+    _surname = surname;
+    _email = email;
+  }
+  setConfig1(surname: "Doe", name: "John");
+  print("Example26 name '${_name}', surname '${_surname}', "
+    "email '${_email}'");
+  setConfig2("Mary", "Jane");
+  print("Example26 name '${_name}', surname '${_surname}', "
+  "email '${_email}'");
+}
+
+// Variáveis declaradas com um final só podem receber valor uma vez.
+// No caso de classes, variáveis final podem ter valor atribuido através
+// de um parâmetro no construtor
+class Example27 {
+  final color1, color2;
+  // Um pouco de flexibilidade ao criar variáveis final com a sintaxe
+  // que é a seguinte:
+  Example27({this.color1, color2}) : color2 = color2;
+}
+example27() {
+  final color = "orange", o = new Example27(color1: "lilac", color2: "white");
+  print("Example27 color is '${color}'");
+  print("Example27 color is '${o.color1}' and '${o.color2}'");
+}
+
+// para importar uma biblioteca, use import "libraryPath" ou se for uma biblioteca da linguagem,
+// import "dart:libraryName". Também tem o gerenciador de pacotes "pub"que tem 
+// sua própria convenção de import "package:packageName".
+// Veja o import "dart:collection"; no início do arquivo. Imports devem vir no início
+// do arquivo. IterableBase vem de dart:collection.
+class Example28 extends IterableBase {
+  var names;
+  Example28() {
+    names = ["a", "b"];
+  }
+  get iterator => names.iterator;
+}
+example28() {
+  var o = new Example28();
+  o.forEach((name) => print("Example28 '${name}'"));
+}
+
+// Para controle de fluxo nós temos:
+// * switch com comandos break obrigatórios
+// * if-else if-else e se-ternário ..?..:.. 
+// * closures e funções anônimas
+// * comandos break, continue e return
+example29() {
+  var v = true ? 30 : 60;
+  switch (v) {
+    case 30:
+      print("Example29 switch statement");
+      break;
+  }
+  if (v < 30) {
+  } else if (v > 30) {
+  } else {
+    print("Example29 if-else statement");
+  }
+  callItForMe(fn()) {
+    return fn();
+  }
+  rand() {
+    v = new DM.Random().nextInt(50);
+    return v;
+  }
+  while (true) {
+    print("Example29 callItForMe(rand) '${callItForMe(rand)}'");
+    if (v != 30) {
+      break;
+    } else {
+      continue;
+    }
+    // Nunca chega aqui.
+  }
+}
+
+// Você pode converter string para int, double para int, ou só pegar a parte inteira da divisão
+// usando o comando ~/. Vamos jogar um jogo de adivinhação.
+example30() {
+  var gn, tooHigh = false,
+    n, n2 = (2.0).toInt(), top = int.parse("123") ~/ n2, bottom = 0;
+  top = top ~/ 6;
+  gn = new DM.Random().nextInt(top + 1); // +1 porque o máximo do nextInt conta o número passado - 1 
+  print("Example30 Diga um número entre 0 e ${top}");
+  guessNumber(i) {
+    if (n == gn) {
+      print("Example30 Você acertou! O número é ${gn}");
+    } else {
+      tooHigh = n > gn;
+      print("Example30 O número ${n} é muito "
+        "${tooHigh ? 'alto' : 'baixo'}. Tente de novo");
+    }
+    return n == gn;
+  }
+  n = (top - bottom) ~/ 2;
+  while (!guessNumber(n)) {
+    if (tooHigh) {
+      top = n - 1;
+    } else {
+      bottom = n + 1;
+    }
+    n = bottom + ((top - bottom) ~/ 2);
+  }
+}
+
+// Programas em Dart só têm um ponto de entrada, que é a função main.
+// Nada será executado antes da funcão main de um programa.
+// Isso ajuda a carregar o programa mais rapidamente, até mesmo quando o
+// carregamento é "Lazy".
+// O programa deve começar com:
+main() {
+  print("Aprenda Dart em 15 minutos!");
+  [example1, example2, example3, example4, example5, example6, example7,
+    example8, example9, example10, example11, example12, example13, example14,
+    example15, example16, example17, example18, example19, example20,
+    example21, example22, example23, example24, example25, example26,
+    example27, example28, example29, example30
+    ].forEach((ef) => ef());
+}
+
+```
+
+## Continue lendo
+
+Dart tem um site bastante fácil de entender. Ele tem os docs da API, tutoriais, artigos e muito mais, incluindo uma
+opção muito útil de testar o Dart online.
+http://www.dartlang.org/
+http://try.dartlang.org/
+
+
+
-- 
cgit v1.2.3


From 784bc7a9bd18b78b344e5fa4057df430ba042e0e Mon Sep 17 00:00:00 2001
From: Pratik Karki <predatoramigo@gmail.com>
Date: Wed, 28 Feb 2018 20:18:45 +0545
Subject: Fix URLs

---
 pt-br/dart-pt.html.markdown | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/dart-pt.html.markdown b/pt-br/dart-pt.html.markdown
index c127034c..e9d72850 100644
--- a/pt-br/dart-pt.html.markdown
+++ b/pt-br/dart-pt.html.markdown
@@ -501,8 +501,9 @@ main() {
 
 Dart tem um site bastante fácil de entender. Ele tem os docs da API, tutoriais, artigos e muito mais, incluindo uma
 opção muito útil de testar o Dart online.
-http://www.dartlang.org/
-http://try.dartlang.org/
+* [https://www.dartlang.org](https://www.dartlang.org)
+* [https://try.dartlang.org](https://try.dartlang.org)
+
 
 
 
-- 
cgit v1.2.3


From caa8993076365c3e650e82a3c5c970dca25ed4c4 Mon Sep 17 00:00:00 2001
From: Adam Bard <adam@adambard.com>
Date: Sun, 4 Mar 2018 19:48:44 -0800
Subject: Assorted fixes

---
 pt-br/common-lisp-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/common-lisp-pt.html.markdown b/pt-br/common-lisp-pt.html.markdown
index 03a7c15c..c3381824 100644
--- a/pt-br/common-lisp-pt.html.markdown
+++ b/pt-br/common-lisp-pt.html.markdown
@@ -19,7 +19,7 @@ Outro livro recente e popular é o
 [Land of Lisp](http://landoflisp.com/).
 
 
-```common_lisp
+```common-lisp
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; 0. Sintaxe
-- 
cgit v1.2.3


From 8330d94dedd8c5636fe4bba83d3a767acecb982f Mon Sep 17 00:00:00 2001
From: meleu <meleu@users.noreply.github.com>
Date: Thu, 8 Mar 2018 00:44:18 -0300
Subject: small typo and better translated words

---
 pt-br/c-pt.html.markdown | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown
index 0dca7ab0..d594b7b9 100644
--- a/pt-br/c-pt.html.markdown
+++ b/pt-br/c-pt.html.markdown
@@ -638,16 +638,17 @@ typedef void (*minha_função_type)(char *);
 ## Leitura adicional
 
 É recomendado ter uma cópia de [K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language).
-Este é *o* livro sobre C, escrito pelos criadores da linguage. Mas cuidado - ele é antigo e contém alguns erros (bem,
-ideias que não são consideradas boas hoje) ou práticas mudadas.
+Este é *o* livro sobre C, escrito pelos criadores da linguagem. Mas cuidado - ele é antigo e contém alguns erros (bem,
+ideias que não são mais consideradas boas) ou práticas ultrapassadas.
 
 Outra boa referência é [Learn C the hard way](http://c.learncodethehardway.org/book/).
 
 Se você tem uma pergunta, leia [compl.lang.c Frequently Asked Questions](http://c-faq.com).
 
 É importante usar espaços e indentação adequadamente e ser consistente com seu estilo de código em geral.
-Código legível é melhor que código 'esperto' e rápido. Para adotar um estilo de código bom e são, veja
+Código legível é melhor que código 'esperto' e rápido. Para adotar um estilo de código bom e sensato, veja
 [Linux kernel coding style](https://www.kernel.org/doc/Documentation/CodingStyle).
 
 Além disso, Google é teu amigo.
+
 [1] http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member
-- 
cgit v1.2.3


From f5bdb745a5471a5f3c292e482b627b85db53fbd1 Mon Sep 17 00:00:00 2001
From: Pratik Karki <predatoramigo@gmail.com>
Date: Wed, 14 Mar 2018 08:44:44 +0545
Subject: Update bf-pt.html.markdown

---
 pt-br/bf-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/bf-pt.html.markdown b/pt-br/bf-pt.html.markdown
index c69995ab..53baa9a2 100644
--- a/pt-br/bf-pt.html.markdown
+++ b/pt-br/bf-pt.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: Brainfuck
+language: bf
 filename: learnbf-pt.bf
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io/"]
-- 
cgit v1.2.3


From d375092374d0a71f95e3a418c08236a68426dad0 Mon Sep 17 00:00:00 2001
From: Aleksandr Mazurik <almaz@yandex-team.ru>
Date: Sat, 28 Jul 2018 21:48:25 +0300
Subject: [awk/en] Fix atan2 args order

---
 pt-br/awk-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/awk-pt.html.markdown b/pt-br/awk-pt.html.markdown
index 75b73abe..761f5294 100644
--- a/pt-br/awk-pt.html.markdown
+++ b/pt-br/awk-pt.html.markdown
@@ -171,7 +171,7 @@ function arithmetic_functions(a, b, c,    d) {
     # Muitas implementações AWK possuem algumas funções trigonométricas padrão
     localvar = sin(a)
     localvar = cos(a)
-    localvar = atan2(a, b) # arco-tangente de b / a
+    localvar = atan2(b, a) # arco-tangente de b / a
 
     # E conteúdo logarítmico
     localvar = exp(a)
-- 
cgit v1.2.3


From e4894a56ff15f1aaa3fa5716fa75499237e96aa9 Mon Sep 17 00:00:00 2001
From: Divay Prakash <divayprakash3@gmail.com>
Date: Wed, 15 Aug 2018 17:11:27 +0530
Subject: Fix build error in 'build/docs/pt-br/markdown-pt/index.html'

---
 pt-br/markdown-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/markdown-pt.html.markdown b/pt-br/markdown-pt.html.markdown
index f22093f9..c2aa515d 100644
--- a/pt-br/markdown-pt.html.markdown
+++ b/pt-br/markdown-pt.html.markdown
@@ -14,7 +14,7 @@ escrever sintaxe que converte facilmente em HTML (hoje, suporta outros formatos
 Dê-me feedback tanto quanto você quiser! / Sinta-se livre para a garfar (fork) e 
 puxar o projeto (pull request)
 
-```markdown
+```md
 <!-- Markdown é um superconjunto do HTML, de modo que qualquer arvquivo HTML é 
 um arquivo Markdown válido, isso significa que nós podemos usar elementos HTML 
 em Markdown, como o elemento de comentário, e eles não serão afetados pelo analisador
-- 
cgit v1.2.3


From b06452efca5c982dc31d2b72ffd7babba1e3cc3a Mon Sep 17 00:00:00 2001
From: Divay Prakash <divayprakash3@gmail.com>
Date: Wed, 15 Aug 2018 17:21:47 +0530
Subject: Fix build error in 'error build/docs/pt-br/common-lisp-pt/index.html'

---
 pt-br/common-lisp-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/common-lisp-pt.html.markdown b/pt-br/common-lisp-pt.html.markdown
index c3381824..c22cfd8e 100644
--- a/pt-br/common-lisp-pt.html.markdown
+++ b/pt-br/common-lisp-pt.html.markdown
@@ -19,7 +19,7 @@ Outro livro recente e popular é o
 [Land of Lisp](http://landoflisp.com/).
 
 
-```common-lisp
+```lisp
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; 0. Sintaxe
-- 
cgit v1.2.3


From e4f328aa476d499fbcb5198b73cb3baf1438b23b Mon Sep 17 00:00:00 2001
From: Divay Prakash <divayprakash3@gmail.com>
Date: Wed, 15 Aug 2018 17:24:15 +0530
Subject: Fix build error in 'build/docs/pt-br/visualbasic-pt/index.html'

---
 pt-br/visualbasic-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/visualbasic-pt.html.markdown b/pt-br/visualbasic-pt.html.markdown
index b94ab609..2a7205cd 100644
--- a/pt-br/visualbasic-pt.html.markdown
+++ b/pt-br/visualbasic-pt.html.markdown
@@ -8,7 +8,7 @@ lang: pt-br
 filename: learnvisualbasic-pt.vb
 ---
 
-```vb
+```
 Module Module1
 
 module Module1
-- 
cgit v1.2.3


From 4d2626d98bfa5ada3a502cda15c416db16ceac5a Mon Sep 17 00:00:00 2001
From: 0u0 <inkydragon@users.noreply.github.com>
Date: Thu, 30 Aug 2018 19:02:36 +0800
Subject: pt-br fix #3054

---
 pt-br/matlab-pt.html.markdown | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/matlab-pt.html.markdown b/pt-br/matlab-pt.html.markdown
index eb660d4c..5ed6b7ba 100644
--- a/pt-br/matlab-pt.html.markdown
+++ b/pt-br/matlab-pt.html.markdown
@@ -206,8 +206,7 @@ size(A) % Resposta = 3 3
 A(1, :) =[] % Remove a primeira linha da matriz
 A(:, 1) =[] % Remove a primeira coluna da matriz
 
-transpose(A) % Transposta a matriz, que é o mesmo de:
-A one
+transpose(A) % Transposta a matriz, que é o mesmo de: A.'
 ctranspose(A) % Transposta a matriz
 % (a transposta, seguida pelo conjugado complexo de cada elemento)
 
-- 
cgit v1.2.3


From 7debaf3bfbe3dcb30edffb25c284011b8c649eb1 Mon Sep 17 00:00:00 2001
From: Divay Prakash <divayprakash3@gmail.com>
Date: Tue, 4 Sep 2018 18:31:52 +0530
Subject: Add language code suffix (#3206)

---
 pt-br/solidity-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/solidity-pt.html.markdown b/pt-br/solidity-pt.html.markdown
index 37d15bf2..d4555fa7 100644
--- a/pt-br/solidity-pt.html.markdown
+++ b/pt-br/solidity-pt.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: Solidity
-filename: learnSolidity.sol
+filename: learnSolidity-br.sol
 contributors:
   - ["Nemil Dalal", "https://www.nemil.com"]
   - ["Joseph Chow", ""]
-- 
cgit v1.2.3


From fbbd0543018ef573deac5074bc7c28d7888513bf Mon Sep 17 00:00:00 2001
From: Victor Bastos <victorwpbastos@gmail.com>
Date: Mon, 1 Oct 2018 17:00:02 -0300
Subject: Small typos

---
 pt-br/latex-pt.html.markdown | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/latex-pt.html.markdown b/pt-br/latex-pt.html.markdown
index a9ed566e..103af28e 100644
--- a/pt-br/latex-pt.html.markdown
+++ b/pt-br/latex-pt.html.markdown
@@ -30,7 +30,7 @@ $ Todo comando LaTeX começa com uma barra invertida (\)
 % Em seguida definimos os pacotes que o documento usa.
 % Se você quiser incluir gráficos, texto colorido, ou código fonte de outra
 % linguagem em outro arquivo em seu documento, você precisa ampliar as
-% capacidade do LaTeX. Isso é feito adicionando-se pacotes.
+% capacidades do LaTeX. Isso é feito adicionando-se pacotes.
 % Serão incluídos os pacotes float e caption para imagens e hyperref
 % para links.
 \usepackage{caption}
@@ -46,7 +46,7 @@ Svetlana Golubeva}
 \date{\today}
 \title{Aprenda \LaTeX \hspace{1pt} em Y Minutos!}
 
-% Agora estamos pronto para começar o documento
+% Agora estamos prontos para começar o documento
 % Tudo antes dessa linha é chamado "preâmbulo".
 \begin{document}
 % Se informarmos os campos author (autores), date (data), "title" (título),
@@ -55,7 +55,7 @@ Svetlana Golubeva}
 % Se tivermos seções, poderemos criar uma tabela de conteúdo. Para isso,
 % o documento deve ser compilado duas vezes, para que tudo apareça na ordem
 % correta.
-% É uma voa prática separar a tabela de conteúdo do corpo do documento. Para
+% É uma boa prática separar a tabela de conteúdo do corpo do documento. Para
 % isso usa-se o comando \newpage
 \newpage
 \tableofcontents
-- 
cgit v1.2.3


From 73ec94dc7b93fc9408ef4a4162cef211829fe971 Mon Sep 17 00:00:00 2001
From: Victor Bastos <victorwpbastos@gmail.com>
Date: Mon, 1 Oct 2018 17:03:32 -0300
Subject: Small typos

---
 pt-br/pyqt-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/pyqt-pt.html.markdown b/pt-br/pyqt-pt.html.markdown
index 10d55784..40fe82d5 100644
--- a/pt-br/pyqt-pt.html.markdown
+++ b/pt-br/pyqt-pt.html.markdown
@@ -10,7 +10,7 @@ lang: pt-br
 ---
 
 **Qt** é amplamente conhecido como um framework para desenvolvimento de
-software multi-plataforma que pode rodar em vários outras plataformas de
+software multi-plataforma que pode rodar em várias outras plataformas de
 softwares e hardwares com pouca ou nenhuma alteração no código, enquanto mantém
 o poder e a velocidade de uma aplicação nativa. Embora o **Qt** tenha sido
 originalmente escrito em *C++*.
-- 
cgit v1.2.3


From 1ab053de7d42df484821c523025bef28b05b9e25 Mon Sep 17 00:00:00 2001
From: Victor Bastos <victorwpbastos@gmail.com>
Date: Mon, 1 Oct 2018 17:07:53 -0300
Subject: Small typos

---
 pt-br/rust-pt.html.markdown | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/rust-pt.html.markdown b/pt-br/rust-pt.html.markdown
index 8134d3c5..b2bab214 100644
--- a/pt-br/rust-pt.html.markdown
+++ b/pt-br/rust-pt.html.markdown
@@ -11,7 +11,7 @@ Rust é uma linguagem de programação desenvolvida pelo Mozilla Research. Rust
 combina controle de baixo nível sobre o desempenho com facilidades de alto
 nível e garantias de segurança.
 
-Ele atinge esse objetico sem necessitar de um coletor de lixo ou um processo
+Ele atinge esse objetivo sem necessitar de um coletor de lixo ou um processo
 *runtime*, permitindo que se use bibliotecas Rust em substituição a bibliotecas 
 em C.
 
@@ -27,7 +27,7 @@ noite. Rust adotou um modelo de versões *train-based* com novas versões
 regularmente liberadas a cada seis semanas. A versão 1.1 beta de Rust foi
 disponibilizada ao mesmo tempo que a versão 1.0.
 
-Apesar de Rust ser uma linguagem mais e baixo nível, Rust tem alguns conceitos
+Apesar de Rust ser uma linguagem mais de baixo nível, Rust tem alguns conceitos
 funcionais geralmente encontradas em linguagens de alto nível. Isso faz Rust
 não apenas rápido, mas também fácil e eficiente para programar.
 
@@ -68,7 +68,7 @@ fn main() {
     // Em geral, o compilador Rust consegue inferir qual o tipo de uma 
     // variável, então você não tem que escrever uma anotação explícita de tipo.
     // Ao longo desse tutorial, os tipos serão explicitamente anotados em 
-    // muitos lugares, mas apenas com propóstico demonstrativo. A inferência de 
+    // muitos lugares, mas apenas com propósito demonstrativo. A inferência de 
     // tipos pode gerenciar isso na maioria das vezes.
     let implicit_x = 1;
     let implicit_f = 1.3;
-- 
cgit v1.2.3


From 26c1a0326fb2c276cdacb2b0665c1a666fe8377b Mon Sep 17 00:00:00 2001
From: Victor Bastos <victorwpbastos@gmail.com>
Date: Mon, 1 Oct 2018 17:10:41 -0300
Subject: Small typos

---
 pt-br/vim-pt.html.markdown | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/vim-pt.html.markdown b/pt-br/vim-pt.html.markdown
index 51eddb48..d7617bbe 100644
--- a/pt-br/vim-pt.html.markdown
+++ b/pt-br/vim-pt.html.markdown
@@ -13,7 +13,7 @@ filename: LearnVim-pt.txt
 [Vim](http://www.vim.org)
 (Vi IMproved - Vi Melhorado) é um clone do editor vi para Unix. Ele é um
 editor de texto projetado para ter velocidade e produtividade, e está presente
-na maioria dos systemas UNIX. O editor tem um grande número de atalhos de teclado
+na maioria dos sistemas UNIX. O editor tem um grande número de atalhos de teclado
 para agilizar a navegação para pontos específicos no arquivo, além de edição rápida.
 
 ## Navegação do Vim: o básico
@@ -25,7 +25,7 @@ para agilizar a navegação para pontos específicos no arquivo, além de ediç
     :wq              # Salva o arquivo e fecha o vim
     :q!              # Fecha o vim e descarta as alterações no arquivo
                      # ! *força* :q a executar, fechando o vim sem salvar antes
-    :x               # Salvar o arquivo e fechao vim (atalho para :wq)
+    :x               # Salva o arquivo e fecha o vim (atalho para :wq)
 
     u                # Desfazer
     CTRL+R           # Refazer
@@ -62,7 +62,7 @@ para agilizar a navegação para pontos específicos no arquivo, além de ediç
     
     # Movendo por palavras
 
-    w                # Move o cursor uma palavra a diante
+    w                # Move o cursor uma palavra adiante
     b                # Move o cursor uma palavra atrás
     e                # Move o cursor ao fim da palavra atual
 
-- 
cgit v1.2.3


From c6691f31004ffa6fc2be0bccd25f210fccfd2377 Mon Sep 17 00:00:00 2001
From: Victor Bastos <victorwpbastos@gmail.com>
Date: Mon, 1 Oct 2018 17:16:56 -0300
Subject: Small typos

---
 pt-br/go-pt.html.markdown | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/go-pt.html.markdown b/pt-br/go-pt.html.markdown
index c7339831..31473ee1 100644
--- a/pt-br/go-pt.html.markdown
+++ b/pt-br/go-pt.html.markdown
@@ -16,7 +16,7 @@ A linguagem Go foi criada a partir da necessidade de ver trabalho feito. Não
 forma de resolver os problemas do mundo real.
 
 Tem conceitos familiares de linguagens imperativas com tipagem estática. É 
-rápida a compilar e rápida a executar, acrescentando mecanismos de concorrência
+rápida para compilar e rápida para executar, acrescentando mecanismos de concorrência
 fáceis de entender para tirar partido dos CPUs multi-core de hoje em dia, e tem
 recursos para ajudar com a programação em larga escala.
 
@@ -39,10 +39,10 @@ import (
 )
 
 // Definição de uma função. Main é especial. É o ponto de entrada para o
-// programa executável. Goste-se ou não, a linguagem Go usa chavetas.
+// programa executável. Goste-se ou não, a linguagem Go usa chaves.
 func main() {
     // A função Println envia uma linha para stdout.
-    // É necessário qualifica-la com o nome do pacote, fmt.
+    // É necessário qualificá-la com o nome do pacote, fmt.
     fmt.Println("Olá Mundo!")
 
     // Chama outra função dentro deste pacote.
-- 
cgit v1.2.3


From e5190aefb1046ebd0174024b1ac437f0bd5c2e80 Mon Sep 17 00:00:00 2001
From: Antonio Roberto Furlaneto <arfurlaneto@gmail.com>
Date: Mon, 1 Oct 2018 19:48:57 -0300
Subject: [asymptotic-notation/pt-br] Small typo

---
 pt-br/asymptotic-notation-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/asymptotic-notation-pt.html.markdown b/pt-br/asymptotic-notation-pt.html.markdown
index aecc2194..2f179f96 100644
--- a/pt-br/asymptotic-notation-pt.html.markdown
+++ b/pt-br/asymptotic-notation-pt.html.markdown
@@ -88,7 +88,7 @@ Função Exponencial - a^n, onde *a* é uma constante
 
 Big-O, também escrita como O, é uma Notação Assintótica para o pior caso. Digamos
 *f(n)* seja o tempo de exeução de um algoritmo e *g(n)) um tempo de complexidade
-arbritário que você quer relacionar com seu algoritmo. *f(n)* é O(g(n)), se, para
+arbitrário que você quer relacionar com seu algoritmo. *f(n)* é O(g(n)), se, para
 quando constante real c (c > 0), *f(n)* <= *c g(n)* para todo tamanho de entrada
 n (n > 0).
 
-- 
cgit v1.2.3


From b3796a94a91897b8bd80e05401641bdd17d655f0 Mon Sep 17 00:00:00 2001
From: Antonio Roberto Furlaneto <arfurlaneto@gmail.com>
Date: Mon, 1 Oct 2018 19:56:14 -0300
Subject: [bash/pt-br] Small typo

---
 pt-br/bash-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/bash-pt.html.markdown b/pt-br/bash-pt.html.markdown
index ae18435a..3a48d994 100644
--- a/pt-br/bash-pt.html.markdown
+++ b/pt-br/bash-pt.html.markdown
@@ -16,7 +16,7 @@ lang: pt-br
 
 Tutorial de shell em português
 
-Bash é o nome do shell do Unix, que também é distribuido como shell do sistema 
+Bash é o nome do shell do Unix, que também é distribuído como shell do sistema 
 operacional GNU e como shell padrão para Linux e Mac OS X. Praticamente todos 
 os exemplos abaixo podem fazer parte de um shell script e pode ser executados
 diretamente no shell.
-- 
cgit v1.2.3


From 260e40ceca594fb17b2902eb8fd4609803a1dafb Mon Sep 17 00:00:00 2001
From: Antonio Roberto Furlaneto <arfurlaneto@gmail.com>
Date: Mon, 1 Oct 2018 20:05:13 -0300
Subject: [c++/pt-br] Better translation

---
 pt-br/c++-pt.html.markdown | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown
index cd4adde7..2c15e92c 100644
--- a/pt-br/c++-pt.html.markdown
+++ b/pt-br/c++-pt.html.markdown
@@ -564,15 +564,15 @@ void doSomethingWithAFile(const std::string& filename)
 
 // Isto tem _grandes_ vantagens:
 // 1. Não importa o que aconteça,
-//    o recurso (neste caso, o identificador de ficheiro) irá ser limpo.
+//    o recurso (neste caso, o identificador de ficheiro) será limpo.
 //    Depois de escrever o destruidor corretamente,
 //    É _impossível_ esquecer de fechar e vazar o recurso
 // 2. Nota-se que o código é muito mais limpo.
 //    As alças destructor fecham o arquivo por trás das cenas
 //    sem que você precise se preocupar com isso.
 // 3. O código é seguro de exceção.
-//    Uma exceção pode ser jogado em qualquer lugar na função e a limpeza
-//    irá ainda ocorrer.
+//    Uma exceção pode ser lançada em qualquer lugar na função e a limpeza
+//    ainda irá ocorrer.
 
 // Todos códigos C++ usam RAII extensivamente para todos os recursos.
 // Outros exemplos incluem
-- 
cgit v1.2.3


From 3f3d5763dd9da4fa6fb7a32d386dbfd707895c77 Mon Sep 17 00:00:00 2001
From: Antonio Roberto Furlaneto <arfurlaneto@gmail.com>
Date: Mon, 1 Oct 2018 20:10:17 -0300
Subject: [c/pt-br] Small typo

---
 pt-br/c-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown
index d594b7b9..e1c27958 100644
--- a/pt-br/c-pt.html.markdown
+++ b/pt-br/c-pt.html.markdown
@@ -538,7 +538,7 @@ int area(retan r)
     return r.largura * r.altura;
 }
 
-// Se você tiver structus grande, você pode passá-las "por ponteiro"
+// Se você tiver structs grandes, você pode passá-las "por ponteiro"
 // para evitar cópia de toda a struct:
 int area(const retan *r)
 {
-- 
cgit v1.2.3


From e58b0d88adaacf8d5cea1e9fe80381a0182368ab Mon Sep 17 00:00:00 2001
From: Antonio Roberto Furlaneto <arfurlaneto@gmail.com>
Date: Mon, 1 Oct 2018 20:15:55 -0300
Subject: [csharp/pt-br] Missing translation

---
 pt-br/csharp-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index b6e95d36..be14a1c8 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -834,7 +834,7 @@ on a new line! ""Wow!"", the masses cried";
         bool Broken { get; } // interfaces can contain properties as well as methods & events
     }
 
-    // Class can inherit only one other class, but can implement any amount of interfaces
+    // Classes podem herdar apenas de uma outra classe, mas podem implementar qualquer quantidade de interfaces.
     class MountainBike : Bicycle, IJumpable, IBreakable
     {
         int damage = 0;
-- 
cgit v1.2.3


From 4f89d81856d85055f93a565da4a39a6e5abaeccf Mon Sep 17 00:00:00 2001
From: Gabriele Luz <gabrieleluz@infojr.com.br>
Date: Mon, 1 Oct 2018 22:00:47 -0300
Subject: Translates `media queries` section to pt-br

---
 pt-br/css-pt.html.markdown | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

(limited to 'pt-br')

diff --git a/pt-br/css-pt.html.markdown b/pt-br/css-pt.html.markdown
index 956b3614..c73669d0 100644
--- a/pt-br/css-pt.html.markdown
+++ b/pt-br/css-pt.html.markdown
@@ -9,6 +9,8 @@ contributors:
     - ["Deepanshu Utkarsh", "https://github.com/duci9y"]
 translators:
     - ["Gabriel Gomes", "https://github.com/gabrielgomesferraz"]
+    - ["Gabriele Luz", "https://github.com/gabrieleluz"]
+
 lang: pt-br
 ---
 
@@ -236,6 +238,45 @@ A precedência de estilo é a seguinte. Lembre-se, a precedência é para cada
 * `B` é o próximo.
 * `D` é a última.
 
+## Media Queries
+Media queries são recursos do CSS3 que permitem especificar quando determinadas regras de CSS devem ser aplicadas; é possível aplicar regras diferentes quando a página é impressa, quando a tela possui determinadas dimensões ou densidade de pixels e quando é lida por um leitor de tela. Media queries não adicionam especificidade ao seletor.
+
+```css
+/* Uma regra que será aplicada a todos os dispositivos */
+h1 {
+  font-size: 2em;
+  color: white;
+  background-color: black;
+}
+
+/* Altera a cor do h1 para utilizar menos tinta durante a impressão */
+@media print {
+  h1 {
+    color: black;
+    background-color: white;
+  }
+}
+
+/* Altera o tamanho da fonte quando exibida numa tela com pelo menos 480px de largura */
+@media screen and (min-width: 480px) {
+  h1 {
+    font-size: 3em;
+    font-weight: normal;
+  }
+}
+```
+Media queries podem incluir os seguintes atributos: `width`, `height`, `device-width`, `device-height`, `orientation`, `aspect-ratio`, `device-aspect-ratio`, `color`, `color-index`, `monochrome`, `resolution`, `scan`, `grid`. A maioria desses atributos pode ser prefixada com `min-` ou `max-`.
+
+O atributo `resolution` não é suportado em dispositivos mais antigos. Em vez disso, use `device-pixel-ratio`.
+
+Muitos smartphones e tablets tentarão renderizar a página como se estivesse num desktop a menos que você utilize a meta-tag `viewport`.
+
+```html
+<head>
+  <meta name="viewport" content="width=device-width; initial-scale=1.0">
+</head>
+```
+
 ## Compatibilidade
 
 A maior parte dos recursos do CSS 2 (e muitos em CSS 3) estão disponíveis em todos os navegadores e dispositivos. Mas é sempre boa prática para verificar antes de usar um novo recurso.
-- 
cgit v1.2.3


From fb58e953434956811b37ebde53be2f148aaa3a5f Mon Sep 17 00:00:00 2001
From: Lucas Pugliesi <ferreiraplucas@gmail.com>
Date: Thu, 11 Oct 2018 15:46:00 -0300
Subject: [html/pt-br] Add Portuguese language for html

---
 pt-br/html-pt.html.markdown | 125 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 125 insertions(+)
 create mode 100644 pt-br/html-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/html-pt.html.markdown b/pt-br/html-pt.html.markdown
new file mode 100644
index 00000000..5a4bc3bc
--- /dev/null
+++ b/pt-br/html-pt.html.markdown
@@ -0,0 +1,125 @@
+---
+language: html
+filename: learnhtml.txt
+contributors:
+    - ["Christophe THOMAS", "https://github.com/WinChris"]
+translators:
+    - ["Robert Steed", "https://github.com/robochat"]
+lang: pt-br
+---
+
+HTML é um acrônimo de HyperText Markup Language(Linguagem de Marcação de HiperTexto).
+É uma linguagem que nos permite escrever páginas para a "world wide web".
+É uma linguagem de marcação, nos permite escrever páginas na web usando código
+para indicar como o texto e os dados serão ser exibidos.
+De fato, arquivos HTML são simples arquivos de texto.
+O que seria marcação? É um método de organização dos dados da página envolvidos
+por abertura e fechamento de tags.
+Essa marcação serve para dar significado ao texto que envolve.
+Assim como outras linguagens, o HTML tem diversas versões. Aqui falaremos sobre o HTML5.
+
+**NOTA :**  Você pode testar diferentes tags e elementos conforme progride os
+tutoriais em sites como [codepen](http://codepen.io/pen/) podendo ver seus efeitos,
+entendendo como funcionam e se familiarizando com a linguagem.
+Esse artigo tem seu foco principal na sintaxe do HTML e algumas dicas úteis.
+
+
+```html
+<!-- Comentários são envolvidos conforme essa linha! -->
+
+<!-- #################### As Tags #################### -->
+
+<!-- Aqui está um exemplo de arquivo HTML que iremos analisar. -->
+
+<!doctype html>
+	<html>
+		<head>
+			<title>Meu Site</title>
+		</head>
+		<body>
+			<h1>Olá, mundo!</h1>
+			<a href = "http://codepen.io/anon/pen/xwjLbZ">Venha ver como isso aparece</a>
+			<p>Esse é um parágrafo.</p>
+			<p>Esse é um outro parágrafo.</p>
+			<ul>
+				<li>Esse é um item de uma lista não enumerada (bullet list)</li>
+				<li>Esse é um outro item</li>
+				<li>E esse é o último item da lista</li>
+			</ul>
+		</body>
+	</html>
+
+<!-- Um arquivo HTML sempre inicia indicando ao navegador que é uma página HTML. -->
+<!doctype html>
+
+<!-- Após isso, inicia abrindo a tag <html>. -->
+<html>
+
+<!-- Essa tag deverá ser fechada ao final do arquivo com </html>. -->
+</html>
+
+<!-- Não deverá haver nada após o fechamento desta tag. -->
+
+<!-- Entre a abertura e o fechamento das tags <html></html>, nós encontramos: -->
+
+<!-- Um cabeçalho definido por <head> (deverá ser fechado com </head>). -->
+<!-- O cabeçalho contém uma descrição e algumas informações adicionais que não serão exibidas; chamam-se metadados. -->
+
+<head>
+	<title>Meu Site</title><!-- Essa tag <title> indica ao navegador o título a ser exibido na barra de títulos e no nome da aba. -->
+</head>
+
+<!-- Após a seção <head>, nós encontramos a tag - <body> -->
+<!-- Até esse ponto, nada descrito irá aparecer na janela do browser. -->
+<!-- Nós deveremos preencher o body(corpo) com o conteúdo a ser exibido. -->
+
+<body>
+	<h1>Olá, mundo!</h1> <!-- A tag h1 cria um título. -->
+  <!-- Há também subtítulos do <h1>, o mais importante, aos mais precisos (h6). -->
+  <a href = "http://codepen.io/anon/pen/xwjLbZ">Venha ver o que isso exibe</a> <!-- Um hiperlink ao endereço preenchido no atributo href="" -->
+	<p>Esse é um parágrafo.</p> <!-- A tag <p> permite incluir um texto na página. -->
+	<p>Esse é um outro parágrafo.</p>
+	<ul> <!-- A tag <ul> cria uma lista de marcação. -->
+	<!-- Para criar uma lista ordenada, devemos usar <ol>, exibindo 1. para o primeiro elemento, 2. para o segundo, etc. -->
+		<li>Esse é um item de uma lista não-enumerada.</li>
+		<li>Esse é um outro item</li>
+		<li>E esse é o último item da lista</li>
+	</ul>
+</body>
+
+<!-- E é isso, criar um arquivo HTML pode ser bem simples. -->
+
+<!-- Também é possível adicionar alguns outros tipos de tags HTML. -->
+
+<!-- Para inserir uma imagem. -->
+<img src="http://i.imgur.com/XWG0O.gif"/> <!-- O caminho da imagem deve ser indicado usando o atributo src="" -->
+<!-- O caminho da imagem pode ser uma URL ou até mesmo o caminho do arquivo no seu computador. -->
+
+<!-- Também é possível criar uma tabela. -->
+
+<table> <!-- Iniciamos a tabela com a tag <table>. -->
+	<tr> <!-- <tr> nos permite criar uma linha. -->
+		<th>Primeiro cabeçalho</th> <!-- <th> nos permite criar o título de uma coluna. -->
+		<th>Segundo cabeçalho</th>
+	</tr>
+	<tr>
+		<td>Primeira linha, primeira coluna</td> <!-- <td> nos permite criar uma célula da tabela. -->
+		<td>Primeira linha, segunda coluna</td>
+	</tr>
+	<tr>
+		<td>Segunda linha, primeira coluna</td>
+		<td>Segunda linha, segunda coluna</td>
+	</tr>
+</table>
+
+```
+
+## Uso
+
+HTML é escrito em arquivos com a extensão `.html` ou `.htm`. Seu mime type é `text/html`.
+
+## Para aprender mais
+
+* [wikipedia](https://en.wikipedia.org/wiki/HTML)
+* [HTML tutorial](https://developer.mozilla.org/en-US/docs/Web/HTML)
+* [W3School](http://www.w3schools.com/html/html_intro.asp)
-- 
cgit v1.2.3


From 1c932a33f99149f6be77aa0de07abc1aedbc0d74 Mon Sep 17 00:00:00 2001
From: Lucas Pugliesi <ferreiraplucas@gmail.com>
Date: Fri, 12 Oct 2018 22:49:15 -0300
Subject: [cmake/pt-br] Add portuguese language for cmake

---
 pt-br/cmake-pt.html.markdown | 178 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 178 insertions(+)
 create mode 100644 pt-br/cmake-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/cmake-pt.html.markdown b/pt-br/cmake-pt.html.markdown
new file mode 100644
index 00000000..bc3e7050
--- /dev/null
+++ b/pt-br/cmake-pt.html.markdown
@@ -0,0 +1,178 @@
+---
+language: cmake
+contributors:
+    - ["Bruno Alano", "https://github.com/brunoalano"]
+filename: CMake
+translators:
+    - ["Lucas Pugliesi", "https://github.com/fplucas"]
+lang: pt-br
+---
+
+CMake é um programa de compilação open-source e multiplataforma. Essa ferramenta
+permitirá testar, compilar e criar pacotes a partir do seu código fonte.
+
+O problema que o CMake tenta resolver são os problemas de configurar os Makefiles
+e Autoconfigure (diferente dos interpretadores make que tem comandos diferentes)
+e sua facilidade de uso envolvendo bibliotecas terceiras.
+
+CMake é um sistema open-source extensível que gerencia o processo de build em um
+sistema operacional e um método independente de compilador. Diferente de sistemas
+multiplataformas, CMake é designado a usar em conjunto ao ambiente de compilação
+nativo. Seus simples arquivos de configuração localizados em seus diretórios
+(chamados arquivos CMakeLists.txt) que são usados para gerar padrões de arquivos
+de compilação (ex: makefiles no Unix e projetos em Windows MSVC) que são usados
+de maneira simples.
+
+```cmake
+# No CMake, isso é um comentário
+
+# Para rodar nosso código, iremos utilizar esses comandos:
+#  - mkdir build && cd build
+#  - cmake ..
+#  - make
+#
+# Com esses comandos, iremos seguir as melhores práticas para compilar em um
+# subdiretório e na segunda linha pediremos ao CMake para gerar um novo Makefile
+# independente de sistema operacional. E finalmente, rodar o comando make.
+
+#------------------------------------------------------------------------------
+# Básico
+#------------------------------------------------------------------------------
+#
+# O arquivo CMake deve ser chamado de "CMakeLists.txt".
+
+# Configura a versão mínima requerida do CMake para gerar o Makefile
+cmake_minimum_required (VERSION 2.8)
+
+# Exibe FATAL_ERROR se a versão for menor que  2.8
+cmake_minimum_required (VERSION 2.8 FATAL_ERROR)
+
+# Configuramos o nome do nosso projeto. Mas antes disso, iremos alterar alguns
+# diretórios em nome da convenção gerada pelo CMake. Podemos enviar a LANG do
+# código como segundo parâmetro
+project (learncmake C)
+
+# Configure o diretório do código do projeto (somente convenção)
+set( LEARN_CMAKE_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR} )
+set( LEARN_CMAKE_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR} )
+
+# Isso é muito útil para configurar a versão do nosso código no sistema de compilação
+# usando um estilo `semver`
+set (LEARN_CMAKE_VERSION_MAJOR 1)
+set (LEARN_CMAKE_VERSION_MINOR 0)
+set (LEARN_CMAKE_VERSION_PATCH 0)
+
+# Envie as variáveis (número da versão) para o cabeçalho de código-fonte
+configure_file (
+  "${PROJECT_SOURCE_DIR}/TutorialConfig.h.in"
+  "${PROJECT_BINARY_DIR}/TutorialConfig.h"
+)
+
+# Inclua Diretórios
+# No GCC, isso irá invocar o comando "-I"
+include_directories( include )
+
+# Onde as bibliotecas adicionais estão instaladas? Nota: permite incluir o path
+# aqui, na sequência as checagens irão resolver o resto
+set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/CMake/modules/" )
+
+# Condições
+if ( CONDICAO )
+  # reposta!
+
+  # Informação incidental
+  message(STATUS "Minha mensagem")
+
+  # Aviso CMake, continua processando
+  message(WARNING "Minha mensagem")
+
+  # Aviso (dev) CMake, continua processando
+  message(AUTHOR_WARNING "Minha mensagem")
+
+  # Erro CMake, continua processando, mas pula a geração
+  message(SEND_ERROR "Minha mensagem")
+
+  # Erro CMake, para o processamento e a geração
+  message(FATAL_ERROR "Minha mensagem")
+endif()
+
+if( CONDICAO )
+
+elseif( CONDICAO )
+
+else( CONDICAO )
+
+endif( CONDICAO )
+
+# Loops
+foreach(loop_var arg1 arg2 ...)
+  COMANDO1(ARGS ...)
+  COMANDO2(ARGS ...)
+  ...
+endforeach(loop_var)
+
+foreach(loop_var RANGE total)
+foreach(loop_var RANGE start stop [step])
+
+foreach(loop_var IN [LISTS [list1 [...]]]
+                    [ITEMS [item1 [...]]])
+
+while(condicao)
+  COMANDO1(ARGS ...)
+  COMANDO2(ARGS ...)
+  ...
+endwhile(condicao)
+
+
+# Operações Lógicas
+if(FALSE AND (FALSE OR TRUE))
+  message("Não exiba!")
+endif()
+
+# Configure um cache normal, ou uma variável de ambiente com o dado valor.
+# Se a opção PARENT_SCOPE for informada em uma variável que será setada no escopo
+# acima do escopo corrente.
+# `set(<variavel> <valor>... [PARENT_SCOPE])`
+
+# Como refencia variáveis dentro de aspas ou não, argumentos com strings vazias
+# não serão setados
+${nome_da_variavel}
+
+# Listas
+# Configure a lista de arquivos código-fonte
+set( LEARN_CMAKE_SOURCES
+  src/main.c
+  src/imagem.c
+  src/pather.c
+)
+
+# Chama o compilador
+#
+# ${PROJECT_NAME} referencia ao Learn_CMake
+add_executable( ${PROJECT_NAME} ${LEARN_CMAKE_SOURCES} )
+
+# Linka as bibliotecas
+target_link_libraries( ${PROJECT_NAME} ${LIBS} m )
+
+# Onde as bibliotecas adicionais serão instaladas? Nota: nos permite incluir o path
+# aqui, em seguida os testes irão resolver o restante
+set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/CMake/modules/" )
+
+# Condição do compilador (gcc ; g++)
+if ( "${CMAKE_C_COMPILER_ID}" STREQUAL "GNU" )
+  message( STATUS "Setting the flags for ${CMAKE_C_COMPILER_ID} compiler" )
+  add_definitions( --std=c99 )
+endif()
+
+# Checa o Sistema Operacional
+if( UNIX )
+    set( LEARN_CMAKE_DEFINITIONS
+        "${LEARN_CMAKE_DEFINITIONS} -Wall -Wextra -Werror -Wno-deprecated-declarations -Wno-unused-parameter -Wno-comment" )
+endif()
+```
+
+### Mais Recursos
+
++ [cmake tutorial](https://cmake.org/cmake-tutorial/)
++ [cmake documentation](https://cmake.org/documentation/)
++ [mastering cmake](http://amzn.com/1930934319/)
-- 
cgit v1.2.3


From 44663fba02c5c5f1f70112c8a5a3610334ef90ee Mon Sep 17 00:00:00 2001
From: Divay Prakash <divayprakash3@gmail.com>
Date: Sun, 14 Oct 2018 05:35:29 +0530
Subject: Fix links and list styling

---
 pt-br/c++-pt.html.markdown | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown
index 2c15e92c..cefa2c64 100644
--- a/pt-br/c++-pt.html.markdown
+++ b/pt-br/c++-pt.html.markdown
@@ -609,7 +609,5 @@ h=sum<double>(f,g);
 ```
 Leitura Adicional:
 
-Uma referência atualizada da linguagem pode ser encontrada em
-<http://cppreference.com/w/cpp>
-
-Uma fonte adicional pode ser encontrada em <http://cplusplus.com>
+* Uma referência atualizada da linguagem pode ser encontrada em [CPP Reference](http://cppreference.com/w/cpp).
+* Uma fonte adicional pode ser encontrada em [CPlusPlus](http://cplusplus.com).
-- 
cgit v1.2.3


From 99618d394e33c51ed8073b2dc013623442201c51 Mon Sep 17 00:00:00 2001
From: Divay Prakash <divayprakash3@gmail.com>
Date: Sun, 14 Oct 2018 05:51:14 +0530
Subject: Add new link from 2242ad7

---
 pt-br/c++-pt.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'pt-br')

diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown
index cefa2c64..42a29991 100644
--- a/pt-br/c++-pt.html.markdown
+++ b/pt-br/c++-pt.html.markdown
@@ -611,3 +611,4 @@ Leitura Adicional:
 
 * Uma referência atualizada da linguagem pode ser encontrada em [CPP Reference](http://cppreference.com/w/cpp).
 * Uma fonte adicional pode ser encontrada em [CPlusPlus](http://cplusplus.com).
+* Um tutorial cobrindo o básico da linguagem e configurando o ambiente de codificação está disponível em [TheChernoProject - C ++](https://www.youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb).
-- 
cgit v1.2.3


From b3da5ca955bd3ad47ab6a7ec1c72f2b189b2335e Mon Sep 17 00:00:00 2001
From: Divay Prakash <divayprakash3@gmail.com>
Date: Sun, 14 Oct 2018 06:07:03 +0530
Subject: Fix links

---
 pt-br/dynamic-programming-pt.html.markdown | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/dynamic-programming-pt.html.markdown b/pt-br/dynamic-programming-pt.html.markdown
index 84b055d9..518660a3 100644
--- a/pt-br/dynamic-programming-pt.html.markdown
+++ b/pt-br/dynamic-programming-pt.html.markdown
@@ -63,13 +63,11 @@ grafo acíclico dirigido.
 ```
 
 ## Alguns Problemas Famosos de Programação Dinâmica
-```
-Floyd Warshall Algorithm - Tutorial and C Program source code:http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code 
-
-Integer Knapsack Problem - Tutorial and C Program source code: http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem 
 
-Longest Common Subsequence - Tutorial and C Program source code : http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence 
-```
+- Floyd Warshall Algorithm - Tutorial and C Program source code: [http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code]()
+- Integer Knapsack Problem - Tutorial and C Program source code: [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem]()
+- Longest Common Subsequence - Tutorial and C Program source code : [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence]()
+ 
 
 ## Recursos Online (EN)
 
-- 
cgit v1.2.3


From cb88631777e409ad7358b39a9902c011a102f000 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rog=C3=A9rio?= <roger.lista@gmail.com>
Date: Fri, 19 Oct 2018 21:27:51 -0300
Subject: [less/pt-br] Add portuguese language for less

---
 pt-br/less-pt.html.markdown | 390 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 390 insertions(+)
 create mode 100644 pt-br/less-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/less-pt.html.markdown b/pt-br/less-pt.html.markdown
new file mode 100644
index 00000000..679a2ed2
--- /dev/null
+++ b/pt-br/less-pt.html.markdown
@@ -0,0 +1,390 @@
+---
+language: less
+filename: learnless.less
+contributors:
+  - ["Saravanan Ganesh", "http://srrvnn.me"]
+
+lang: pt-br
+---
+
+Less é um pré-processador de CSS, que adiciona recursos como variáveis, aninhamento, mixins e muito mais.
+Less (e outros pré-processadores, como o [Sass](http://sass-lang.com/)) ajudam os desenvolvedores a escreverem código que pode ser mantido e DRY (não se repita).
+
+```css
+
+
+//Comentários de linha única são removidos quando Less é compilado para CSS.
+
+/*Comentários de várias linhas são preservados.*/
+
+
+
+/* Variáveis
+==============================*/
+
+
+/* Você pode armazenar um valor de CSS (como uma cor) em uma variável.
+   Use o símbolo '@' para criar uma variável. */
+
+@primary-color: #a3a4ff;
+@secondary-color: #51527f;
+@body-font: 'Roboto', sans-serif;
+
+/* Você pode usar as variáveis ​​em toda a sua folha de estilo.
+   Agora, se você quiser alterar uma cor, só precisa fazer a alteração uma vez. */
+
+body {
+	background-color: @primary-color;
+	color: @secondary-color;
+	font-family: @body-font;
+}
+
+/* Isso compilará para: */
+
+body {
+	background-color: #a3a4ff;
+	color: #51527F;
+	font-family: 'Roboto', sans-serif;
+}
+
+
+/* Isso é muito mais sustentável do que ter que mudar a cor
+   cada vez que aparece em toda a sua folha de estilo. */
+
+
+
+/* Mixins
+==============================*/
+
+
+/* Se você achar que está escrevendo o mesmo código para mais de um
+   elemento, você pode querer reutilizá-lo facilmente. */
+
+.center {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+}
+
+/* Você pode usar o mixin simplesmente adicionando o seletor como um estilo. */
+
+div {
+	.center;
+	background-color: @primary-color;
+}
+
+/* Que compilaria para: */
+
+.center {
+  display: block;
+  margin-left: auto;
+  margin-right: auto;
+  left: 0;
+  right: 0;
+}
+div {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+	background-color: #a3a4ff;
+}
+
+/* Você pode omitir o código mixin de ser compilado adicionando parênteses
+   depois do seletor. */
+
+.center() {
+  display: block;
+  margin-left: auto;
+  margin-right: auto;
+  left: 0;
+  right: 0;
+}
+
+div {
+  .center;
+  background-color: @primary-color;
+}
+
+/* Que compilaria para: */
+div {
+  display: block;
+  margin-left: auto;
+  margin-right: auto;
+  left: 0;
+  right: 0;
+  background-color: #a3a4ff;
+}
+
+
+
+/* Aninhamento
+==============================*/
+
+
+/* Less permite aninhar seletores nos seletores. */
+
+ul {
+	list-style-type: none;
+	margin-top: 2em;
+
+	li {
+		background-color: #f00;
+	}
+}
+
+/* '&' será substituído pelo seletor pai. */
+/* Você também pode aninhar pseudo-classes. */
+/* Tenha em mente que o aninhamento excessivo tornará seu código menos sustentável.
+   As melhores práticas recomendam não ultrapassar 3 níveis de profundidade ao aninhar.
+   Por exemplo: */
+
+ul {
+  list-style-type: none;
+  margin-top: 2em;
+
+  li {
+    background-color: red;
+
+    &:hover {
+      background-color: blue;
+    }
+
+    a {
+      color: white;
+    }
+  }
+}
+
+/* Compila para: */
+
+ul {
+  list-style-type: none;
+  margin-top: 2em;
+}
+
+ul li {
+  background-color: red;
+}
+
+ul li:hover {
+  background-color: blue;
+}
+
+ul li a {
+  color: white;
+}
+
+
+
+/* Functions
+==============================*/
+
+
+/* Less fornece funções que podem ser usadas para realizar uma variedade de
+   tarefas. Considere o seguinte: */
+
+/* Funções podem ser invocadas usando seu nome e passando os
+   argumentos requeridos. */
+
+body {
+  width: round(10.25px);
+}
+
+.header {
+	background-color: lighten(#000, 0.5);
+}
+
+.footer {
+  background-color: fadeout(#000, 0.25)
+}
+
+/* Compila para: */
+
+body {
+  width: 10px;
+}
+
+.header {
+  background-color: #010101;
+}
+
+.footer {
+  background-color: rgba(0, 0, 0, 0.75);
+}
+
+/* Você também pode definir suas próprias funções. Funções são muito semelhantes às
+   mixins. Ao tentar escolher entre uma função ou a um mixin, lembre-se
+   que mixins são melhores para gerar CSS, enquanto as funções são melhores para
+   lógica que pode ser usada em todo o seu código Less. Os exemplos na
+   seção 'Operadores Matemáticos' são candidatos ideais para se tornarem funções reutilizáveis. */
+
+/* Esta função calcula a média de dois números: */
+
+.average(@x, @y) {
+  @average-result: ((@x + @y) / 2);
+}
+
+div {
+  .average(16px, 50px); // "chama" o mixin
+  padding: @average-result;    // use seu valor de "retorno"
+}
+
+/* Compila para: */
+
+div {
+  padding: 33px;
+}
+
+
+
+/* Estender (herança)
+==============================*/
+
+
+/* Estender é uma maneira de compartilhar as propriedades de um seletor com outro. */
+
+.display {
+  height: 50px;
+}
+
+.display-success {
+  &:extend(.display);
+	border-color: #22df56;
+}
+
+/* Compila para: */
+
+.display,
+.display-success {
+  height: 50px;
+}
+.display-success {
+  border-color: #22df56;
+}
+
+/* Estender uma instrução CSS é preferível para criar um mixin
+   por causa da maneira como agrupa as classes que compartilham
+   o mesmo estilo base. Se isso foi feito com um mixin, as propriedades
+   seriam duplicadas para cada declaração que
+   chamou o mixin. Embora isso não afete o seu fluxo de trabalho,
+   adicione o inchaço desnecessário aos arquivos criados pelo compilador Less. */
+
+
+
+/* Parciais e Importações
+==============================*/
+
+
+/* Less permite criar arquivos parciais. Isso pode ajudar a manter o seu
+   código Less modularizado. Arquivos parciais convencionalmente começam com um '_',
+   por exemplo. _reset.less. e são importados para um arquivo less principal que recebe
+   o css compilado. */
+
+/* Considere o seguinte CSS que vamos colocar em um arquivo chamado _reset.less */
+
+html,
+body,
+ul,
+ol {
+  margin: 0;
+  padding: 0;
+}
+
+/* Less disponibiliza @import que podem ser usadas para importar parciais em um arquivo.
+   Isso difere da declaração tradicional CSS @import que faz
+   outra solicitação HTTP para buscar o arquivo importado. Less leva o
+   arquivo importado e combina com o código compilado. */
+
+@import 'reset';
+
+body {
+  font-size: 16px;
+  font-family: Helvetica, Arial, Sans-serif;
+}
+
+/* Compila para: */
+
+html, body, ul, ol {
+  margin: 0;
+  padding: 0;
+}
+
+body {
+  font-size: 16px;
+  font-family: Helvetica, Arial, Sans-serif;
+}
+
+
+
+/* Operações Matemáticas
+==============================*/
+
+
+/* Less fornece os seguintes operadores: +, -, *, / e %. Estes podem
+   ser úteis para calcular valores diretamente nos seus arquivos Less
+   para usar valores que você já calculou manualmente. Abaixo está um exemplo
+   de como configurar um design simples de duas colunas. */
+
+@content-area: 960px;
+@main-content: 600px;
+@sidebar-content: 300px;
+
+@main-size: @main-content / @content-area * 100%;
+@sidebar-size: @sidebar-content / @content-area * 100%;
+@gutter: 100% - (@main-size + @sidebar-size);
+
+body {
+  width: 100%;
+}
+
+.main-content {
+  width: @main-size;
+}
+
+.sidebar {
+  width: @sidebar-size;
+}
+
+.gutter {
+  width: @gutter;
+}
+
+/* Compila para: */
+
+body {
+  width: 100%;
+}
+
+.main-content {
+  width: 62.5%;
+}
+
+.sidebar {
+  width: 31.25%;
+}
+
+.gutter {
+  width: 6.25%;
+}
+
+
+```
+
+## Pratique Less
+
+Se você quiser praticar com Less no seu navegador, confira: * [Codepen](http://codepen.io/) * [LESS2CSS](http://lesscss.org/less-preview/)
+
+## Compatibilidade
+
+Less pode ser usado em qualquer projeto, desde que você tenha um programa para compilá-lo em CSS. Você deseja verificar
+se o CSS que você está usando é compatível com seus navegadores de destino.
+
+[QuirksMode CSS](http://www.quirksmode.org/css/) e [CanIUse](http://caniuse.com) são ótimos recursos para verificar a compatibilidade.
+
+## Leitura adicional
+* [Documentação Oficial](http://lesscss.org/features/)
+* [Less CSS - Guia do iniciante](http://www.hongkiat.com/blog/less-basic/)
-- 
cgit v1.2.3


From 097fbf70761a8e525e574162b684e14e166f871b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rog=C3=A9rio?= <roger.lista@gmail.com>
Date: Sat, 20 Oct 2018 23:10:56 -0300
Subject: [make/pt-br] Add portuguese language for make

---
 pt-br/make-pt.html.markdown | 242 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 242 insertions(+)
 create mode 100644 pt-br/make-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/make-pt.html.markdown b/pt-br/make-pt.html.markdown
new file mode 100644
index 00000000..8e7603cc
--- /dev/null
+++ b/pt-br/make-pt.html.markdown
@@ -0,0 +1,242 @@
+---
+language: make
+contributors:
+    - ["Robert Steed", "https://github.com/robochat"]
+    - ["Stephan Fuhrmann", "https://github.com/sfuhrm"]
+filename: Makefile
+
+lang: pt-br
+---
+
+Um Makefile define um gráfico de regras para criar um alvo (ou alvos). Sua finalidade é fazer o mínimo de trabalho necessário para atualizar um alvo para a versão mais recente da fonte. Famosamente escrito ao longo de um fim de semana por Stuart Feldman em 1976, ainda é amplamente usada (particularmente no Unix e no Linux) apesar de muitos concorrentes e críticas.
+
+Existem muitas variedades de make na existência, no entanto, este artigo pressupõe que estamos usando o GNU make, que é o padrão no Linux.
+
+```make
+
+# Comentários podem ser escritos assim.
+
+# O arquivo deve ser nomeado Makefile e então pode ser executado como `make <alvo>`.
+# Caso contrário, nós usamos `make -f "nome-do-arquivo" <alvo>`.
+
+# Aviso - use somente TABS para identar em Makefiles, nunca espaços!
+
+#-----------------------------------------------------------------------
+# Noções básicas
+#-----------------------------------------------------------------------
+
+# Regras são do formato
+# alvo: <pré-requisito>
+# onde os pré-requisitos são opcionais.
+
+# Uma regra - esta regra só será executada se o arquivo0.txt não existir.
+arquivo0.txt:
+	echo "foo" > arquivo0.txt
+	# Mesmo os comentários nestas seções da 'receita' são passados ​​para o shell.
+	# Experimentar `make arquivo0.txt` or simplyou simplesmente `make` - primeira regra é o padrão.
+
+# Esta regra só será executada se arquivo0.txt for mais recente que arquivo1.txt.
+arquivo1.txt: arquivo0.txt
+	cat arquivo0.txt > arquivo1.txt
+	# se as mesmas regras de citação do shell.
+	@cat arquivo0.txt >> arquivo1.txt
+	# @ pára o comando de ser ecoado para stdout.
+	-@echo 'hello'
+	# - significa que make continuará em caso de erro.
+	# Experimentar `make arquivo1.txt` na linha de comando.
+
+# Uma regra pode ter vários alvos e vários pré-requisitos
+arquivo2.txt arquivo3.txt: arquivo0.txt arquivo1.txt
+	touch arquivo2.txt
+	touch arquivo3.txt
+
+# Make vai reclamar sobre várias receitas para a mesma regra. Esvaziar
+# receitas não contam e podem ser usadas para adicionar novas dependências.
+
+#-----------------------------------------------------------------------
+# Alvos falsos
+#-----------------------------------------------------------------------
+
+# Um alvo falso. Qualquer alvo que não seja um arquivo.
+# Ele nunca será atualizado, portanto, o make sempre tentará executá-lo.
+all: maker process
+
+# Podemos declarar as coisas fora de ordem.
+maker:
+	touch ex0.txt ex1.txt
+
+# Pode evitar quebrar regras falsas quando um arquivo real tem o mesmo nome
+.PHONY: all maker process
+# Este é um alvo especial. Existem vários outros.
+
+# Uma regra com dependência de um alvo falso sempre será executada
+ex0.txt ex1.txt: maker
+
+# Alvos falsos comuns são: todos fazem instalação limpa ...
+
+#-----------------------------------------------------------------------
+# Variáveis ​​Automáticas e Curingas
+#-----------------------------------------------------------------------
+
+process: Arquivo*.txt	# Usando um curinga para corresponder nomes de arquivos
+	@echo $^	# $^ é uma variável que contém a lista de pré-requisitos
+	@echo $@	# imprime o nome do alvo
+	#(fpara várias regras alvo, $@ é o que causou a execução da regra)
+	@echo $<	# o primeiro pré-requisito listado
+	@echo $?	# somente as dependências que estão desatualizadas
+	@echo $+	# todas as dependências, incluindo duplicadas (ao contrário do normal)
+	#@echo $|	# todos os pré-requisitos 'somente pedidos'
+
+# Mesmo se dividirmos as definições de dependência de regra, $^ vai encontrá-los
+process: ex1.txt arquivo0.txt
+# ex1.txt será encontrado, mas arquivo0.txt será desduplicado.
+
+#-----------------------------------------------------------------------
+# Padrões
+#-----------------------------------------------------------------------
+
+# Pode ensinar make a converter certos arquivos em outros arquivos.
+
+%.png: %.svg
+	inkscape --export-png $^
+
+# As regras padrões só farão qualquer coisa se decidirem criar o alvo.
+
+# Os caminhos de diretório são normalmente ignorados quando as regras de
+# padrões são correspondentes. Mas make tentará usar a regra mais
+# apropriada disponível.
+small/%.png: %.svg
+	inkscape --export-png --export-dpi 30 $^
+
+# make utilizará a última versão para uma regra de padrão que encontrar.
+%.png: %.svg
+	@echo esta regra é escolhida
+
+# No entanto, o make usará a primeira regra padrão que pode se tornar o alvo
+%.png: %.ps
+	@echo esta regra não é escolhida se *.svg and *.ps estão ambos presentes
+
+# make já tem algumas regras padrões embutidas. Por exemplo, ele sabe
+# como transformar arquivos *.c em arquivos *.o.
+
+# Makefiles antigos podem usar regras de sufixo em vez de regras padrões
+.png.ps:
+	@echo essa regra é semelhante a uma regra de padrão.
+
+# make sobre a regra de sufixo
+.SUFFIXES: .png
+
+#-----------------------------------------------------------------------
+# Variáveis
+#-----------------------------------------------------------------------
+# aka. macros
+
+# As variáveis ​​são basicamente todos os tipos de string
+
+name = Ted
+name2="Sarah"
+
+echo:
+	@echo $(name)
+	@echo ${name2}
+	@echo $name    # Isso não funcionará, tratado como $ (n)ame.
+	@echo $(name3) # Variáveis ​​desconhecidas são tratadas como strings vazias.
+
+# Existem 4 lugares para definir variáveis.
+# Em ordem de prioridade, do maior para o menor:
+# 1: argumentos de linha de comando
+# 2: Makefile
+# 3: variáveis ​​de ambiente do shell - faça importações automaticamente.
+# 4: make tem algumas variáveis ​​predefinidas
+
+name4 ?= Jean
+# Somente defina a variável se a variável de ambiente ainda não estiver definida.
+
+override name5 = David
+# Pára os argumentos da linha de comando de alterar essa variável.
+
+name4 +=grey
+# Anexar valores à variável (inclui um espaço).
+
+# Valores variáveis ​​específicos de padrões (extensão GNU).
+echo: name2 = Sara # Verdadeiro dentro da regra de correspondência
+	# e também dentro de suas recursivas dependências
+	# (exceto que ele pode quebrar quando seu gráfico ficar muito complicado!)
+
+# Algumas variáveis ​​definidas automaticamente pelo make
+echo_inbuilt:
+	echo $(CC)
+	echo ${CXX}
+	echo $(FC)
+	echo ${CFLAGS}
+	echo $(CPPFLAGS)
+	echo ${CXXFLAGS}
+	echo $(LDFLAGS)
+	echo ${LDLIBS}
+
+#-----------------------------------------------------------------------
+# Variáveis 2
+#-----------------------------------------------------------------------
+
+# O primeiro tipo de variáveis ​​é avaliado a cada vez que elas são usadas.
+# TIsso pode ser caro, então existe um segundo tipo de variável que é
+# avaliado apenas uma vez. (Esta é uma extensão do GNU make)
+
+var := hello
+var2 ::=  $(var) hello
+#:= e ::= são equivalentes.
+
+# Essas variáveis ​​são avaliadas procedimentalmente (na ordem em que
+# aparecem), quebrando assim o resto da línguagem!
+
+# Isso não funciona
+var3 ::= $(var4) and good luck
+var4 ::= good night
+
+#-----------------------------------------------------------------------
+# Funções
+#-----------------------------------------------------------------------
+
+# make tem muitas funções disponíveis.
+
+sourcefiles = $(wildcard *.c */*.c)
+objectfiles = $(patsubst %.c,%.o,$(sourcefiles))
+
+# O formato é $(func arg0,arg1,arg2...)
+
+# Alguns exemplos
+ls:	* src/*
+	@echo $(filter %.txt, $^)
+	@echo $(notdir $^)
+	@echo $(join $(dir $^),$(notdir $^))
+
+#-----------------------------------------------------------------------
+# Diretivas
+#-----------------------------------------------------------------------
+
+# Inclua outros makefiles, úteis para código específico da plataforma
+include foo.mk
+
+sport = tennis
+# Compilação condicional
+report:
+ifeq ($(sport),tennis)
+	@echo 'game, set, match'
+else
+	@echo "They think it's all over; it is now"
+endif
+
+# Há também ifneq, ifdef, ifndef
+
+foo = true
+
+ifdef $(foo)
+bar = 'hello'
+endif
+```
+
+### More Resources
+
++ [documentação gnu make](https://www.gnu.org/software/make/manual/)
++ [tutorial de carpintaria de software](http://swcarpentry.github.io/make-novice/)
++ aprenda C da maneira mais difícil [ex2](http://c.learncodethehardway.org/book/ex2.html) [ex28](http://c.learncodethehardway.org/book/ex28.html)
-- 
cgit v1.2.3


From e3123b92837ed05dd802c24e5e99d966d2a9f306 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rog=C3=A9rio?= <roger.lista@gmail.com>
Date: Sat, 20 Oct 2018 23:47:54 -0300
Subject: Remove make translate

---
 pt-br/make-pt.html.markdown | 242 --------------------------------------------
 1 file changed, 242 deletions(-)
 delete mode 100644 pt-br/make-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/make-pt.html.markdown b/pt-br/make-pt.html.markdown
deleted file mode 100644
index 8e7603cc..00000000
--- a/pt-br/make-pt.html.markdown
+++ /dev/null
@@ -1,242 +0,0 @@
----
-language: make
-contributors:
-    - ["Robert Steed", "https://github.com/robochat"]
-    - ["Stephan Fuhrmann", "https://github.com/sfuhrm"]
-filename: Makefile
-
-lang: pt-br
----
-
-Um Makefile define um gráfico de regras para criar um alvo (ou alvos). Sua finalidade é fazer o mínimo de trabalho necessário para atualizar um alvo para a versão mais recente da fonte. Famosamente escrito ao longo de um fim de semana por Stuart Feldman em 1976, ainda é amplamente usada (particularmente no Unix e no Linux) apesar de muitos concorrentes e críticas.
-
-Existem muitas variedades de make na existência, no entanto, este artigo pressupõe que estamos usando o GNU make, que é o padrão no Linux.
-
-```make
-
-# Comentários podem ser escritos assim.
-
-# O arquivo deve ser nomeado Makefile e então pode ser executado como `make <alvo>`.
-# Caso contrário, nós usamos `make -f "nome-do-arquivo" <alvo>`.
-
-# Aviso - use somente TABS para identar em Makefiles, nunca espaços!
-
-#-----------------------------------------------------------------------
-# Noções básicas
-#-----------------------------------------------------------------------
-
-# Regras são do formato
-# alvo: <pré-requisito>
-# onde os pré-requisitos são opcionais.
-
-# Uma regra - esta regra só será executada se o arquivo0.txt não existir.
-arquivo0.txt:
-	echo "foo" > arquivo0.txt
-	# Mesmo os comentários nestas seções da 'receita' são passados ​​para o shell.
-	# Experimentar `make arquivo0.txt` or simplyou simplesmente `make` - primeira regra é o padrão.
-
-# Esta regra só será executada se arquivo0.txt for mais recente que arquivo1.txt.
-arquivo1.txt: arquivo0.txt
-	cat arquivo0.txt > arquivo1.txt
-	# se as mesmas regras de citação do shell.
-	@cat arquivo0.txt >> arquivo1.txt
-	# @ pára o comando de ser ecoado para stdout.
-	-@echo 'hello'
-	# - significa que make continuará em caso de erro.
-	# Experimentar `make arquivo1.txt` na linha de comando.
-
-# Uma regra pode ter vários alvos e vários pré-requisitos
-arquivo2.txt arquivo3.txt: arquivo0.txt arquivo1.txt
-	touch arquivo2.txt
-	touch arquivo3.txt
-
-# Make vai reclamar sobre várias receitas para a mesma regra. Esvaziar
-# receitas não contam e podem ser usadas para adicionar novas dependências.
-
-#-----------------------------------------------------------------------
-# Alvos falsos
-#-----------------------------------------------------------------------
-
-# Um alvo falso. Qualquer alvo que não seja um arquivo.
-# Ele nunca será atualizado, portanto, o make sempre tentará executá-lo.
-all: maker process
-
-# Podemos declarar as coisas fora de ordem.
-maker:
-	touch ex0.txt ex1.txt
-
-# Pode evitar quebrar regras falsas quando um arquivo real tem o mesmo nome
-.PHONY: all maker process
-# Este é um alvo especial. Existem vários outros.
-
-# Uma regra com dependência de um alvo falso sempre será executada
-ex0.txt ex1.txt: maker
-
-# Alvos falsos comuns são: todos fazem instalação limpa ...
-
-#-----------------------------------------------------------------------
-# Variáveis ​​Automáticas e Curingas
-#-----------------------------------------------------------------------
-
-process: Arquivo*.txt	# Usando um curinga para corresponder nomes de arquivos
-	@echo $^	# $^ é uma variável que contém a lista de pré-requisitos
-	@echo $@	# imprime o nome do alvo
-	#(fpara várias regras alvo, $@ é o que causou a execução da regra)
-	@echo $<	# o primeiro pré-requisito listado
-	@echo $?	# somente as dependências que estão desatualizadas
-	@echo $+	# todas as dependências, incluindo duplicadas (ao contrário do normal)
-	#@echo $|	# todos os pré-requisitos 'somente pedidos'
-
-# Mesmo se dividirmos as definições de dependência de regra, $^ vai encontrá-los
-process: ex1.txt arquivo0.txt
-# ex1.txt será encontrado, mas arquivo0.txt será desduplicado.
-
-#-----------------------------------------------------------------------
-# Padrões
-#-----------------------------------------------------------------------
-
-# Pode ensinar make a converter certos arquivos em outros arquivos.
-
-%.png: %.svg
-	inkscape --export-png $^
-
-# As regras padrões só farão qualquer coisa se decidirem criar o alvo.
-
-# Os caminhos de diretório são normalmente ignorados quando as regras de
-# padrões são correspondentes. Mas make tentará usar a regra mais
-# apropriada disponível.
-small/%.png: %.svg
-	inkscape --export-png --export-dpi 30 $^
-
-# make utilizará a última versão para uma regra de padrão que encontrar.
-%.png: %.svg
-	@echo esta regra é escolhida
-
-# No entanto, o make usará a primeira regra padrão que pode se tornar o alvo
-%.png: %.ps
-	@echo esta regra não é escolhida se *.svg and *.ps estão ambos presentes
-
-# make já tem algumas regras padrões embutidas. Por exemplo, ele sabe
-# como transformar arquivos *.c em arquivos *.o.
-
-# Makefiles antigos podem usar regras de sufixo em vez de regras padrões
-.png.ps:
-	@echo essa regra é semelhante a uma regra de padrão.
-
-# make sobre a regra de sufixo
-.SUFFIXES: .png
-
-#-----------------------------------------------------------------------
-# Variáveis
-#-----------------------------------------------------------------------
-# aka. macros
-
-# As variáveis ​​são basicamente todos os tipos de string
-
-name = Ted
-name2="Sarah"
-
-echo:
-	@echo $(name)
-	@echo ${name2}
-	@echo $name    # Isso não funcionará, tratado como $ (n)ame.
-	@echo $(name3) # Variáveis ​​desconhecidas são tratadas como strings vazias.
-
-# Existem 4 lugares para definir variáveis.
-# Em ordem de prioridade, do maior para o menor:
-# 1: argumentos de linha de comando
-# 2: Makefile
-# 3: variáveis ​​de ambiente do shell - faça importações automaticamente.
-# 4: make tem algumas variáveis ​​predefinidas
-
-name4 ?= Jean
-# Somente defina a variável se a variável de ambiente ainda não estiver definida.
-
-override name5 = David
-# Pára os argumentos da linha de comando de alterar essa variável.
-
-name4 +=grey
-# Anexar valores à variável (inclui um espaço).
-
-# Valores variáveis ​​específicos de padrões (extensão GNU).
-echo: name2 = Sara # Verdadeiro dentro da regra de correspondência
-	# e também dentro de suas recursivas dependências
-	# (exceto que ele pode quebrar quando seu gráfico ficar muito complicado!)
-
-# Algumas variáveis ​​definidas automaticamente pelo make
-echo_inbuilt:
-	echo $(CC)
-	echo ${CXX}
-	echo $(FC)
-	echo ${CFLAGS}
-	echo $(CPPFLAGS)
-	echo ${CXXFLAGS}
-	echo $(LDFLAGS)
-	echo ${LDLIBS}
-
-#-----------------------------------------------------------------------
-# Variáveis 2
-#-----------------------------------------------------------------------
-
-# O primeiro tipo de variáveis ​​é avaliado a cada vez que elas são usadas.
-# TIsso pode ser caro, então existe um segundo tipo de variável que é
-# avaliado apenas uma vez. (Esta é uma extensão do GNU make)
-
-var := hello
-var2 ::=  $(var) hello
-#:= e ::= são equivalentes.
-
-# Essas variáveis ​​são avaliadas procedimentalmente (na ordem em que
-# aparecem), quebrando assim o resto da línguagem!
-
-# Isso não funciona
-var3 ::= $(var4) and good luck
-var4 ::= good night
-
-#-----------------------------------------------------------------------
-# Funções
-#-----------------------------------------------------------------------
-
-# make tem muitas funções disponíveis.
-
-sourcefiles = $(wildcard *.c */*.c)
-objectfiles = $(patsubst %.c,%.o,$(sourcefiles))
-
-# O formato é $(func arg0,arg1,arg2...)
-
-# Alguns exemplos
-ls:	* src/*
-	@echo $(filter %.txt, $^)
-	@echo $(notdir $^)
-	@echo $(join $(dir $^),$(notdir $^))
-
-#-----------------------------------------------------------------------
-# Diretivas
-#-----------------------------------------------------------------------
-
-# Inclua outros makefiles, úteis para código específico da plataforma
-include foo.mk
-
-sport = tennis
-# Compilação condicional
-report:
-ifeq ($(sport),tennis)
-	@echo 'game, set, match'
-else
-	@echo "They think it's all over; it is now"
-endif
-
-# Há também ifneq, ifdef, ifndef
-
-foo = true
-
-ifdef $(foo)
-bar = 'hello'
-endif
-```
-
-### More Resources
-
-+ [documentação gnu make](https://www.gnu.org/software/make/manual/)
-+ [tutorial de carpintaria de software](http://swcarpentry.github.io/make-novice/)
-+ aprenda C da maneira mais difícil [ex2](http://c.learncodethehardway.org/book/ex2.html) [ex28](http://c.learncodethehardway.org/book/ex28.html)
-- 
cgit v1.2.3


From 678e42b2a34cd91f40139eefa7cc3dd3e6e4e30a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rog=C3=A9rio?= <roger.lista@gmail.com>
Date: Sun, 21 Oct 2018 00:27:00 -0300
Subject: [make/pt-br] Add portuguese language for make

---
 pt-br/make-pt.html.markdown | 242 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 242 insertions(+)
 create mode 100644 pt-br/make-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/make-pt.html.markdown b/pt-br/make-pt.html.markdown
new file mode 100644
index 00000000..8e7603cc
--- /dev/null
+++ b/pt-br/make-pt.html.markdown
@@ -0,0 +1,242 @@
+---
+language: make
+contributors:
+    - ["Robert Steed", "https://github.com/robochat"]
+    - ["Stephan Fuhrmann", "https://github.com/sfuhrm"]
+filename: Makefile
+
+lang: pt-br
+---
+
+Um Makefile define um gráfico de regras para criar um alvo (ou alvos). Sua finalidade é fazer o mínimo de trabalho necessário para atualizar um alvo para a versão mais recente da fonte. Famosamente escrito ao longo de um fim de semana por Stuart Feldman em 1976, ainda é amplamente usada (particularmente no Unix e no Linux) apesar de muitos concorrentes e críticas.
+
+Existem muitas variedades de make na existência, no entanto, este artigo pressupõe que estamos usando o GNU make, que é o padrão no Linux.
+
+```make
+
+# Comentários podem ser escritos assim.
+
+# O arquivo deve ser nomeado Makefile e então pode ser executado como `make <alvo>`.
+# Caso contrário, nós usamos `make -f "nome-do-arquivo" <alvo>`.
+
+# Aviso - use somente TABS para identar em Makefiles, nunca espaços!
+
+#-----------------------------------------------------------------------
+# Noções básicas
+#-----------------------------------------------------------------------
+
+# Regras são do formato
+# alvo: <pré-requisito>
+# onde os pré-requisitos são opcionais.
+
+# Uma regra - esta regra só será executada se o arquivo0.txt não existir.
+arquivo0.txt:
+	echo "foo" > arquivo0.txt
+	# Mesmo os comentários nestas seções da 'receita' são passados ​​para o shell.
+	# Experimentar `make arquivo0.txt` or simplyou simplesmente `make` - primeira regra é o padrão.
+
+# Esta regra só será executada se arquivo0.txt for mais recente que arquivo1.txt.
+arquivo1.txt: arquivo0.txt
+	cat arquivo0.txt > arquivo1.txt
+	# se as mesmas regras de citação do shell.
+	@cat arquivo0.txt >> arquivo1.txt
+	# @ pára o comando de ser ecoado para stdout.
+	-@echo 'hello'
+	# - significa que make continuará em caso de erro.
+	# Experimentar `make arquivo1.txt` na linha de comando.
+
+# Uma regra pode ter vários alvos e vários pré-requisitos
+arquivo2.txt arquivo3.txt: arquivo0.txt arquivo1.txt
+	touch arquivo2.txt
+	touch arquivo3.txt
+
+# Make vai reclamar sobre várias receitas para a mesma regra. Esvaziar
+# receitas não contam e podem ser usadas para adicionar novas dependências.
+
+#-----------------------------------------------------------------------
+# Alvos falsos
+#-----------------------------------------------------------------------
+
+# Um alvo falso. Qualquer alvo que não seja um arquivo.
+# Ele nunca será atualizado, portanto, o make sempre tentará executá-lo.
+all: maker process
+
+# Podemos declarar as coisas fora de ordem.
+maker:
+	touch ex0.txt ex1.txt
+
+# Pode evitar quebrar regras falsas quando um arquivo real tem o mesmo nome
+.PHONY: all maker process
+# Este é um alvo especial. Existem vários outros.
+
+# Uma regra com dependência de um alvo falso sempre será executada
+ex0.txt ex1.txt: maker
+
+# Alvos falsos comuns são: todos fazem instalação limpa ...
+
+#-----------------------------------------------------------------------
+# Variáveis ​​Automáticas e Curingas
+#-----------------------------------------------------------------------
+
+process: Arquivo*.txt	# Usando um curinga para corresponder nomes de arquivos
+	@echo $^	# $^ é uma variável que contém a lista de pré-requisitos
+	@echo $@	# imprime o nome do alvo
+	#(fpara várias regras alvo, $@ é o que causou a execução da regra)
+	@echo $<	# o primeiro pré-requisito listado
+	@echo $?	# somente as dependências que estão desatualizadas
+	@echo $+	# todas as dependências, incluindo duplicadas (ao contrário do normal)
+	#@echo $|	# todos os pré-requisitos 'somente pedidos'
+
+# Mesmo se dividirmos as definições de dependência de regra, $^ vai encontrá-los
+process: ex1.txt arquivo0.txt
+# ex1.txt será encontrado, mas arquivo0.txt será desduplicado.
+
+#-----------------------------------------------------------------------
+# Padrões
+#-----------------------------------------------------------------------
+
+# Pode ensinar make a converter certos arquivos em outros arquivos.
+
+%.png: %.svg
+	inkscape --export-png $^
+
+# As regras padrões só farão qualquer coisa se decidirem criar o alvo.
+
+# Os caminhos de diretório são normalmente ignorados quando as regras de
+# padrões são correspondentes. Mas make tentará usar a regra mais
+# apropriada disponível.
+small/%.png: %.svg
+	inkscape --export-png --export-dpi 30 $^
+
+# make utilizará a última versão para uma regra de padrão que encontrar.
+%.png: %.svg
+	@echo esta regra é escolhida
+
+# No entanto, o make usará a primeira regra padrão que pode se tornar o alvo
+%.png: %.ps
+	@echo esta regra não é escolhida se *.svg and *.ps estão ambos presentes
+
+# make já tem algumas regras padrões embutidas. Por exemplo, ele sabe
+# como transformar arquivos *.c em arquivos *.o.
+
+# Makefiles antigos podem usar regras de sufixo em vez de regras padrões
+.png.ps:
+	@echo essa regra é semelhante a uma regra de padrão.
+
+# make sobre a regra de sufixo
+.SUFFIXES: .png
+
+#-----------------------------------------------------------------------
+# Variáveis
+#-----------------------------------------------------------------------
+# aka. macros
+
+# As variáveis ​​são basicamente todos os tipos de string
+
+name = Ted
+name2="Sarah"
+
+echo:
+	@echo $(name)
+	@echo ${name2}
+	@echo $name    # Isso não funcionará, tratado como $ (n)ame.
+	@echo $(name3) # Variáveis ​​desconhecidas são tratadas como strings vazias.
+
+# Existem 4 lugares para definir variáveis.
+# Em ordem de prioridade, do maior para o menor:
+# 1: argumentos de linha de comando
+# 2: Makefile
+# 3: variáveis ​​de ambiente do shell - faça importações automaticamente.
+# 4: make tem algumas variáveis ​​predefinidas
+
+name4 ?= Jean
+# Somente defina a variável se a variável de ambiente ainda não estiver definida.
+
+override name5 = David
+# Pára os argumentos da linha de comando de alterar essa variável.
+
+name4 +=grey
+# Anexar valores à variável (inclui um espaço).
+
+# Valores variáveis ​​específicos de padrões (extensão GNU).
+echo: name2 = Sara # Verdadeiro dentro da regra de correspondência
+	# e também dentro de suas recursivas dependências
+	# (exceto que ele pode quebrar quando seu gráfico ficar muito complicado!)
+
+# Algumas variáveis ​​definidas automaticamente pelo make
+echo_inbuilt:
+	echo $(CC)
+	echo ${CXX}
+	echo $(FC)
+	echo ${CFLAGS}
+	echo $(CPPFLAGS)
+	echo ${CXXFLAGS}
+	echo $(LDFLAGS)
+	echo ${LDLIBS}
+
+#-----------------------------------------------------------------------
+# Variáveis 2
+#-----------------------------------------------------------------------
+
+# O primeiro tipo de variáveis ​​é avaliado a cada vez que elas são usadas.
+# TIsso pode ser caro, então existe um segundo tipo de variável que é
+# avaliado apenas uma vez. (Esta é uma extensão do GNU make)
+
+var := hello
+var2 ::=  $(var) hello
+#:= e ::= são equivalentes.
+
+# Essas variáveis ​​são avaliadas procedimentalmente (na ordem em que
+# aparecem), quebrando assim o resto da línguagem!
+
+# Isso não funciona
+var3 ::= $(var4) and good luck
+var4 ::= good night
+
+#-----------------------------------------------------------------------
+# Funções
+#-----------------------------------------------------------------------
+
+# make tem muitas funções disponíveis.
+
+sourcefiles = $(wildcard *.c */*.c)
+objectfiles = $(patsubst %.c,%.o,$(sourcefiles))
+
+# O formato é $(func arg0,arg1,arg2...)
+
+# Alguns exemplos
+ls:	* src/*
+	@echo $(filter %.txt, $^)
+	@echo $(notdir $^)
+	@echo $(join $(dir $^),$(notdir $^))
+
+#-----------------------------------------------------------------------
+# Diretivas
+#-----------------------------------------------------------------------
+
+# Inclua outros makefiles, úteis para código específico da plataforma
+include foo.mk
+
+sport = tennis
+# Compilação condicional
+report:
+ifeq ($(sport),tennis)
+	@echo 'game, set, match'
+else
+	@echo "They think it's all over; it is now"
+endif
+
+# Há também ifneq, ifdef, ifndef
+
+foo = true
+
+ifdef $(foo)
+bar = 'hello'
+endif
+```
+
+### More Resources
+
++ [documentação gnu make](https://www.gnu.org/software/make/manual/)
++ [tutorial de carpintaria de software](http://swcarpentry.github.io/make-novice/)
++ aprenda C da maneira mais difícil [ex2](http://c.learncodethehardway.org/book/ex2.html) [ex28](http://c.learncodethehardway.org/book/ex28.html)
-- 
cgit v1.2.3


From c73fbc27631e51598bcefecc5ac9606e1bab6476 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rog=C3=A9rio?= <roger.lista@gmail.com>
Date: Sun, 21 Oct 2018 16:45:44 -0300
Subject: [cypher/pt-br] Add portuguese language for cypher

---
 pt-br/cypher-pt.html.markdown | 250 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 250 insertions(+)
 create mode 100644 pt-br/cypher-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/cypher-pt.html.markdown b/pt-br/cypher-pt.html.markdown
new file mode 100644
index 00000000..7cfd8dcd
--- /dev/null
+++ b/pt-br/cypher-pt.html.markdown
@@ -0,0 +1,250 @@
+---
+language: cypher
+filename: LearnCypher.cql
+contributors:
+    - ["Théo Gauchoux", "https://github.com/TheoGauchoux"]
+
+lang: pt-br
+---
+
+O Cypher é a linguagem de consulta do Neo4j para manipular gráficos facilmente. Ela reutiliza a sintaxe do SQL e a mistura com o tipo de ascii-art para representar gráficos. Este tutorial pressupõe que você já conheça conceitos de gráficos como nós e relacionamentos.
+
+[Leia mais aqui.](https://neo4j.com/developer/cypher-query-language/)
+
+
+Nós
+---
+
+**Representa um registro em um gráfico.**
+
+`()`
+É um *nó* vazio, para indicar que existe um *nó*, mas não é relevante para a consulta.
+
+`(n)`
+É um *nó* referido pela variável **n**, reutilizável na consulta. Começa com minúsculas e usa o camelCase.
+
+`(p:Person)`
+Você pode adicionar um *label* ao seu nó, aqui **Person**. É como um tipo / uma classe / uma categoria. Começa com maiúsculas e usa o camelCase.
+
+`(p:Person:Manager)`
+Um nó pode ter muitos *labels*.
+
+`(p:Person {name : 'Théo Gauchoux', age : 22})`
+Um nó pode ter algumas *propriedades*, aqui **name** e **age**. Começa com minúsculas e usa o camelCase.
+
+Os tipos permitidos nas propriedades:
+
+ - Numeric
+ - Boolean
+ - String
+ - Lista de tipos primitivos anteriores
+
+*Aviso: não há propriedade datetime no Cypher! Você pode usar String com um padrão específico ou um Numeric a partir de uma data específica.*
+
+`p.name`
+Você pode acessar uma propriedade com o estilo de ponto.
+
+
+Relacionamentos (ou Arestas)
+---
+
+**Conecta dois nós**
+
+`[:KNOWS]`
+É um *relacionamento* com o *label* **KNOWS**. É um *label* como um rótulo do nó. Começa com maiúsculas e usa UPPER_SNAKE_CASE.
+
+`[k:KNOWS]`
+O mesmo *relacionamento*, referido pela variável **k**, reutilizável na consulta, mas não é necessário.
+
+`[k:KNOWS {since:2017}]`
+O mesmo *relacionamento*, com *propriedades* (como *nó*), aqui **since**.
+
+`[k:KNOWS*..4]`
+É uma informação estrutural para usar em um *path* (visto posteriormente). Aqui, **\*..4** diz, “Corresponda o padrão, com a relação **k** que é repetida de 1 a 4 vezes.
+
+
+Paths
+---
+
+**A maneira de misturar nós e relacionamentos.**
+
+`(a:Person)-[:KNOWS]-(b:Person)`
+Um path descrevendo que **a** e **b** se conhecem.
+
+`(a:Person)-[:MANAGES]->(b:Person)`
+Um path pode ser direcionado. Este path descreve que **a** é o gerente de **b**.
+
+`(a:Person)-[:KNOWS]-(b:Person)-[:KNOWS]-(c:Person)`
+Você pode encadear vários relacionamentos. Este path descreve o amigo de um amigo.
+
+`(a:Person)-[:MANAGES]->(b:Person)-[:MANAGES]->(c:Person)`
+Uma encadeamento também pode ser direcionada. Este path descreve que **a** é o chefe de **b** e o grande chefe de **c**.
+
+Padrões frequentemente usados ​​(do Neo4j doc) :
+
+```
+// Amigo de um amigo
+(user)-[:KNOWS]-(friend)-[:KNOWS]-(foaf)
+
+// Path mais curto
+path = shortestPath( (user)-[:KNOWS*..5]-(other) )
+
+// Filtragem colaborativa
+(user)-[:PURCHASED]->(product)<-[:PURCHASED]-()-[:PURCHASED]->(otherProduct)
+
+// Navegação de árvore
+(root)<-[:PARENT*]-(leaf:Category)-[:ITEM]->(data:Product)
+
+```
+
+
+Crie consultas
+---
+
+Create a new node
+```
+CREATE (a:Person {name:"Théo Gauchoux"})
+RETURN a
+```
+*`RETURN` permite ter um resultado após a consulta. Pode ser múltiplo, como `RETURN a, b`.*
+
+Crie um novo relacionamento (com 2 novos nós)
+```
+CREATE (a:Person)-[k:KNOWS]-(b:Person)
+RETURN a,k,b
+```
+
+Consultas que casam
+---
+
+Casam todos os nós
+```
+MATCH (n)
+RETURN n
+```
+
+Casam nós por label
+```
+MATCH (a:Person)
+RETURN a
+```
+
+Casam nós por label e propriedade
+```
+MATCH (a:Person {name:"Théo Gauchoux"})
+RETURN a
+```
+
+Casam nós de acordo com os relacionamentos (não direcionados)
+```
+MATCH (a)-[:KNOWS]-(b)
+RETURN a,b
+```
+
+Casam nós de acordo com os relacionamentos (direcionados)
+```
+MATCH (a)-[:MANAGES]->(b)
+RETURN a,b
+```
+
+Casam nós com um cláusula `WHERE`
+```
+MATCH (p:Person {name:"Théo Gauchoux"})-[s:LIVES_IN]->(city:City)
+WHERE s.since = 2015
+RETURN p,state
+```
+
+Você pode usa a cláusula `MATCH WHERE` com a cláusula `CREATE`
+```
+MATCH (a), (b)
+WHERE a.name = "Jacquie" AND b.name = "Michel"
+CREATE (a)-[:KNOWS]-(b)
+```
+
+
+Atualizar consultas
+---
+
+Atualizar uma propriedade específica de um nó
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p.age = 23
+```
+
+Substituir todas as propriedades de um nó
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p = {name: "Michel", age: 23}
+```
+
+Adicionar nova propriedade a um nó
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p + = {studies: "IT Engineering"}
+```
+
+Adicione um label a um nó
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p:Internship
+```
+
+
+Excluir consultas
+---
+
+Excluir um nó específico (os relacionamentos vinculados devem ser excluídos antes)
+```
+MATCH (p:Person)-[relationship]-()
+WHERE p.name = "Théo Gauchoux"
+DELETE relationship, p
+```
+
+Remover uma propriedade em um nó específico
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+REMOVE p.age
+```
+*Prestar atenção à palavra chave `REMOVE`, não é `DELETE` !*
+
+Remover um label de um nó específico
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+DELETE p:Person
+```
+
+Excluir o banco de dados inteiro
+```
+MATCH (n)
+OPTIONAL MATCH (n)-[r]-()
+DELETE n, r
+```
+*Sério, é o `rm -rf /` do Cypher !*
+
+
+Outras cláusulas úteis
+---
+
+`PROFILE`
+Antes de uma consulta, mostre o plano de execução dela.
+
+`COUNT(e)`
+Contar entidades (nós ou relacionamentos) que casam com **e**.
+
+`LIMIT x`
+Limite o resultado aos primeiros x resultados.
+
+
+Dicas Especiais
+---
+
+- Há apenas comentários de uma linha no Cypher, com barras duplas : // Comentários
+- Você pode executar um script Cypher armazenado em um arquivo **.cql** diretamente no Neo4j (é uma importação). No entanto, você não pode ter várias instruções neste arquivo (separadas por **;**).
+- Use o shell Neo4j para escrever Cypher, é realmente incrível.
+- O Cypher será a linguagem de consulta padrão para todos os bancos de dados de gráficos (conhecidos como **OpenCypher**).
-- 
cgit v1.2.3


From cb1ef05aa638d5e99e9956c215b79767bc02c1ad Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rog=C3=A9rio?= <roger.lista@gmail.com>
Date: Sun, 21 Oct 2018 20:35:57 -0300
Subject: [factor/pt-br] Add portuguese language for factor

---
 pt-br/factor-pt.html.markdown | 184 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 184 insertions(+)
 create mode 100644 pt-br/factor-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/factor-pt.html.markdown b/pt-br/factor-pt.html.markdown
new file mode 100644
index 00000000..99e2b67f
--- /dev/null
+++ b/pt-br/factor-pt.html.markdown
@@ -0,0 +1,184 @@
+---
+language: factor
+contributors:
+    - ["hyphz", "http://github.com/hyphz/"]
+filename: learnfactor.factor
+
+lang: pt-br
+---
+
+Factor é uma linguagem moderna baseada em pilha, baseado em Forth, criada por Slava Pestov.
+
+Código neste arquivo pode ser digitado em Fator, mas não importado diretamente porque o cabeçalho de vocabulário e importação faria o início completamente confuso.
+
+```
+! Este é um comentário
+
+! Como Forth, toda a programação é feita manipulando a pilha.
+! A indicação de um valor literal o coloca na pilha.
+5 2 3 56 76 23 65    ! Nenhuma saída, mas a pilha é impressa no modo interativo
+
+! Esses números são adicionados à pilha, da esquerda para a direita.
+! .s imprime a pilha de forma não destrutiva.
+.s     ! 5 2 3 56 76 23 65
+
+! A aritmética funciona manipulando dados na pilha.
+5 4 +    ! Sem saída
+
+! `.` mostra o resultado superior da pilha e o imprime.
+.    ! 9
+
+! Mais exemplos de aritmética:
+6 7 * .        ! 42
+1360 23 - .    ! 1337
+12 12 / .      ! 1
+13 2 mod .     ! 1
+
+99 neg .       ! -99
+-99 abs .      ! 99
+52 23 max .    ! 52
+52 23 min .    ! 23
+
+! Várias palavras são fornecidas para manipular a pilha, coletivamente conhecidas como palavras embaralhadas.
+
+3 dup -          ! duplica o primeiro item (1st agora igual a 2nd): 3 - 3
+2 5 swap /       ! troca o primeiro com o segundo elemento:         5 / 2
+4 0 drop 2 /     ! remove o primeiro item (não imprima na tela):    4 / 2
+1 2 3 nip .s     ! remove o segundo item (semelhante a drop):       1 3
+1 2 clear .s     ! acaba com toda a pilha
+1 2 3 4 over .s  ! duplica o segundo item para o topo:   1 2 3 4 3
+1 2 3 4 2 pick .s ! duplica o terceiro item para o topo: 1 2 3 4 2 3
+
+! Criando Palavras
+! O `:` conjuntos de palavras do Factor no modo de compilação até que ela veja a palavra `;`.
+: square ( n -- n ) dup * ;    ! Sem saída
+5 square .                     ! 25
+
+! Podemos ver o que as palavra fazem também.
+! \ suprime a avaliação de uma palavra e coloca seu identificador na pilha.
+\ square see    ! : square ( n -- n ) dup * ;
+
+! Após o nome da palavra para criar, a declaração entre parênteses dá o efeito da pilha.
+! Podemos usar os nomes que quisermos dentro da declaração:
+: weirdsquare ( camel -- llama ) dup * ;
+
+! Contanto que sua contagem corresponda ao efeito da pilha da palavra:
+: doubledup ( a -- b ) dup dup ; ! Error: Stack effect declaration is wrong
+: doubledup ( a -- a a a ) dup dup ; ! Ok
+: weirddoubledup ( i -- am a fish ) dup dup ; ! Além disso Ok
+
+! Onde Factor difere do Forth é no uso de citações.
+! Uma citação é um bloco de código que é colocado na pilha como um valor.
+! [ inicia o modo de citação; ] termina.
+[ 2 + ]       ! A citação que adiciona 2 é deixada na pilha
+4 swap call . ! 6
+
+! E assim, palavras de ordem mais alta. TONS de palavras de ordem superior.
+2 3 [ 2 + ] dip .s      ! Retira valor do topo da pilha, execute citação, empurre de volta: 4 3
+3 4 [ + ] keep .s       ! Copie o valor do topo da pilha, execute a citação, envie a cópia: 7 4
+1 [ 2 + ] [ 3 + ] bi .s ! Executar cada citação no valor do topo, empurrar os dois resultados: 3 4
+4 3 1 [ + ] [ + ] bi .s ! As citações em um bi podem extrair valores mais profundos da pilha: 4 5 ( 1+3 1+4 )
+1 2 [ 2 + ] bi@ .s      ! Executar a citação no primeiro e segundo valores
+2 [ + ] curry           ! Injeta o valor fornecido no início da citação: [ 2 + ] é deixado na pilha
+
+! Condicionais
+! Qualquer valor é verdadeiro, exceto o valor interno f.
+! m valor interno não existe, mas seu uso não é essencial.
+! Condicionais são palavras de maior ordem, como com os combinadores acima.
+
+5 [ "Five is true" . ] when                     ! Cinco é verdadeiro
+0 [ "Zero is true" . ] when                     ! Zero é verdadeiro
+f [ "F is true" . ] when                        ! Sem saída
+f [ "F is false" . ] unless                     ! F é falso
+2 [ "Two is true" . ] [ "Two is false" . ] if   ! Two é verdadeiro
+
+! Por padrão, as condicionais consomem o valor em teste, mas variantes com asterisco
+! deixe sozinho se é verdadeiro:
+
+5 [ . ] when*      ! 5
+f [ . ] when*      ! Nenhuma saída, pilha vazia, f é consumida porque é falsa
+
+
+! Laços
+! Você adivinhou .. estas são palavras de ordem mais elevada também.
+
+5 [ . ] each-integer               ! 0 1 2 3 4
+4 3 2 1 0 5 [ + . ] each-integer   ! 0 2 4 6 8
+5 [ "Hello" . ] times              ! Hello Hello Hello Hello Hello
+
+! Here's a list:
+{ 2 4 6 8 }                        ! Goes on the stack as one item
+
+! Aqui está uma lista:
+{ 2 4 6 8 } [ 1 + . ] each          ! Exibe 3 5 7 9
+{ 2 4 6 8 } [ 1 + ] map             ! Sai { 3 5 7 9 } na pilha
+
+! Reduzir laços ou criar listas:
+{ 1 2 3 4 5 } [ 2 mod 0 = ] filter  ! Mantém apenas membros da lista para os quais a citação é verdadeira: { 2 4 }
+{ 2 4 6 8 } 0 [ + ] reduce .        ! Como "fold" em linguagens funcionais: exibe 20 (0+2+4+6+8)
+{ 2 4 6 8 } 0 [ + ] accumulate . .  ! Como reduzir, mas mantém os valores intermediários em uma lista: exibe { 0 2 6 12 } então 20
+1 5 [ 2 * dup ] replicate .         ! Repete a citação 5 vezes e coleta os resultados em uma lista: { 2 4 8 16 32 }
+1 [ dup 100 < ] [ 2 * dup ] produce ! Repete a segunda citação até que a primeira retorne como falsa e colete os resultados: { 2 4 8 16 32 64 128 }
+
+! Se tudo mais falhar, uma finalidade geral, enquanto repete:
+1 [ dup 10 < ] [ "Hello" . 1 + ] while  ! Exibe "Hello" 10 vezes
+                                        ! Sim, é difícil de ler
+                                        ! Isso é o que todos esses loops variantes são para
+
+! Variáveis
+! Normalmente, espera-se que os programas Factor mantenham todos os dados na pilha.
+! Usar variáveis ​​nomeadas torna a refatoração mais difícil (e é chamada de Factor por um motivo)
+! Variáveis ​​globais, se você precisar:
+
+SYMBOL: name            ! Cria o nome como uma palavra identificadora
+"Bob" name set-global   ! Sem saída
+name get-global .       ! "Bob"
+
+! Variáveis ​​locais nomeadas são consideradas uma extensão, mas estão disponíveis
+! Em uma citação ..
+[| m n                  ! A citação captura os dois principais valores da pilha em m e n
+ | m n + ]              ! Leia-os
+
+! Ou em uma palavra..
+:: lword ( -- )           ! Note os dois pontos duplos para invocar a extensão da variável lexica
+   2 :> c                 ! Declara a variável imutável c para manter 2
+   c . ;                  ! Imprima isso
+
+! Em uma palavra declarada dessa maneira, o lado de entrada da declaração de pilha
+! torna-se significativo e fornece os valores das variáveis ​​em que os valores da pilha são capturados
+:: double ( a -- result ) a 2 * ;
+
+! Variáveis ​​são declaradas mutáveis ​​ao terminar seu nome com um ponto de exclamação
+:: mword2 ( a! -- x y )   ! Capture o topo da pilha na variável mutável a
+   a                      ! Empurrar a
+   a 2 * a!               ! Multiplique por 2 e armazene o resultado em a
+   a ;                    ! Empurre novo valor de a
+5 mword2                  ! Pilha: 5 10
+
+! Listas e Sequências
+! Vimos acima como empurrar uma lista para a pilha
+
+0 { 1 2 3 4 } nth         ! Acessar um membro específico de uma lista: 1
+10 { 1 2 3 4 } nth        ! Error: índice de sequência fora dos limites
+1 { 1 2 3 4 } ?nth        ! O mesmo que nth se o índice estiver dentro dos limites: 2
+10 { 1 2 3 4 } ?nth       ! Nenhum erro se estiver fora dos limites: f
+
+{ "at" "the" "beginning" } "Append" prefix    ! { "Append" "at" "the" "beginning" }
+{ "Append" "at" "the" } "end" suffix          ! { "Append" "at" "the" "end" }
+"in" 1 { "Insert" "the" "middle" } insert-nth ! { "Insert" "in" "the" "middle" }
+"Concat" "enate" append                       ! "Concatenate" - strings are sequences too
+"Concatenate" "Reverse " prepend              ! "Reverse Concatenate"
+{ "Concatenate " "seq " "of " "seqs" } concat ! "Concatenate seq of seqs"
+{ "Connect" "subseqs" "with" "separators" } " " join  ! "Connect subseqs with separators"
+
+! E se você quiser obter meta, as citações são seqüências e podem ser desmontadas..
+0 [ 2 + ] nth                              ! 2
+1 [ 2 + ] nth                              ! +
+[ 2 + ] \ - suffix                         ! Quotation [ 2 + - ]
+
+
+```
+
+##Pronto para mais?
+
+* [Documentação do Factor](http://docs.factorcode.org/content/article-help.home.html)
-- 
cgit v1.2.3


From 868b22058fe14b270c55116d8a5943c2d708415b Mon Sep 17 00:00:00 2001
From: Adam Bard <adam@adambard.com>
Date: Tue, 23 Oct 2018 20:36:28 -0700
Subject: Factor highlight is here

---
 pt-br/factor-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/factor-pt.html.markdown b/pt-br/factor-pt.html.markdown
index 99e2b67f..e3c8f4a9 100644
--- a/pt-br/factor-pt.html.markdown
+++ b/pt-br/factor-pt.html.markdown
@@ -11,7 +11,7 @@ Factor é uma linguagem moderna baseada em pilha, baseado em Forth, criada por S
 
 Código neste arquivo pode ser digitado em Fator, mas não importado diretamente porque o cabeçalho de vocabulário e importação faria o início completamente confuso.
 
-```
+```factor
 ! Este é um comentário
 
 ! Como Forth, toda a programação é feita manipulando a pilha.
-- 
cgit v1.2.3


From 360349bf35a301b8c4586798560d410c892a1540 Mon Sep 17 00:00:00 2001
From: LukaxFeh <outrolucas2002@gmail.com>
Date: Tue, 30 Oct 2018 22:15:10 -0300
Subject: [Dynamic programming-PT/BR] Fixed links

---
 pt-br/dynamic-programming-pt.html.markdown | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/dynamic-programming-pt.html.markdown b/pt-br/dynamic-programming-pt.html.markdown
index 518660a3..93171955 100644
--- a/pt-br/dynamic-programming-pt.html.markdown
+++ b/pt-br/dynamic-programming-pt.html.markdown
@@ -64,9 +64,9 @@ grafo acíclico dirigido.
 
 ## Alguns Problemas Famosos de Programação Dinâmica
 
-- Floyd Warshall Algorithm - Tutorial and C Program source code: [http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code]()
-- Integer Knapsack Problem - Tutorial and C Program source code: [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem]()
-- Longest Common Subsequence - Tutorial and C Program source code : [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence]()
+- [Floyd Warshall Algorithm - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code)
+- [Integer Knapsack Problem - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem)
+- [Longest Common Subsequence - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence)
  
 
 ## Recursos Online (EN)
-- 
cgit v1.2.3


From 1b1acc6f3ed7d24733fbacee2d3a6bf6df7c66a4 Mon Sep 17 00:00:00 2001
From: daniloyamauti <33129352+daniloyamauti@users.noreply.github.com>
Date: Wed, 31 Oct 2018 08:23:24 -0300
Subject: Update csharp-pt.html.markdown

Translation of comments (line 98 and 99)  and correction of comments (line 62)
---
 pt-br/csharp-pt.html.markdown | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index be14a1c8..2b61a8fa 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -59,7 +59,7 @@ namespace Learning.CSharp
             Console.Write("World");
 
             ///////////////////////////////////////////////////
-            // Tpos e Variáveis
+            // Tipos e Variáveis
             //
             // Declare uma variável usando <tipo> <nome>
             ///////////////////////////////////////////////////
@@ -95,8 +95,9 @@ namespace Learning.CSharp
             float fooFloat = 234.5f; // Precision: 7 digits
             // f is used to denote that this variable value is of type float
 
-            // Decimal - a 128-bits data type, with more precision than other floating-point types,
-            // suited for financial and monetary calculations
+            // Decimal - um tipo de dados de 128 bits, com mais precisão do que outros tipos de ponto flutuante,
+            // adequado para cálculos financeiros e monetários
+
             decimal fooDecimal = 150.3m;
 
             // Boolean - true & false
-- 
cgit v1.2.3


From 6d23388f632bc2149a59269a6456ad2bea5552c0 Mon Sep 17 00:00:00 2001
From: Fer <nanda.fer@gmail.com>
Date: Wed, 31 Oct 2018 08:33:18 -0300
Subject: [typescript/pt-br] Removed duplicate text

---
 pt-br/typescript-pt.html.markdown | 7 -------
 1 file changed, 7 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/typescript-pt.html.markdown b/pt-br/typescript-pt.html.markdown
index f072b257..077aa2cc 100644
--- a/pt-br/typescript-pt.html.markdown
+++ b/pt-br/typescript-pt.html.markdown
@@ -8,13 +8,6 @@ translators:
 lang: pt-br
 ---
 
-TypeScript is a language that aims at easing development of large scale applications written in JavaScript.
-TypeScript adds common concepts such as classes, modules, interfaces, generics and (optional) static typing to JavaScript.
-It is a superset of JavaScript: all JavaScript code is valid TypeScript code so it can be added seamlessly to any project. The TypeScript compiler emits JavaScript.
-
-This article will focus only on TypeScript extra syntax, as opposed to [JavaScript] (../javascript/).
-
-
 Typescript é uma linguagem que visa facilitar o desenvolvimento de aplicações em grande escala escritos em JavaScript.
 Typescript acrescenta conceitos comuns como classes, módulos, interfaces, genéricos e (opcional) tipagem estática para JavaScript.
 É um super conjunto de JavaScript: todo o código JavaScript é o código do texto dactilografado válido para que possa ser adicionados diretamente a qualquer projeto. O compilador emite typescript JavaScript.
-- 
cgit v1.2.3


From cb9b22fa54cf29eda343904cef7a26c6860270e8 Mon Sep 17 00:00:00 2001
From: daniloyamauti <33129352+daniloyamauti@users.noreply.github.com>
Date: Wed, 31 Oct 2018 08:37:56 -0300
Subject: [ruby/pt-br] Update ruby-pt.html.markdown

Translation of comment.
---
 pt-br/ruby-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/ruby-pt.html.markdown b/pt-br/ruby-pt.html.markdown
index 1078f6c5..7ae28ac2 100644
--- a/pt-br/ruby-pt.html.markdown
+++ b/pt-br/ruby-pt.html.markdown
@@ -71,7 +71,7 @@ false.class #=> FalseClass
 2 <= 2 #=> true
 2 >= 2 #=> true
 
-# Strings são objects
+# Strings são objetos
 
 'Eu sou uma string'.class #=> String
 "Eu também sou uma string".class #=> String
-- 
cgit v1.2.3


From f08c02338ae371ecffe07f18a11caee64100b8b1 Mon Sep 17 00:00:00 2001
From: Fer <nanda.fer@gmail.com>
Date: Wed, 31 Oct 2018 08:40:34 -0300
Subject: [csharp/pt-br] Missing translation

---
 pt-br/csharp-pt.html.markdown | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index be14a1c8..f0d01e6e 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -294,9 +294,9 @@ on a new line! ""Wow!"", the masses cried";
                 case 3:
                     monthString = "March";
                     break;
-                // You can assign more than one case to an action
-                // But you can't add an action without a break before another case
-                // (if you want to do this, you would have to explicitly add a goto case x
+                // Você pode declarar mais de um "case" para uma ação
+                // Mas você não pode adicionar uma ação sem um "break" antes de outro "case"
+                // (se você quiser fazer isso, você tem que explicitamente adicionar um "goto case x")
                 case 6:
                 case 7:
                 case 8:
-- 
cgit v1.2.3


From 8bad4d109cff8165d1dddf5796db41a4f8273128 Mon Sep 17 00:00:00 2001
From: daniloyamauti <33129352+daniloyamauti@users.noreply.github.com>
Date: Wed, 31 Oct 2018 08:41:41 -0300
Subject: [csharp/pt-br] Update csharp-pt.html.markdown

Translation of comments.
---
 pt-br/csharp-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index be14a1c8..c310ce2e 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -522,7 +522,7 @@ on a new line! ""Wow!"", the masses cried";
             foreach (var key in responses.Keys)
                 Console.WriteLine("{0}:{1}", key, responses[key]);
 
-            // DYNAMIC OBJECTS (great for working with other languages)
+            // OBJETOS DINÂMICOS (ótimo para trabalhar com outros idiomas)
             dynamic student = new ExpandoObject();
             student.FirstName = "First Name"; // No need to define class first!
 
-- 
cgit v1.2.3


From fd5ee982bc9f2f10bafb8b4d7cf15c15e646da10 Mon Sep 17 00:00:00 2001
From: daniloyamauti <33129352+daniloyamauti@users.noreply.github.com>
Date: Wed, 31 Oct 2018 08:45:05 -0300
Subject: [csharp/pt-br] Update csharp-pt.html.markdown

Translation of comments.
---
 pt-br/csharp-pt.html.markdown | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index be14a1c8..3d84f91f 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -522,7 +522,7 @@ on a new line! ""Wow!"", the masses cried";
             foreach (var key in responses.Keys)
                 Console.WriteLine("{0}:{1}", key, responses[key]);
 
-            // DYNAMIC OBJECTS (great for working with other languages)
+            // OBJETOS DINÂMICOS (ótimo para trabalhar com outros idiomas)
             dynamic student = new ExpandoObject();
             student.FirstName = "First Name"; // No need to define class first!
 
@@ -730,10 +730,10 @@ on a new line! ""Wow!"", the masses cried";
             set { _hasTassles = value; }
         }
 
-        // You can also define an automatic property in one line
-        // this syntax will create a backing field automatically.
-        // You can set an access modifier on either the getter or the setter (or both)
-        // to restrict its access:
+        // Você também pode definir uma propriedade automática em uma linha
+        // Esta sintaxe criará um campo de apoio automaticamente.
+        // Você pode definir um modificador de acesso no getter ou no setter (ou ambos)
+        // para restringir seu acesso:
         public bool IsBroken { get; private set; }
 
         // Properties can be auto-implemented
-- 
cgit v1.2.3


From b0d213ca09f5453a1f957b202bc5b1cc20cc5cb9 Mon Sep 17 00:00:00 2001
From: daniloyamauti <33129352+daniloyamauti@users.noreply.github.com>
Date: Wed, 31 Oct 2018 08:50:50 -0300
Subject: [csharp/pt-br] Update csharp-pt.html.markdown

Translation of comments.
---
 pt-br/csharp-pt.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index be14a1c8..e5c7eed0 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -854,8 +854,8 @@ on a new line! ""Wow!"", the masses cried";
     }
 
     /// <summary>
-    /// Used to connect to DB for LinqToSql example.
-    /// EntityFramework Code First is awesome (similar to Ruby's ActiveRecord, but bidirectional)
+    /// Exemplo de como conectar-se ao DB via LinqToSql.
+    /// EntityFramework First Code é impressionante (semelhante ao ActiveRecord de Ruby, mas bidirecional)
     /// http://msdn.microsoft.com/en-us/data/jj193542.aspx
     /// </summary>
     public class BikeRepository : DbContext
-- 
cgit v1.2.3


From 049838460e27f0a9777ac92dfc2843a5f9056358 Mon Sep 17 00:00:00 2001
From: Fer <nanda.fer@gmail.com>
Date: Wed, 31 Oct 2018 08:51:04 -0300
Subject: [yaml/pt-br] Fixing translation

---
 pt-br/yaml-pt.html.markdown | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/yaml-pt.html.markdown b/pt-br/yaml-pt.html.markdown
index 341ae675..569bde75 100644
--- a/pt-br/yaml-pt.html.markdown
+++ b/pt-br/yaml-pt.html.markdown
@@ -11,9 +11,9 @@ lang: pt-br
 YAML é uma linguagem de serialização de dados projetado para ser diretamente gravável e
 legível por seres humanos.
 
-É um estrito subconjunto de JSON, com a adição de sintaticamente
-novas linhas e recuo significativos, como Python. Ao contrário de Python, no entanto,
-YAML não permite caracteres de tabulação literais em tudo.
+It's a strict superset of JSON, with the addition of syntactically significant newlines and indentation, like Python. Unlike Python, however, YAML doesn't allow literal tab characters for indentation.
+
+É um superconjunto de JSON, com a adição de indentação e quebras de linhas sintaticamente significativas, como Python. Ao contrário de Python, entretanto, YAML não permite o caracter literal tab para identação.
 
 ```yaml
 # Commentários em YAML são como este.
-- 
cgit v1.2.3


From 1255d7166830068d6e1ed1e5b0532b858f3fdf14 Mon Sep 17 00:00:00 2001
From: Fer <nanda.fer@gmail.com>
Date: Wed, 31 Oct 2018 08:54:09 -0300
Subject: [xml/pt-bt] Better translation

---
 pt-br/xml-pt.html.markdown | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/xml-pt.html.markdown b/pt-br/xml-pt.html.markdown
index f347f8ef..6710b387 100644
--- a/pt-br/xml-pt.html.markdown
+++ b/pt-br/xml-pt.html.markdown
@@ -10,8 +10,7 @@ lang: pt-br
 
 XML é uma linguagem de marcação projetada para armazenar e transportar dados.
 
-Ao contrário de HTML, XML não especifica como exibir ou formatar os dados, 
-basta carregá-lo.
+Ao contrário de HTML, XML não especifica como exibir ou formatar os dados, apenas o transporta.
 
 * Sintaxe XML
 
-- 
cgit v1.2.3


From 34621899d314845bb116e922d8947db12056852d Mon Sep 17 00:00:00 2001
From: Fer <nanda.fer@gmail.com>
Date: Wed, 31 Oct 2018 09:01:02 -0300
Subject: [whip/pt-br] Better translation

---
 pt-br/whip-pt.html.markdown | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/whip-pt.html.markdown b/pt-br/whip-pt.html.markdown
index 989bae05..7bdeec25 100644
--- a/pt-br/whip-pt.html.markdown
+++ b/pt-br/whip-pt.html.markdown
@@ -15,13 +15,13 @@ Whip é um dialeto de Lisp feito para construir scripts e trabalhar com
 conceitos mais simples.
 Ele também copia muitas funções e sintaxe de Haskell (uma linguagem não correlata)
 
-Esse documento foi escrito pelo próprio  autor da linguagem. Então é isso.
+Esse documento foi escrito pelo próprio autor da linguagem. Então é isso.
 
 ```scheme
 ; Comentário são como em Lisp. Pontos-e-vírgulas...
 
 ; A maioria das declarações de primeiro nível estão dentro de "listas"
-; que nada mais são que coisas entre parêntesis separadas por espaços em branco
+; que nada mais são que coisas entre parênteses separadas por espaços em branco
 nao_é_uma_lista
 (uma lista)
 
@@ -64,7 +64,7 @@ false
 (not false) ; => true
 
 ; Mas a maioria das funções não-haskell tem atalhos
-; o não atalho é um '!'.
+; o atalho para "não" é um '!'.
 (! (! true)) ; => true
 
 ; Igualdade é `equal` ou `=`.
@@ -114,7 +114,7 @@ undefined ; usada para indicar que um valor não foi informado
 (1 2 3) ; => [1, 2, 3] (sintaxe JavaScript)
 
 ; Dicionários em Whip são o equivalente a 'object' em JavaScript ou
-; 'dict' em python ou 'hash' em Ruby: eles s]ão uma coleção desordenada
+; 'dict' em python ou 'hash' em Ruby: eles são uma coleção desordenada
 de pares chave-valor.
 {"key1" "value1" "key2" 2 3 3}
 
@@ -222,7 +222,7 @@ linguagens imperativas.
 (take 1 (1 2 3 4)) ; (1 2)
 ; Contrário de `take`
 (drop 1 (1 2 3 4)) ; (3 4)
-; Menos valor em uma lista
+; Menor valor em uma lista
 (min (1 2 3 4)) ; 1
 ; Maior valor em uma lista
 (max (1 2 3 4)) ; 4
-- 
cgit v1.2.3


From ac42b7b824bdfb0b85852a7a4f9f82f281e99d76 Mon Sep 17 00:00:00 2001
From: Thiago Ribeiro <thiagofribeiro@gmail.com>
Date: Wed, 31 Oct 2018 09:33:00 -0300
Subject: [csharp/pt-br] Missing translation

---
 pt-br/csharp-pt.html.markdown | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index be14a1c8..10e8a201 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -336,28 +336,28 @@ on a new line! ""Wow!"", the masses cried";
         }
 
         ///////////////////////////////////////
-        // CLASSES - see definitions at end of file
+        // CLASSES - Veja definições no fim do arquivo
         ///////////////////////////////////////
         public static void Classes()
         {
-            // See Declaration of objects at end of file
+            // Veja Declaração de objetos no fim do arquivo
 
-            // Use new to instantiate a class
+            // Use new para instanciar uma classe
             Bicycle trek = new Bicycle();
 
-            // Call object methods
-            trek.SpeedUp(3); // You should always use setter and getter methods
+            // Chame métodos do objeto
+            trek.SpeedUp(3); // Você deve sempre usar métodos setter e getter
             trek.Cadence = 100;
 
-            // ToString is a convention to display the value of this Object.
+            // ToString é uma convenção para exibir o valor desse Objeto.
             Console.WriteLine("trek info: " + trek.Info());
 
-            // Instantiate a new Penny Farthing
+            // Instancie um novo Penny Farthing
             PennyFarthing funbike = new PennyFarthing(1, 10);
             Console.WriteLine("funbike info: " + funbike.Info());
 
             Console.Read();
-        } // End main method
+        } // Fim do método principal
 
         // CONSOLE ENTRY A console application must have a main method as an entry point
         public static void Main(string[] args)
-- 
cgit v1.2.3


From a9c9379d4f359c79f3d44687ee19e65eaae4208c Mon Sep 17 00:00:00 2001
From: Thiago Ribeiro <thiagofribeiro@gmail.com>
Date: Wed, 31 Oct 2018 09:54:59 -0300
Subject: [paren/pt-br] Small typos

---
 pt-br/paren-pt.html.markdown | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/paren-pt.html.markdown b/pt-br/paren-pt.html.markdown
index 464a69d2..92414ba3 100644
--- a/pt-br/paren-pt.html.markdown
+++ b/pt-br/paren-pt.html.markdown
@@ -182,8 +182,8 @@ a ; => (3 2)
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Macros lhe permitem estender a sintaxe da linguagem.
-;; Os macros no Paren são fáceis.
-;; Na verdade, (defn) é um macro.
+;; As macros no Paren são fáceis.
+;; Na verdade, (defn) é uma macro.
 (defmacro setfn (nome ...) (set nome (fn ...)))
 (defmacro defn (nome ...) (def nome (fn ...)))
 
@@ -191,6 +191,6 @@ a ; => (3 2)
 (defmacro infix (a op ...) (op a ...))
 (infix 1 + 2 (infix 3 * 4)) ; => 15
 
-;; Macros não são higiênicos, você pode sobrescrever as variáveis já existentes!
-;; Eles são transformações de códigos.
+;; Macros não são higiênicas, você pode sobrescrever as variáveis já existentes!
+;; Elas são transformações de códigos.
 ```
-- 
cgit v1.2.3


From e2637963b93d6fd610de994273713ccbd94a6522 Mon Sep 17 00:00:00 2001
From: Fer <nanda.fer@gmail.com>
Date: Wed, 31 Oct 2018 10:38:22 -0300
Subject: [yaml/pt-br] Remove lines

---
 pt-br/yaml-pt.html.markdown | 2 --
 1 file changed, 2 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/yaml-pt.html.markdown b/pt-br/yaml-pt.html.markdown
index 569bde75..0b71877e 100644
--- a/pt-br/yaml-pt.html.markdown
+++ b/pt-br/yaml-pt.html.markdown
@@ -11,8 +11,6 @@ lang: pt-br
 YAML é uma linguagem de serialização de dados projetado para ser diretamente gravável e
 legível por seres humanos.
 
-It's a strict superset of JSON, with the addition of syntactically significant newlines and indentation, like Python. Unlike Python, however, YAML doesn't allow literal tab characters for indentation.
-
 É um superconjunto de JSON, com a adição de indentação e quebras de linhas sintaticamente significativas, como Python. Ao contrário de Python, entretanto, YAML não permite o caracter literal tab para identação.
 
 ```yaml
-- 
cgit v1.2.3


From ec8231e6c25a9db40705c5336105652bfb43b8c5 Mon Sep 17 00:00:00 2001
From: fnscoder <fnscoder@gmail.com>
Date: Wed, 31 Oct 2018 15:11:33 -0300
Subject: [python3/pr-br] Fixed typo

---
 pt-br/python3-pt.html.markdown | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/python3-pt.html.markdown b/pt-br/python3-pt.html.markdown
index 9b6bd1b6..ea0617f4 100644
--- a/pt-br/python3-pt.html.markdown
+++ b/pt-br/python3-pt.html.markdown
@@ -105,9 +105,9 @@ False or True   # => True
 1 < 2 < 3  # => True
 2 < 3 < 2  # => False
 
-# (operador 'is' e operador '==') is verifica se duas referenciam um
-# mesmo objeto, mas == verifica se as variáveis apontam para o
-# mesmo valor.
+# (operador 'is' e operador '==') is verifica se duas variáveis
+# referenciam um mesmo objeto, mas == verifica se as variáveis
+# apontam para o mesmo valor.
 a = [1, 2, 3, 4]  # Referência a uma nova lista, [1, 2, 3, 4]
 b = a             # b referencia o que está referenciado por a
 b is a            # => True, a e b referenciam o mesmo objeto
-- 
cgit v1.2.3


From e9622c01f4a22106546c58c6e3fc8d1f6ef42cb6 Mon Sep 17 00:00:00 2001
From: David Lima <dave@blogdodave.com.br>
Date: Tue, 30 Oct 2018 20:16:06 -0300
Subject: Translate Haxe documentation to pt-br

---
 pt-br/haxe-pt.html.markdown | 795 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 795 insertions(+)
 create mode 100644 pt-br/haxe-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/haxe-pt.html.markdown b/pt-br/haxe-pt.html.markdown
new file mode 100644
index 00000000..13264dec
--- /dev/null
+++ b/pt-br/haxe-pt.html.markdown
@@ -0,0 +1,795 @@
+---
+language: haxe
+filename: LearnHaxe3-br.hx
+contributors:
+    - ["Justin Donaldson", "https://github.com/jdonaldson/"]
+    - ["Dan Korostelev", "https://github.com/nadako/"]
+translators:
+    - ["David Lima", "https://github.com/davelima/"]
+lang: pt-br
+---
+
+Haxe é uma linguagem baseada na web que provê suporte a C++, C#, SWF/ActionScript,
+Java e Neko byte code (também desenvolvida pelo autor de Haxe). Observe que
+este guia é para a versão 3 de Haxe. Alguns pontos do guia são aplicáveis
+para versões anteriores, mas é recomendado que você busque outras referências
+para essas versões.
+
+
+```csharp
+/*
+   Bem vindo ao Aprenda Haxe 3 em 15 minutos. http://www.haxe.org
+   Este é um tutorial executável. Você pode compilar e rodar este tutorial
+   usando o compilador haxe, estando no mesmo diretório de LearnHaxe.hx:
+   $> haxe -main LearnHaxe3 -x out
+
+   Olhe para os sinais de /* e */ em volta desses parágrafos. Nós estamos
+   dentro de um "Comentário multilinha". Nós podemos colocar observações aqui
+   e elas serão ignoradas pelo compilador.
+
+   Comentários multilinha também são utilizados para gerar documentação haxedoc,
+   seguindo o estilo javadoc. Eles serão usados pelo haxedoc se precerem imediatamente
+   uma classe, uma função de uma classe ou uma variável de uma classe.
+
+ */
+
+// Duas barras, como as dessa linha, farão um comentário de linha única.
+
+
+/*
+   Este será o primeiro código haxe de verdade, e está declarando um pacote vazio.
+   Não é necessário usar um pacote, mas ele será útil se você quiser criar
+   um namespace para o seu código (exemplo: org.seuapp.SuaClasse).
+   
+   Omitir a declaração de pacote é a mesma coisa que declarar um pacote vazio.
+ */
+package; // pacote vazio, sem namespace.
+
+/*
+   Pacotes são diretórios que contém módulos. Cada módulo é um arquivo .hx que
+   contém tipos definidos em um pacote. Nomes de pacotes (ex. org.seuapp)
+   devem estar em letras minúsculas, enquanto nomes de módulos devem começar
+   com uma letra maiúscula. Um módulo contem um ou mais tipos, cujo os nomes
+   também devem começar com uma letra maiúscula.
+
+   Exemplo: a classe "org.seuapp.Foo" deve ter a estrutura de diretório org/module/Foo.hx,
+   sendo acessível do diretório do compilador ou caminho da classe.   
+
+   Se você importar código de outros arquivos, isso deve ser declarado antes
+   do restante do código. Haxe disponibiliza várias classes padrões para você
+   começar:
+ */
+import haxe.ds.ArraySort;
+
+// você pode importar várias classes/módulos de uma vez usando "*"
+import haxe.ds.*;
+
+// você pode importar campos estáticos
+import Lambda.array;
+
+// você também pode usar "*" para importar todos os campos estáticos
+import Math.*;
+
+/*
+   Você também pode importar classes de uma forma diferente, habilitando-as para
+   extender a funcionalidade de outras classes, como um "mixin". Falaremos sobre
+   "using" em breve.
+ */
+using StringTools;
+
+/*
+   Typedefs são como variáveis... para tipos. Eles devem ser declarados antes
+   de qualquer código. Veremos isso em breve.
+ */
+typedef FooString = String;
+
+// Typedefs também podem referenciar tipos "estruturais". Também veremos isso em breve.
+typedef FooObject = { foo: String };
+
+/*
+   Esta é a definição da classe. É a classe principal do arquivo, visto que
+   possui o mesmo nome (LearnHaxe3)
+ */
+class LearnHaxe3{
+    /*
+       Se você quiser que um determinado código rode automaticamente, você
+       precisa colocá-lo em uma função estática "main", e especificar a classe
+       nos argumentos do compilador.
+       Nesse caso, nós especificamos a classe "LearnHaxe3" no nos argumentos
+       do compilador acima.
+     */
+    static function main(){
+
+        /*
+           Trace é o método padrão para imprimir expressões haxe na tela.
+           Temos diferentes métodos para conseguir isso em diferentes destinos.
+           Por exemplo: Java, C++, C#, etc. irão imprimir para stdout.
+           Javascript irá imprimir no console.log, e Flash irá imprimir para um
+           TextField anexado. Todos os "traces" imprimem também uma linha em branco
+           por padrão. Por fim, é possível prevenir um trace de ser exibido usando
+           o argumento "--no-traces" no compilador.
+         */
+        trace("Olá mundo, com trace()!");
+
+        /*
+           Trace pode tratar qualquer tipo de valor ou objeto. O método tentará
+           imprimir a representação de uma expressão da melhor forma. Você também
+           pode concatenar strings usando o operador "+":
+         */
+        trace( " Integer: " + 10 + " Float: " + 3.14 + " Boolean: " + true);
+
+        /*
+           Em Haxe, é obrigatório separar expressões no mesmo bloco com ';'. Mas
+           é possível colocar duas expressões na mesma linha, dessa forma:
+         */
+        trace('duas expressões..'); trace('uma linha');
+
+
+        //////////////////////////////////////////////////////////////////
+        // Tipos & Variáveis
+        //////////////////////////////////////////////////////////////////
+        trace("***Tipos & Variáveis***");
+
+        /*
+           Vcoê pode atrelar valores e referências à estruturas usando a
+           palavra-chave "var":
+         */
+        var um_inteiro:Int = 1;
+        trace(um_inteiro + " é o valor de um_inteiro");
+
+
+        /*
+           Haxe é tipada estaticamente, então "um_inteiro" temos que declarar
+           um valor do tipo "Int", e o restante da expressão atrela o valor "1"
+           a esta variável. Em muitos casos, não é necessário declarar o tipo.
+           Aqui, o compilador haxe assume que o tipo de "outro_inteiro" deve
+           ser "Int"
+         */
+        var outro_inteiro = 2;
+        trace(outro_inteiro + " é o valor de outro_inteiro");
+
+        // O método $type() imprime o tipo que o compilador assume:
+        $type(outro_inteiro);
+
+        // Você também pode representar inteiros em hexadecimal:
+        var hex_inteiro = 0xffffff;
+
+        /*
+           Haxe usa precisão de pltaforma para os tamanhos de Int e Float.
+           Ele também usa o comportamento de plataforma para sobrecarga.
+           (É possível ter outros tipos numéricos e comportamentos usando
+           bibliotecas especiais)
+         */
+
+        /*
+           Em adição a valores simples como Integers, Floats e Booleans,
+           Haxe disponibiliza implementações padrões de bibliotecas para
+           dados comuns de estrutura como strings, arrays, lists e maps:
+         */
+
+        var uma_string = "alguma" + 'string';  // strings podem estar entre aspas simples ou duplas
+        trace(uma_string + " é o valor de uma_string");
+
+        /*
+           Strings podem ser "interpoladas" se inserirmos variáveis em
+           posições específicas. A string deve estar entre aspas simples, e as
+           variáveis devem ser precedidas por "$". Expressões podem estar entre
+           ${...}.
+         */
+        var x = 1;
+        var uma_string_interpolada = 'o valor de x é $x';
+        var outra_string_interpolada = 'o valor de x + 1 é ${x + 1}';
+
+        /*
+           Strings são imutáveis, métodos retornarão uma cópia de partes
+           ou de toda a string. (Veja também a classe StringBuf)
+         */
+        var uma_sub_string = a_string.substr(0,4);
+        trace(uma_sub_string + " é o valor de a_sub_string");
+
+        /*
+           Regex também são suportadas, mas não temos espaço suficiente para
+           entrar em muitos detalhes.
+         */
+        var re = ~/foobar/;
+        trace(re.match('foo') + " é o valor de (~/foobar/.match('foo')))");
+
+        /*
+           Arrays são indexadas a partir de zero, dinâmicas e mutáveis. Valores
+           faltando são definidos como null.
+         */
+        var a = new Array<String>(); // um array que contém Strings
+        a[0] = 'foo';
+        trace(a.length + " é o valor de a.length");
+        a[9] = 'bar';
+        trace(a.length + " é o valor de a.length (depois da modificação)");
+        trace(a[3] + " é o valor de a[3]"); // null
+
+        /*
+           Arrays são *genéricas*, então você pode indicar quais valores elas
+           contém usando um parâmetro de tipo:
+         */
+        var a2 = new Array<Int>(); // um Array de Ints
+        var a3 = new Array<Array<String>>(); // um Array de Arrays (de Strings).
+
+        /*
+           Mapas são estruturas simples de chave/valor. A chave e o valor podem
+           ser de qualquer tipo.
+         */
+        var m = new Map<String, Int>();  // As chaves são strings, os valores são Ints.
+        m.set('foo', 4);
+        // Você também pode usar a notação de array;
+        m['bar'] = 5;
+        trace(m.exists('bar') + " é o valor de m.exists('bar')");
+        trace(m.get('bar') + " é o valor de m.get('bar')");
+        trace(m['bar'] + " é o valor de m['bar']");
+
+        var m2 =  ['foo' => 4, 'baz' => 6]; // Syntaxe alternativa de map
+        trace(m2 + " é o valor de m2");
+
+        /*
+           Lembre-se, você pode usar descoberta de tipo. O compilador
+           Haxe irá decidir o tipo da variável assim que você passar um
+           argumento que define um parâmetro de tipo.
+         */
+        var m3 = new Map();
+        m3.set(6, 'baz'); // m3 agora é Map<Int,String>
+        trace(m3 + " é o valor de m3");
+
+        /*
+           Haxe possui mais algumas estruturas de dados padrões no módulo haxe.ds,
+           tais como List, Stack e BalancedTree
+         */
+
+
+        //////////////////////////////////////////////////////////////////
+        // Operadores
+        //////////////////////////////////////////////////////////////////
+        trace("***OPERADORES***");
+
+        // aritmética básica
+        trace((4 + 3) + " é o valor de (4 + 3)");
+        trace((5 - 1) + " é o valor de (5 - 1)");
+        trace((2 * 4) + " é o valor de (2 * 4)");
+        trace((8 / 3) + " é o valor de (8 / 3) (divisão sempre produz Floats)");
+        trace((12 % 4) + " é o valor de (12 % 4)");
+
+
+        // comparação básica
+        trace((3 == 2) + " é o valor de 3 == 2");
+        trace((3 != 2) + " é o valor de 3 != 2");
+        trace((3 >  2) + " é o valor de 3 > 2");
+        trace((3 <  2) + " é o valor de 3 < 2");
+        trace((3 >= 2) + " é o valor de 3 >= 2");
+        trace((3 <= 2) + " é o valor de 3 <= 2");
+
+        // operadores bit-a-bit padrões
+        /*
+        ~       Complemento bit-a-bit unário
+        <<      Deslocamento a esquerda
+        >>      Deslocamento a direita
+        >>>     Deslocamento a direita com preenchimento de 0
+        &       Bit-a-bit AND
+        ^       Bit-a-bit OR exclusivo
+        |       Bit-a-bit OR inclusivo
+        */
+
+        // incrementos
+        var i = 0;
+        trace("Incrementos e decrementos");
+        trace(i++); //i = 1. Pós-incremento
+        trace(++i); //i = 2. Pré-incremento
+        trace(i--); //i = 1. Pós-decremento
+        trace(--i); //i = 0. Pré-decremento
+
+        //////////////////////////////////////////////////////////////////
+        // Estruturas de controle
+        //////////////////////////////////////////////////////////////////
+        trace("***ESTRUTURAS DE CONTROLE***");
+
+        // operadores if
+        var j = 10;
+        if (j == 10){
+            trace("isto é impresso");
+        } else if (j > 10){
+            trace("não é maior que 10, então não é impresso");
+        } else {
+            trace("também não é impresso.");
+        }
+
+        // temos também um if "ternário":
+        (j == 10) ?  trace("igual a 10") : trace("diferente de 10");
+
+        /*
+           Por fim, temos uma outra forma de estrutura de controle que opera
+           e na hora da compilação: compilação condicional.
+         */
+#if neko
+        trace('olá de neko');
+#elseif js
+        trace('olá de js');
+#else
+        trace('olá de outra plataforma!');
+#end
+        /*
+           O código compilado irá mudar de acordo com o alvo de plataforma.
+           Se estivermos compilando para neko (-x ou -neko), só teremos a
+           saudação de neko.
+         */
+
+
+        trace("Loops e Interações");
+
+        // loop while
+        var k = 0;
+        while(k < 100){
+            // trace(counter); // irá iprimir números de 0 a 99
+            k++;
+        }
+
+        // loop do-while
+        var  l = 0;
+        do{
+            trace("do sempre rodará pelo menos uma vez");
+        } while (l > 0);
+
+        // loop for
+        /*
+           Não há loop for no estilo C para Haxe, pois é propenso
+           a erros e não é necessário. Ao invés disso, Haxe possui
+           uma versão muito mais simples e segura que usa Iterators
+           (veremos isso logo mais).
+         */
+        var m = [1,2,3];
+        for (val in m){
+            trace(val + " é o valor de val no array m");
+        }
+
+        // Perceba que você pode iterar em um índice usando uma lista limitada
+        // (veremos isso em breve também)
+        var n = ['foo', 'bar', 'baz'];
+        for (val in 0...n.length){
+            trace(val + " é o valor de val (um índice de n)");
+        }
+
+
+        trace("Compreensões de array");
+
+        // Compreensões de array servem para que você posse iterar um array
+        // enquanto cria filtros e modificações
+        var n_filtrado = [for (val in n) if (val != "foo") val];
+        trace(n_filtrado + " é o valor de n_filtrado");
+
+        var n_modificado = [for (val in n) val += '!'];
+        trace(n_modificado + " é o valor de n_modificado");
+
+        var n_filtrado_e_modificado = [for (val in n) if (val != "foo") val += "!"];
+        trace(n_filtrado_e_modificado + " é o valor de n_filtrado_e_modificado");
+
+        //////////////////////////////////////////////////////////////////
+        // Blocos Switch (Tipos de valor)
+        //////////////////////////////////////////////////////////////////
+        trace("***BLOCOS SWITCH (Tipos de valor)***");
+
+        /*
+           Blocos Switch no Haxe são muito poderosos. Além de funcionar com
+           valores básicos como strings e ints, também funcionam com tipos
+           algébricos em enums (falaremos sobre enums depois).
+           Veja alguns exemplos de valor básico por enquanto:
+         */
+        var meu_cachorro = "fido";
+        var coisa_favorita  = "";
+        switch(meu_cachorro){
+            case "fido" : favorite_thing = "osso";
+            case "rex"  : favorite_thing = "sapato";
+            case "spot" : favorite_thing = "bola de tênis";
+            default     : favorite_thing = "algum brinquedo desconhecido";
+            // case _   : favorite_thing = "algum brinquedo desconhecido"; // mesma coisa que default
+        }
+        // O case "_" acima é um valor "coringa" que
+        // que funcionará para qualquer coisa.
+
+        trace("O nome do meu cachorro é " + meu_cachorro
+                + ", e sua coisa favorita é: "
+                + coisa_favorita);
+
+        //////////////////////////////////////////////////////////////////
+        // Declarações de expressão
+        //////////////////////////////////////////////////////////////////
+        trace("***DECLARAÇÕES DE EXPRESSÃO***");
+
+        /*
+           As declarações de controle em Haxe são muito poderosas pois
+           toda declaração também é uma expressão, considere o seguinte:
+        */
+
+        // declarações if
+        var k = if (true) 10 else 20;
+
+        trace("k igual a ", k); // retorna 10
+
+        var outra_coisa_favorita = switch(meu_cachorro) {
+            case "fido" : "ursinho";
+            case "rex"  : "graveto";
+            case "spot" : "bola de futebol";
+            default     : "algum brinquedo desconhecido";
+        }
+
+        trace("O nome do meu cachorro é " + meu cachorro
+                + ", e sua outra coisa favorita é: "
+                + outra_coisa_favorita);
+
+        //////////////////////////////////////////////////////////////////
+        // Convertendo tipos de valores
+        //////////////////////////////////////////////////////////////////
+        trace("***CONVERTENDO TIPOS DE VALORES***");
+
+        // Você pode converter strings em ints de forma bem fácil.
+
+        // string para int
+        Std.parseInt("0"); // retorna 0
+        Std.parseFloat("0.4"); // retorna 0.4;
+
+        // int para string
+        Std.string(0); // retorna "0";
+        // concatenar com strings irá converter automaticamente em string.
+        0 + "";  // retorna "0";
+        true + ""; // retorna "true";
+        // Veja a documentação de parseamento em Std para mais detalhes.
+
+
+        //////////////////////////////////////////////////////////////////
+        // Lidando com Tipos
+        //////////////////////////////////////////////////////////////////
+
+        /*
+           Como mencionamos anteriormente, Haxe é uma linguagem tipada
+           estaticamente. Tipagem estática é uma coisa maravilhosa. Isto
+           permite autocompletar mais preciso, e pode ser usado para checar
+           completamente o funcionamento de um programa. Além disso, o compilador
+           Haxe é super rápido.
+
+           *ENTRETANTO*, há momentos em que você espera que o compilador apenas
+           deixe algo passar, e não lance um "type error" em um determinado caso.
+
+           Para fazer isso, Haxe tem duas palavras-chave separadas. A primeira
+           é o tipo "Dynamic":
+         */
+        var din: Dynamic = "qualquer tipo de variável, assim como essa string";
+
+        /*
+           Tudo o que você sabe sobre uma variável Dynamic é que o compilador
+           não irá mais se preocupar com o tipo dela. É como uma variável
+           "coringa": você pode usar isso ao invés de qualquer tipo de variável,
+           e você pode atrelar qualquer valor a essa variável.
+
+           A outra (e mais extrema) opção é a palavra-chave "untyped":
+         */
+
+            untyped {
+                var x:Int = 'foo'; // não faz sentido!
+                var y:String = 4; // loucura!
+            }
+
+        /*
+           A palavra-chave "untyped" opera em *blocos* inteiros de código,
+           ignorando qualquer verificação de tipo que seria obrigatória em
+           outros casos. Essa palavra-chave deve ser usada com muita cautela,
+           como em situações limitadas de compilação condicional onde a
+           verificação de tipo pode ser um obstáculo.
+
+           No geral, ignorar verificações de tipo *não* é recomendado. Use
+           os modelos de enum, herança ou estrutural para garantir o correto
+           funcionamento do seu programa. Só quando você tiver certeza de que
+           nenhum desses modelos funcionam no seu caso, você deve usar "Dynamic"
+           ou "untyped".
+         */
+
+        //////////////////////////////////////////////////////////////////
+        // Programação básica orientada a objetos
+        //////////////////////////////////////////////////////////////////
+        trace("***PROGRAMAÇÃO BÁSICA ORIENTADA A OBJETOS***");
+
+
+        /*
+           Cria uma instância da FooClass. As definicções dessas classes
+           estão no final do arquivo.
+         */
+        var instancia_foo = new FooClass(3);
+
+        // lê a variável pública normalmente
+        trace(instancia_foo.variavel_publica + " é o valor de instancia_foo.variavel_publica");
+
+        // nós podemos ler essa variável
+        trace(instancia_foo.publica_leitura + " é o valor de instancia_foo.publica_leitura");
+        // mas não podemos escrever nela
+        // instancia_foo.publica_leitura = 4; // isso irá causar um erro se descomentado:
+        // trace(instancia_foo.public_escrita); // e isso também.
+
+        // chama o método toString:
+        trace(instancia_foo + " é o valor de instancia_foo");
+        // mesma coisa:
+        trace(instancia_foo.toString() + " é o valor de instancia_foo.toString()");
+
+
+        /*
+           A instancia_foo é do tipo "FooClass", enquanto acceptBarInstance
+           é do tipo BarClass. Entretanto, como FooClass extende BarClass,
+           ela é aceita.
+         */
+        BarClass.acceptBarInstance(instancia_foo);
+
+        /*
+           As classes abaixo têm mais alguns exemplos avançados, o método
+           "example()" executará esses exemplos aqui:
+         */
+        SimpleEnumTest.example();
+        ComplexEnumTest.example();
+        TypedefsAndStructuralTypes.example();
+        UsingExample.example();
+
+    }
+
+}
+
+/*
+   Essa é a "classe filha" do classe principal LearnHaxe3
+ */
+class FooClass extends BarClass implements BarInterface{
+    public var variavel_publica:Int; // variáveis públicas são acessíveis de qualquer lugar
+    public var publica_leitura (default, null): Int; // somente leitura pública habilitada
+    public var publica_escrita (null, default): Int; // somente escrita pública habilitada
+    public var property (get, set): Int; // use este estilo para habilitar getters e setters
+
+    // variáveis privadas não estão disponíveis fora da classe.
+    // veja @:allow para formas de fazer isso.
+    var _private:Int; // variáveis são privadas se não forem marcadas como públicas
+
+    // um construtor público
+    public function new(arg:Int){
+        // chama o construtor do objeto pai, já que nós extendemos a BarClass:
+        super();
+
+        this.variavel_publica = 0;
+        this._private = arg;
+
+    }
+
+    // getter para _private
+    function get_property() : Int {
+        return _private;
+    }
+
+    // setter para _private
+    function set_property(val:Int) : Int {
+        _private = val;
+        return val;
+    }
+
+    // função especial que é chamada sempre que uma instância é convertida em string.
+    public function toString(){
+        return _private + " com o método toString()!";
+    }
+
+    // essa classe precisa ter essa função definida, pois ela implementa
+    // a interface BarInterface
+    public function baseFunction(x: Int) : String{
+        // converte o int em string automaticamente
+        return x + " foi passado pela baseFunction!";
+    }
+}
+
+/*
+    Uma classe simples para extendermos
+*/
+class BarClass {
+    var base_variable:Int;
+    public function new(){
+        base_variable = 4;
+    }
+    public static function acceptBarInstance(b:BarClass){
+    }
+}
+
+/*
+    Uma interface simples para implementarmos
+*/
+interface BarInterface{
+    public function baseFunction(x:Int):String;
+}
+
+//////////////////////////////////////////////////////////////////
+// Declarações Enum e Switch
+//////////////////////////////////////////////////////////////////
+
+/*
+   Enums no Haxe são muito poderosos. Resumidamente, enums são
+   um tipo com um número limitado de estados:
+ */
+
+enum SimpleEnum {
+    Foo;
+    Bar;
+    Baz;
+}
+
+//   Uma classe que faz uso desse enum:
+
+class SimpleEnumTest{
+    public static function example(){
+        var e_explicit:SimpleEnum = SimpleEnum.Foo; // você pode especificar o nome "completo"
+        var e = Foo; // bas descoberta de tipo também funciona.
+        switch(e){
+            case Foo: trace("e era Foo");
+            case Bar: trace("e era Bar");
+            case Baz: trace("e era Baz"); // comente esta linha e teremos um erro.
+        }
+
+        /*
+           Isso não parece tão diferente de uma alteração simples de valor em strings.
+           Entretanto, se nós não incluirmos *todos* os estados, o compilador
+           reclamará. Você pode testar isso comentando a linha mencionada acima.
+           
+           Você também pode especificar um valor padrão (default) para enums:
+         */
+        switch(e){
+            case Foo: trace("e é Foo outra vez");
+            default : trace("default funciona aqui também");
+        }
+    }
+}
+
+/*
+    Enums vão muito mais além que estados simples, nós também
+    podemos enumerar *construtores*, mas nós precisaremos de um
+    exemplo mais complexo de enum:
+ */
+enum ComplexEnum{
+    IntEnum(i:Int);
+    MultiEnum(i:Int, j:String, k:Float);
+    SimpleEnumEnum(s:SimpleEnum);
+    ComplexEnumEnum(c:ComplexEnum);
+}
+// Observação: O enum acima pode incluir *outros* enums também, incluindo ele mesmo!
+// Observação: Isto é o que chamamos de *Tipos de dado algébricos* em algumas outras linguagens.
+
+class ComplexEnumTest{
+    public static function example(){
+        var e1:ComplexEnum = IntEnum(4); // especificando o parâmetro enum
+        /*
+           Agora nós podemos usar switch no enum, assim como extrair qualquer
+           parâmetros que ele possa ter.
+         */
+        switch(e1){
+            case IntEnum(x) : trace('$x foi o parâmetro passado para e1');
+            default: trace("Isso não deve ser impresso");
+        }
+
+        // outro parâmetro aqui que também é um enum... um enum enum?
+        var e2 = SimpleEnumEnum(Foo);
+        switch(e2){
+            case SimpleEnumEnum(s): trace('$s foi o parâmetro passado para e2');
+            default: trace("Isso não deve ser impresso");
+        }
+
+        // enum dentro de enum dentro de enum
+        var e3 = ComplexEnumEnum(ComplexEnumEnum(MultiEnum(4, 'hi', 4.3)));
+        switch(e3){
+            // Você pode buscar por certos enums aninhados especificando-os
+            // explicitamente:
+            case ComplexEnumEnum(ComplexEnumEnum(MultiEnum(i,j,k))) : {
+                trace('$i, $j, e $k foram passados dentro desse monstro aninhado.');
+            }
+            default: trace("Isso não deve ser impresso");
+        }
+        /*
+           Veja outros "tipos de dado algébricos" (GADT, do inglês) para mais
+           detalhes sobre o porque eles são tão úteis.
+         */
+    }
+}
+
+class TypedefsAndStructuralTypes {
+    public static function example(){
+        /*
+           Aqui nós usaremos tipos typedef, ao invés de tipos base.
+           Lá no começo, nós definimos que o tipo "FooString" é um tipo "String". 
+         */
+        var t1:FooString = "alguma string";
+
+        /*
+           Aqui nós usamos typedefs para "tipos estruturais" também. Esses tipos
+           são definidos pela sua estrutura de campos, não por herança de classe.
+           Aqui temos um objeto anônimo com um campo String chamado "foo":
+         */
+
+        var anon_obj = { foo: 'hi' };
+
+        /*
+           A variável anon_obj não tem um tipo declarado, e é um objeto anônimo
+           de acordo com o compilador. Entretanto, lembra que lá no início nós
+           declaramos a typedef FooObj? Visto que o anon_obj tem a mesma estrutura,
+           nós podemos usar ele em qualquer lugar que um "FooObject" é esperado.
+         */
+
+        var f = function(fo:FooObject){
+            trace('$fo foi passado para esta função');
+        }
+        f(anon_obj); // chama a assinatura de FooObject com anon_obj.
+
+        /*
+           Note que typedefs podem ter campos opcionais também, marcados com "?"
+
+           typedef OptionalFooObj = {
+                ?optionalString: String,
+                requiredInt: Int
+           }
+         */
+
+        /*
+           Typedefs também funcionam com compilação condicional. Por exemplo,
+           nós poderíamos ter incluído isso no topo deste arquivo:
+
+#if( js )
+        typedef Surface = js.html.CanvasRenderingContext2D;
+#elseif( nme )
+        typedef Surface = nme.display.Graphics;
+#elseif( !flash9 )
+        typedef Surface = flash8.MovieClip;
+#elseif( java )
+        typedef Surface = java.awt.geom.GeneralPath;
+#end
+
+        E teríamos apenas um tipo "Surface" para funcionar em todas
+        essas plataformas.
+        */
+    }
+}
+
+class UsingExample {
+    public static function example() {
+
+        /*
+           A palavra-chave "using" é um tipo especial de import de classe que
+           altera o comportamento de qualquer método estático na classe.
+
+           Neste arquivo, nós aplicamos "using" em "StringTools", que contém
+           alguns métodos estáticos para tratar tipos String.
+         */
+        trace(StringTools.endsWith("foobar", "bar") + " deve ser verdadeiro!");
+
+        /*
+           Com um import "using", o primeiro argumento é extendido com o método.
+           O que isso significa? Bem, como "endsWith" tem um primeiro argumento
+           de tipo "String", isso significa que todos os tipos "String" agora
+           possuem o método "endsWith":
+         */
+        trace("foobar".endsWith("bar") + " deve ser verdadeiro!");
+
+        /*
+           Essa técnica habilita uma grande quantidade de expressões para certos
+           tipos, e limita o escopo de modificações para um único arquivo.
+
+           Note que a instância String *não* é modificada em tempo de execução.
+           O novo método adicionado não é uma parte da instância anexada, e o
+           compilador ainda irá gerar o código equivalente ao método estático.
+         */
+      }
+
+}
+
+```
+Isso foi apenas o começo do que Haxe pode fazer. Para uma documentação de todos
+os recursos de Haxe, veja o [manual](https://haxe.org/manual) e a
+[documentação de API](https://api.haxe.org/). Para um diretório de bibliotecas de terceiros
+disponíveis, veja a [Haxelib](https://lib.haxe.org/)
+
+Para tópicos mais avançados, dê uma olhada em:
+
+* [Tipos abstratos](https://haxe.org/manual/types-abstract.html)
+* [Macros](https://haxe.org/manual/macro.html)
+* [Recursos do compilador](https://haxe.org/manual/cr-features.html)
+
+Por fim, participe do [forum Haxe](https://community.haxe.org/),
+ou no IRC [#haxe onfreenode](http://webchat.freenode.net/), ou no
+[Chat Gitter](https://gitter.im/HaxeFoundation/haxe).
-- 
cgit v1.2.3


From 833714f75ec5b61291c086a98238f4e570ea8fa8 Mon Sep 17 00:00:00 2001
From: Divay Prakash <divayprakash@users.noreply.github.com>
Date: Fri, 2 Nov 2018 04:43:08 +0530
Subject: Update csharp-pt.html.markdown

Remove unnecessary newline
---
 pt-br/csharp-pt.html.markdown | 1 -
 1 file changed, 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index 2b61a8fa..53fb11e9 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -97,7 +97,6 @@ namespace Learning.CSharp
 
             // Decimal - um tipo de dados de 128 bits, com mais precisão do que outros tipos de ponto flutuante,
             // adequado para cálculos financeiros e monetários
-
             decimal fooDecimal = 150.3m;
 
             // Boolean - true & false
-- 
cgit v1.2.3


From f5b3d1c97c23a28200ca122e29578470c91b8df1 Mon Sep 17 00:00:00 2001
From: Divay Prakash <divayprakash@users.noreply.github.com>
Date: Sat, 17 Nov 2018 23:55:42 +0530
Subject: YAML fixes (#3400)

---
 pt-br/cmake-pt.html.markdown  | 2 +-
 pt-br/cypher-pt.html.markdown | 2 +-
 pt-br/factor-pt.html.markdown | 2 +-
 pt-br/html-pt.html.markdown   | 2 +-
 pt-br/less-pt.html.markdown   | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/cmake-pt.html.markdown b/pt-br/cmake-pt.html.markdown
index bc3e7050..8d4c3fda 100644
--- a/pt-br/cmake-pt.html.markdown
+++ b/pt-br/cmake-pt.html.markdown
@@ -2,7 +2,7 @@
 language: cmake
 contributors:
     - ["Bruno Alano", "https://github.com/brunoalano"]
-filename: CMake
+filename: CMake-br
 translators:
     - ["Lucas Pugliesi", "https://github.com/fplucas"]
 lang: pt-br
diff --git a/pt-br/cypher-pt.html.markdown b/pt-br/cypher-pt.html.markdown
index 7cfd8dcd..9b60f771 100644
--- a/pt-br/cypher-pt.html.markdown
+++ b/pt-br/cypher-pt.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: cypher
-filename: LearnCypher.cql
+filename: LearnCypher-br.cql
 contributors:
     - ["Théo Gauchoux", "https://github.com/TheoGauchoux"]
 
diff --git a/pt-br/factor-pt.html.markdown b/pt-br/factor-pt.html.markdown
index e3c8f4a9..b4b5c7f5 100644
--- a/pt-br/factor-pt.html.markdown
+++ b/pt-br/factor-pt.html.markdown
@@ -2,7 +2,7 @@
 language: factor
 contributors:
     - ["hyphz", "http://github.com/hyphz/"]
-filename: learnfactor.factor
+filename: learnfactor-br.factor
 
 lang: pt-br
 ---
diff --git a/pt-br/html-pt.html.markdown b/pt-br/html-pt.html.markdown
index 5a4bc3bc..22b7836e 100644
--- a/pt-br/html-pt.html.markdown
+++ b/pt-br/html-pt.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: html
-filename: learnhtml.txt
+filename: learnhtml-br.txt
 contributors:
     - ["Christophe THOMAS", "https://github.com/WinChris"]
 translators:
diff --git a/pt-br/less-pt.html.markdown b/pt-br/less-pt.html.markdown
index 679a2ed2..f6cf2d71 100644
--- a/pt-br/less-pt.html.markdown
+++ b/pt-br/less-pt.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: less
-filename: learnless.less
+filename: learnless-br.less
 contributors:
   - ["Saravanan Ganesh", "http://srrvnn.me"]
 
-- 
cgit v1.2.3


From 5b5fbc4e48e3ed471d7f7ec7a491a16fe5b491f6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Salom=C3=A3o=20Neto?= <salomaosnff3@gmail.com>
Date: Wed, 26 Dec 2018 16:10:45 -0300
Subject: Learn Stylus in pt-BR!

---
 pt-br/stylus-pt.html.markdown | 228 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 228 insertions(+)
 create mode 100755 pt-br/stylus-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/stylus-pt.html.markdown b/pt-br/stylus-pt.html.markdown
new file mode 100755
index 00000000..c42bec34
--- /dev/null
+++ b/pt-br/stylus-pt.html.markdown
@@ -0,0 +1,228 @@
+---
+language: stylus
+filename: learnStylus-pt.styl
+contributors:
+  - ["Salomão Neto", "https://github.com/salomaosnff"]
+  - ["Isaac Henrique", "https://github.com/Isaachi1"]
+lang: pt-br
+---
+
+Stylus tem como propósito, adicionar funcionalidades às suas folhas de estilos CSS que te ajudam no desenvolvimento, sem que haja a quebra de compartibilidade entre os navegadores Web.
+Entre elas estão variáveis, aninhamento, mixins, funções e muito mais.
+
+A sintaxe do Stylus é muito flexivel podendo utilizar a sintaxe padrão do CSS e deixando opcional o ponto e vírgula (;), dois pontos (:) e até mesmo as chaves ({ e }), tornando assim o seu código ainda mais legível.
+
+Stylus não fornece novas opções de estilos, mas dá funcionalidades que permitem deixar seu CSS muito mais dinâmico.
+
+
+```stylus
+
+/* Estilo de código
+==============================*/
+
+/* As chaves, ponto e vírgula, e dois pontos são opcionais no Stylus. */
+
+body {
+  background: #000;
+}
+
+body {
+  background: #000
+}
+
+body {
+  background #000
+}
+
+body
+  background #000
+
+body
+  background: #000;
+
+body
+  background: #000
+
+
+// Comentários de linha única são removidos quando Stylus é compilado para CSS.
+
+/* Comentários multi-line são preservados. */
+
+
+/* Seletores
+==============================*/
+
+/* Selecionando elementos dentro de outro elemento */
+body {
+  background: #000000;
+  h1 {
+    color: #FF0000;
+  }
+}
+
+/* Ou se preferir... */
+body
+  background #000000
+  h1
+    color #FF0000
+
+
+/* Obtendo a referência do elemento pai
+==============================*/
+a {
+  color: #0088dd;
+  &:hover {
+    color: #DD8800;
+  }
+}
+
+
+/*Variáveis
+==============================*/
+
+
+/* 
+  É possível armazenar um valor CSS (tais como a cor) de uma variável.
+  Embora seja opcional, é recomendado adicionar $ antes de um nome de variável 
+  para que você possa distinguir uma variável de outro valor CSS.
+*/
+
+$primary-color = #A3A4FF
+$secondary-color = #51527F
+$body-font = 'Roboto', sans-serif
+
+/* Você pode usar as variáveis em toda a sua folha de estilo.
+Agora, se você quer mudar a cor, você só tem que fazer a mudança uma vez. */
+
+body
+	background-color $primary-color
+	color $secondary-color
+	font-family $body-font
+
+/* Quando compilar ficaria assim: */
+body {
+	background-color: #A3A4FF;
+	color: #51527F;
+	font-family: 'Roboto', sans-serif;
+}
+
+/ * 
+Este é muito mais fácil de manter do que ter de mudar a cor
+cada vez que aparece em toda a sua folha de estilo. 
+* /
+
+
+
+/*Mixins
+==============================*/
+
+/* Se você achar que você está escrevendo o mesmo código para mais de um
+elemento, você pode querer armazenar esse código em um mixin.
+
+center()
+  display block
+	margin-left auto
+	margin-right auto
+	left 0
+	right 0
+
+/* Utilizando um mixin */
+body {
+  center()
+  background-color: $primary-color
+}
+
+/* Apoś compilar ficaria assim: */
+div {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+	background-color: #A3A4FF;
+}
+
+/* Você pode usar mixins para criar uma propriedade estenográfica. */
+
+size($width, $height)
+  width $width
+  height $height
+
+.rectangle
+  size(100px, 60px)
+
+.square
+	size(40px, 40px)
+
+/* Você pode usar um mixin como uma propriedade CSS. */
+circle($ratio)
+  width $ratio * 2
+  height $ratio * 2
+  border-radius $ratio
+
+.ball
+  circle 25px
+
+
+/* Interpolação
+==============================*/
+
+vendor(prop, args)
+  -webkit-{prop} args
+  -moz-{prop} args
+  {prop} args
+
+border-radius()
+  vendor('border-radius', arguments)
+
+box-shadow()
+  vendor('box-shadow', arguments)
+
+button
+  border-radius 1px 2px / 3px 4px
+
+/* Funções
+==============================*/
+
+/* Funções no Stylus permitem fazer uma variedade de tarefas, como por exemplo, menipular algum dado. */
+
+body {
+  background darken(#0088DD, 50%) // Escurece a cor #0088DD em 50%
+}
+
+/** Criando sua própria função */
+somar(a, b)
+  a + b
+
+body
+  padding somar(10px, 5)
+
+/* Condições
+==============================*/
+comparar(a, b)
+  if a > b
+    maior
+  else if a < b
+    menor
+  else
+    igual
+
+comparar(5, 2)   // => maior
+comparar(1, 5)   // => menor
+comparar(10, 10) // => igual
+
+/* Iterações
+==============================*/
+
+/**
+Sintaxe de laço de repetição for:
+for <val-name> [, <key-name>] in <expression>
+**/
+
+for $item in (1..2) /* Repete o bloco 12 vezes */
+  .col-{$item}
+    width ($item / 12) * 100% /* Calcula a largula pelo número da coluna*
+
+```
+
+Agora que você conhece um pouco sobre esse poderoso pré-processador de CSS, você está pronto para criar folhas de estilos mais dinâmicas. Para aprofundar seus conhecimentos visite a documentação oficial do stylus em http://stylus-lang.com.
\ No newline at end of file
-- 
cgit v1.2.3


From a33a90899f4ee52d483929c1b2b2e85d8c567d07 Mon Sep 17 00:00:00 2001
From: Leonardo Santos <devleeo@outlook.com>
Date: Wed, 2 Jan 2019 08:22:46 -0200
Subject: [asymptotic-notation/pt-br] fix several typos

---
 pt-br/asymptotic-notation-pt.html.markdown | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/asymptotic-notation-pt.html.markdown b/pt-br/asymptotic-notation-pt.html.markdown
index 2f179f96..b70d26b7 100644
--- a/pt-br/asymptotic-notation-pt.html.markdown
+++ b/pt-br/asymptotic-notation-pt.html.markdown
@@ -13,7 +13,7 @@ lang: pt-br
 ## O que é?
 
 Notação Assintótica é uma linguagem que nos permite analisar o tempo de execução
- de um algoritmo através da indentificação de seu comportamento com o
+ de um algoritmo através da identificação de seu comportamento com o
  crescimento da entrada oferecida. Isso também é conhecido como taxa de
  crescimento do algoritmo. O algoritmo de repente torna-se lento quando o
  tamanho da entrada cresce? O algoritmo mantém, em geral, seu tempo de execução
@@ -33,12 +33,12 @@ Um modo seria contar o número de operações primitivas com diferentes tamanhos
 
 ## Tipos de Notação Assintótica
 
-Na primeira seção desse documento, descrevemos como Notação Assintótica identifica o comportamento de um algoritmo
+Na primeira seção deste documento, descrevemos como Notação Assintótica identifica o comportamento de um algoritmo
  a medida que o tamanho da entrada cresce. Imaginemos um algoritmo como uma função
  *f*, *n* como o tamanho da entrada e *f(n)* sendo o tempo de execução. Então,
  para dado algoritmo *f*, com entrada de tamanho *n*, você terá tempo de execução
- *f(n)*. Isto resulta em um gráfico onde a coordernada Y é o tempo de execução
-, a coordernada X representa o tamanho da entrada e os pontos representam o tempo
+ *f(n)*. Isto resulta em um gráfico onde a coordenada Y é o tempo de execução, 
+ a coordenada X representa o tamanho da entrada e os pontos representam o tempo
 de execução para dado tamanho de entrada.
 
 Você pode representar a função, ou o algoritmo, com Notação Assintótica de várias
@@ -49,7 +49,7 @@ não avalia o melhor caso, porque essas condições não são atingidas com freq
 Um bom exemplo disto seria em algoritmos de ordenação; especificamente, na adição
 de elementos à árvores. O melhor caso na maioria de algoritmos pode ser de apenas
 uma operação. Entretanto, na maioria dos casos, o elemento a ser adicionado terá
-que percorrer a árvore de forma apropriada, o que pode causar a analise de um
+que percorrer a árvore de forma apropriada, o que pode causar a análise de um
 ramo inteiro.
 Este é o pior caso, e isto é o que você está se preparando.
 
@@ -63,16 +63,16 @@ Função Polinomial - an^z + . . . + an^2 + a*n^1 + a*n^0, onde *z* é uma const
 Função Exponencial -  a^n, onde a é alguma constante
 ```
 Estas são as funções básicas de crescimento usadas em várias notações. A lista
- começa com a de crescimento mais lento (logarítima, a de execução mais rápida)
+ começa com a de crescimento mais lento (logarítmica, a de execução mais rápida)
 e segue para a de crescimento mais rápido (exponencial, de execução mais lenta).
-Repare que enquando *n*, a entrada, cresce, cada uma dessas funções cresce mais
-rápido que quadrático, polinimial e exponencial, comparadas com logaritma e linear.
+Repare que enquanto *n*, a entrada, cresce, cada uma dessas funções cresce mais
+rápido que quadrático, polinomial e exponencial, comparadas com logarítmica e linear.
 
 Uma nota extremamente importante para notações é tentar usar os termos mais simples.
 Isto significa descartar constantes e termos de ordem mais baixa, pois quando o
 tamanho da entrada cresce para o infinito (limites matemáticos), os termos de ordem
 mais baixa e constantes tornam-se irrelevantes. Por exemplo, se você tiver uma
-constante muito grande, 2^9001, a simplificação não afeterá sua notação.
+constante muito grande, 2^9001, a simplificação não afetará sua notação.
 
 Já que queremos as formas mais simples, mudemos nossa tabela um pouco...
 
@@ -87,7 +87,7 @@ Função Exponencial - a^n, onde *a* é uma constante
 ### Big-O
 
 Big-O, também escrita como O, é uma Notação Assintótica para o pior caso. Digamos
-*f(n)* seja o tempo de exeução de um algoritmo e *g(n)) um tempo de complexidade
+*f(n)* seja o tempo de execução de um algoritmo e *g(n)) um tempo de complexidade
 arbitrário que você quer relacionar com seu algoritmo. *f(n)* é O(g(n)), se, para
 quando constante real c (c > 0), *f(n)* <= *c g(n)* para todo tamanho de entrada
 n (n > 0).
@@ -116,7 +116,7 @@ Há alguma constante c que satisfaça a definição para todo n?
 3log n + 100 <= 150 * log n, n > 2 (Indefinido em n = 1)
 ```
 
-Sim! A definição de Big-I for atentida, portante `f(n)` é `O(g(n))`.
+Sim! A definição de Big-O foi atendida, portanto `f(n)` é `O(g(n))`.
 
 *Exemplo 2*
 
@@ -146,7 +146,7 @@ Big-Omega, também escrita como Ω, é uma Notação Assintótica para o melhor
 Sinta-se livre para adicionar mais exemplos. Big-O é a notação primária usada para medir complexidade de algoritmos.
 
 ### Notas Finais
-É difícil manter esse tipo de tópico curto e você deveria ler os livros e artigos listados abaixo. Eles cobrem muito mais profundamente definições e exemplos. Mais x='Algoritms & Data Structures' virá; teremos um documento sobre analisar código em breve.
+É difícil manter esse tipo de tópico curto e você deveria ler os livros e artigos listados abaixo. Eles cobrem muito mais profundamente definições e exemplos. Mais x='Algorithms & Data Structures' virá; teremos um documento sobre analisar código em breve.
 
 ## Livros
 
-- 
cgit v1.2.3


From 41ef626a18766ec6eec02faa3e252622ccaf4688 Mon Sep 17 00:00:00 2001
From: Adam Bard <github@adambard.com>
Date: Tue, 8 Jan 2019 16:13:15 -0800
Subject: Try scss highlighting

---
 pt-br/stylus-pt.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/stylus-pt.html.markdown b/pt-br/stylus-pt.html.markdown
index c42bec34..804fa806 100755
--- a/pt-br/stylus-pt.html.markdown
+++ b/pt-br/stylus-pt.html.markdown
@@ -15,7 +15,7 @@ A sintaxe do Stylus é muito flexivel podendo utilizar a sintaxe padrão do CSS
 Stylus não fornece novas opções de estilos, mas dá funcionalidades que permitem deixar seu CSS muito mais dinâmico.
 
 
-```stylus
+```scss
 
 /* Estilo de código
 ==============================*/
@@ -225,4 +225,4 @@ for $item in (1..2) /* Repete o bloco 12 vezes */
 
 ```
 
-Agora que você conhece um pouco sobre esse poderoso pré-processador de CSS, você está pronto para criar folhas de estilos mais dinâmicas. Para aprofundar seus conhecimentos visite a documentação oficial do stylus em http://stylus-lang.com.
\ No newline at end of file
+Agora que você conhece um pouco sobre esse poderoso pré-processador de CSS, você está pronto para criar folhas de estilos mais dinâmicas. Para aprofundar seus conhecimentos visite a documentação oficial do stylus em http://stylus-lang.com.
-- 
cgit v1.2.3


From 9b5b5f6d31b64be55e64c5f45084e45115f2f350 Mon Sep 17 00:00:00 2001
From: Anindya Srivastava <pro.anindya@gmail.com>
Date: Wed, 6 Feb 2019 07:26:25 +0530
Subject: Type correction for the output of math.sqrt() propagated across
 versions and languages

---
 pt-br/python-pt.html.markdown  | 2 +-
 pt-br/python3-pt.html.markdown | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/python-pt.html.markdown b/pt-br/python-pt.html.markdown
index 5afd46d0..82b70117 100644
--- a/pt-br/python-pt.html.markdown
+++ b/pt-br/python-pt.html.markdown
@@ -464,7 +464,7 @@ Humano.ronca() #=> "*arrrrrrr*"
 
 # Você pode importar módulos
 import math
-print math.sqrt(16) #=> 4
+print math.sqrt(16) #=> 4.0
 
 # Você pode importar funções específicas de um módulo
 from math import ceil, floor
diff --git a/pt-br/python3-pt.html.markdown b/pt-br/python3-pt.html.markdown
index ea0617f4..b72c732a 100644
--- a/pt-br/python3-pt.html.markdown
+++ b/pt-br/python3-pt.html.markdown
@@ -647,7 +647,7 @@ Human.grunt()    # => "*grunt*"
 
 # Você pode importar módulos
 import math
-print(math.sqrt(16))  # => 4
+print(math.sqrt(16))  # => 4.0
 
 # Você pode importar apenas funções específicas de um módulo
 from math import ceil, floor
-- 
cgit v1.2.3


From 722dc2d63fc63d9e4514280c8d44d7f87d65b7ff Mon Sep 17 00:00:00 2001
From: Raul Gomes Pimentel de Almeida <haltsimog@gmail.com>
Date: Mon, 11 Feb 2019 14:31:33 -0200
Subject: Translated the Pascal text to Brazilian Portuguese

(created pascal-pt.html.markdown)

TO DO/Observations:
-Change capitalization of native words
-Change some variable names (to more portuguese-appropriate
alternatives)
-Introduction is still in English
---
 pt-br/pascal-pt.html.markdown | 208 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 208 insertions(+)
 create mode 100644 pt-br/pascal-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/pascal-pt.html.markdown b/pt-br/pascal-pt.html.markdown
new file mode 100644
index 00000000..6e175216
--- /dev/null
+++ b/pt-br/pascal-pt.html.markdown
@@ -0,0 +1,208 @@
+---
+language: Pascal
+filename: learnpascal.pas
+contributors:
+    - ["Raul Almeida", "http://github.com/almeidaraul"]
+---
+
+
+>Pascal is an imperative and procedural programming language, which Niklaus Wirth designed in 1968–69 and published in 1970, as a small, efficient language intended to encourage good programming practices using structured programming and data structuring. It is named in honor of the French mathematician, philosopher and physicist Blaise Pascal. 
+source : [wikipedia](https://en.wikipedia.org/wiki/Pascal_(programming_language))
+
+
+
+Para compilar e executar um programa em Pascal, você pode usar o freepascal, um compilador gratuito. [Faça o download aqui](https://www.freepascal.org/)
+
+```pascal
+//Corpo de um programa em Pascal
+//isso é um comentário
+{
+    isso também é um comentário,
+    mas com várias linhas
+}
+
+//cabeçalho do programa
+program learn_pascal; //<-- não esqueça o ponto e vírgula. O nome do programa deve começar com uma letra.
+
+const
+    {
+        aqui você declara valores constantes
+    }
+type
+    {
+        aqui você declara tipos não nativos
+    }
+var
+    {
+        aqui você declara variáveis
+    }
+
+//programa de fato
+begin
+    {
+        aqui ficam todas as instruções que não pertencem nem a funções nem a procedimentos
+    }
+end. //o "end" no final do programa requer um ponto final.
+```
+
+```pascal
+//formas de declarar uma variável
+var a:integer;
+var b:integer;
+
+var 
+    a : integer;
+    b : integer;
+
+var a,b : integer;
+```
+
+```pascal
+program Learn_More;
+//agora, mais sobre tipos de dados e operações
+
+const
+    PI = 3.141592654;
+    GNU = 'GNU''s Not Unix';
+        // a convenção é usar caixa alta para constantes
+        // constantes têm valores fixos que só podem ser alterados antes da compilação
+        // constantes podem ser de qualquer tipo nativo (integer, real, boolean, char, string)
+
+type
+    ch_array : array [0..255] of char;
+        // isso declara um novo tipo de variável, ch_array, que tem 256 caracteres
+    md_array : array of array of integer;
+        // vetores de vetores são vetores multidimensionais
+        // pode-se definir vetores de tamanho 0 (daí, usa-se alocação dinâmica)
+        // vetores do tipo md_array são de duas dimensões
+
+//declarando variáveis
+var
+    int, c, d  : integer;
+           // três variáveis que guardam valores inteiros
+           // inteiros têm 16 bits (vão de -32768 a 32767)
+    r    : real;
+           // uma variável que guarda um valor real
+           // reais vão de 3.4E-38 a 3.4E38
+    bool : boolean;
+           // uma variável que guarda um valor booleano (verdadeiro ou falso)
+    ch   : char;
+           // uma variável que guarda um caractere
+           // caracteres têm 8 bits 
+    str  : string;
+           // esse tipo de variável não é padrão, mas é incluído na maioria dos compiladores
+           // string é um vetor de caracteres com tamanho padrão de 255 elementos
+    s    : string[50];
+           // você pode especificar o tamanho de uma string desta maneira para otimizar o uso de memória
+    my_str: ch_array;
+           // aqui, uma variável de um tipo personalizado declarado acima
+    my_2d : md_array;
+           // vetores de alocação dinâmica de memória precisam receber um tamanho antes de serem usados
+
+    // tipos adicionais de inteiros
+    b    : byte;     // faixa [0..255]
+    shi  : shortint; // faixa [-128..127]
+    smi  : smallint; // faixa [-32,768..32,767] (inteiro padrão)
+    w    : word;     // faixa [0..65,535]
+    li   : longint;  // faixa [-2,147,483,648..2,147,483,647]
+    lw   : longword; // faixa [0..4,294,967,295]
+    c    : cardinal; // longword
+    i64  : int64;    // faixa [-9223372036854775808..9223372036854775807]
+    qw   : qword;    // faixa [0..18,446,744,073,709,551,615]
+
+    // tipos adicionais de reais
+    rr   : real;     // faixa depende da plataforma (8 bits, 16 bits, etc)
+    rs   : single;   // faixa [1.5E-45..3.4E38]
+    rd   : double;   // faixa [5.0E-324 .. 1.7E308]
+    re   : extended; // faixa [1.9E-4932..1.1E4932]
+    rc   : comp;     // faixa [-2E64+1 .. 2E63-1]
+
+Begin
+    int := 1;// usa-se := para atribuir valores a variáveis
+    r   := 3.14; 
+    ch  := 'a';
+    str := 'apple';
+    bool := true;
+    //pascal não é case-sensitive (não diferencia maiúsculas de minúsculas)
+	//uma opção de organização é usar maiúsculas para termos da linguagem (BEGIN, END, INTEGER, etc) e constantes
+    //aritmética
+    int := 1 + 1; // int deixa de ser 1 e passa a ser 2
+    int := int + 1; // int = 2 + 1 = 3;
+    int := 4 div 2; //int = 2 (DIV é uma divisão inteira, ou seja, o resto é "jogado fora")
+    int := 3 div 2; //int = 1
+    int := 1 div 2; //int = 0
+
+    bool := true or false; // bool = true
+    bool := false and true; // bool = false
+    bool := true xor true; // bool = false
+
+    r := 3 / 2; // usa-se a "/" para divisões entre inteiros
+    r := int; // um real pode receber um valor inteiro (mas não o contrário)
+
+    c := str[1]; //acessando elementos de um vetor: vetor[índice do elemento]
+    str := 'hello' + 'world'; //concatenção de strings
+
+    my_str[0] := 'a'; // só se pode atribuir valores a vetores elemento por elemento (não o vetor inteiro de uma vez)
+
+    setlength(my_2d,10,10); // inicialização de um vetor com alocação dinâmica de memória; my_2d vira um 10x10 
+    for c := 0 to 9 do // vetores começam em 0 e terminam em tamanho-1 (exceto se, na declaração do tipo, forem especificados valores diferentes)
+        for d := 0 to 9 do // a variável usada em um laço FOR deve ter sido declarada no cabeçalho do programa
+        my_2d[c,d] := c * d; // acessam-se elementos de vetores multidimensionais com [dimensão1, dimensão2, dimensão3...]
+
+End.
+```
+
+```pascal
+program Functional_Programming;
+
+Var
+    i, dummy : integer;
+
+{ OBS: diferença entre procedimento e função
+	função: realiza operações e retorna valor
+	procedimento: só realiza operações
+} 
+//declarando e descrevendo uma função
+function fatorial_recursiva(const a: integer) : integer;
+{ calcula a! recursivamente }
+
+// pode-se declarar variáveis locais para funções e procedimentos
+// exemplo:
+// Var
+//    local_a : integer;
+
+Begin
+    If a >= 1 Then
+    // o valor de retorno é atribuído como se a função fosse uma variável
+        fatorial_recursiva := a * fatorial_recursiva(a-1)
+    Else
+        fatorial_recursiva := 1;
+End; // o END de funções e procedimentos recebe ponto e vírgula
+
+//declarando e descrevendo um procedimento 
+procedure salvainteiro(var i : integer; dummy : integer);
+{ recebe entrada do usuário e salva na variável i
+  passagem de valor:
+	por referência - "VAR i: integer"; implica que alterações na variável i dentro da função são guardadas para o escopo de todo o programa
+	por valor - "dummy: integer"; implica que o valor do argumento é copiado e alterações na variável dummy não são guardadas
+}
+
+Begin
+    write('Insira um inteiro: '); //escreve sem quebrar linha
+    readln(i); //lê i com quebra de linha
+    dummy := 4; // dummy não terá seu valor alterado fora do procedimento. 
+End;
+
+Begin // programa principal
+    dummy := 3;
+    salvainteiro(i, dummy);
+
+	// escrevendo i! 
+    writeln(i, '! = ', factorial_recursion(i)); // escreve e quebra linha; valores numéricos são automaticamente convertidos para texto na escrita
+
+    // escrevendo o valor de dummy
+    writeln('dummy = ', dummy); // sempre vai escrever 3, já que o valor de dummy não é alterado por salvainteiro
+End.
+
+```
+
-- 
cgit v1.2.3


From d5529d632ff29549db61296e9c21d195625037cc Mon Sep 17 00:00:00 2001
From: Raul Gomes Pimentel de Almeida <haltsimog@gmail.com>
Date: Mon, 11 Feb 2019 19:32:24 -0200
Subject: Finished the Pascal text for Brazilian Portuguese.

Added some extra details about loops and if/else blocks

(modified pascal-pt.html.markdown)
---
 pt-br/pascal-pt.html.markdown | 171 +++++++++++++++++++++++-------------------
 1 file changed, 92 insertions(+), 79 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/pascal-pt.html.markdown b/pt-br/pascal-pt.html.markdown
index 6e175216..3c6343ca 100644
--- a/pt-br/pascal-pt.html.markdown
+++ b/pt-br/pascal-pt.html.markdown
@@ -6,8 +6,8 @@ contributors:
 ---
 
 
->Pascal is an imperative and procedural programming language, which Niklaus Wirth designed in 1968–69 and published in 1970, as a small, efficient language intended to encourage good programming practices using structured programming and data structuring. It is named in honor of the French mathematician, philosopher and physicist Blaise Pascal. 
-source : [wikipedia](https://en.wikipedia.org/wiki/Pascal_(programming_language))
+>Pascal é uma linguagem de programação estruturada, que recebeu este nome em homenagem ao matemático e físico Blaise Pascal. Foi criada em 1970 pelo suíço Niklaus Wirth,tendo em mente encorajar o uso de código estruturado. 
+fonte : [wikipédia](https://pt.wikipedia.org/wiki/Pascal_(linguagem_de_programa%C3%A7%C3%A3o))
 
 
 
@@ -22,102 +22,105 @@ Para compilar e executar um programa em Pascal, você pode usar o freepascal, um
 }
 
 //cabeçalho do programa
-program learn_pascal; //<-- não esqueça o ponto e vírgula. O nome do programa deve começar com uma letra.
+PROGRAM aprendendo_pascal; //<-- não esqueça o ponto e vírgula. O nome do programa deve começar com uma letra.
 
-const
+CONST
     {
         aqui você declara valores constantes
     }
-type
+TYPE
     {
         aqui você declara tipos não nativos
     }
-var
+VAR
     {
         aqui você declara variáveis
     }
 
 //programa de fato
-begin
+BEGIN
     {
         aqui ficam todas as instruções que não pertencem nem a funções nem a procedimentos
+		blocos de código começam com BEGIN e terminam com END (como as chaves em C)
     }
-end. //o "end" no final do programa requer um ponto final.
+END. //o "end" no final do programa requer um ponto final.
 ```
 
 ```pascal
 //formas de declarar uma variável
-var a:integer;
-var b:integer;
+VAR a:INTEGER;
+VAR b:INTEGER;
 
-var 
-    a : integer;
-    b : integer;
+VAR 
+    a : INTEGER;
+    b : INTEGER;
 
-var a,b : integer;
+VAR a,b : INTEGER;
 ```
 
 ```pascal
-program Learn_More;
+PROGRAM Learn_More;
 //agora, mais sobre tipos de dados e operações
 
-const
+CONST
     PI = 3.141592654;
     GNU = 'GNU''s Not Unix';
         // a convenção é usar caixa alta para constantes
         // constantes têm valores fixos que só podem ser alterados antes da compilação
         // constantes podem ser de qualquer tipo nativo (integer, real, boolean, char, string)
 
-type
-    ch_array : array [0..255] of char;
-        // isso declara um novo tipo de variável, ch_array, que tem 256 caracteres
-    md_array : array of array of integer;
+TYPE
+    vet_char : array [0..255] of CHAR;
+        // isso declara um novo tipo de variável, vet_char, que tem 256 caracteres
+    vet_multd : array of array of INTEGER;
         // vetores de vetores são vetores multidimensionais
         // pode-se definir vetores de tamanho 0 (daí, usa-se alocação dinâmica)
-        // vetores do tipo md_array são de duas dimensões
+        // vetores do tipo vet_multd são de duas dimensões
 
 //declarando variáveis
-var
-    int, c, d  : integer;
+VAR
+    int, c, d  : INTEGER;
            // três variáveis que guardam valores inteiros
            // inteiros têm 16 bits (vão de -32768 a 32767)
-    r    : real;
+    r    : REAL;
            // uma variável que guarda um valor real
            // reais vão de 3.4E-38 a 3.4E38
-    bool : boolean;
+    bool : BOOLEAN;
            // uma variável que guarda um valor booleano (verdadeiro ou falso)
-    ch   : char;
+    ch   : CHAR;
            // uma variável que guarda um caractere
            // caracteres têm 8 bits 
-    str  : string;
+    str  : STRING;
            // esse tipo de variável não é padrão, mas é incluído na maioria dos compiladores
            // string é um vetor de caracteres com tamanho padrão de 255 elementos
-    s    : string[50];
+    s    : STRING[50];
            // você pode especificar o tamanho de uma string desta maneira para otimizar o uso de memória
-    my_str: ch_array;
+    my_str: vet_char;
            // aqui, uma variável de um tipo personalizado declarado acima
-    my_2d : md_array;
+    my_2d : vet_multd;
            // vetores de alocação dinâmica de memória precisam receber um tamanho antes de serem usados
 
+// outros tipos de dados (pascal é uma linguagem fortemente tipada)
+
     // tipos adicionais de inteiros
-    b    : byte;     // faixa [0..255]
-    shi  : shortint; // faixa [-128..127]
-    smi  : smallint; // faixa [-32,768..32,767] (inteiro padrão)
-    w    : word;     // faixa [0..65,535]
-    li   : longint;  // faixa [-2,147,483,648..2,147,483,647]
-    lw   : longword; // faixa [0..4,294,967,295]
-    c    : cardinal; // longword
-    i64  : int64;    // faixa [-9223372036854775808..9223372036854775807]
-    qw   : qword;    // faixa [0..18,446,744,073,709,551,615]
+    b    : BYTE;     // faixa [0..255]
+    shi  : SHORTINT; // faixa [-128..127]
+    smi  : SMALLINT; // faixa [-32,768..32,767] (inteiro padrão)
+    w    : WORD;     // faixa [0..65,535]
+    li   : LONGINT;  // faixa [-2,147,483,648..2,147,483,647]
+    lw   : LONGWORD; // faixa [0..4,294,967,295]
+    c    : CARDINAL; // longword
+    i64  : INT64;    // faixa [-9223372036854775808..9223372036854775807]
+    qw   : QWORD;    // faixa [0..18,446,744,073,709,551,615]
 
     // tipos adicionais de reais
-    rr   : real;     // faixa depende da plataforma (8 bits, 16 bits, etc)
-    rs   : single;   // faixa [1.5E-45..3.4E38]
-    rd   : double;   // faixa [5.0E-324 .. 1.7E308]
-    re   : extended; // faixa [1.9E-4932..1.1E4932]
-    rc   : comp;     // faixa [-2E64+1 .. 2E63-1]
+    rr   : REAL;     // faixa depende da plataforma (8 bits, 16 bits, etc)
+    rs   : SINGLE;   // faixa [1.5E-45..3.4E38]
+    rd   : DOUBLE;   // faixa [5.0E-324 .. 1.7E308]
+    re   : EXTENDED; // faixa [1.9E-4932..1.1E4932]
+    rc   : COMP;     // faixa [-2E64+1 .. 2E63-1]
 
-Begin
+BEGIN
     int := 1;// usa-se := para atribuir valores a variáveis
     r   := 3.14; 
     ch  := 'a';
@@ -128,13 +131,13 @@ Begin
     //aritmética
     int := 1 + 1; // int deixa de ser 1 e passa a ser 2
     int := int + 1; // int = 2 + 1 = 3;
-    int := 4 div 2; //int = 2 (DIV é uma divisão inteira, ou seja, o resto é "jogado fora")
-    int := 3 div 2; //int = 1
-    int := 1 div 2; //int = 0
+    int := 4 DIV 2; //int = 2 (DIV é uma divisão inteira, ou seja, o resto é "jogado fora")
+    int := 3 DIV 2; //int = 1
+    int := 1 DIV 2; //int = 0
 
-    bool := true or false; // bool = true
-    bool := false and true; // bool = false
-    bool := true xor true; // bool = false
+    bool := true OR false; // bool = true
+    bool := false AND true; // bool = false
+    bool := true XOR true; // bool = false
 
     r := 3 / 2; // usa-se a "/" para divisões entre inteiros
     r := int; // um real pode receber um valor inteiro (mas não o contrário)
@@ -144,65 +147,75 @@ Begin
 
     my_str[0] := 'a'; // só se pode atribuir valores a vetores elemento por elemento (não o vetor inteiro de uma vez)
 
-    setlength(my_2d,10,10); // inicialização de um vetor com alocação dinâmica de memória; my_2d vira um 10x10 
-    for c := 0 to 9 do // vetores começam em 0 e terminam em tamanho-1 (exceto se, na declaração do tipo, forem especificados valores diferentes)
-        for d := 0 to 9 do // a variável usada em um laço FOR deve ter sido declarada no cabeçalho do programa
+    // LAÇOS
+	WHILE (ch != 'a') DO
+		BEGIN
+			writeln('ch é diferente de a');
+			IF (ch = 'c') THEN
+				writeln('ch é igual a c');
+		END;
+	
+	SETLENGTH(my_2d,10,10); // inicialização de um vetor com alocação dinâmica de memória; my_2d vira um 10x10 
+    FOR c := 0 to 9 DO // vetores começam em 0 e terminam em tamanho-1 (exceto se, na declaração do tipo, forem especificados valores diferentes)
+        FOR d := 0 to 9 DO // a variável usada em um laço FOR deve ter sido declarada no cabeçalho do programa
         my_2d[c,d] := c * d; // acessam-se elementos de vetores multidimensionais com [dimensão1, dimensão2, dimensão3...]
+	
 
-End.
+END.
 ```
 
 ```pascal
-program Functional_Programming;
+PROGRAM programacao_com_funcoes;
 
-Var
-    i, dummy : integer;
+VAR
+    i, inutil : INTEGER;
 
 { OBS: diferença entre procedimento e função
 	função: realiza operações e retorna valor
 	procedimento: só realiza operações
 } 
 //declarando e descrevendo uma função
-function fatorial_recursiva(const a: integer) : integer;
+FUNCTION fatorial_recursiva(CONST a: INTEGER) : INTEGER;
 { calcula a! recursivamente }
 
 // pode-se declarar variáveis locais para funções e procedimentos
 // exemplo:
-// Var
-//    local_a : integer;
+// VAR
+//    local_a : INTEGER;
 
-Begin
-    If a >= 1 Then
+BEGIN
+	// obs: o ELSE só funciona se não houver ponto e vírgula no bloco do IF (exemplo: IF a THEN writeln('a'); ELSE writeln('b') é um programa que não compila)
+    IF a >= 1 THEN
     // o valor de retorno é atribuído como se a função fosse uma variável
         fatorial_recursiva := a * fatorial_recursiva(a-1)
-    Else
+    ELSE
         fatorial_recursiva := 1;
-End; // o END de funções e procedimentos recebe ponto e vírgula
+END; // o END de funções e procedimentos recebe ponto e vírgula
 
 //declarando e descrevendo um procedimento 
-procedure salvainteiro(var i : integer; dummy : integer);
+PROCEDURE salvainteiro(VAR i : INTEGER; inutil : INTEGER);
 { recebe entrada do usuário e salva na variável i
   passagem de valor:
 	por referência - "VAR i: integer"; implica que alterações na variável i dentro da função são guardadas para o escopo de todo o programa
-	por valor - "dummy: integer"; implica que o valor do argumento é copiado e alterações na variável dummy não são guardadas
+	por valor - "inutil: integer"; implica que o valor do argumento é copiado e alterações na variável inutil não são guardadas
 }
 
-Begin
-    write('Insira um inteiro: '); //escreve sem quebrar linha
-    readln(i); //lê i com quebra de linha
-    dummy := 4; // dummy não terá seu valor alterado fora do procedimento. 
-End;
+BEGIN
+    WRITE('Insira um inteiro: '); //escreve sem quebrar linha
+    READLN(i); //lê i com quebra de linha
+    inutil := 4; // inutil não terá seu valor alterado fora do procedimento. 
+END;
 
-Begin // programa principal
-    dummy := 3;
-    salvainteiro(i, dummy);
+BEGIN // programa principal
+    inutil := 3;
+    salvainteiro(i, inutil);
 
 	// escrevendo i! 
-    writeln(i, '! = ', factorial_recursion(i)); // escreve e quebra linha; valores numéricos são automaticamente convertidos para texto na escrita
+    WRITELN(i, '! = ', factorial_recursion(i)); // escreve e quebra linha; valores numéricos são automaticamente convertidos para texto na escrita
 
-    // escrevendo o valor de dummy
-    writeln('dummy = ', dummy); // sempre vai escrever 3, já que o valor de dummy não é alterado por salvainteiro
-End.
+    // escrevendo o valor de inutil
+    WRITELN('inutil = ', inutil); // sempre vai escrever 3, já que o valor de inutil não é alterado por salvainteiro
+END.
 
 ```
 
-- 
cgit v1.2.3


From a689a8c7dbef6b6148ba10ebcf910fc77a98ccae Mon Sep 17 00:00:00 2001
From: Raul Gomes Pimentel de Almeida <haltsimog@gmail.com>
Date: Mon, 11 Feb 2019 19:58:20 -0200
Subject: Minor changes on line breaking for Pascal in pt-br

---
 pt-br/pascal-pt.html.markdown | 84 +++++++++++++++++++++++++++++--------------
 1 file changed, 57 insertions(+), 27 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/pascal-pt.html.markdown b/pt-br/pascal-pt.html.markdown
index 3c6343ca..d6d675c3 100644
--- a/pt-br/pascal-pt.html.markdown
+++ b/pt-br/pascal-pt.html.markdown
@@ -2,7 +2,9 @@
 language: Pascal
 filename: learnpascal.pas
 contributors:
-    - ["Raul Almeida", "http://github.com/almeidaraul"]
+	- ["Ganesha Danu", "https://github.com/blinfoldking"]
+	- ["Keith Miyake", "https//github.com/kaymmm"]
+    - ["Raul Almeida", "https://github.com/almeidaraul"]
 ---
 
 
@@ -11,7 +13,8 @@ fonte : [wikipédia](https://pt.wikipedia.org/wiki/Pascal_(linguagem_de_programa
 
 
 
-Para compilar e executar um programa em Pascal, você pode usar o freepascal, um compilador gratuito. [Faça o download aqui](https://www.freepascal.org/)
+Para compilar e executar um programa em Pascal, você pode usar o freepascal, 
+um compilador gratuito. [Faça o download aqui](https://www.freepascal.org/)
 
 ```pascal
 //Corpo de um programa em Pascal
@@ -22,7 +25,8 @@ Para compilar e executar um programa em Pascal, você pode usar o freepascal, um
 }
 
 //cabeçalho do programa
-PROGRAM aprendendo_pascal; //<-- não esqueça o ponto e vírgula. O nome do programa deve começar com uma letra.
+PROGRAM aprendendo_pascal; //<-- não esqueça o ponto e vírgula. O nome do 
+programa deve começar com uma letra.
 
 CONST
     {
@@ -40,8 +44,11 @@ VAR
 //programa de fato
 BEGIN
     {
-        aqui ficam todas as instruções que não pertencem nem a funções nem a procedimentos
-		blocos de código começam com BEGIN e terminam com END (como as chaves em C)
+        aqui ficam todas as instruções que não pertencem nem a funções 
+		nem a procedimentos 
+		
+		blocos de código começam com BEGIN e terminam com END 
+		(como as chaves em C)
     }
 END. //o "end" no final do programa requer um ponto final.
 ```
@@ -65,16 +72,20 @@ PROGRAM Learn_More;
 CONST
     PI = 3.141592654;
     GNU = 'GNU''s Not Unix';
-        // a convenção é usar caixa alta para constantes
-        // constantes têm valores fixos que só podem ser alterados antes da compilação
-        // constantes podem ser de qualquer tipo nativo (integer, real, boolean, char, string)
+        { a convenção é usar caixa alta para constantes
+          
+		  constantes têm valores fixos que só podem ser alterados 
+		  antes da compilação
+          
+		  constantes podem ser de qualquer tipo nativo (integer, real, boolean, 
+		  char, string)
 
 TYPE
     vet_char : array [0..255] of CHAR;
-        // isso declara um novo tipo de variável, vet_char, que tem 256 caracteres
+        // isso declara um novo tipo de variável, vet_char, com 256 caracteres
     vet_multd : array of array of INTEGER;
         // vetores de vetores são vetores multidimensionais
-        // pode-se definir vetores de tamanho 0 (daí, usa-se alocação dinâmica)
+        // use vetores de tamanho 0 (daí, usa-se alocação dinâmica)
         // vetores do tipo vet_multd são de duas dimensões
 
 //declarando variáveis
@@ -91,14 +102,14 @@ VAR
            // uma variável que guarda um caractere
            // caracteres têm 8 bits 
     str  : STRING;
-           // esse tipo de variável não é padrão, mas é incluído na maioria dos compiladores
+           // STRING não é um tipo padrão, mas vem na maioria dos compiladores
            // string é um vetor de caracteres com tamanho padrão de 255 elementos
     s    : STRING[50];
-           // você pode especificar o tamanho de uma string desta maneira para otimizar o uso de memória
+           // especificar o tamanho de uma string assim otimiza o uso de memória
     my_str: vet_char;
            // aqui, uma variável de um tipo personalizado declarado acima
     my_2d : vet_multd;
-           // vetores de alocação dinâmica de memória precisam receber um tamanho antes de serem usados
+           // defina o tamanho de vetores dinâmicos antes de usá-los
 
 // outros tipos de dados (pascal é uma linguagem fortemente tipada)
 
@@ -127,11 +138,12 @@ BEGIN
     str := 'apple';
     bool := true;
     //pascal não é case-sensitive (não diferencia maiúsculas de minúsculas)
-	//uma opção de organização é usar maiúsculas para termos da linguagem (BEGIN, END, INTEGER, etc) e constantes
-    //aritmética
+	// uma opção de organização é usar maiúsculas para termos da linguagem 
+	// (BEGIN, END, INTEGER, etc) e constantes
+    // aritmética
     int := 1 + 1; // int deixa de ser 1 e passa a ser 2
     int := int + 1; // int = 2 + 1 = 3;
-    int := 4 DIV 2; //int = 2 (DIV é uma divisão inteira, ou seja, o resto é "jogado fora")
+    int := 4 DIV 2; //int = 2 (DIV é uma divisão inteira - ignora o resto) 
     int := 3 DIV 2; //int = 1
     int := 1 DIV 2; //int = 0
 
@@ -145,7 +157,8 @@ BEGIN
     c := str[1]; //acessando elementos de um vetor: vetor[índice do elemento]
     str := 'hello' + 'world'; //concatenção de strings
 
-    my_str[0] := 'a'; // só se pode atribuir valores a vetores elemento por elemento (não o vetor inteiro de uma vez)
+    my_str[0] := 'a'; { só se pode atribuir valores a vetores elemento 
+						por elemento (não o vetor inteiro de uma vez) }
 
     // LAÇOS
 	WHILE (ch != 'a') DO
@@ -155,10 +168,15 @@ BEGIN
 				writeln('ch é igual a c');
 		END;
 	
-	SETLENGTH(my_2d,10,10); // inicialização de um vetor com alocação dinâmica de memória; my_2d vira um 10x10 
-    FOR c := 0 to 9 DO // vetores começam em 0 e terminam em tamanho-1 (exceto se, na declaração do tipo, forem especificados valores diferentes)
-        FOR d := 0 to 9 DO // a variável usada em um laço FOR deve ter sido declarada no cabeçalho do programa
-        my_2d[c,d] := c * d; // acessam-se elementos de vetores multidimensionais com [dimensão1, dimensão2, dimensão3...]
+	SETLENGTH(my_2d,10,10); 
+	// inicialização de um vetor com alocação dinâmica; my_2d vira um 10x10 
+    FOR c := 0 to 9 DO 
+		{ vetores começam em 0 e terminam em tamanho-1
+		  (exceto se, declarando o tipo, forem especificados valores diferentes) }
+        FOR d := 0 to 9 DO 
+			// a variável usada em um laço FOR deve ter sido declarada no cabeçalho
+        my_2d[c,d] := c * d; 
+			// acessam-se elementos de vetores multidimensionais com [d1, d2, d3...]
 	
 
 END.
@@ -184,7 +202,14 @@ FUNCTION fatorial_recursiva(CONST a: INTEGER) : INTEGER;
 //    local_a : INTEGER;
 
 BEGIN
-	// obs: o ELSE só funciona se não houver ponto e vírgula no bloco do IF (exemplo: IF a THEN writeln('a'); ELSE writeln('b') é um programa que não compila)
+	{ O bloco ELSE só funciona se não houver ponto e vírgula no bloco do IF 
+	  exemplo: 
+	  	IF a THEN
+			writeln('a'); 
+		ELSE 
+			writeln('b'); 
+		Isso não permitiria que o programa compilasse }
+
     IF a >= 1 THEN
     // o valor de retorno é atribuído como se a função fosse uma variável
         fatorial_recursiva := a * fatorial_recursiva(a-1)
@@ -196,8 +221,12 @@ END; // o END de funções e procedimentos recebe ponto e vírgula
 PROCEDURE salvainteiro(VAR i : INTEGER; inutil : INTEGER);
 { recebe entrada do usuário e salva na variável i
   passagem de valor:
-	por referência - "VAR i: integer"; implica que alterações na variável i dentro da função são guardadas para o escopo de todo o programa
-	por valor - "inutil: integer"; implica que o valor do argumento é copiado e alterações na variável inutil não são guardadas
+
+	POR REFERÊNCIA - "VAR i: integer"; implica que alterações na variável i
+	dentro da função são guardadas para o escopo de todo o programa
+
+	POR VALOR - "inutil: integer"; implica que o valor do argumento é copiado 
+	e alterações na variável inutil não são guardadas
 }
 
 BEGIN
@@ -211,10 +240,11 @@ BEGIN // programa principal
     salvainteiro(i, inutil);
 
 	// escrevendo i! 
-    WRITELN(i, '! = ', factorial_recursion(i)); // escreve e quebra linha; valores numéricos são automaticamente convertidos para texto na escrita
+    WRITELN(i, '! = ', factorial_recursion(i)); // escreve e quebra linha
+	// valores numéricos são automaticamente convertidos para texto na escrita
 
-    // escrevendo o valor de inutil
-    WRITELN('inutil = ', inutil); // sempre vai escrever 3, já que o valor de inutil não é alterado por salvainteiro
+    // escrever valor de inutil (sempre 3, já que salvainteiro não a altera)
+    WRITELN('inutil = ', inutil); 
 END.
 
 ```
-- 
cgit v1.2.3


From 14357102aa1c818272b7c5077adbc4fca62e5b7b Mon Sep 17 00:00:00 2001
From: Andre Polykanine <ap@oire.me>
Date: Wed, 13 Feb 2019 02:14:08 +0200
Subject: Fixed frontmatter

---
 pt-br/pascal-pt.html.markdown | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/pascal-pt.html.markdown b/pt-br/pascal-pt.html.markdown
index d6d675c3..3a37271a 100644
--- a/pt-br/pascal-pt.html.markdown
+++ b/pt-br/pascal-pt.html.markdown
@@ -1,10 +1,12 @@
 ---
 language: Pascal
-filename: learnpascal.pas
+filename: learnpascal-pt.pas
 contributors:
-	- ["Ganesha Danu", "https://github.com/blinfoldking"]
-	- ["Keith Miyake", "https//github.com/kaymmm"]
+    - ["Ganesha Danu", "https://github.com/blinfoldking"]
+    - ["Keith Miyake", "https//github.com/kaymmm"]
+translators:
     - ["Raul Almeida", "https://github.com/almeidaraul"]
+lang: pt-br
 ---
 
 
@@ -43,7 +45,7 @@ VAR
 
 //programa de fato
 BEGIN
-    {
+    80
         aqui ficam todas as instruções que não pertencem nem a funções 
 		nem a procedimentos 
 		
-- 
cgit v1.2.3


From ed100434e33ed95e69620fc9ff6167bb130d3862 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pierre-Fran=C3=A7ois=20Clement?= <likeyn@gmail.com>
Date: Fri, 8 Mar 2019 17:18:42 +0100
Subject: Move "awk" articles to the "tool" category

---
 pt-br/awk-pt.html.markdown | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/awk-pt.html.markdown b/pt-br/awk-pt.html.markdown
index 761f5294..9bf770fd 100644
--- a/pt-br/awk-pt.html.markdown
+++ b/pt-br/awk-pt.html.markdown
@@ -1,5 +1,6 @@
 ---
-language: awk
+category: tool
+tool: awk
 filename: learnawk-pt.awk
 contributors:
     - ["Marshall Mason", "http://github.com/marshallmason"]
-- 
cgit v1.2.3


From 6ca3b99774483f320cd430b8166df58dba178dc8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pierre-Fran=C3=A7ois=20Clement?= <likeyn@gmail.com>
Date: Fri, 8 Mar 2019 17:20:20 +0100
Subject: Move "cmake" articles to the "tool" category

---
 pt-br/cmake-pt.html.markdown | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/cmake-pt.html.markdown b/pt-br/cmake-pt.html.markdown
index 8d4c3fda..d11fe4f4 100644
--- a/pt-br/cmake-pt.html.markdown
+++ b/pt-br/cmake-pt.html.markdown
@@ -1,5 +1,6 @@
 ---
-language: cmake
+category: tool
+tool: cmake
 contributors:
     - ["Bruno Alano", "https://github.com/brunoalano"]
 filename: CMake-br
-- 
cgit v1.2.3


From 0a3207587d7a548f1691f11a7bff2bfead264026 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pierre-Fran=C3=A7ois=20Clement?= <likeyn@gmail.com>
Date: Fri, 8 Mar 2019 17:21:53 +0100
Subject: Move "make" articles to the "tool" category

---
 pt-br/make-pt.html.markdown | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/make-pt.html.markdown b/pt-br/make-pt.html.markdown
index 8e7603cc..cbdebde7 100644
--- a/pt-br/make-pt.html.markdown
+++ b/pt-br/make-pt.html.markdown
@@ -1,5 +1,6 @@
 ---
-language: make
+category: tool
+tool: make
 contributors:
     - ["Robert Steed", "https://github.com/robochat"]
     - ["Stephan Fuhrmann", "https://github.com/sfuhrm"]
-- 
cgit v1.2.3


From 52c74e4f17f034a398a85a8f7832264f31bb9787 Mon Sep 17 00:00:00 2001
From: Claudio Busatto <c.busatto@wille-enginering.com>
Date: Wed, 27 Mar 2019 19:46:41 +0100
Subject: Fix layout and typos

---
 pt-br/coffeescript-pt.html.markdown | 23 ++++++++++++-----------
 1 file changed, 12 insertions(+), 11 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/coffeescript-pt.html.markdown b/pt-br/coffeescript-pt.html.markdown
index 8b1094b1..37a70006 100644
--- a/pt-br/coffeescript-pt.html.markdown
+++ b/pt-br/coffeescript-pt.html.markdown
@@ -31,24 +31,24 @@ Você deveria entender mais de semântica de JavaScript antes de continuar...
 ###
 
 # Tarefa: 
-numero = 42 #=> número var = 42; 
+numero = 42 #=> var numero = 42; 
 oposto = true #=> var oposto = true;
 
 # Condições: 
-numero = -42 if oposto #=> if (oposto) {número = -42;}
+numero = -42 if oposto #=> if (oposto) {numero = -42;}
 
 # Funções: 
 quadrado = (x) -> x * x #=> var quadrado = function (x) {return x * x;}
 
-preencher = (recipiente, líquido = "coffee") ->
-  "Preenchendo o #{recipiente} with #{líquido}..."
+preencher = (recipiente, liquido = "coffee") ->
+  "Preenchendo o #{recipiente} with #{liquido}..."
 #=>var preencher;
 #
-#preencher = function(recipiente, líquido) {
-#  if (líquido == null) {
-#    líquido = "coffee";
+#preencher = function(recipiente, liquido) {
+#  if (liquido == null) {
+#    liquido = "coffee";
 #  }
-#  return "Preenchendo o " + recipiente + " with " + líquido + "...";
+#  return "Preenchendo o " + recipiente + " with " + liquido + "...";
 #};
 
 # Alcances: 
@@ -90,17 +90,18 @@ cubes = (math.cube num for num in list)
 #   return _results;
 #  })();
 
-comidas = ['brócolis', 'espinafre', 'chocolate']
+comidas = ['brocolis', 'espinafre', 'chocolate']
 eat alimento for alimento in comidas when alimento isnt 'chocolate'
-#=>comidas = ['brócolis', 'espinafre', 'chocolate'];
+#=>comidas = ['brocolis', 'espinafre', 'chocolate'];
 #
 #for (_k = 0, _len2 = comidas.length; _k < _len2; _k++) {
 #  alimento = comidas[_k];
 #  if (alimento !== 'chocolate') {
 #    eat(alimento);
 #  }
+```
 
 ## Recursos adicionais
 
 - [Smooth CoffeeScript](http://autotelicum.github.io/Smooth-CoffeeScript/)
-- [CoffeeScript Ristretto](https://leanpub.com/coffeescript-ristretto/read)
\ No newline at end of file
+- [CoffeeScript Ristretto](https://leanpub.com/coffeescript-ristretto/read)
-- 
cgit v1.2.3


From 56e7570b12b001d4c094c9a8b8b10508f3db6f19 Mon Sep 17 00:00:00 2001
From: Claudio Busatto <c.busatto@wille-enginering.com>
Date: Wed, 27 Mar 2019 19:48:50 +0100
Subject: Include me as a contributor

---
 pt-br/coffeescript-pt.html.markdown | 29 +++++++++++++++--------------
 1 file changed, 15 insertions(+), 14 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/coffeescript-pt.html.markdown b/pt-br/coffeescript-pt.html.markdown
index 37a70006..03098e90 100644
--- a/pt-br/coffeescript-pt.html.markdown
+++ b/pt-br/coffeescript-pt.html.markdown
@@ -3,19 +3,20 @@ language: coffeescript
 contributors:
   - ["Tenor Biel", "http://github.com/L8D"]
   - ["Xavier Yao", "http://github.com/xavieryao"]
+  - ["Claudio Busatto", "http://github.com/cjcbusatto"]
 translators:
     - ["Miguel Araújo", "https://github.com/miguelarauj1o"]
 lang: pt-br
 filename: learncoffeescript-pt.coffee
 ---
 
-CoffeeScript é uma pequena linguagem que compila um-para-um para o JavaScript 
-equivalente, e não há interpretação em tempo de execução. Como um dos sucessores 
-de JavaScript, CoffeeScript tenta o seu melhor para exibir uma saída legível, 
-bem-impressa e bom funcionamento dos códigos JavaScript em todo o tempo de 
+CoffeeScript é uma pequena linguagem que compila um-para-um para o JavaScript
+equivalente, e não há interpretação em tempo de execução. Como um dos sucessores
+de JavaScript, CoffeeScript tenta o seu melhor para exibir uma saída legível,
+bem-impressa e bom funcionamento dos códigos JavaScript em todo o tempo de
 execução JavaScript.
 
-Veja também [site do CoffeeScript](http://coffeescript.org/), que tem um tutorial 
+Veja também [site do CoffeeScript](http://coffeescript.org/), que tem um tutorial
 completo sobre CoffeeScript.
 
 ``` coffeescript
@@ -23,21 +24,21 @@ completo sobre CoffeeScript.
 #Segue as tendências de muitas linguagens modernas
 #Assim, os comentários são iguais a Ruby e Python, eles usam símbolos numéricos.
 
-### 
-Os comentários em bloco são como estes, e eles traduzem diretamente para '/ *'s e 
+###
+Os comentários em bloco são como estes, e eles traduzem diretamente para '/ *'s e
 '* /'s para o código JavaScript que resulta...
 
-Você deveria entender mais de semântica de JavaScript antes de continuar... 
+Você deveria entender mais de semântica de JavaScript antes de continuar...
 ###
 
-# Tarefa: 
-numero = 42 #=> var numero = 42; 
+# Tarefa:
+numero = 42 #=> var numero = 42;
 oposto = true #=> var oposto = true;
 
-# Condições: 
+# Condições:
 numero = -42 if oposto #=> if (oposto) {numero = -42;}
 
-# Funções: 
+# Funções:
 quadrado = (x) -> x * x #=> var quadrado = function (x) {return x * x;}
 
 preencher = (recipiente, liquido = "coffee") ->
@@ -51,7 +52,7 @@ preencher = (recipiente, liquido = "coffee") ->
 #  return "Preenchendo o " + recipiente + " with " + liquido + "...";
 #};
 
-# Alcances: 
+# Alcances:
 list = [1 .. 5] #=> lista var = [1, 2, 3, 4, 5];
 
 # Objetos:
@@ -79,7 +80,7 @@ alert "Eu sabia!" if elvis?
 #=> if(typeof elvis !== "undefined" && elvis !== null) { alert("Eu sabia!"); }
 
 # Compressão de Matrizes:
-cubes = (math.cube num for num in list) 
+cubes = (math.cube num for num in list)
 #=>cubes = (function() {
 #   var _i, _len, _results;
 #   _results = [];
-- 
cgit v1.2.3


From fc7e08639656cba77170160880f505d9f3dfe044 Mon Sep 17 00:00:00 2001
From: Claudio Busatto <c.busatto@wille-enginering.com>
Date: Wed, 27 Mar 2019 20:00:34 +0100
Subject: User data has to follow the grammar of the target language

---
 pt-br/coffeescript-pt.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/coffeescript-pt.html.markdown b/pt-br/coffeescript-pt.html.markdown
index 03098e90..7129a463 100644
--- a/pt-br/coffeescript-pt.html.markdown
+++ b/pt-br/coffeescript-pt.html.markdown
@@ -91,9 +91,9 @@ cubes = (math.cube num for num in list)
 #   return _results;
 #  })();
 
-comidas = ['brocolis', 'espinafre', 'chocolate']
+comidas = ['brócolis', 'espinafre', 'chocolate']
 eat alimento for alimento in comidas when alimento isnt 'chocolate'
-#=>comidas = ['brocolis', 'espinafre', 'chocolate'];
+#=>comidas = ['brócolis', 'espinafre', 'chocolate'];
 #
 #for (_k = 0, _len2 = comidas.length; _k < _len2; _k++) {
 #  alimento = comidas[_k];
-- 
cgit v1.2.3


From 9f7893995ca5653ccb651181a76d7bb19883a43a Mon Sep 17 00:00:00 2001
From: Raphael <raphaelsantos.j@gmail.com>
Date: Sat, 1 Jun 2019 10:32:20 -0300
Subject: fix some typos

---
 pt-br/clojure-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/clojure-pt.html.markdown b/pt-br/clojure-pt.html.markdown
index 7e8b3f7b..b88d4eec 100644
--- a/pt-br/clojure-pt.html.markdown
+++ b/pt-br/clojure-pt.html.markdown
@@ -340,7 +340,7 @@ keymap ; => {:a 1, :b 2, :c 3}
 (def my-atom (atom {}))
 
 ; Atualize o atom com um swap!.
-; swap! pega uma funçnao and chama ela com o valor atual do atom
+; swap! pega uma função e chama ela com o valor atual do atom
 ; como primeiro argumento, e qualquer argumento restante como o segundo
 (swap! my-atom assoc :a 1) ; Coloca o valor do átomo my-atom como o resultado de  (assoc {} :a 1)
 (swap! my-atom assoc :b 2) ; Coloca o valor do átomo my-atom como o resultado de (assoc {:a 1} :b 2)
-- 
cgit v1.2.3


From 3e1fe4dc0077817c8946fc8644c29d2ba585b0e1 Mon Sep 17 00:00:00 2001
From: Victor Bastos <victorwpbastos@gmail.com>
Date: Tue, 1 Oct 2019 11:55:55 -0300
Subject: [php/pt-br] Small typo

---
 pt-br/php-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/php-pt.html.markdown b/pt-br/php-pt.html.markdown
index 8a1c956e..e55f1100 100644
--- a/pt-br/php-pt.html.markdown
+++ b/pt-br/php-pt.html.markdown
@@ -20,7 +20,7 @@ Este documento descreve PHP 5+.
 
 // Duas barras iniciam o comentário de uma linha.
 
-# O hash (aka pound symbol) também inicia, mas // é mais comum.
+# O hash (conhecido como "pound symbol") também inicia, mas // é mais comum.
 
 /*
      O texto envolto por barra-asterisco e asterisco-barra
-- 
cgit v1.2.3


From 4df895568d5600f20636e88b58cdfd74e7df4410 Mon Sep 17 00:00:00 2001
From: Victor Bastos <victorwpbastos@gmail.com>
Date: Tue, 1 Oct 2019 11:58:32 -0300
Subject: [cypher/pt-br] Small typo

---
 pt-br/cypher-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/cypher-pt.html.markdown b/pt-br/cypher-pt.html.markdown
index 9b60f771..d4400148 100644
--- a/pt-br/cypher-pt.html.markdown
+++ b/pt-br/cypher-pt.html.markdown
@@ -101,7 +101,7 @@ path = shortestPath( (user)-[:KNOWS*..5]-(other) )
 Crie consultas
 ---
 
-Create a new node
+Crie um novo nó
 ```
 CREATE (a:Person {name:"Théo Gauchoux"})
 RETURN a
-- 
cgit v1.2.3


From ffd1fed725668b48ec8c11cbe419bd1e8d136ae3 Mon Sep 17 00:00:00 2001
From: Fer <nanda.fer@gmail.com>
Date: Tue, 1 Oct 2019 12:06:10 -0300
Subject: Update markdown-pt.html.markdown

Translation adjustments
---
 pt-br/markdown-pt.html.markdown | 33 +++++++++++++++++----------------
 1 file changed, 17 insertions(+), 16 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/markdown-pt.html.markdown b/pt-br/markdown-pt.html.markdown
index f22093f9..53049c13 100644
--- a/pt-br/markdown-pt.html.markdown
+++ b/pt-br/markdown-pt.html.markdown
@@ -11,17 +11,17 @@ filename: learnmarkdown-pt.md
 Markdown foi criado por John Gruber in 2004. Originado para ser fácil de ler e 
 escrever sintaxe que converte facilmente em HTML (hoje, suporta outros formatos também).
 
-Dê-me feedback tanto quanto você quiser! / Sinta-se livre para a garfar (fork) e 
+Dê-me feedback tanto quanto você quiser! / Sinta-se livre para fazer uma bifurcação (fork) e 
 puxar o projeto (pull request)
 
 ```markdown
 <!-- Markdown é um superconjunto do HTML, de modo que qualquer arvquivo HTML é 
 um arquivo Markdown válido, isso significa que nós podemos usar elementos HTML 
 em Markdown, como o elemento de comentário, e eles não serão afetados pelo analisador
-de remarcação. No entanto, se você criar um elemento HTML em seu arquivo Markdown, você
-não pode usar sintaxe remarcação dentro desse conteúdo do elemento.-->
+de marcação. No entanto, se você criar um elemento HTML em seu arquivo Markdown, você
+não pode usar sintaxe de marcação dentro desse conteúdo do elemento.-->
 
-<!--Markdown também varia de implementação de um analisador para uma próxima.
+<!--Markdown também varia de implementação de um analisador para outro.
 Este guia vai tentar esclarecer quando as características são universais, ou quando eles são 
 específico para um determinado parser -->
 
@@ -77,19 +77,20 @@ Termino com dois espaços (destacar-me para vê-los).
 
 Há um <br /> acima de mim!
 
-<!-- Bloco de citações são fáceis e feito com o caractere >. -->
-
+<!-- Bloco de citações são fáceis e feitos com o caractere >. -->
+	
 > Este é um bloco de citação. Você pode 
-> Enrolar manualmente suas linhas e colocar um `>` antes de cada linha ou você pode
-> deixar suas linhas ficarem muito longas e enrolar por conta própria. Não faz diferença, 
+> Quebrar manualmente suas linhas e colocar um `>` antes de cada linha ou você pode
+> deixar suas linhas ficarem muito longas e quebrarem por conta própria. Não faz diferença, 
 > desde que eles começam com um `>`.
+	
 
 > Você também pode usar mais de um nível 
 >> De recuo? 
 > Como pura é isso?
 
 <!-- Listas --> 
-<!-- As listas não ordenadas podem ser feitas usando asteriscos, positivos ou hífens -->
+<!-- As listas não ordenadas podem ser feitas usando asteriscos, soma ou hífens -->
 
 * Item
 * Item
@@ -113,8 +114,8 @@ ou
 2. Item dois
 3. Tem três
 
-<!-- Você não tem poder para rotular os itens corretamente e a remarcação será ainda
-tornar os números em ordem, mas isso pode não ser uma boa idéia -->
+<!-- Você não tem poder para rotular os itens corretamente e a remarcação ainda deixará os 
+itens em ordem, mas isso pode não ser uma boa idéia -->
 
 1. Item um
 1. Item dois
@@ -137,14 +138,14 @@ uma linha com quatro espaços ou uma guia -->
 	Isto é código
 	É assim, sacou?
 
-<!-- Você pode também re-guia (ou adicionar mais quatro espaços adicionais) para o recuo 
+<!-- Você pode também tabular (ou adicionar mais quatro espaços adicionais) para o recuo 
 dentro do seu código -->
 
 	my_array.each do |item|
         puts item
     end	
 
-<!-- Código embutido pode ser criada usando o caractere de crase ` -->
+<!-- Código embutido pode ser criado usando o caractere de crase ` -->
 
 John não sabia nem o que o função 'goto()' fazia!
 
@@ -155,13 +156,13 @@ ruby! -->
 def foobar
     puts "Hello world!"
 end
-\`\`\` <!-- Aqui também, não barras invertidas, apenas ``` -->
+\`\`\` <!-- Aqui também, não use barras invertidas, apenas ``` -->
 
 <-- O texto acima não requer recuo, mas o GitHub vai usar a sintaxe 
 destacando do idioma que você especificar após a ``` -->
 
 <!-- Regra Horizontal (<hr />) --> 
-<!-- Regras horizontais são facilmente adicionados com três ou mais asteriscos ou hífens,
+<!-- Regras horizontais são facilmente adicionadas com três ou mais asteriscos ou hífens,
 com ou sem espaços. -->
 
 ***
@@ -175,7 +176,7 @@ o texto a ser exibido entre parênteses rígidos [] seguido pela url em parênte
 
 [Click aqui!](http://test.com/)
 
-<!-- Você também pode adicionar um título link usando aspas dentro dos parênteses -->
+<!-- Você também pode adicionar um título para o link usando aspas dentro dos parênteses -->
 
 [Click aqui!](http://test.com/ "Link para Test.com")
 
-- 
cgit v1.2.3


From 1e17f8e3c7c3e7c3bf287af242dc4311f5cda615 Mon Sep 17 00:00:00 2001
From: Antonio Roberto Furlaneto <arfurlaneto@gmail.com>
Date: Tue, 1 Oct 2019 12:07:14 -0300
Subject: [csharp/pt-br] Missing translation

---
 pt-br/csharp-pt.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index 2ff59296..3bdbcdb1 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -85,8 +85,8 @@ namespace Learning.CSharp
             // Long - 64-bit integer
             long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
             ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615)
-            // Numbers default to being int or uint depending on size.
-            // L is used to denote that this variable value is of type long or ulong
+            // Números por padrão são int ou uint dependendo do tamanho.
+            // L é usado para denotar que o valor da variável é do tipo long ou ulong.
 
             // Double - Double-precision 64-bit IEEE 754 Floating Point
             double fooDouble = 123.4; // Precision: 15-16 digits
-- 
cgit v1.2.3


From 1ccbe647ede9c36aa1d789811826e43341b7911f Mon Sep 17 00:00:00 2001
From: Victor Bastos <victorwpbastos@gmail.com>
Date: Tue, 1 Oct 2019 12:10:38 -0300
Subject: [typescript/pt-br] Small typo

---
 pt-br/typescript-pt.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/typescript-pt.html.markdown b/pt-br/typescript-pt.html.markdown
index 077aa2cc..e8ed6a7f 100644
--- a/pt-br/typescript-pt.html.markdown
+++ b/pt-br/typescript-pt.html.markdown
@@ -22,7 +22,7 @@ var isDone: boolean = false;
 var lines: number = 42;
 var name: string = "Anders";
 
-// Quando é impossível saber, há o "Qualquer" tipo
+// Quando é impossível saber, há o tipo "Qualquer"
 var notSure: any = 4;
 notSure = "maybe a string instead";
 notSure = false; // Ok, definitivamente um boolean
@@ -65,7 +65,7 @@ interface Person {
   move(): void;
 }
 
-// Objeto que implementa a "Pessoa" Interface
+// Objeto que implementa a Interface "Pessoa"
 // Pode ser tratado como uma pessoa desde que tem o nome e mover propriedades
 var p: Person = { name: "Bobby", move: () => {} };
 // Os objetos que têm a propriedade opcional:
-- 
cgit v1.2.3


From 0e5203510bcd6500d707e0a03f30cb9f90b93cac Mon Sep 17 00:00:00 2001
From: Fer <nanda.fer@gmail.com>
Date: Tue, 1 Oct 2019 12:16:59 -0300
Subject: [css/pt-br] Translation adjustments

---
 pt-br/css-pt.html.markdown | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/css-pt.html.markdown b/pt-br/css-pt.html.markdown
index c73669d0..1c4be746 100644
--- a/pt-br/css-pt.html.markdown
+++ b/pt-br/css-pt.html.markdown
@@ -14,15 +14,15 @@ translators:
 lang: pt-br
 ---
 
-Nos primeiros dias da web não havia elementos visuais, apenas texto puro. Mas com maior desenvolvimento de navegadores da web, páginas web totalmente visuais também se tornou comum.
+No início da web não havia elementos visuais, apenas texto puro. Mas com maior desenvolvimento de navegadores da web, páginas web totalmente visuais também se tornara comum.
 
-CSS ajuda a manter a separação entre o conteúdo (HTML) e o look-and-feel de uma página web.
+CSS ajuda a manter a separação entre o conteúdo (HTML) e o visual de uma página web.
 
 CSS permite atingir diferentes elementos em uma página HTML e atribuir diferentes propriedades visuais para eles.
 
-Este guia foi escrito para CSS2, embora CSS3 está rapidamente se tornando popular.
+Este guia foi escrito para CSS2, embora CSS3 esteja rapidamente se tornando popular.
 
-**NOTA:** Porque CSS produz resultados visuais, a fim de aprender, você precisa tentar de tudo em um playground CSS como [dabblet](http://dabblet.com/).
+**NOTA:** Porque CSS produz resultados visuais, a fim de aprender, você precisa treinar em um playground CSS como [dabblet](http://dabblet.com/).
 O foco principal deste artigo é sobre a sintaxe e algumas dicas gerais.
 
 ```css
@@ -42,7 +42,7 @@ Abaixo um elemento de exemplo:
 <div class='class1 class2' id='anID' attr='value' otherAttr='pt-br foo bar' />
 */
 
-/* Você pode direciona-lo usando uma das suas classes CSS */
+/* Você pode direcioná-lo usando uma das suas classes CSS */
 .class1 { }
 
 /* ou ambas as classes! */
@@ -82,9 +82,9 @@ classe div.some [attr $ = 'ue'] {}
 /* Você pode selecionar um elemento que é filho de outro elemento */
 div.some-parent> .class-name {}
 
-/* Ou um descendente de um outro elemento. As crianças são os descendentes diretos de
-   seu elemento pai, apenas um nível abaixo da árvore. Pode ser qualquer descendentes
-   nivelar por baixo da árvore. */
+/* Ou um descendente de um outro elemento. Os filhos são os descendentes diretos de
+   seu elemento pai, apenas um nível abaixo da árvore. Pode ser quaisquer descendentes
+   nivelados por baixo da árvore. */
 div.some-parent class-name {}
 
 /* Atenção: o mesmo seletor sem espaço tem um outro significado.
@@ -118,7 +118,7 @@ seletor:first-child {}
 /* Qualquer elemento que é o último filho de seu pai */
 seletor:last-child {}
 
-/* Assim como pseudo classes, pseudo elementos permitem que você estilo certas partes de um documento */
+/* Assim como pseudo classes, pseudo elementos permitem que você estilize certas partes de um documento */
 
 /* Corresponde a um primeiro filho virtual do elemento selecionado */
 seletor::before {}
@@ -127,7 +127,7 @@ seletor::before {}
 seletor::after {}
 
 /* Nos locais apropriados, um asterisco pode ser utilizado como um curinga para selecionar todos
-   elemento */
+   os elementos */
 * {} /* */ Todos os elementos
 .parent * {} /* */ todos os descendentes
 .parent> * {} /* */ todas as crianças
@@ -181,7 +181,7 @@ seletor {
 
 ## Uso
 
-Guardar uma folha de estilo CSS com a extensão `.css`.
+Salvar uma folha de estilo CSS com a extensão `.css`.
 
 ```xml
 <!-- Você precisa incluir o arquivo css no da sua página <head>. Isto é o
-- 
cgit v1.2.3


From f933d7f66f45423a859aa0105ad7b3271e44d776 Mon Sep 17 00:00:00 2001
From: Antonio Roberto Furlaneto <arfurlaneto@gmail.com>
Date: Tue, 1 Oct 2019 12:25:00 -0300
Subject: [julia/pt-br] Better translation

---
 pt-br/julia-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/julia-pt.html.markdown b/pt-br/julia-pt.html.markdown
index 48d97e58..11771d96 100644
--- a/pt-br/julia-pt.html.markdown
+++ b/pt-br/julia-pt.html.markdown
@@ -8,7 +8,7 @@ translators:
 lang: pt-br
 ---
 
-Julia é uma linguagem homoiconic funcional focada na computação tecnica. Ao mesmo tempo que ela tem todo o poder dos homoiconic macros, funções de primeira classe, e controle de baixo nivel, Julia é tão facil para aprender e usar quanto Python.
+Julia é uma linguagem homoicônica funcional focada na computação técnica. Ao mesmo tempo que ela tem todo o poder dos macros homoicônicos, funções de primeira classe, e controle de baixo nível, Julia é tão fácil para aprender e usar quanto Python.
 
 Este tutorial é baseado no Julia 0.3.
 
-- 
cgit v1.2.3


From 989809bb8fe12a5d481b58a52289a95adad377e6 Mon Sep 17 00:00:00 2001
From: Antonio Roberto Furlaneto <arfurlaneto@gmail.com>
Date: Tue, 1 Oct 2019 12:27:25 -0300
Subject: [latex/pt-br] Grammar error

---
 pt-br/latex-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/latex-pt.html.markdown b/pt-br/latex-pt.html.markdown
index 103af28e..58586522 100644
--- a/pt-br/latex-pt.html.markdown
+++ b/pt-br/latex-pt.html.markdown
@@ -62,7 +62,7 @@ Svetlana Golubeva}
 
 \newpage
 
-% Muitos artigos de pesquisa possuem um resumo, e pode-se isar comandos
+% Muitos artigos de pesquisa possuem um resumo, e pode-se usar comandos
 % predefinidos para isso.
 % Isso deve aparecer em sua ordem lógica, portanto, após o topo,
 % mas antes das seções principais do corpo.
-- 
cgit v1.2.3


From c8365375f14a5fe5776f465115e7c0129ec86f0e Mon Sep 17 00:00:00 2001
From: Fer <nanda.fer@gmail.com>
Date: Tue, 1 Oct 2019 12:28:54 -0300
Subject: [bash/pt-br] Translation adjustments

---
 pt-br/bash-pt.html.markdown | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/bash-pt.html.markdown b/pt-br/bash-pt.html.markdown
index 3a48d994..86d1a8ea 100644
--- a/pt-br/bash-pt.html.markdown
+++ b/pt-br/bash-pt.html.markdown
@@ -33,7 +33,7 @@ diretamente no shell.
 # Exemplo simples de hello world:
 echo Hello World!
 
-# Cada comando começa com uma nova linha, ou após um ponto virgula:
+# Cada comando começa com uma nova linha, ou após um ponto e vírgula:
 echo 'Essa é a primeira linha'; echo 'Essa é a segunda linha'
 
 # A declaração de variáveis é mais ou menos assim
@@ -41,14 +41,14 @@ Variavel="Alguma string"
 
 # Mas não assim:
 Variavel = "Alguma string"
-# Bash interpretará Variavel como um comando e tentará executar e lhe retornar
+# Bash interpretará Variavel como um comando e tentará executar e lhe retornará
 # um erro porque o comando não pode ser encontrado.
 
 # Ou assim:
 Variavel= 'Alguma string'
-# Bash interpretará 'Alguma string' como um comando e tentará executar e lhe retornar
+# Bash interpretará 'Alguma string' como um comando e tentará executar e lhe retornará
 # um erro porque o comando não pode ser encontrado. (Nesse caso a a parte 'Variavel=' 
-# é vista com uma declaração de variável valida apenas para o escopo do comando 'Uma string').
+# é vista com uma declaração de variável válida apenas para o escopo do comando 'Uma string').
 
 # Usando a variável:
 echo $Variavel
@@ -65,12 +65,12 @@ echo ${Variavel/Alguma/Uma}
 # Substring de uma variável
 Tamanho=7
 echo ${Variavel:0:Tamanho}
-# Isso retornará apenas os 7 primeiros caractéres da variável
+# Isso retornará apenas os 7 primeiros caracteres da variável
 
 # Valor padrão de uma variável
 echo ${Foo:-"ValorPadraoSeFooNaoExistirOuEstiverVazia"}
 # Isso funciona para nulo (Foo=) e (Foo=""); zero (Foo=0) retorna 0.
-# Note que isso apenas retornar o valor padrão e não mudar o valor da variável.
+# Note que isso apenas retornará o valor padrão e não mudará o valor da variável.
 
 # Variáveis internas
 # Tem algumas variáveis internas bem uteis, como
@@ -86,7 +86,7 @@ read Nome # Note que nós não precisamos declarar a variável
 echo Ola, $Nome
 
 # Nós temos a estrutura if normal:
-# use 'man test' para mais infomações para as condicionais
+# use 'man test' para mais informações para as condicionais
 if [ $Nome -ne $USER ]
 then
 	echo "Seu nome não é o seu username"
@@ -109,7 +109,7 @@ then
 	echo "Isso vai rodar se $Nome é Daniela ou Jose."
 fi
 
-# Expressões são denotadas com o seguinte formato
+# Expressões são escritas com o seguinte formato
 echo $(( 10 + 5))
 
 # Diferentemente das outras linguagens de programação, bash é um shell, então ele 
@@ -118,9 +118,9 @@ echo $(( 10 + 5))
 ls
 
 #Esse comando tem opções que controlam sua execução
-ls -l # Lista todo arquivo e diretorio em linhas separadas
+ls -l # Lista todo arquivo e diretório em linhas separadas
 
-# Os resultados do comando anterior pode ser passado para outro comando como input.
+# Os resultados do comando anterior podem ser passados para outro comando como input.
 # O comando grep filtra o input com o padrão passado. É assim que listamos apenas
 # os arquivos .txt no diretório atual:
 ls -l | grep "\.txt"
@@ -241,7 +241,7 @@ head -n 10 arquivo.txt
 sort arquivo.txt
 # reporta ou omite as linhas repetidas, com -d você as reporta
 uniq -d arquivo.txt
-# exibe apenas a primeira coluna após o caráctere ','
+# exibe apenas a primeira coluna após o caractere ','
 cut -d ',' -f 1 arquivo.txt
 # substitui todas as ocorrencias de 'okay' por 'legal' em arquivo.txt (é compativel com regex)
 sed -i 's/okay/legal/g' file.txt
-- 
cgit v1.2.3


From 39842323850cb75480982f32a6239362754b77aa Mon Sep 17 00:00:00 2001
From: daniloyamauti <33129352+daniloyamauti@users.noreply.github.com>
Date: Tue, 1 Oct 2019 12:29:38 -0300
Subject: [csharp/pt-br] Missing translation

---
 pt-br/csharp-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index 2ff59296..44294ccb 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -78,7 +78,7 @@ namespace Learning.CSharp
             short fooShort = 10000;
             ushort fooUshort = 10000;
 
-            // Integer - 32-bit integer
+            // Integer - inteiro de 32 bits 
             int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647)
             uint fooUint = 1; // (0 <= uint <= 4,294,967,295)
 
-- 
cgit v1.2.3


From aeb1fb64a1a79cb83415f5b30fb550e3119d2be1 Mon Sep 17 00:00:00 2001
From: Antonio Roberto Furlaneto <arfurlaneto@gmail.com>
Date: Tue, 1 Oct 2019 12:35:12 -0300
Subject: Update typescript-pt.html.markdown

---
 pt-br/typescript-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/typescript-pt.html.markdown b/pt-br/typescript-pt.html.markdown
index 077aa2cc..ceec8fd5 100644
--- a/pt-br/typescript-pt.html.markdown
+++ b/pt-br/typescript-pt.html.markdown
@@ -10,7 +10,7 @@ lang: pt-br
 
 Typescript é uma linguagem que visa facilitar o desenvolvimento de aplicações em grande escala escritos em JavaScript.
 Typescript acrescenta conceitos comuns como classes, módulos, interfaces, genéricos e (opcional) tipagem estática para JavaScript.
-É um super conjunto de JavaScript: todo o código JavaScript é o código do texto dactilografado válido para que possa ser adicionados diretamente a qualquer projeto. O compilador emite typescript JavaScript.
+É um super conjunto de JavaScript: todo o código JavaScript é TypeScript válido então ele pode ser adicionado diretamente a qualquer projeto. O compilador emite typescript JavaScript.
 
 Este artigo irá se concentrar apenas em texto datilografado sintaxe extra, ao contrário de [JavaScript](javascript-pt.html.markdown).
 
-- 
cgit v1.2.3


From 32f1db9ac3d9d02aa185d6ef453e84e847fc251f Mon Sep 17 00:00:00 2001
From: Fer <nanda.fer@gmail.com>
Date: Tue, 1 Oct 2019 12:36:01 -0300
Subject: [yaml/pt-br] Translation adjustments

---
 pt-br/yaml-pt.html.markdown | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/yaml-pt.html.markdown b/pt-br/yaml-pt.html.markdown
index 0b71877e..ba4b329f 100644
--- a/pt-br/yaml-pt.html.markdown
+++ b/pt-br/yaml-pt.html.markdown
@@ -11,7 +11,7 @@ lang: pt-br
 YAML é uma linguagem de serialização de dados projetado para ser diretamente gravável e
 legível por seres humanos.
 
-É um superconjunto de JSON, com a adição de indentação e quebras de linhas sintaticamente significativas, como Python. Ao contrário de Python, entretanto, YAML não permite o caracter literal tab para identação.
+É um superconjunto de JSON, com a adição de identação e quebras de linhas sintaticamente significativas, como Python. Ao contrário de Python, entretanto, YAML não permite o caracter literal tab para identação.
 
 ```yaml
 # Commentários em YAML são como este.
@@ -33,7 +33,7 @@ chave com espaco: valor
 porem: "Uma string, entre aspas."
 "Chaves podem estar entre aspas tambem.": "É útil se você quiser colocar um ':' na sua chave."
 
-# Seqüências de várias linhas podem ser escritos como um 'bloco literal' (utilizando |),
+# Seqüências de várias linhas podem ser escritas como um 'bloco literal' (utilizando |),
 # ou em um 'bloco compacto' (utilizando '>').
 bloco_literal: |
     Todo esse bloco de texto será o valor da chave 'bloco_literal',
@@ -76,7 +76,7 @@ um_mapa_aninhado:
 # também permite tipos de coleção de chaves, mas muitas linguagens de programação
 # vão reclamar.
 
-# Sequências (equivalente a listas ou arrays) semelhante à isso:
+# Sequências (equivalente a listas ou arrays) semelhante a isso:
 uma_sequencia:
     - Item 1
     - Item 2
@@ -118,7 +118,7 @@ datetime: 2001-12-15T02: 59: 43.1Z
 datetime_com_espacos 2001/12/14: 21: 59: 43.10 -5
 Data: 2002/12/14
 
-# A tag !!binary indica que a string é na verdade um base64-encoded (condificado)
+# A tag !!binary indica que a string é na verdade um base64-encoded (codificado)
 # representação de um blob binário.
 gif_file: !!binary |
     R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
-- 
cgit v1.2.3


From c618eeb603b94a4592b9bc06ebf97722ef2b16a9 Mon Sep 17 00:00:00 2001
From: daniloyamauti <33129352+daniloyamauti@users.noreply.github.com>
Date: Tue, 1 Oct 2019 12:37:42 -0300
Subject: [csharp/pt-br] Missing translation

---
 pt-br/csharp-pt.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index 2ff59296..804f0c1e 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -81,11 +81,11 @@ namespace Learning.CSharp
             // Integer - 32-bit integer
             int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647)
             uint fooUint = 1; // (0 <= uint <= 4,294,967,295)
-
+            //Números por padrão são int ou uint, dependendo do tamanho.
+            
             // Long - 64-bit integer
             long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
             ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615)
-            // Numbers default to being int or uint depending on size.
             // L is used to denote that this variable value is of type long or ulong
 
             // Double - Double-precision 64-bit IEEE 754 Floating Point
-- 
cgit v1.2.3


From 35472772e3fff1759e9cde9c65332fba4cc8fe68 Mon Sep 17 00:00:00 2001
From: daniloyamauti <33129352+daniloyamauti@users.noreply.github.com>
Date: Tue, 1 Oct 2019 12:46:03 -0300
Subject: [csharp/pt-br] Missing translation

---
 pt-br/csharp-pt.html.markdown | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index 2ff59296..cf134dd1 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -311,10 +311,10 @@ on a new line! ""Wow!"", the masses cried";
             // Converting Data Types And Typecasting
             ///////////////////////////////////////
 
-            // Converting data
+            // Convertendo dados
 
-            // Convert String To Integer
-            // this will throw a FormatException on failure
+            // Converter String para Integer
+            // isso lançará uma exceção "FormatException"
             int.Parse("123");//returns an integer version of "123"
 
             // try parse will default to type default on failure
-- 
cgit v1.2.3


From 03b67fff48f75c318bdf73d1c9d1750ab88367d6 Mon Sep 17 00:00:00 2001
From: daniloyamauti <33129352+daniloyamauti@users.noreply.github.com>
Date: Tue, 1 Oct 2019 12:50:33 -0300
Subject: [csharp/pt-br] Missing translation

---
 pt-br/csharp-pt.html.markdown | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index 2ff59296..e6fc4258 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -407,12 +407,12 @@ on a new line! ""Wow!"", the masses cried";
             return result;
         }
 
-        // You can narrow down the objects that are passed in
+        // Você pode pode restringir os objetos que são passados
         public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>
         {
-            // We can iterate, since T is a IEnumerable
+            // Nos podemos iterar, desde que T seja um "IEnumerable"
             foreach (var item in toPrint)
-                // Item is an int
+                // Item é um inteiro
                 Console.WriteLine(item.ToString());
         }
 
-- 
cgit v1.2.3


From caf2531ad0a35a9253216c8af75a6a19d26b4ae1 Mon Sep 17 00:00:00 2001
From: daniloyamauti <33129352+daniloyamauti@users.noreply.github.com>
Date: Tue, 1 Oct 2019 13:02:26 -0300
Subject: [csharp/pt-br] Missing translation

---
 pt-br/csharp-pt.html.markdown | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index 2ff59296..506ec330 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -720,9 +720,9 @@ on a new line! ""Wow!"", the masses cried";
             _speed -= decrement;
         }
 
-        // properties get/set values
-        // when only data needs to be accessed, consider using properties.
-        // properties may have either get or set, or both
+        // propriedade recupera e/ou atribui valores (get/set). 
+        // quando os dados precisam apenas ser acessados, considere o uso de propriedades.
+        // uma propriedade pode ter "get" ou "set", ou ambos.
         private bool _hasTassles; // private variable
         public bool HasTassles // public accessor
         {
-- 
cgit v1.2.3


From edccffb0c10d7fc23d2cda63e9063079f18ddfdf Mon Sep 17 00:00:00 2001
From: Ana Beatriz Cavalcanti <55802251+Anabaac@users.noreply.github.com>
Date: Tue, 1 Oct 2019 13:25:07 -0300
Subject: [groovy/pt-br] Small typo

---
 pt-br/groovy-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/groovy-pt.html.markdown b/pt-br/groovy-pt.html.markdown
index aed23df1..1eab9cc3 100644
--- a/pt-br/groovy-pt.html.markdown
+++ b/pt-br/groovy-pt.html.markdown
@@ -17,7 +17,7 @@ Groovy - Uma linguagem dinâmica para a plataforma Java. [Leia mais aqui.](http:
   Prepara-se:
 
   1) Instale a máquina virtual de Groovy - http://gvmtool.net/
-  2) Intalse o Groovy: gvm install groovy
+  2) Instale o Groovy: gvm install groovy
   3) Inicie o console groovy digitando: groovyConsole
 
 */
-- 
cgit v1.2.3


From 80b785ab226cfaa99f1b564ca65a0975abf4c006 Mon Sep 17 00:00:00 2001
From: Renan Muliterno Ferreira <45672566+rmuliterno@users.noreply.github.com>
Date: Tue, 1 Oct 2019 13:27:42 -0300
Subject: Adding more translations

---
 pt-br/csharp-pt.html.markdown | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index 2ff59296..4bcf1d84 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -308,25 +308,25 @@ on a new line! ""Wow!"", the masses cried";
             }
 
             ///////////////////////////////////////
-            // Converting Data Types And Typecasting
+            // Convertendo Data Types e Typecasting
             ///////////////////////////////////////
 
             // Converting data
 
-            // Convert String To Integer
-            // this will throw a FormatException on failure
-            int.Parse("123");//returns an integer version of "123"
+            // Converter String para Integer
+            // isso vai jogar um erro FormatException quando houver falha
+            int.Parse("123");//retorna uma verão em Integer da String "123"
 
-            // try parse will default to type default on failure
-            // in this case: 0
+            // try parse vai ir por padrão para o typo default quando houver uma falha
+            // nesse caso: 0
             int tryInt;
-            if (int.TryParse("123", out tryInt)) // Function is boolean
+            if (int.TryParse("123", out tryInt)) // Função booleana
                 Console.WriteLine(tryInt);       // 123
 
-            // Convert Integer To String
-            // Convert class has a number of methods to facilitate conversions
+            // Converter Integer para String
+            // A classe Convert possuí métodos para facilitar as conversões
             Convert.ToString(123);
-            // or
+            // ou
             tryInt.ToString();
 
             // Casting
-- 
cgit v1.2.3


From 2ba63ef72928d809a341325951be4bf33e224eef Mon Sep 17 00:00:00 2001
From: Ana Beatriz Cavalcanti <55802251+Anabaac@users.noreply.github.com>
Date: Tue, 1 Oct 2019 13:30:53 -0300
Subject: [yaml/pt-br] Small typo

---
 pt-br/yaml-pt.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/yaml-pt.html.markdown b/pt-br/yaml-pt.html.markdown
index 0b71877e..fa9f42ec 100644
--- a/pt-br/yaml-pt.html.markdown
+++ b/pt-br/yaml-pt.html.markdown
@@ -11,10 +11,10 @@ lang: pt-br
 YAML é uma linguagem de serialização de dados projetado para ser diretamente gravável e
 legível por seres humanos.
 
-É um superconjunto de JSON, com a adição de indentação e quebras de linhas sintaticamente significativas, como Python. Ao contrário de Python, entretanto, YAML não permite o caracter literal tab para identação.
+É um superconjunto de JSON, com a adição de indentação e quebras de linhas sintaticamente significativas, como Python. Ao contrário de Python, entretanto, YAML não permite o caracter literal tab para indentação.
 
 ```yaml
-# Commentários em YAML são como este.
+# Comentários em YAML são como este.
 
 ###################
 # TIPOS ESCALARES #
-- 
cgit v1.2.3


From 53d697b66cd06cabe127d811355bb4dde22a561f Mon Sep 17 00:00:00 2001
From: Ana Beatriz Cavalcanti <55802251+Anabaac@users.noreply.github.com>
Date: Tue, 1 Oct 2019 13:40:16 -0300
Subject: [stylus/pt-br] Typos

---
 pt-br/stylus-pt.html.markdown | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/stylus-pt.html.markdown b/pt-br/stylus-pt.html.markdown
index 804fa806..40c3c02c 100755
--- a/pt-br/stylus-pt.html.markdown
+++ b/pt-br/stylus-pt.html.markdown
@@ -132,7 +132,7 @@ body {
   background-color: $primary-color
 }
 
-/* Apoś compilar ficaria assim: */
+/* Após compilar ficaria assim: */
 div {
 	display: block;
 	margin-left: auto;
@@ -184,13 +184,13 @@ button
 /* Funções
 ==============================*/
 
-/* Funções no Stylus permitem fazer uma variedade de tarefas, como por exemplo, menipular algum dado. */
+/* Funções no Stylus permitem fazer uma variedade de tarefas, como por exemplo, manipular algum dado. */
 
 body {
   background darken(#0088DD, 50%) // Escurece a cor #0088DD em 50%
 }
 
-/** Criando sua própria função */
+/* Criando sua própria função */
 somar(a, b)
   a + b
 
@@ -221,7 +221,7 @@ for <val-name> [, <key-name>] in <expression>
 
 for $item in (1..2) /* Repete o bloco 12 vezes */
   .col-{$item}
-    width ($item / 12) * 100% /* Calcula a largula pelo número da coluna*
+    width ($item / 12) * 100% /* Calcula a largura pelo número da coluna*
 
 ```
 
-- 
cgit v1.2.3


From 2ddc949b7997f2f4549722a70b13ebd7101fd585 Mon Sep 17 00:00:00 2001
From: Renan Muliterno Ferreira <45672566+rmuliterno@users.noreply.github.com>
Date: Tue, 1 Oct 2019 13:49:20 -0300
Subject: Small Typos Fix

---
 pt-br/javascript-pt.html.markdown | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/javascript-pt.html.markdown b/pt-br/javascript-pt.html.markdown
index ed4a6ff3..f12d275b 100644
--- a/pt-br/javascript-pt.html.markdown
+++ b/pt-br/javascript-pt.html.markdown
@@ -361,7 +361,7 @@ myObj.myFunc(); // = "Olá mundo!"
 var myFunc = myObj.myFunc;
 myFunc(); // = undefined
 
-// Inversamente, uma função pode ser atribuída a um objeto e ganhar a acesso
+// Inversamente, uma função pode ser atribuída à um objeto e ganhar a acesso
 // através do `this`, até mesmo se ela não for chamada quando foi definida.
 var myOtherFunc = function(){
     return this.myString.toUpperCase();
@@ -416,7 +416,7 @@ myNewObj.myNumber; // = 5
 // vai olhar imediatamente para o seu prototype.
 
 // Algumas implementações em JS deixam você acessar o objeto prototype com a 
-// propriedade mágica `__proto__`. Enquanto isso é util para explicar 
+// propriedade mágica `__proto__`. Enquanto isso é útil para explicar 
 // prototypes, não é parte de um padrão; nós vamos falar de algumas formas de 
 // usar prototypes depois.
 
@@ -489,7 +489,7 @@ if (0){
 }
 
 // Entretanto, esses objetos encapsulados e as funções originais compartilham
-// um mesmo prototype, portanto você pode adicionar funcionalidades a uma string,
+// um mesmo prototype, portanto você pode adicionar funcionalidades à uma string,
 // por exemplo.
 String.prototype.firstCharacter = function(){
     return this.charAt(0);
-- 
cgit v1.2.3


From 3d75c100b4b79d78786860effb9dbaea1620e4ce Mon Sep 17 00:00:00 2001
From: Ana Beatriz Cavalcanti <55802251+Anabaac@users.noreply.github.com>
Date: Tue, 1 Oct 2019 13:53:40 -0300
Subject: [css/pt-br] Better translation

---
 pt-br/css-pt.html.markdown | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/css-pt.html.markdown b/pt-br/css-pt.html.markdown
index c73669d0..382caf38 100644
--- a/pt-br/css-pt.html.markdown
+++ b/pt-br/css-pt.html.markdown
@@ -14,7 +14,7 @@ translators:
 lang: pt-br
 ---
 
-Nos primeiros dias da web não havia elementos visuais, apenas texto puro. Mas com maior desenvolvimento de navegadores da web, páginas web totalmente visuais também se tornou comum.
+Nos primeiros dias da web não havia elementos visuais, apenas texto puro. Mas com maior desenvolvimento de navegadores da web, páginas web totalmente visuais também se tornaram comuns.
 
 CSS ajuda a manter a separação entre o conteúdo (HTML) e o look-and-feel de uma página web.
 
@@ -97,7 +97,7 @@ div.some-parent.class-name {}
 /* Ou qualquer irmão que o precede */
 .i am-qualquer-elemento antes ~ .Este elemento {}
 
-/* Existem alguns selectores chamado pseudo classes que podem ser usados para selecionar um
+/* Existem alguns seletores chamados pseudo classes que podem ser usados para selecionar um
    elemento quando ele está em um determinado estado */
 
 /* Por exemplo, quando o cursor passa sobre um elemento */
@@ -118,7 +118,7 @@ seletor:first-child {}
 /* Qualquer elemento que é o último filho de seu pai */
 seletor:last-child {}
 
-/* Assim como pseudo classes, pseudo elementos permitem que você estilo certas partes de um documento */
+/* Assim como pseudo classes, pseudo elementos permitem que você estilize certas partes de um documento */
 
 /* Corresponde a um primeiro filho virtual do elemento selecionado */
 seletor::before {}
-- 
cgit v1.2.3


From 809c01a0a076b5ef9ce3f1342334ee39d04ee133 Mon Sep 17 00:00:00 2001
From: Victor Bastos <victorwpbastos@gmail.com>
Date: Tue, 1 Oct 2019 17:57:51 -0300
Subject: [haskell/pt-br] Small typo

---
 pt-br/haskell-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/haskell-pt.html.markdown b/pt-br/haskell-pt.html.markdown
index 181aa471..f72fd296 100644
--- a/pt-br/haskell-pt.html.markdown
+++ b/pt-br/haskell-pt.html.markdown
@@ -41,7 +41,7 @@ o desenvolvimento deste paradigma de programação.
 7 * 7 -- 7 vezes 7
 7 / 7 -- 7 dividido por 7
 
--- Divisões não são inteiras, são fracionádas por padrão da linguagem
+-- Divisões não são inteiras, são fracionadas por padrão da linguagem
 28736 / 82374 -- 0.3488479374559934
 
 
-- 
cgit v1.2.3


From c643189c0f792402237d253dcf4110f4f69b09d6 Mon Sep 17 00:00:00 2001
From: Heitor Pascoal de Bittencourt <heitorpbittencourt@gmail.com>
Date: Tue, 8 Oct 2019 21:30:02 -0300
Subject: [c/pt-br] Fix book link

---
 pt-br/c-pt.html.markdown | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown
index e1c27958..4e55f068 100644
--- a/pt-br/c-pt.html.markdown
+++ b/pt-br/c-pt.html.markdown
@@ -8,6 +8,7 @@ translators:
     - ["João Farias", "https://github.com/JoaoGFarias"]
     - ["Elton Viana", "https://github.com/eltonvs"]
     - ["Cássio Böck", "https://github.com/cassiobsilva"]
+    - ["Heitor P. de Bittencourt", "https://github.com/heitorPB/"]
 lang: pt-br
 filename: c-pt.el
 ---
@@ -641,7 +642,7 @@ typedef void (*minha_função_type)(char *);
 Este é *o* livro sobre C, escrito pelos criadores da linguagem. Mas cuidado - ele é antigo e contém alguns erros (bem,
 ideias que não são mais consideradas boas) ou práticas ultrapassadas.
 
-Outra boa referência é [Learn C the hard way](http://c.learncodethehardway.org/book/).
+Outra boa referência é [Learn C the hard way](http://learncodethehardway.org/c/).
 
 Se você tem uma pergunta, leia [compl.lang.c Frequently Asked Questions](http://c-faq.com).
 
-- 
cgit v1.2.3


From ccde50813f72e9c2bd6b8e2a9025985a8646619f Mon Sep 17 00:00:00 2001
From: lbertolazzi <33129418+lbertolazzi@users.noreply.github.com>
Date: Fri, 11 Oct 2019 10:10:44 -0300
Subject: =?UTF-8?q?[elisp/pt]=20Corre=C3=A7=C3=A3o=20ortogr=C3=A1fica?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 pt-br/elisp-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/elisp-pt.html.markdown b/pt-br/elisp-pt.html.markdown
index fc2d1e40..aa611097 100644
--- a/pt-br/elisp-pt.html.markdown
+++ b/pt-br/elisp-pt.html.markdown
@@ -111,7 +111,7 @@ filename: learn-emacs-lisp-pt.el
 (hello)
 ;; `C-xC-e' => Hello, I am Bastien
 
-;; Os parêntesis vazios na definição da função significam que ela
+;; Os parênteses vazios na definição da função significam que ela
 ;; não aceita argumentos. Mas sempre utilizar `my-name' é um tédio!
 ;; Vamos dizer à função para aceitar um argumento (o argumento é
 ;; chamado "name"):
-- 
cgit v1.2.3


From 2c13b562f8d5c3a81027ee3abd46410452fbf3af Mon Sep 17 00:00:00 2001
From: lbertolazzi <33129418+lbertolazzi@users.noreply.github.com>
Date: Fri, 11 Oct 2019 10:19:39 -0300
Subject: Update pascal-pt.html.markdown

---
 pt-br/pascal-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/pascal-pt.html.markdown b/pt-br/pascal-pt.html.markdown
index 3a37271a..82cce843 100644
--- a/pt-br/pascal-pt.html.markdown
+++ b/pt-br/pascal-pt.html.markdown
@@ -157,7 +157,7 @@ BEGIN
     r := int; // um real pode receber um valor inteiro (mas não o contrário)
 
     c := str[1]; //acessando elementos de um vetor: vetor[índice do elemento]
-    str := 'hello' + 'world'; //concatenção de strings
+    str := 'hello' + 'world'; //concatenação de strings
 
     my_str[0] := 'a'; { só se pode atribuir valores a vetores elemento 
 						por elemento (não o vetor inteiro de uma vez) }
-- 
cgit v1.2.3


From 3496f8228f7d53131ed6496dab45e4038a808e65 Mon Sep 17 00:00:00 2001
From: lbertolazzi <33129418+lbertolazzi@users.noreply.github.com>
Date: Fri, 11 Oct 2019 10:41:24 -0300
Subject: =?UTF-8?q?[whip/pt]=20Corre=C3=A7=C3=A3o=20ortogr=C3=A1fica?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 pt-br/whip-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/whip-pt.html.markdown b/pt-br/whip-pt.html.markdown
index 7bdeec25..b11faf28 100644
--- a/pt-br/whip-pt.html.markdown
+++ b/pt-br/whip-pt.html.markdown
@@ -71,7 +71,7 @@ false
 (= 1 1) ; => true
 (equal 2 1) ; => false
 
-; Por exemplo, inigualdade pode ser verificada combinando as funções
+; Por exemplo, desigualdade pode ser verificada combinando as funções
 ;`not` e `equal`.
 (! (= 2 1)) ; => true
 
-- 
cgit v1.2.3


From 9fb99aa5bd2bcd742d972fa269de76c1994aff97 Mon Sep 17 00:00:00 2001
From: lbertolazzi <33129418+lbertolazzi@users.noreply.github.com>
Date: Fri, 11 Oct 2019 10:51:55 -0300
Subject: =?UTF-8?q?[haskell/pt]=20Corre=C3=A7=C3=A3o=20ortogr=C3=A1fica?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 pt-br/haskell-pt.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/haskell-pt.html.markdown b/pt-br/haskell-pt.html.markdown
index 181aa471..c55a4c03 100644
--- a/pt-br/haskell-pt.html.markdown
+++ b/pt-br/haskell-pt.html.markdown
@@ -41,7 +41,7 @@ o desenvolvimento deste paradigma de programação.
 7 * 7 -- 7 vezes 7
 7 / 7 -- 7 dividido por 7
 
--- Divisões não são inteiras, são fracionádas por padrão da linguagem
+-- Divisões não são inteiras, são fracionadas por padrão da linguagem
 28736 / 82374 -- 0.3488479374559934
 
 
@@ -67,7 +67,7 @@ not False -- Nega uma falácia
 7 > 7 -- 7 é maior que 7 ?
 
 
-{- Haskell é uma linguagem que tem uma sintáxe bastante familiar na
+{- Haskell é uma linguagem que tem uma sintaxe bastante familiar na
    matemática, por exemplo em chamadas de funções você tem:
 
    NomeFunção ArgumentoA ArgumentoB ArgumentoC ...
-- 
cgit v1.2.3


From 17360e644f81f702d436e7d2230a1114abe16dcb Mon Sep 17 00:00:00 2001
From: Ygor Sad <ysads2010@gmail.com>
Date: Sun, 13 Oct 2019 19:36:14 -0300
Subject: [clojure/pt-br] Rewrite text to be more natural

---
 pt-br/clojure-pt.html.markdown | 599 +++++++++++++++++++++++++++--------------
 1 file changed, 391 insertions(+), 208 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/clojure-pt.html.markdown b/pt-br/clojure-pt.html.markdown
index b88d4eec..862d73ea 100644
--- a/pt-br/clojure-pt.html.markdown
+++ b/pt-br/clojure-pt.html.markdown
@@ -5,12 +5,13 @@ contributors:
     - ["Adam Bard", "http://adambard.com/"]
 translators:
     - ["Mariane Siqueira Machado", "https://twitter.com/mariane_sm"]
+    - ["Ygor Sad", "https://github.com/ysads"]
 lang: pt-br
 ---
 
-Clojure é uma linguagem da família do Lisp desenvolvida para a JVM (máquina virtual Java). Possui uma ênfase muito mais forte em [programação funcional] (https://pt.wikipedia.org/wiki/Programa%C3%A7%C3%A3o_funcional) pura do que Common Lisp, mas inclui diversas utilidades [STM](https://en.wikipedia.org/wiki/Software_transactional_memory) para lidar com estado a medida que isso se torna necessário.
+Clojure é uma linguagem da família do Lisp desenvolvida para a JVM (máquina virtual Java). Possui uma ênfase muito mais forte em [programação funcional] (https://pt.wikipedia.org/wiki/Programa%C3%A7%C3%A3o_funcional) pura do que Common Lisp, mas inclui diversos recursos [STM](https://en.wikipedia.org/wiki/Software_transactional_memory) para lidar com estado e mutabilidade, caso isso seja necessário.
 
-Essa combinação permite gerenciar processamento concorrente de maneira muito simples, e frequentemente de maneira automática.
+Essa combinação permite gerenciar processamento concorrente de maneira muito simples - frequentemente, de modo automático.
 
 (Sua versão de clojure precisa ser pelo menos 1.2)
 
@@ -18,367 +19,549 @@ Essa combinação permite gerenciar processamento concorrente de maneira muito s
 ```clojure
 ; Comentários começam por ponto e vírgula
 
-; Clojure é escrito em "forms", os quais são simplesmente 
-; listas de coisas dentro de parênteses, separados por espaços em branco.
+; Código Clojure é escrito em formas - 'forms', em inglês. Tais estruturas são
+; simplesmente listas de valores encapsuladas dentro de parênteses, separados por
+; espaços em branco.
 
-; O "reader" (leitor) de Clojure presume que o primeiro elemento de 
-; uma par de parênteses é uma função ou macro, e que os resto são argumentos.
+; Ao interpretar um código em Clojure, o interpretador ou leitor - do inglês 'reader' - assume
+; que o primeiro valor dentro de uma forma é uma função ou macro, de modo que os demais valores
+; são seus argumentos. Isso se deve ao fato de que Clojure, por ser uma derivação de Lisp,
+; usa notação prefixa (ou polonesa).
 
-: A primeira chamada de um arquivo deve ser ns, para configurar o namespace (espaço de nomes)
+; Num arquivo, a primeira chamada deve ser sempre para a função ns,
+; que é responsável por definir em qual namespace o código em questão
+; deve ser alocado
 (ns learnclojure)
 
 ; Alguns exemplos básicos:
 
-; str cria uma string concatenando seus argumentos
-(str "Hello" " " "World") ; => "Hello World"
+; Aqui, str é uma função e "Olá" " " e "Mundo" são seus argumentos. O que ela faz é criar
+; uma string concatenando seus argumentos.
+(str "Olá" " " "Mundo") ; => "Olá Mundo"
 
-; Cálculos são feitos de forma direta e intuitiva
+; Note que espaços em branco separam os argumentos de uma função. Opcionalmente vírgulas
+; podem ser usadas, se você quiser.
+(str, "Olá", " ", "Mundo") ; => "Olá Mundo"
+
+; As operações matemáticas básicas usam os operadores de sempre
 (+ 1 1) ; => 2
 (- 2 1) ; => 1
 (* 1 2) ; => 2
 (/ 2 1) ; => 2
 
-; Você pode comparar igualdade utilizando =
+; Esses operadores aceitam um número arbitrário de argumentos
+(+ 2 2 2) ; = 2 + 2 + 2 => 6
+(- 5 1 1) ; = 5 - 1 - 1 => 3
+(* 3 3 3 3) ; = 3 * 3 * 3 * 3 => 81
+
+; Para verificar se dois valores são iguais, o operador = pode ser usado
 (= 1 1) ; => true
 (= 2 1) ; => false
 
-; Negação para operações lógicas
-(not true) ; => false
+; Para saber se dois valores são diferentes
+(not= 1 2) ; => true
+(not (= 1 2)) ; => true
 
-; Aninhar "forms" funciona como esperado
+; Conforme vimos acima, é possível aninhar duas formas
 (+ 1 (- 3 2)) ; = 1 + (3 - 2) => 2
+(* (- 3 2) (+ 1 2)) ; = (3 - 2) * (1 + 2) => 3
+
+; Se a leitura ficar comprometida, as fórmulas também podem ser escritas em múltiplas linhas
+(* (- 3 2)
+   (+ 1 2)) ; => 3
+(*
+ (- 3 2)
+ (+ 1 2)) ; => 3
+
 
 ; Tipos
 ;;;;;;;;;;;;;
 
-; Clojure usa os tipos de objetos de Java para booleanos, strings e números.
-; Use `class` para inspecioná-los
-(class 1) ; Literais Integer são java.lang.Long por padrão
-(class 1.); Literais Float são java.lang.Double
-(class ""); Strings são sempre com aspas duplas, e são java.lang.String
+; Por ter interoperabilidade com Java, Clojure usa os tipos de objetos de Java para booleanos,
+; strings e números. Para descobrir qual o tipo de um valor, você pode usar a função `class`:
+(class 1234) ; Literais Integer são java.lang.Long por padrão
+(class 1.50) ; Literais Float são java.lang.Double
+(class "oi") ; Strings sempre usam aspas duplas e são java.lang.String
 (class false) ; Booleanos são java.lang.Boolean
-(class nil); O valor "null" é chamado nil
 
-; Se você quiser criar um lista de literais, use aspa simples para 
-; ela não ser avaliada
-'(+ 1 2) ; => (+ 1 2)
-; (que é uma abreviação de (quote (+ 1 2)))
+; Tenha cuidado, ao dividir valores inteiros:
+(= (/ 1 2)
+   (/ 1.0 2.0)) ; => false
+
+(class (/ 1 2)) ; => clojure.lang.Ratio
+(class (/ 1.0 2.0)) ; => java.lang.Double
+
+; Aqui temos uma diferença em relação a Java, pois valores nulos são representados por `nil`
+(class nil) ; nil
 
-; É possível avaliar uma lista com aspa simples
-(eval '(+ 1 2)) ; => 3
 
 ; Coleções e sequências
 ;;;;;;;;;;;;;;;;;;;
 
-; Listas são estruturas encadeadas, enquanto vetores são implementados como arrays.
-; Listas e Vetores são classes Java também!
-(class [1 2 3]); => clojure.lang.PersistentVector
-(class '(1 2 3)); => clojure.lang.PersistentList
+; Os dois tipos básicos de coleção são listas - "list" em inglês - e vetores - "vectors"
+; no original. A principal diferença entre eles se
+; dá pela implementação:
+; - Vetores são implementados como arrays
+; - Listas são listas ligadas
+(class [1 2 3]) ; => clojure.lang.PersistentVector
+(class '(1 2 3)) ; => clojure.lang.PersistentList
 
-; Uma lista é escrita como (1 2 3), mas temos que colocar a aspa 
-; simples para impedir o leitor (reader) de pensar que é uma função.
-; Também, (list 1 2 3) é o mesmo que '(1 2 3)
+; Outra forma de declarar listas é usando a função list
+(list 1 2 3) ; => '(1 2 3)
 
-; "Coleções" são apenas grupos de dados
-; Listas e vetores são ambos coleções:
+; Clojure classifica conjuntos de dados de duas maneiras
+
+; "Coleções" são grupos simples de dados
+; Tanto listas quanto vetores são coleções:
 (coll? '(1 2 3)) ; => true
 (coll? [1 2 3]) ; => true
 
 ; "Sequências" (seqs) são descrições abstratas de listas de dados.
-; Apenas listas são seqs.
+; Sequências - ou seqs - são conjuntos de dados com avaliação "lazy"
+; Apenas listas são seqs:
 (seq? '(1 2 3)) ; => true
 (seq? [1 2 3]) ; => false
 
-; Um seq precisa apenas prover uma entrada quando é acessada.
-; Portanto, já que seqs podem ser avaliadas sob demanda (lazy) -- elas podem definir séries infinitas:
-(range 4) ; => (0 1 2 3)
-(range) ; => (0 1 2 3 4 ...) (uma série infinita)
-(take 4 (range)) ;  (0 1 2 3)
+; Ter avaliação lazy significa que uma seq somente precisa prover uma informação quando
+; ela for requisitada. Isso permite às seqs representar listas infinitas.
+(range) ; => (0 1 2 3 4 ...)
+(cycle [1 2]) ; => (1 2 1 2 1 2 ...)
+(take 4 (range)) ; => (0 1 2 3)
 
-; Use cons para adicionar um item no início de uma lista ou vetor
+; A função cons é usada para adicionar um item ao início de uma lista ou vetor:
 (cons 4 [1 2 3]) ; => (4 1 2 3)
 (cons 4 '(1 2 3)) ; => (4 1 2 3)
 
-; Conj adiciona um item em uma coleção sempre do jeito mais eficiente.
-; Para listas, elas inserem no início. Para vetores, é inserido no final.
+; Já conj adiciona um item em uma coleção sempre do jeito mais eficiente.
+; Em listas, isso significa inserir no início. Já em vetores, ao final.
 (conj [1 2 3] 4) ; => [1 2 3 4]
 (conj '(1 2 3) 4) ; => (4 1 2 3)
 
-; Use concat para concatenar listas e vetores
+; Concatenação de coleções pode ser feita usando concat. Note que ela sempre gera uma
+; seq como resultado e está sujeita a problemas de perfomance em coleções grandes, por
+; conta da natureza lazy das seqs.
+(concat '(1 2) [3 4]) ; => (1 2 3 4)
 (concat [1 2] '(3 4)) ; => (1 2 3 4)
 
-; Use filter, map para interagir com coleções
+; Outra forma de concatenar coleções é usando into. Ela não está sujeita a problemas
+; com a avaliação lazy, mas o resultado final da ordem e do tipo dos argumentos passados
+(into [1 2] '(3 4)) ; => [1 2 3 4]
+(into '(1 2) [3 4]) ; => (4 3 1 2)
+
+; Note que em into a ordem dos parâmetros influencia a coleção final.
+(into [1 2] '(3 4)) ; => (1 2 3 4)
+(into '(1 2) [3 4]) ; => (4 3 1 2)
+
+; As funções filter e map podem ser usadas para interagir com as coleções. Repare que
+; elas sempre retornam seqs, independentemente do tipo do seu argumento.
 (map inc [1 2 3]) ; => (2 3 4)
-(filter even? [1 2 3]) ; => (2)
+(filter even? [1 2 3 4]) ; => (2 4)
+
+; Use reduce reduzir coleções a um único valor. Também é possível passar um argumento
+; para o valor inicial das operações
+(reduce + [1 2 3]) ; = (+ (+ (+ 1 2) 3) 4) => 10
+(reduce + 10 [1 2 3 4]) ; = (+ (+ (+ (+ 10 1) 2) 3) 4) => 20
+(reduce conj [] '(3 2 1)) ; = (conj (conj (conj [] 3) 2) 1) => [3 2 1]
+
+; Reparou na semelhança entre listas e as chamadas de código Clojure? Isso se deve ao
+; fato de que todo código clojure é escrito usando listas. É por isso que elas sempre
+; são declaradas com o caracter ' na frente. Dessa forma o interpretador não tenta
+; avaliá-las.
+'(+ 2 3) ; cria uma lista com os elementos +, 2 e 3
+(+ 2 3) ; o interpretador chama a função + passando como argumentos 2 e 3
 
-; Use reduce para reduzi-los
-(reduce + [1 2 3 4])
-; = (+ (+ (+ 1 2) 3) 4)
-; => 10
+; Note que ' é apenas uma abreviação para a função quote.
+(quote (1 2 3)) ; => '(1 2 3)
+
+; É possível passar uma lista para que o interpretador a avalie. Note que isso está
+; sujeito ao primeiro elemento da lista ser um literal com um nome de uma função válida.
+(eval '(+ 2 3)) ; => 5
+(eval '(1 2 3)) ; dá erro pois o interpretador tenta chamar a função 1, que não existe
 
-; Reduce pode receber um argumento para o valor inicial
-(reduce conj [] '(3 2 1))
-; = (conj (conj (conj [] 3) 2) 1)
-; => [3 2 1]
 
 ; Funções
 ;;;;;;;;;;;;;;;;;;;;;
 
-; Use fn para criar novas funções. Uma função sempre retorna
-; sua última expressão.
-(fn [] "Hello World") ; => fn
+; Use fn para criar novas funções. Uma função sempre retorna sua última expressão.
+(fn [] "Olá Mundo") ; => fn
+
+; Para executar suas funções, é preciso chamá-las, envolvendo-as em parênteses.
+((fn [] "Olá Mundo")) ; => "Olá Mundo"
+
+; Como isso não é muito prático, você pode nomear funções atribuindo elas a literais.
+; Isso torna muito mais fácil chamá-las:
+(def ola-mundo (fn [] "Olá Mundo")) ; => fn
+(ola-mundo) ; => "Olá Mundo"
 
-; (É necessário colocar parênteses para chamá-los)
-((fn [] "Hello World")) ; => "Hello World"
+; Você pode abreviar esse processo usando defn:
+(defn ola-mundo [] "Olá Mundo")
 
-; Você pode atribuir valores a variáveis utilizando def
-(def x 1)
-x ; => 1
+; Uma função pode receber uma lista de argumentos:
+(defn ola
+  [nome]
+  (str "Olá " nome))
+(ola "Jonas") ; => "Olá Jonas"
 
-; Atribua uma função para uma var
-(def hello-world (fn [] "Hello World"))
-(hello-world) ; => "Hello World"
+; É possível criar funções que recebam multivariadas, isto é, que aceitam números
+; diferentes de argumentos:
+(defn soma
+  ([] 0)
+  ([a] a)
+  ([a b] (+ a b)))
 
-; Você pode abreviar esse processo usando defn
-(defn hello-world [] "Hello World")
+(soma) ; => 0
+(soma 1) ; => 1
+(soma 1 2) ; => 3
 
-; O [] é uma lista de argumentos para um função.
-(defn hello [name]
-  (str "Hello " name))
-(hello "Steve") ; => "Hello Steve"
+; Funções podem agrupar argumentos extras em uma seq:
+(defn conta-args
+  [& args]
+  (str "Você passou " (count args) " argumentos: " args))
+(conta-args 1 2 3 4) ; => "Você passou 4 argumentos: (1 2 3 4)"
 
-; Você pode ainda usar essa abreviação para criar funcões:
-(def hello2 #(str "Hello " %1))
-(hello2 "Fanny") ; => "Hello Fanny"
+; Você pode misturar argumentos regulares e argumentos em seq:
+(defn ola-e-conta
+  [nome & args]
+  (str "Olá " nome ", você passou " (count args) " argumentos extras"))
+(ola-e-conta "Maria" 1 2 3 4) ; => "Olá Maria, você passou 4 argumentos extras"
 
-; Vocé pode ter funções multi-variadic, isto é, com um número variável de argumentos
-(defn hello3
-  ([] "Hello World")
-  ([name] (str "Hello " name)))
-(hello3 "Jake") ; => "Hello Jake"
-(hello3) ; => "Hello World"
 
-; Funções podem agrupar argumentos extras em uma seq
-(defn count-args [& args]
-  (str "You passed " (count args) " args: " args))
-(count-args 1 2 3) ; => "You passed 3 args: (1 2 3)"
+; Nos exemplos acima usamos def para associar nomes a funções, mas poderíamos usá-lo
+; para associar nomes a quaisquer valores:
+(def xis :x)
+xis ; => :x
 
-; Você pode misturar argumentos regulares e argumentos em seq
-(defn hello-count [name & args]
-  (str "Hello " name ", you passed " (count args) " extra args"))
-(hello-count "Finn" 1 2 3)
-; => "Hello Finn, you passed 3 extra args"
+; Inclusive, tais literais podem possuir alguns caracteres não usuais em outras linguagens:
+(def *num-resposta* 42)
+(def conexao-ativa? true)
+(def grito-de-medo! "AAAAAAA")
+(def ->vector-vazio [])
+
+; É possível, inclusive, criar apelidos a nomes que já existem:
+(def somar! soma)
+(somar! 41 1) ; => 42 
+
+; Uma forma rápida de criar funções é por meio de funções anônimas. Elas são ótimas
+; para manipulação de coleções e seqs, já que podem ser passadas para map, filter
+; e reduce. Nessas funções, % é substituído por cada um dos items na seq ou na coleção:
+(filter #(not= % nil) ["Joaquim" nil "Maria" nil "Antônio"]) ; => ("Joaquim" "Maria" "Antônio")
+(map #(* % (+ % 2)) [1 2]) ; => (3 8)
 
 
 ; Mapas
 ;;;;;;;;;;
 
-; Hash maps e array maps compartilham uma mesma interface. Hash maps são mais
-; rápidos para pesquisa mas não mantém a ordem da chave.
+; Existem dois tipos de mapas: hash maps e array maps. Ambos compartilham uma mesma
+; interface e funções. Hash maps são mais rápidos para retornar dados, mas não mantém
+; as chaves ordenadas.
 (class {:a 1 :b 2 :c 3}) ; => clojure.lang.PersistentArrayMap
 (class (hash-map :a 1 :b 2 :c 3)) ; => clojure.lang.PersistentHashMap
 
-; Arraymaps pode automaticamente se tornar hashmaps através da maioria das
-; operações se eles ficarem grandes o suficiente, portanto não há necessida de 
-; se preocupar com isso.
-
-;Mapas podem usar qualquer valor que se pode derivar um hash como chave
+; Clojure converte automaticamente array maps em hash maps, por meio da maioria das
+; funções de manipulação de mapas, caso eles fiquem grandes o suficiente. Não é
+; preciso se preocupar com isso.
 
-
-; Mapas podem usar qualquer valor em que se pode derivar um hash como chave, 
-; mas normalmente palavras-chave (keywords) são melhores.
-; Keywords são como strings mas com algumas vantagens.
+; Chaves podem ser qualquer valor do qual possa ser obtido um hash, mas normalmente
+; usam-se keywords como chave, por possuírem algumas vantagens.
 (class :a) ; => clojure.lang.Keyword
 
-(def stringmap {"a" 1, "b" 2, "c" 3})
-stringmap  ; => {"a" 1, "b" 2, "c" 3}
+; Keywords são como strings, porém, duas keywords de mesmo valor são sempre armazenadas
+; na mesma posição de memória, o que as torna mais eficientes.
+(identical? :a :a) ; => true
+(identical? (String. "a") (String. "a")) ; => false
 
-(def keymap {:a 1, :b 2, :c 3})
-keymap ; => {:a 1, :c 3, :b 2}
+(def mapa-strings {"a" 1 "b" 2 "c" 3})
+mapa-strings ; => {"a" 1, "b" 2, "c" 3}
 
-; A propósito, vírgulas são sempre tratadas como espaçoes em branco e não fazem nada.
+(def mapa-keywords {:a 1 :b 2 :c 3})
+mapa-keywords ; => {:a 1, :c 3, :b 2}
 
-; Recupere o valor de um mapa chamando ele como uma função
-(stringmap "a") ; => 1
-(keymap :a) ; => 1
+; Você pode usar um mapa como função para recuperar um valor dele:
+(mapa-strings "a") ; => 1
+(mapa-keywords :a) ; => 1
 
-; Uma palavra-chave pode ser usada pra recuperar os valores de um mapa
-(:b keymap) ; => 2
+; Se a chave buscada for uma keyword, ela também pode ser usada como função para recuperar 
+; valores. Note que isso não funciona com strings.
+(:b mapa-keywords) ; => 2
+("b" mapa-strings) ; => java.lang.String cannot be cast to clojure.lang.IFn
 
-; Não tente isso com strings
-;("a" stringmap)
-; => Exception: java.lang.String cannot be cast to clojure.lang.IFn
+; Se você buscar uma chave que não existe, Clojure retorna nil:
+(mapa-strings "d") ; => nil
 
-; Buscar uma chave não presente retorna nil
-(stringmap "d") ; => nil
+; Use assoc para adicionar novas chaves em um mapa.
+(def mapa-keywords-estendido (assoc mapa-keywords :d 4))
+mapa-keywords-estendido ; => {:a 1, :b 2, :c 3, :d 4}
 
-; Use assoc para adicionar novas chaves para hash-maps
-(def newkeymap (assoc keymap :d 4))
-newkeymap ; => {:a 1, :b 2, :c 3, :d 4}
+; Mas lembre-se que tipos em Clojure são sempre imutáveis! Isso significa que o mapa
+; inicial continua com as mesmas informações e um novo mapa, com mais dados, é criado
+; a partir dele
+mapa-keywords ; => {:a 1, :b 2, :c 3}
 
-; Mas lembre-se, tipos em Clojure são sempre imutáveis!
-keymap ; => {:a 1, :b 2, :c 3}
+; assoc também pode ser usado para atualizar chaves:
+(def outro-mapa-keywords (assoc mapa-keywords :a 0))
+outro-mapa-keywords ; => {:a 0, :b 2, :c 3}
 
 ; Use dissoc para remover chaves
-(dissoc keymap :a :b) ; => {:c 3}
+(dissoc mapa-keywords :a :b) ; => {:c 3}
+
+; Mapas também são coleções - mas não seqs!
+(coll? mapa-keywords) ; => true
+(seq? mapa-keywords) ; => false
+
+; É possível usar filter, map e qualquer outra função de coleções em mapas.
+; Porém a cada iteração um vetor no formato [chave valor] vai ser passado como
+; argumento. Por isso é conveniente usar funções anônimas.
+(filter #(odd? (second %)) mapa-keywords) ; => ([:a 1] [:c 3])
+(map #(inc (second %)) mapa-keywords) ; => (2 3 4)
 
 ; Conjuntos
 ;;;;;;
 
-(class #{1 2 3}) ; => clojure.lang.PersistentHashSet
+; Conjuntos são um tipo especial de coleções que não permitem elementos repetidos.
+; Eles podem ser criados com #{} ou com a função set.
 (set [1 2 3 1 2 3 3 2 1 3 2 1]) ; => #{1 2 3}
+(class #{1 2 3}) ; => clojure.lang.PersistentHashSet
 
-; Adicione um membro com conj
-(conj #{1 2 3} 4) ; => #{1 2 3 4}
+; Note que nem sempre um set vai armazenar seus elementos na ordem esperada.
+(def meu-conjunto #{1 2 3})
+meu-conjunto ; => #{1 3 2}
 
-; Remova um membro com disj
-(disj #{1 2 3} 1) ; => #{2 3}
+; Adição funciona normalmente com conj.
+(conj meu-conjunto 4) ; => #{1 4 3 2}
 
-; Test por existência usando set como função:
-(#{1 2 3} 1) ; => 1
-(#{1 2 3} 4) ; => nil
+; Remoção, no entanto, precisa ser feita com disj:
+(disj meu-conjunto 1) ; => #{3 2}
 
-; Existem muitas outras funções no namespace clojure.sets
+; Para saber se um elemento está em um conjunto, use-o como função. Nesse aspecto
+; conjuntos funcionam de maneira semelhante a mapas.
+(meu-conjunto 1) ; => 1
+(meu-conjunto 4) ; => nil
 
-; Forms úteis
-;;;;;;;;;;;;;;;;;
 
-; Construções lógicas em Clojure são como macros, e 
-; se parecem com as demais
-(if false "a" "b") ; => "b"
-(if false "a") ; => nil
+; Condicionais e blocos
+;;;;;;;;;;;;;;;;;
 
-; Use let para criar um novo escopo associando sîmbolos a valores (bindings)
+; Você pode usar um bloco let para criar um escopo local, no qual estarão disponíveis
+; os nomes que você definir:
 (let [a 1 b 2]
-  (> a b)) ; => false
+  (+ a b)) ; => 3
 
-; Agrupe comandos juntos com "do"
-(do
-  (print "Hello")
-  "World") ; => "World" (prints "Hello")
+(let [cores {:yellow "Amarelo" :blue "Azul"}
+      nova-cor :red
+      nome-cor "Vermelho"]
+  (assoc cores nova-cor nome-cor)) ; => {:yellow "Amarelo", :blue "Azul", :red "Vermelho"}
 
-; Funções tem um do implícito
-(defn print-and-say-hello [name]
-  (print "Saying hello to " name)
-  (str "Hello " name))
-(print-and-say-hello "Jeff") ;=> "Hello Jeff" (prints "Saying hello to Jeff")
+; Formas do tipo if aceitam três argumentos: a condição de teste, o comando a ser
+; executado caso a condição seja positiva; e o comando para o caso de ela ser falsa.
+(if true "a" "b") ; => "a"
+(if false "a" "b") ; => "b"
+
+; Opcionalmente você pode não passar o último argumento, mas se a condição for falsa
+; o if vai retornar nil. 
+(if false "a") ; => nil
+
+; A forma if somente aceita um comando para ser executado em cada caso. Se você
+; precisar executar mais comandos, você pode usar a função do:
+(if true
+  (do
+    (print "Olá ")
+    (print "Mundo"))) ; => escreve "Olá Mundo" na saída
+
+; Se você só deseja tratar o caso de sua condição ser verdadeira, o comando when é
+; uma alternativa melhor. Seu comportamento é idêntico a um if sem condição negativa.
+; Uma de suas vantagens é permitir a execução de vários comandos sem exigir do:
+(when true "a") ; => "a"
+(when true
+  (print "Olá ")
+  (print "Mundo")) ; => também escreve "Olá Mundo" na saída
+
+; Isso ocorre porque when possui um bloco do implícito. O mesmo se aplica a funções e
+; comandos let:
+(defn escreve-e-diz-xis
+  [nome]
+  (print "Diga xis, " nome)
+  (str "Olá " nome))
+(escreve-e-diz-xis "João") ;=> "Olá João", além de escrever "Diga xis, João" na saída.
+
+(let [nome "Nara"]
+  (print "Diga xis, " nome)
+  (str "Olá " nome)) ;=> "Olá João", além de escrever "Diga xis, João" na saída.
 
-; Assim como let
-(let [name "Urkel"]
-  (print "Saying hello to " name)
-  (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel")
 
 ; Módulos
 ;;;;;;;;;;;;;;;
 
-; Use "use" para poder usar todas as funções de um modulo
+; Você pode usar a função use para carregar todas as funções de um módulo.
 (use 'clojure.set)
 
-; Agora nós podemos usar operações com conjuntos
+; Agora nós podemos usar operações de conjuntos definidas nesse módulo:
 (intersection #{1 2 3} #{2 3 4}) ; => #{2 3}
 (difference #{1 2 3} #{2 3 4}) ; => #{1}
 
-; Você pode escolher um subconjunto de funções para importar
-(use '[clojure.set :only [intersection]])
-
-; Use require para importar um módulo
+; Isso porém não é uma boa prática pois dificulta saber de qual módulo cada função
+; veio, além de expor o código a conflitos de nomes, caso dois módulos diferentes
+; definam funções com o mesmo nome. A melhor forma de referenciar módulos é por meio
+; de require:
 (require 'clojure.string)
 
-; Use / para chamar funções de um módulo
+; Com isso podemos chamar as funções de clojure.string usando o operador /
 ; Aqui, o módulo é clojure.string e a função é blank?
 (clojure.string/blank? "") ; => true
 
-; Você pode dar para um módulo um nome mais curto no import
+; Porém isso não é muito prático, por isso é possível dar para um nome mais curto para
+; o módulo ao carregá-lo:
 (require '[clojure.string :as str])
-(str/replace "This is a test." #"[a-o]" str/upper-case) ; => "THIs Is A tEst."
-; (#"" denota uma expressão regular literal)
+(str/replace "alguém quer teste?" #"[aeiou]" str/upper-case) ; => "AlgUém qUEr tEstE?"
 
-; Você pode usar require (e até "use", mas escolha require) de um namespace utilizando :require.
-; Não é necessário usar aspa simples nos seus módulos se você usar desse jeito.
+; Nesse exemplo usamos também a construção #"", que delimita uma expressão regular.
+
+; É possível carregar outros módulos direto na definição do namespace. Note que nesse
+; contexto não é preciso usar ' antes do vetor que define a importação do módulo.
 (ns test
   (:require
     [clojure.string :as str]
     [clojure.set :as set]))
 
+
+; Operadores thread
+;;;;;;;;;;;;;;;;;
+
+; Uma das funções mais interessantes de clojure são os operadores -> e ->> - respectivamente
+; thread-first e thread-last macros. Elas permitem o encadeamento de chamadas de funções,
+; sendo perfeitas para melhorar a legibilidade em transformações de dados.
+
+; -> usa o resultado de uma chamada como o primeiro argumento da chamada à função seguinte:
+(-> "  uMa   StRIng com! aLG_uNs  ##problemas. "
+    (str/replace #"[!#_]" "")
+    (str/replace #"\s+" " ")
+    str/trim          ; se a função só aceitar um argumento, não é preciso usar parênteses
+    (str/lower-case)) ; => "uma string com alguns problemas."
+
+; Na thread uma string com vários problemas foi passada como primeiro argumento à função
+; str/replace, que criou uma nova string, a partir da original, porém somente com caracteres
+; alfabéticos. Essa nova string foi passada como primeiro argumento para a chamada str/replace
+; seguinte, que criou uma nova string sem espaços duplos. Essa nova string foi então passada
+; como primeiro argumento para str/trim, que removeu espaços de seu início e fim, passando essa
+; última string para str/lower-case, que a converteu para caracteres em caixa baixa.
+
+; ->> é equivalente a ->, porém o retorno de cada função é passado como último argumento da
+; função seguinte. Isso é particularmente útil para lidar com seqs, já que as funções que
+; as manipulam sempre as tomam como último argumento.
+(->> '(1 2 3 4)
+     (filter even?) ; => '(2 4)
+     (map inc)      ; => '(3 5)
+     (reduce *))    ; => 15
+
+
 ; Java
 ;;;;;;;;;;;;;;;;;
 
-; Java tem uma biblioteca padrão enorme e muito útil, 
-; portanto é importante aprender como utiliza-la.
+; A biblioteca padrão de Java é enorme e possui inúmeros algoritmos e estruturas de
+; dados já implementados. Por isso é bastante conveniente saber como usá-la dentro
+; de Clojure.
 
-; Use import para carregar um modulo java
+; Use import para carregar um módulo Java.
 (import java.util.Date)
 
-; Você pode importar usando ns também.
+; Você pode importar classes Java dentro de ns também:
 (ns test
   (:import java.util.Date
-           java.util.Calendar))
+           java.util.Calendar
+           java.util.ArrayList))
 
 ; Use o nome da clase com um "." no final para criar uma nova instância
-(Date.) ; <a date object>
+(def instante (Date.))
+(class instante) => ; java.util.Date
+
+; Para chamar um método, use o operador . com o nome do método. Outra forma é
+; usar simplesmente .<nome do método>
+(. instante getTime) ; => retorna um inteiro representando o instante
+(.getTime instante) ; => exatamente o mesmo que acima
 
-; Use . para chamar métodos. Ou, use o atalho ".method"
-(. (Date.) getTime) ; <a timestamp>
-(.getTime (Date.)) ; exatamente a mesma coisa.
+; Para chamar métodos estáticos dentro de classes Java, use /
+(System/currentTimeMillis) ; => retorna um timestamp
 
-; Use / para chamar métodos estáticos
-(System/currentTimeMillis) ; <a timestamp> (o módulo System está sempre presente)
+; Note que não é preciso importar o módulo System, pois ele está sempre presente
+
+; Caso queira submeter uma instância de uma classe mutável a uma sequência de operações,
+; você pode usar a função doto. Ela é funciona de maneira semelhante à função -> - ou
+; thread-first -, exceto pelo fato de que ele opera com valores mutáveis.
+(doto (java.util.ArrayList.)
+  (.add 11)
+  (.add 3)
+  (.add 7)
+  (java.util.Collections/sort)) ; => #<ArrayList [3, 7, 11]>
 
-; Use doto para pode lidar com classe (mutáveis) de forma mais tolerável
-(import java.util.Calendar)
-(doto (Calendar/getInstance)
-  (.set 2000 1 1 0 0 0)
-  .getTime) ; => A Date. set to 2000-01-01 00:00:00
 
 ; STM
 ;;;;;;;;;;;;;;;;;
 
-; Software Transactional Memory é o mecanismo que Clojure usa para gerenciar
-; estado persistente. Tem algumas construções em Clojure que o utilizam.
+; Até aqui usamos def para associar nomes a valores. Isso, no entanto, possui algumas
+; limitações, já que, uma vez definido essa associação, não podemos alterar o valor
+; para o qual um nome aponta. Isso significa que nomes definidos com def não se
+; comportam como as variáveis de outras linguagens.
+
+; Para lidar com estado persistente e mutação de valores, Clojure usa o mecanismo Software
+; Transactional Memory. O atom é o mais simples de todos. Passe pra ele um valor inicial e
+; e ele criará um objeto que é seguro de atualizar:
+(def atom-mapa (atom {}))
+
+; Para acessar o valor de um atom, você pode usar a função deref ou o operador @: 
+@atom-mapa ; => {}
+(deref atom-mapa) ; => {}
 
-; O atom é o mais simples. Passe pra ele um valor inicial
-(def my-atom (atom {}))
+; Para mudar o valor de um atom, você deve usar a função swap!
+; O que ela faz é chamar a função passada usando o atom como seu primeiro argumento. Com
+; isso, ela altera o valor do atom de maneira segura. 
+(swap! atom-mapa assoc :a 1) ; Atribui a atom-mapa o resultado de (assoc {} :a 1)
+(swap! atom-mapa assoc :b 2) ; Atribui a atom-mapa o resultado de (assoc {:a 1} :b 2)
 
-; Atualize o atom com um swap!.
-; swap! pega uma função e chama ela com o valor atual do atom
-; como primeiro argumento, e qualquer argumento restante como o segundo
-(swap! my-atom assoc :a 1) ; Coloca o valor do átomo my-atom como o resultado de  (assoc {} :a 1)
-(swap! my-atom assoc :b 2) ; Coloca o valor do átomo my-atom como o resultado de (assoc {:a 1} :b 2)
+; Observe que essas chamadas alteraram de fato o valor de atom-mapa. Seu novo valor é:
+@atom-mapa ; => {:a 1 :b 2}
 
-; Use '@' para desreferenciar um atom e acessar seu valor
-my-atom  ;=> Atom<#...> (Retorna o objeto do Atom)
-@my-atom ; => {:a 1 :b 2}
+; Isso é diferente de fazer:
+(def atom-mapa-2 (atom {}))
+(def atom-mapa-3 (assoc @atom-mapa-2 :a 1))
 
-; Abaixo um contador simples usando um atom
-(def counter (atom 0))
-(defn inc-counter []
-  (swap! counter inc))
+; Nesse exemplo, atom-mapa-2 permanece com o seu valor original e é gerado um novo mapa,
+; atom-mapa-3, que contém o valor de atom-mapa-2 atualizado. Note que atom-mapa-3 é um
+; simples mapa, e não uma instância de um atom
+@atom-mapa-2 ; => {}
+atom-mapa-3 ; => {:a 1}
 
-(inc-counter)
-(inc-counter)
-(inc-counter)
-(inc-counter)
-(inc-counter)
+(class atom-mapa-2) ; => clojure.lang.Atom
+(class atom-mapa-3) ; => clojure.lang.PersistentArrayMap
 
-@counter ; => 5
+; A ideia é que o valor do atom só será atualizado se, após ser executada a função passada
+; para swap!, o atom ainda estiver com o mesmo valor de antes. Isto é, se durante a execução
+; da função alguém alterar o valor do atom, swap! reexecutará a função recebida usando o valor
+; atual do átoma como argumento.
 
-; Outras construção STM são refs e agents.
+; Isso é ótimo em situações nas quais é preciso garantir a consistência de algum valor - tais
+; como sistemas bancários e sites de compra. Para mais exemplos e informações sobre outras
+; construções STM:
+
+; Exemplos e aplicações: https://www.braveclojure.com/zombie-metaphysics/
 ; Refs: http://clojure.org/refs
 ; Agents: http://clojure.org/agents
 ```
 
 ### Leitura adicional
 
-Esse tutorial está longe de ser exaustivo, mas deve ser suficiente para que você possa começar.
+Esse tutorial está longe de ser completo, mas deve ser suficiente para que você possa dar seus primeiros passos em Clojure.
+Caso queira aprender mais:
 
-Clojure.org tem vários artigos:
+* clojure.org tem vários artigos:
 [http://clojure.org/](http://clojure.org/)
 
-Clojuredocs.org tem documentação com exemplos para quase todas as funções principais (pertecentes ao core):
+* Brave Clojure possui um e-book que explora em profundidade diversos recursos de clojure, incluindo ótimos exemplos:
+[https://www.braveclojure.com/](https://www.braveclojure.com/)
+
+* clojuredocs.org tem documentação com exemplos para quase todas as funções principais (pertecentes ao core):
 [http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core)
 
-4Clojure é um grande jeito de aperfeiçoar suas habilidades em Clojure/Programação Funcional:
+* 4clojure possui alguns problemas e desafios interessantes para quem quiser treinar clojure ou programação funcional:
 [http://www.4clojure.com/](http://www.4clojure.com/)
 
-Clojure-doc.org tem um bom número de artigos para iniciantes:
+* clojure-doc.org tem um bom número de artigos para iniciantes:
 [http://clojure-doc.org/](http://clojure-doc.org/)
-- 
cgit v1.2.3


From 05018243abce940afe4e221054759d588e812342 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andr=C3=A9=20de=20Santa?= <andredesanta20@gmail.com>
Date: Thu, 24 Oct 2019 12:20:33 -0300
Subject: Fix language typos in clojure-macros-pt.html.markdown

---
 pt-br/clojure-macros-pt.html.markdown | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/clojure-macros-pt.html.markdown b/pt-br/clojure-macros-pt.html.markdown
index d56840e0..c686bb80 100644
--- a/pt-br/clojure-macros-pt.html.markdown
+++ b/pt-br/clojure-macros-pt.html.markdown
@@ -13,15 +13,15 @@ do Clojure lhe dá acesso a toda a extensão da linguagem
 para escrever rotinas de geração de código chamados "macros". Macros fornecem uma poderosa forma de adequar a linguagem 
 às suas necessidades.
 
-Pórem Tenha cuidado. É considerado má pratica escrever uma macro quando uma função vai fazer. Use uma macro apenas 
-quando você precisar do controle sobre quando ou se os argumentos para um formulário será avaliado.
+Pórem, tenha cuidado. É considerado má pratica escrever uma macro quando uma função vai fazer. Use uma macro apenas 
+quando você precisar de controle sobre quando ou se os argumentos de um formulário serão avaliados.
 
 Você vai querer estar familiarizado com Clojure. Certifique-se de entender tudo em 
-[Clojure em Y Minutos](/docs/clojure/).
+[Aprenda Clojure em Y Minutos](/docs/clojure/).
 
 ```clojure
-;; Defina uma macro utilizando defmacro. Sua macro deve ter como saida uma lista que possa
-;; ser avaliada como codigo Clojure.
+;; Defina uma macro utilizando defmacro. Sua macro deve ter como saída uma lista que possa
+;; ser avaliada como código Clojure.
 ;;
 ;; Essa macro é a mesma coisa que se você escrever (reverse "Hello World")
 (defmacro my-first-macro []
@@ -33,14 +33,14 @@ Você vai querer estar familiarizado com Clojure. Certifique-se de entender tudo
 (macroexpand '(my-first-macro))
 ;; -> (#<core$reverse clojure.core$reverse@xxxxxxxx> "Hello World")
 
-;; Você pode avaliar o resultad de macroexpand diretamente:
+;; Você pode avaliar o resultado de macroexpand diretamente:
 (eval (macroexpand '(my-first-macro)))
 ; -> (\d \l \o \r \W \space \o \l \l \e \H)
 
-;; mas você deve usar esse mais suscinto, sintax como de função:
+;; mas você deve usar essa sintaxe mais sucinta e familiar a funções:
 (my-first-macro)  ; -> (\d \l \o \r \W \space \o \l \l \e \H)
 
-;; Você pode tornar as coisas mais faceis pra você, utilizando a sintaxe de citação mais suscinta
+;; Você pode tornar as coisas mais fáceis pra você, utilizando a sintaxe de citação mais suscinta
 ;; para criar listas nas suas macros:
 (defmacro my-first-quoted-macro []
   '(reverse "Hello World"))
-- 
cgit v1.2.3


From 68083173eca275cbb4f9e068ab47812786146797 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andr=C3=A9=20de=20Santa?= <andredesanta20@gmail.com>
Date: Thu, 24 Oct 2019 13:22:35 -0300
Subject: Add "Clojure for the Brave and True" resource

---
 pt-br/clojure-pt.html.markdown | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'pt-br')

diff --git a/pt-br/clojure-pt.html.markdown b/pt-br/clojure-pt.html.markdown
index b88d4eec..409394f2 100644
--- a/pt-br/clojure-pt.html.markdown
+++ b/pt-br/clojure-pt.html.markdown
@@ -382,3 +382,6 @@ Clojuredocs.org tem documentação com exemplos para quase todas as funções pr
 
 Clojure-doc.org tem um bom número de artigos para iniciantes:
 [http://clojure-doc.org/](http://clojure-doc.org/)
+
+Clojure for the Brave and True é um livro de introdução ao Clojure e possui uma versão gratuita online:
+[https://www.braveclojure.com/clojure-for-the-brave-and-true/](https://www.braveclojure.com/clojure-for-the-brave-and-true/)
-- 
cgit v1.2.3


From f47496b08327441eb3d6e553ce80efdd16fddc82 Mon Sep 17 00:00:00 2001
From: Felipe N Souza <fnscoder@gmail.com>
Date: Sat, 26 Oct 2019 21:39:37 -0300
Subject: [Python/pt-br] Improve translation

---
 pt-br/python3-pt.html.markdown | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/python3-pt.html.markdown b/pt-br/python3-pt.html.markdown
index b72c732a..c8b234f6 100644
--- a/pt-br/python3-pt.html.markdown
+++ b/pt-br/python3-pt.html.markdown
@@ -11,11 +11,11 @@ lang: pt-br
 filename: learnpython3-pt.py
 ---
 
-Python foi criado por Guido Van Rossum nos anos 1990. Ele é atualmente uma
-das mais populares linguagens em existência. Eu fiquei morrendo de amor
-pelo Python por sua clareza sintática. É praticamente pseudocódigo executável.
+Python foi criada por Guido Van Rossum nos anos 1990. Ela é atualmente uma
+das linguagens mais populares existentes. Eu me apaixonei por
+Python por sua clareza sintática. É praticamente pseudocódigo executável.
 
-Suas opiniões são grandemente apreciadas. Você pode encontrar-me em
+Opniões são muito bem vindas. Você pode encontrar-me em
 [@louiedinh](http://twitter.com/louiedinh) ou louiedinh [em]
 [serviço de e-mail do google].
 
-- 
cgit v1.2.3


From daa3502767283a3fd0922d2e5cde2bdb779328b0 Mon Sep 17 00:00:00 2001
From: Raul Almeida <36135994+almeidaraul@users.noreply.github.com>
Date: Tue, 29 Oct 2019 15:26:15 -0300
Subject: Add command tips and examples, fix wild text

Added information under "Alguns atalhos e dicas" and "Macros"; removed some wild text in the header (essentially, one of the contributors was one of vim's modes)
---
 pt-br/vim-pt.html.markdown | 11 +++++++++++
 1 file changed, 11 insertions(+)

(limited to 'pt-br')

diff --git a/pt-br/vim-pt.html.markdown b/pt-br/vim-pt.html.markdown
index d7617bbe..cc304381 100644
--- a/pt-br/vim-pt.html.markdown
+++ b/pt-br/vim-pt.html.markdown
@@ -5,6 +5,7 @@ contributors:
     - ["RadhikaG", "https://github.com/RadhikaG"]
 translators:
     - ["David Lima", "https://github.com/davelima"]
+    - ["Raul Almeida", "https://github.com/almeidaraul"]
 lang: pt-br
 filename: LearnVim-pt.txt
 ---
@@ -24,6 +25,7 @@ para agilizar a navegação para pontos específicos no arquivo, além de ediç
     :w               # Salva o arquivo atual
     :wq              # Salva o arquivo e fecha o vim
     :q!              # Fecha o vim e descarta as alterações no arquivo
+                     # ! depois de qualquer comando força a sua execução
                      # ! *força* :q a executar, fechando o vim sem salvar antes
     :x               # Salva o arquivo e fecha o vim (atalho para :wq)
 
@@ -158,7 +160,15 @@ Alguns exemplos importantes de 'Verbos', 'Modificadores' e 'Nomes':
     :earlier 15m     # Reverte o documento para como ele estava há 15 minutos atrás
     :later 15m       # Reverte o comando acima
     ddp              # Troca linhas consecutivas de posição, dd e depois p
+    xp               # Permuta caractere atual e o seguinte
+    Xp               # Permuta caractere atual e o anterior
     .                # Repete a última ação
+
+    # Em geral, o usuário pode associar um comando em maísculas (exemplo: D) com
+    # "executar este comando até o final da linha"
+
+    # Usar a tecla de um comando duas vezes geralmente significa executar este 
+    # comando sobre toda a linha (exemplo: dd apaga a linha inteira)
 ```
 
 ## Macros
@@ -172,6 +182,7 @@ exatamente a mesma sequencia de ações e comandos na seleção atual.
     qa               # Inicia a gravação de uma macro chamado 'a'
     q                # Para a gravação
     @a               # Executa a macro
+    @@               # Executa a última macro executada
 ```
 
 ### Configurando o ~/.vimrc
-- 
cgit v1.2.3


From 87b2be61024a7ccc1e8cb66a3b8e1cccffb8deee Mon Sep 17 00:00:00 2001
From: Raul Almeida <36135994+almeidaraul@users.noreply.github.com>
Date: Tue, 29 Oct 2019 19:53:29 -0300
Subject: Update contributors in pascal-pt

I translated this a while back and decided to add myself as a contributor besides a translator because I changed much of the original text to what I feel is a more legible, better explanation of the Pascal language.
---
 pt-br/pascal-pt.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'pt-br')

diff --git a/pt-br/pascal-pt.html.markdown b/pt-br/pascal-pt.html.markdown
index 3a37271a..749b2d0d 100644
--- a/pt-br/pascal-pt.html.markdown
+++ b/pt-br/pascal-pt.html.markdown
@@ -4,6 +4,7 @@ filename: learnpascal-pt.pas
 contributors:
     - ["Ganesha Danu", "https://github.com/blinfoldking"]
     - ["Keith Miyake", "https//github.com/kaymmm"]
+    - ["Raul Almeida", "https://github.com/almeidaraul"]
 translators:
     - ["Raul Almeida", "https://github.com/almeidaraul"]
 lang: pt-br
-- 
cgit v1.2.3


From cb5ef7349db00a36f9ea268a7490f3ba79d0ecd8 Mon Sep 17 00:00:00 2001
From: bfmonique <42034934+bfmonique@users.noreply.github.com>
Date: Tue, 29 Oct 2019 20:02:08 -0300
Subject: Fix markdown-pt portuguese mistakes

---
 pt-br/markdown-pt.html.markdown | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/markdown-pt.html.markdown b/pt-br/markdown-pt.html.markdown
index c2aa515d..1a26e406 100644
--- a/pt-br/markdown-pt.html.markdown
+++ b/pt-br/markdown-pt.html.markdown
@@ -4,6 +4,7 @@ contributors:
     - ["Dan Turkel", "http://danturkel.com/"]
 translators:
     - ["Miguel Araújo", "https://github.com/miguelarauj1o"]
+    - ["Monique Baptista", "https://github.com/bfmonique"]
 lang: pt-br    
 filename: learnmarkdown-pt.md
 ---
@@ -15,19 +16,19 @@ Dê-me feedback tanto quanto você quiser! / Sinta-se livre para a garfar (fork)
 puxar o projeto (pull request)
 
 ```md
-<!-- Markdown é um superconjunto do HTML, de modo que qualquer arvquivo HTML é 
-um arquivo Markdown válido, isso significa que nós podemos usar elementos HTML 
+<!-- Markdown é um superconjunto do HTML, de modo que qualquer arquivo HTML é 
+um arquivo Markdown válido. Isso significa que nós podemos usar elementos HTML 
 em Markdown, como o elemento de comentário, e eles não serão afetados pelo analisador
 de remarcação. No entanto, se você criar um elemento HTML em seu arquivo Markdown, você
-não pode usar sintaxe remarcação dentro desse conteúdo do elemento.-->
+não pode usar sintaxe de remarcação dentro desse conteúdo do elemento.-->
 
-<!--Markdown também varia de implementação de um analisador para uma próxima.
+<!--A maneira como o Markdown é analisado varia de software para software.
 Este guia vai tentar esclarecer quando as características são universais, ou quando eles são 
-específico para um determinado parser -->
+específico para um determinado interpretador -->
 
 <!-- Cabeçalhos -->
 <!-- Você pode criar elementos HTML <h1> até <h6> facilmente antecedendo o texto
-que deseja estar nesse elemento por um número de hashes (#) -->
+que deseja estar nesse elemento por um número de cerquilhas (#) -->
 # Isto é um cabeçalho <h1>
 ## Isto é um cabeçalho <h2>
 ### Isto é um cabeçalho <h3>
@@ -65,7 +66,7 @@ uma ou múltiplas linhas em branco. -->
 
 Este é um parágrafo. Eu estou digitando em um parágrafo, não é legal?
 
-Agora, eu estou no parágrado 2.
+Agora, eu estou no parágrafo 2.
 ... Ainda continuo no parágrafo 2! :)
 
 Eu estou no parágrafo três.
@@ -111,7 +112,7 @@ ou
 
 1. Item um
 2. Item dois
-3. Tem três
+3. Item três
 
 <!-- Você não tem poder para rotular os itens corretamente e a remarcação será ainda
 tornar os números em ordem, mas isso pode não ser uma boa idéia -->
-- 
cgit v1.2.3


From 53488ee57128a653f7a4d65d9abc9e11dc69ede7 Mon Sep 17 00:00:00 2001
From: bfmonique <42034934+bfmonique@users.noreply.github.com>
Date: Tue, 29 Oct 2019 20:09:46 -0300
Subject: Fix python3-pt portuguese mistakes

---
 pt-br/python3-pt.html.markdown | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/python3-pt.html.markdown b/pt-br/python3-pt.html.markdown
index b72c732a..23a9b3ce 100644
--- a/pt-br/python3-pt.html.markdown
+++ b/pt-br/python3-pt.html.markdown
@@ -7,6 +7,7 @@ contributors:
     - ["Zachary Ferguson", "http://github.com/zfergus2"]
 translators:
     - ["Paulo Henrique Rodrigues Pinheiro", "http://www.sysincloud.it"]
+    - ["Monique Baptista", "https://github.com/bfmonique"]
 lang: pt-br
 filename: learnpython3-pt.py
 ---
@@ -44,7 +45,7 @@ aprender o velho Python 2.7.
 8 - 1   # => 7
 10 * 2  # => 20
 
-# Números inteiros por padrão, exceto na divisão, que retorna número
+# Números são inteiros por padrão, exceto na divisão, que retorna número
 # de ponto flutuante (float).
 35 / 5  # => 7.0
 
@@ -64,7 +65,7 @@ aprender o velho Python 2.7.
 # Exponenciação (x**y, x elevado à potência y)
 2**4  # => 16
 
-# Determine a precedência usando parêntesis
+# Determine a precedência usando parênteses
 (1 + 3) * 2  # => 8
 
 # Valores lógicos são primitivos (Atenção à primeira letra maiúscula)
@@ -105,9 +106,8 @@ False or True   # => True
 1 < 2 < 3  # => True
 2 < 3 < 2  # => False
 
-# (operador 'is' e operador '==') is verifica se duas variáveis
-# referenciam um mesmo objeto, mas == verifica se as variáveis
-# apontam para o mesmo valor.
+# 'is' verifica se duas variáveis representam o mesmo endereço
+# na memória; '==' verifica se duas variáveis têm o mesmo valor
 a = [1, 2, 3, 4]  # Referência a uma nova lista, [1, 2, 3, 4]
 b = a             # b referencia o que está referenciado por a
 b is a            # => True, a e b referenciam o mesmo objeto
@@ -174,7 +174,7 @@ input_string_var = input("Digite alguma coisa: ") # Retorna o que foi digitado e
 # Observação: Em versões antigas do Python, o método input() era chamado raw_input()
 
 # Não é necessário declarar variáveis antes de iniciá-las
-# È uma convenção usar letras_minúsculas_com_sublinhados
+# É uma convenção usar letras_minúsculas_com_sublinhados
 alguma_variavel = 5
 alguma_variavel  # => 5
 
@@ -182,31 +182,31 @@ alguma_variavel  # => 5
 # Veja Controle de Fluxo para aprender mais sobre tratamento de exceções.
 alguma_variavel_nao_inicializada  # Gera a exceção NameError
 
-# Listas armazenam sequencias
+# Listas armazenam sequências
 li = []
-# Você pode iniciar com uma lista com alguns valores
+# Você pode iniciar uma lista com valores
 outra_li = [4, 5, 6]
 
-# Adicionar conteúdo ao fim da lista com append
+# Adicione conteúdo ao fim da lista com append
 li.append(1)    # li agora é [1]
 li.append(2)    # li agora é [1, 2]
 li.append(4)    # li agora é [1, 2, 4]
 li.append(3)    # li agora é [1, 2, 4, 3]
-# Remover do final da lista com pop
+# Remova do final da lista com pop
 li.pop()        # => 3 e agora li é [1, 2, 4]
 # Vamos colocá-lo lá novamente!
 li.append(3)    # li agora é [1, 2, 4, 3] novamente.
 
-# Acessar uma lista da mesma forma que você faz com um array
+# Acesse uma lista da mesma forma que você faz com um array
 li[0]   # => 1
-# Acessa o último elemento
+# Acessando o último elemento
 li[-1]  # => 3
 
-# Acessando além dos limites gera um IndexError
+# Acessar além dos limites gera um IndexError
 li[4]  # Gera o IndexError
 
 # Você pode acessar vários elementos com a sintaxe de limites
-# (É um limite fechado, aberto pra você que gosta de matemática.)
+# Inclusivo para o primeiro termo, exclusivo para o segundo
 li[1:3]   # => [2, 4]
 # Omitindo o final
 li[2:]    # => [4, 3]
-- 
cgit v1.2.3


From 21a5423b2b91f3c97e67bf7661028d07afc35f32 Mon Sep 17 00:00:00 2001
From: Gabriele Luz <gabrieleluz@infojr.com.br>
Date: Sun, 2 Feb 2020 06:46:35 -0300
Subject: [markdown/pt-br] formatting adjustments (#3738)

---
 pt-br/markdown-pt.html.markdown | 199 ++++++++++++++++++++++++++++------------
 1 file changed, 139 insertions(+), 60 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/markdown-pt.html.markdown b/pt-br/markdown-pt.html.markdown
index 63afffd5..dc50cac1 100644
--- a/pt-br/markdown-pt.html.markdown
+++ b/pt-br/markdown-pt.html.markdown
@@ -4,7 +4,9 @@ contributors:
     - ["Dan Turkel", "http://danturkel.com/"]
 translators:
     - ["Miguel Araújo", "https://github.com/miguelarauj1o"]
+    - ["Gabriele Luz", "https://github.com/gabrieleluz"]
     - ["Monique Baptista", "https://github.com/bfmonique"]
+
 lang: pt-br    
 filename: learnmarkdown-pt.md
 ---
@@ -15,6 +17,9 @@ escrever sintaxe que converte facilmente em HTML (hoje, suporta outros formatos
 Dê-me feedback tanto quanto você quiser! / Sinta-se livre para fazer uma bifurcação (fork) e 
 puxar o projeto (pull request)
 
+## Elementos HTML
+Markdown é um superconjunto do HTML, de modo que qualquer arvquivo HTML é 
+um arquivo Markdown válido.
 ```md
 <!-- Markdown é um superconjunto do HTML, de modo que qualquer arquivo HTML é 
 um arquivo Markdown válido. Isso significa que nós podemos usar elementos HTML 
@@ -23,29 +28,36 @@ de remarcação. No entanto, se você criar um elemento HTML em seu arquivo Mark
 não pode usar sintaxe de remarcação dentro desse conteúdo do elemento.-->
 
 <!--A maneira como o Markdown é analisado varia de software para software.
-Este guia vai tentar esclarecer quando as características são universais, ou quando eles são 
-específico para um determinado interpretador -->
+Este guia vai tentar esclarecer quando as características são universais, ou quando eles são específicos para um determinado interpretador -->
+
+
+## Cabeçalhos
+
+Você pode criar elementos HTML `<h1>` até `<h6>` facilmente antecedendo o texto
+que deseja estar nesse elemento por um número de hashes (#)
 
-<!-- Cabeçalhos -->
-<!-- Você pode criar elementos HTML <h1> até <h6> facilmente antecedendo o texto
-que deseja estar nesse elemento por um número de cerquilhas (#) -->
 # Isto é um cabeçalho <h1>
 ## Isto é um cabeçalho <h2>
 ### Isto é um cabeçalho <h3>
 #### Isto é um cabeçalho <h4>
 ##### Isto é um cabeçalho <h5>
 ###### Isto é um cabeçalho <h6>
+```
 
-<!-- Markdown também nos fornece duas maneiras alternativas de indicar h1 e h2 -->
+Markdown também nos fornece duas maneiras alternativas de indicar h1 e h2
+
+```md
 Isto é um cabeçalho h1
 ======================
 
 Isto é um cabeçalho h2
 ----------------------
+```
 
-<!-- Estilos de texto simples --> 
-<!-- O texto pode ser facilmente denominado como remarcação itálico, negrito ou tachado usando -->
+## Estilos de texto simples
+O texto pode ser facilmente denominado como marcação itálico, negrito ou tachado usando:
 
+```md
 *Este texto está em itálico*
 _E este também está._
 
@@ -55,31 +67,41 @@ __E este também está._
 ***Este texto está em negrito e itálico.***
 **_E este também está_**
 *--Danouse! Este também__*
+```
 
-<!-- Em GitHub Flavored Markdown, que é usado para processar arquivos Markdown 
-GitHub, nós também temos: --> 
+Em GitHub Flavored Markdown, que é usado para processar arquivos Markdown 
+GitHub, nós também temos:
 
+```md
 ~~Este texto é processado com tachado.~~
+```
 
-<!-- Os parágrafos estão uma ou várias linhas adjacentes de texto separadas por 
-uma ou múltiplas linhas em branco. -->
+## Parágrafos
+Os parágrafos estão uma ou várias linhas adjacentes de texto separadas por 
+uma ou múltiplas linhas em branco.
 
+```md
 Este é um parágrafo. Eu estou digitando em um parágrafo, não é legal?
 
 Agora, eu estou no parágrafo 2.
 ... Ainda continuo no parágrafo 2! :)
 
 Eu estou no parágrafo três.
+```
 
-<!-- Se você quiser inserir uma tag HTML <br />, você pode acabar com um parágrafo 
-com dois ou mais espaços e, em seguida, começar um novo parágrafo -->
+Se você quiser inserir uma tag HTML `<br />`, você pode acabar com um parágrafo 
+com dois ou mais espaços e, em seguida, começar um novo parágrafo
 
+```md
 Termino com dois espaços (destacar-me para vê-los). 
 
 Há um <br /> acima de mim!
+```
 
-<!-- Bloco de citações são fáceis e feitos com o caractere >. -->
-	
+
+Bloco de citações são fáceis e feito com o caractere >.
+
+```md
 > Este é um bloco de citação. Você pode 
 > Quebrar manualmente suas linhas e colocar um `>` antes de cada linha ou você pode
 > deixar suas linhas ficarem muito longas e quebrarem por conta própria. Não faz diferença, 
@@ -87,12 +109,13 @@ Há um <br /> acima de mim!
 	
 
 > Você também pode usar mais de um nível 
->> De recuo? 
-> Como pura é isso?
+>> De recuo?
+```
 
-<!-- Listas --> 
-<!-- As listas não ordenadas podem ser feitas usando asteriscos, soma ou hífens -->
+## Listas
+As listas não ordenadas podem ser feitas usando asteriscos, positivos ou hífens
 
+```md
 * Item
 * Item
 * Outro item
@@ -108,50 +131,83 @@ ou
 - Item
 - Item
 - Um último item
+```
 
-<!-- Listas ordenadas são feitas com um número seguido por um ponto -->
+Listas ordenadas são feitas com um número seguido por um ponto.
 
+```md
 1. Item um
 2. Item dois
 3. Item três
+```
 
 <!-- Você não tem poder para rotular os itens corretamente e a remarcação ainda deixará os 
 itens em ordem, mas isso pode não ser uma boa idéia -->
 
+
+```md
 1. Item um
 1. Item dois
 1. Item três
-<!-- (Isto é processado da mesma forma que o exemplo acima) -->
+```
+(Isto é processado da mesma forma que o exemplo acima)
 
-<!-- Você também pode usar subtítulos -->
+Você também pode usar sublistas
 
+```md
 1. Item um
 2. Item dois
 3. Item três
     * Sub-item
     * Sub-item
 4. Item quatro
+```
+
+Existem também listas de tarefas. Isso cria checkboxes (caixas de seleção) de HTML
+
+```md
+As caixas abaixo sem o 'x' são checkboxes HTML desmarcadas
+- [ ] Primeira tarefa a completar
+- [ ] Segunda tarefa a completar
+A caixa de seleção abaixo será exibida como uma checkbox HTML marcada
+- [x] Essa tarefa foi completa
+
+```
 
-<!-- blocos de código --> 
-<!-- Você pode indicar um bloco de código (que utiliza o elemento <code>) pelo recuo
-uma linha com quatro espaços ou uma guia -->
 
+## Blocos de código
+Você pode indicar um bloco de código (que utiliza o elemento `<code>`) pelo recuo
+uma linha com quatro espaços ou uma guia
+```md
 	Isto é código
 	É assim, sacou?
+	
+```
 
-<!-- Você pode também tabular (ou adicionar mais quatro espaços adicionais) para o recuo 
-dentro do seu código -->
+Você pode também re-guia (ou adicionar mais quatro espaços adicionais) para o recuo 
+dentro do seu código
 
+```md
 	my_array.each do |item|
         puts item
     end	
+ ```
 
-<!-- Código embutido pode ser criado usando o caractere de crase ` -->
-
-John não sabia nem o que o função 'goto()' fazia!
+Código embutido pode ser criada usando o caractere de crase `` ` ``
 
-<!-- Em GitHub Flavored Markdown, você pode usar uma sintaxe especial para o código -->
+```md
+John não sabia nem o que o função `goto()` fazia!
+```
 
+Em GitHub Flavored Markdown, você pode usar uma sintaxe especial para o código
+```md
+	``` ruby
+	def foobar
+    	puts "Hello world!"
+	end
+	```
+```
+=======
 \`\`\`ruby <!-- exceto remover essas barras invertidas quando você faz isso, apenas ```
 ruby! --> 
 def foobar
@@ -159,95 +215,118 @@ def foobar
 end
 \`\`\` <!-- Aqui também, não use barras invertidas, apenas ``` -->
 
-<-- O texto acima não requer recuo, mas o GitHub vai usar a sintaxe 
-destacando do idioma que você especificar após a ``` -->
+O texto acima não requer recuo, além disso o GitHub vai usar a sintaxe highlight da linguagem que você especificar após a \`\`\`.
 
-<!-- Regra Horizontal (<hr />) --> 
-<!-- Regras horizontais são facilmente adicionadas com três ou mais asteriscos ou hífens,
-com ou sem espaços. -->
+## Linha Horizontal
+Linhas horizontais são facilmente adicionados com três ou mais asteriscos ou hífens,
+com ou sem espaços.
 
+```md
 ***
 ---
 - - - 
 ****************
+```
 
-<!-- Links --> 
-<!-- Uma das melhores coisas sobre a remarcação é o quão fácil é fazer ligações. Colocar 
-o texto a ser exibido entre parênteses rígidos [] seguido pela url em parênteses () -->
+## Links
+Uma das melhores coisas sobre a marcação é o quão fácil é fazer ligações. Colocar 
+o texto a ser exibido entre parênteses rígidos [] seguido pela url em parênteses ()
 
+```md
 [Click aqui!](http://test.com/)
+```
 
-<!-- Você também pode adicionar um título para o link usando aspas dentro dos parênteses -->
+Você também pode adicionar um título link usando aspas dentro dos parênteses
 
+```md
 [Click aqui!](http://test.com/ "Link para Test.com")
+```
 
-<!-- Caminhos relativos funcionam também. -->
+Caminhos relativos funcionam também.
 
+```md
 [Ir para música](/música/).
+```
 
-<!-- Markdown também suporta ligações de estilo de referência -->
+Markdown também suporta ligações de estilo de referência
 
+```md
 [Clique neste link] [link1] para mais informações sobre isso!
 [Além disso, verifique este link] [foobar] se você quiser.
 
 [link1]: http://test.com/ "Legal!"
 [foobar]: http://foobar.biz/ "OK!"
+```
 
-<!-- O título também pode estar entre aspas simples ou entre parênteses, ou omitido 
+O título também pode estar entre aspas simples ou entre parênteses, ou omitido 
 inteiramente. As referências podem estar em qualquer lugar no documento e os IDs de referência 
-pode ser qualquer um, desde que eles são únicos. -->
+pode ser qualquer um, desde que eles são únicos.
 
-<!-- Existe também o "nomear implícita", que permite que você use o texto do link como o id --> 
+Existe também a "nomeação implicita", que permite que você use o texto do link como o id
 
+```md
 [Este] [] é um link. 
 
 [este]: http://thisisalink.com/ 
+```
 
-<!-- Mas não são usados normalmente--> 
+Mas não são usados normalmente
 
-<!-- Imagens --> 
-<!-- As imagens são feitas da mesma forma que as ligações, mas com um ponto de exclamação na frente! -->
+## Imagens
+As imagens são feitas da mesma forma que as ligações, mas com um ponto de exclamação na frente!
 
+```md
 ![Este é pairar-texto (texto alternativo) para minha imagem](http://imgur.com/myimage.jpg "Um título opcional") 
+```
 
-<!-- E estilo de referência funciona como esperado --> 
+E estilo de referência funciona como esperado
 
+```md
 ![Este é o pairar-texto.][Myimage] 
 
 [myimage]: relative/urls/legal/image.jpg "se você precisa de um título, é aqui" 
+```
 
-<!-- Miscelânea --> 
-<!-- Auto-links --> 
+## Miscelânea 
+### Auto-links 
 
+```md
 <http://testwebsite.com/> é equivalente a 
 [http://testwebsite.com/](http://testwebsite.com/) 
+```
 
-<!-- Auto-links para e-mails --> 
+### Auto-links para e-mails
 
+```md
 <foo@bar.com> 
+```
 
-<!-- Escapando caracteres --> 
+### Escapando caracteres
 
 Quero digitar * Este texto entre asteriscos *, mas eu não quero que ele seja 
 em itálico, então eu faço o seguinte: \*Este texto entre asteriscos \*.
 
-<!-- Tabelas --> 
-<!-- Tabelas estão disponíveis apenas no GitHub Flavored Markdown e são ligeiramente 
-complicadas, mas se você realmente quer: -->
+### Tabelas 
+Tabelas estão disponíveis apenas no GitHub Flavored Markdown e são ligeiramente 
+complicadas, mas se você realmente quer:
+```md
 
 | Col1         | Col2     | Col3          |
 | :----------- | :------: | ------------: |
 | esquerda-alin| Centrado | direita-alinh |
 | blah         | blah     | blah          |
+```
 
-<!-- Ou, para os mesmos resultados -->
+Ou, para os mesmos resultados 
 
+```md
 Col 1 | Col2 | Col3
 :-- | :-: | --:
 Ugh isso é tão feio | faça isto | parar
+```
 
-<!-- O fim! -->
+Fim!
 
-```
+---
 Para mais informações, confira o post oficial de John Gruber de sintaxe [aqui](http://daringfireball.net/projects/markdown/syntax)
 e de Adam Pritchard grande cheatsheet [aqui](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
-- 
cgit v1.2.3


From 1adab9bc3f80d82123987ff34083568030735db7 Mon Sep 17 00:00:00 2001
From: Simon Shine <shreddedglory@gmail.com>
Date: Wed, 12 Feb 2020 04:49:56 +0100
Subject: Rename Python 2 markdown files into 'pythonlegacy'

```
for f in $(find . -iname "*python*" | grep -vE 'python3|git|statcomp'); do
  flegacy=$(echo "$f" | sed 's/python/pythonlegacy/')
  git mv "$f" "$flegacy"
done
```
---
 pt-br/python-pt.html.markdown       | 509 ------------------------------------
 pt-br/pythonlegacy-pt.html.markdown | 509 ++++++++++++++++++++++++++++++++++++
 2 files changed, 509 insertions(+), 509 deletions(-)
 delete mode 100644 pt-br/python-pt.html.markdown
 create mode 100644 pt-br/pythonlegacy-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/python-pt.html.markdown b/pt-br/python-pt.html.markdown
deleted file mode 100644
index 82b70117..00000000
--- a/pt-br/python-pt.html.markdown
+++ /dev/null
@@ -1,509 +0,0 @@
----
-language: python
-contributors:
-    - ["Louie Dinh", "http://ldinh.ca"]
-translators:
-    - ["Vilson Vieira", "http://automata.cc"]
-lang: pt-br
-filename: learnpython-pt.py
----
-
-Python foi criado por Guido Van Rossum no começo dos anos 90. Atualmente é uma
-das linguagens de programação mais populares. Eu me apaixonei por Python, por
-sua clareza de sintaxe. É basicamente pseudocódigo executável.
-
-Comentários serão muito apreciados! Você pode me contactar em
-[@louiedinh](http://twitter.com/louiedinh) ou louiedinh [arroba]
-[serviço de email do google]
-
-Nota: Este artigo usa Python 2.7 especificamente, mas deveria ser aplicável a
-qualquer Python 2.x. Logo haverá uma versão abordando Python 3!
-
-```python
-# Comentários de uma linha começam com cerquilha (ou sustenido)
-""" Strings de várias linhas podem ser escritas
-    usando três ", e são comumente usadas
-    como comentários
-"""
-
-####################################################
-## 1. Tipos de dados primitivos e operadores
-####################################################
-
-# Você usa números normalmente
-3 #=> 3
-
-# Operadores matemáticos são aqueles que você já está acostumado
-1 + 1 #=> 2
-8 - 1 #=> 7
-10 * 2 #=> 20
-35 / 5 #=> 7
-
-# A divisão é um pouco estranha. A divisão de números inteiros arredonda
-# para baixo o resultado, automaticamente
-5 / 2 #=> 2
-
-# Para concertar a divisão, precisamos aprender sobre números de ponto
-# flutuante (conhecidos como 'float').
-2.0     # Isso é um 'float'
-11.0 / 4.0 #=> 2.75 ahhh... muito melhor
-
-# Forçamos a precedência de operadores usando parênteses
-(1 + 3) * 2 #=> 8
-
-# Valores booleanos (ou 'boolean') são também tipos primitivos
-True
-False
-
-# Negamos usando 'not'
-not True #=> False
-not False #=> True
-
-# Testamos igualdade usando '=='
-1 == 1 #=> True
-2 == 1 #=> False
-
-# E desigualdade com '!='
-1 != 1 #=> False
-2 != 1 #=> True
-
-# Mais comparações
-1 < 10 #=> True
-1 > 10 #=> False
-2 <= 2 #=> True
-2 >= 2 #=> True
-
-# As comparações podem ser encadeadas!
-1 < 2 < 3 #=> True
-2 < 3 < 2 #=> False
-
-# Strings são criadas com " ou '
-"Isso é uma string."
-'Isso também é uma string.'
-
-# Strings podem ser somadas (ou melhor, concatenadas)!
-"Olá " + "mundo!" #=> "Olá mundo!"
-
-# Uma string pode ser tratada como uma lista de caracteres
-"Esta é uma string"[0] #=> 'E'
-
-# O caractere % pode ser usado para formatar strings, desta forma:
-"%s podem ser %s" % ("strings", "interpoladas")
-
-# Um jeito novo de formatar strings é usando o método 'format'.
-# Esse método é o jeito mais usado
-"{0} podem ser {1}".format("strings", "formatadas")
-# Você pode usar palavras-chave (ou 'keywords') se você não quiser contar.
-"{nome} quer comer {comida}".format(nome="João", comida="lasanha")
-
-# 'None' é um objeto
-None #=> None
-
-# Não use o operador de igualdade `==` para comparar objetos com 'None'
-# Ao invés disso, use `is`
-"etc" is None #=> False
-None is None  #=> True
-
-# O operador 'is' teste a identidade de um objeto. Isso não é
-# muito útil quando estamos lidando com valores primitivos, mas é
-# muito útil quando lidamos com objetos.
-
-# None, 0, e strings/listas vazias são todas interpretadas como 'False'.
-# Todos os outros valores são 'True'
-0 == False  #=> True
-"" == False #=> True
-
-
-####################################################
-## 2. Variáveis e Coleções
-####################################################
-
-# Imprimir na tela é muito fácil
-print "Eu sou o Python. Prazer em te conhecer!"
-
-
-# Nós não precisamos declarar variáveis antes de usá-las, basta usar!
-alguma_variavel = 5    # A convenção é usar caixa_baixa_com_sobrescritos
-alguma_variavel #=> 5
-
-# Acessar uma variável que não teve nenhum valor atribuído anteriormente é
-# uma exceção.
-# Veja a seção 'Controle' para aprender mais sobre tratamento de exceção.
-outra_variavel  # Gera uma exceção de erro de nome
-
-# 'if' pode ser usado como uma expressão
-"uepa!" if 3 > 2 else 2 #=> "uepa!"
-
-# Listas armazenam sequências de elementos
-lista = []
-# Você pode inicializar uma lista com valores
-outra_lista = [4, 5, 6]
-
-# Adicione elementos no final da lista usando 'append'
-lista.append(1)    # lista é agora [1]
-lista.append(2)    # lista é agora [1, 2]
-lista.append(4)    # lista é agora [1, 2, 4]
-lista.append(3)    # lista é agora [1, 2, 4, 3]
-# Remova elementos do fim da lista usando 'pop'
-lista.pop()        #=> 3 e lista é agora [1, 2, 4]
-# Vamos adicionar o elemento novamente
-lista.append(3)    # lista agora é [1, 2, 4, 3] novamente.
-
-# Acesse elementos de uma lista através de seu índices
-lista[0] #=> 1
-# Acesse o último elemento com índice negativo!
-lista[-1] #=> 3
-
-# Tentar acessar um elemento fora dos limites da lista gera uma exceção
-# do tipo 'IndexError'
-lista[4] # Gera uma exceção 'IndexError'
-
-# Você pode acessar vários elementos ao mesmo tempo usando a sintaxe de
-# limites
-# (Para quem gosta de matemática, isso é um limite fechado/aberto)
-lista[1:3] #=> [2, 4]
-# Você pode omitir o fim se quiser os elementos até o final da lista
-lista[2:] #=> [4, 3]
-# O mesmo para o início
-lista[:3] #=> [1, 2, 4]
-
-# Remova um elemento qualquer de uma lista usando 'del'
-del lista[2] # lista agora é [1, 2, 3]
-
-# Você pode somar listas (obs: as listas originais não são modificadas)
-lista + outra_lista #=> [1, 2, 3, 4, 5, 6]
-
-# Você também pode concatenar usando o método 'extend' (lista será modificada!)
-lista.extend(outra_lista) # Agora lista é [1, 2, 3, 4, 5, 6]
-
-# Para checar se um elemento pertence a uma lista, use 'in'
-1 in lista #=> True
-
-# Saiba quantos elementos uma lista possui com 'len'
-len(lista) #=> 6
-
-
-# Tuplas são iguais a listas, mas são imutáveis
-tup = (1, 2, 3)
-tup[0] #=> 1
-tup[0] = 3  # Isso gera uma exceção do tipo TypeError
-
-# Você pode fazer nas tuplas todas aquelas coisas fez com a lista
-len(tup) #=> 3
-tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6)
-tup[:2] #=> (1, 2)
-2 in tup #=> True
-
-# Você pode 'desempacotar' tuplas (ou listas) em variáveis, associando cada
-# elemento da tupla/lista a uma variável correspondente
-a, b, c = (1, 2, 3)     # a agora é 1, b agora é 2, c agora é 3
-# Tuplas são criadas por padrão, mesmo se você não usar parênteses
-d, e, f = 4, 5, 6
-# Sabendo disso, veja só como é fácil trocar os valores de duas variáveis!
-e, d = d, e     # d agora é 5, e agora é 4
-
-
-# Dicionários armazenam 'mapeamentos' (do tipo chave-valor)
-dicionario_vazio = {}
-# Aqui criamos um dicionário já contendo valores
-dicionario = {"um": 1, "dois": 2, "três": 3}
-
-# Acesse valores usando []
-dicionario["um"] #=> 1
-
-# Retorna uma lista com todas as chaves do dicionário
-dicionario.keys() #=> ["três", "dois", "um"]
-# Nota: A ordem das chaves não é garantida.
-# O resultado no seu interpretador não necessariamente será igual a esse.
-
-# Retorna uma lista com todos os valores do dicionário
-dicionario.values() #=> [3, 2, 1]
-# Nota: A mesma nota acima sobre a ordenação é válida aqui.
-
-# Veja se uma chave qualquer está em um dicionário usando 'in'
-"um" in dicionario #=> True
-1 in dicionario #=> False
-
-# Tentar acessar uma chave que não existe gera uma exceção do tipo 'KeyError'
-dicionario["quatro"] # Gera uma exceção KeyError
-
-# Você pode usar o método 'get' para evitar gerar a exceção 'KeyError'.
-# Ao invés de gerar essa exceção, irá retornar 'None' se a chave não existir.
-dicionario.get("um") #=> 1
-dicionario.get("quatro") #=> None
-# O método 'get' suporta um argumento que diz qual valor deverá ser
-# retornado se a chave não existir (ao invés de 'None').
-dicionario.get("um", 4) #=> 1
-dicionario.get("quatro", 4) #=> 4
-
-# O método 'setdefault' é um jeito seguro de adicionar um novo par
-# chave-valor a um dicionário, associando um valor padrão imutável à uma chave
-dicionario.setdefault("cinco", 5) # dicionario["cinco"] é definido como 5
-dicionario.setdefault("cinco", 6) # dicionario["cinco"] ainda é igual a 5
-
-
-# Conjuntos (ou sets) armazenam ... bem, conjuntos
-# Nota: lembre-se que conjuntos não admitem elementos repetidos!
-conjunto_vazio = set()
-# Podemos inicializar um conjunto com valores
-conjunto = set([1, 2, 2, 3, 4]) # conjunto é set([1, 2, 3, 4]), sem repetição!
-
-# Desde o Python 2.7, {} pode ser usado para declarar um conjunto
-conjunto = {1, 2, 2, 3, 4} # => {1 2 3 4}
-
-# Adicione mais ítens a um conjunto com 'add'
-conjunto.add(5) # conjunto agora é {1, 2, 3, 4, 5}
-
-# Calcule a intersecção de dois conjuntos com &
-outro_conj = {3, 4, 5, 6}
-conjunto & outro_conj #=> {3, 4, 5}
-
-# Calcule a união de dois conjuntos com |
-conjunto | outro_conj #=> {1, 2, 3, 4, 5, 6}
-
-# E a diferença entre dois conjuntos com -
-{1,2,3,4} - {2,3,5} #=> {1, 4}
-
-# Veja se um elemento existe em um conjunto usando 'in'
-2 in conjunto #=> True
-10 in conjunto #=> False
-
-
-####################################################
-## 3. Controle
-####################################################
-
-# Para começar, vamos apenas criar uma variável
-alguma_var = 5
-
-# Aqui está uma expressão 'if'. Veja como a identação é importante em Python!
-# Esses comandos irão imprimir "alguma_var é menor que 10"
-if alguma_var > 10:
-    print "some_var é maior que 10."
-elif some_var < 10:    # Esse 'elif' é opcional
-    print "some_var é menor que 10."
-else:           # Esse 'else' também é opcional
-    print "some_var é igual a 10."
-
-
-"""
-Laços (ou loops) 'for' iteram em listas.
-Irá imprimir:
-    cachorro é um mamífero
-    gato é um mamífero
-    rato é um mamífero
-"""
-for animal in ["cachorro", "gato", "rato"]:
-    # Você pode usar % para interpolar strings formatadas
-    print "%s é um mamífero" % animal
-    
-"""
-A função `range(um número)` retorna uma lista de números
-do zero até o número dado.
-Irá imprimir:
-    0
-    1
-    2
-    3
-"""
-for i in range(4):
-    print i
-
-"""
-Laços 'while' executam enquanto uma condição dada for verdadeira.
-Irá imprimir:
-    0
-    1
-    2
-    3
-"""
-x = 0
-while x < 4:
-    print x
-    x += 1  # Isso é um atalho para a expressão x = x + 1
-
-# Tratamos excessões usando o bloco try/except
-# Funciona em Python 2.6 e versões superiores:
-
-try:
-    # Use 'raise' para gerar um erro
-    raise IndexError("Isso é um erro de índice")
-except IndexError as e:
-    pass    # Pass é um operador que não faz nada, deixa passar.
-            # Usualmente você iria tratar a exceção aqui...
-
-
-####################################################
-## 4. Funções
-####################################################
-
-# Use 'def' para definir novas funções
-def soma(x, y):
-    print "x é %s e y é %s" % (x, y)
-    return x + y    # Retorne valores usando 'return'
-
-# Chamando funções com parâmetros
-soma(5, 6) #=> imprime "x é 5 e y é 6" e retorna o valor 11
-
-# Um outro jeito de chamar funções é especificando explicitamente os valores
-# de cada parâmetro com chaves
-soma(y=6, x=5)   # Argumentos com chaves podem vir em qualquer ordem.
-
-# Você pode definir funções que recebem um número qualquer de argumentos
-# (respeitando a sua ordem)
-def varargs(*args):
-    return args
-
-varargs(1, 2, 3) #=> (1,2,3)
-
-
-# Você também pode definir funções que recebem um número qualquer de argumentos
-# com chaves
-def args_com_chaves(**ch_args):
-    return ch_args
-
-# Vamos chamar essa função para ver o que acontece
-args_com_chaves(pe="grande", lago="Ness") #=> {"pe": "grande", "lago": "Ness"}
-
-# Você pode fazer as duas coisas ao mesmo tempo, se desejar
-def todos_args(*args, **ch_wargs):
-    print args
-    print ch_args
-"""
-todos_args(1, 2, a=3, b=4) imprime:
-    (1, 2)
-    {"a": 3, "b": 4}
-"""
-
-# Quando você chamar funções, pode fazer o oposto do que fizemos até agora!
-# Podemos usar * para expandir tuplas de argumentos e ** para expandir
-# dicionários de argumentos com chave.
-args = (1, 2, 3, 4)
-ch_args = {"a": 3, "b": 4}
-todos_args(*args)  # equivalente a todos_args(1, 2, 3, 4)
-todos_args(**ch_args) # equivalente a todos_args(a=3, b=4)
-todos_args(*args, **ch_args) # equivalente a todos_args(1, 2, 3, 4, a=3, b=4)
-
-# Em Python, funções são elementos de primeira ordem (são como objetos, 
-# strings ou números)
-def cria_somador(x):
-    def somador(y):
-        return x + y
-    return somador
-
-soma_10 = cria_somador(10)
-soma_10(3) #=> 13
-
-# Desta forma, existem também funções anônimas
-(lambda x: x > 2)(3) #=> True
-
-# E existem funções de alta ordem por padrão
-map(soma_10, [1,2,3]) #=> [11, 12, 13]
-filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
-reduce(lambda x, y: x + y, [3, 4, 5, 6, 7]) #=> 25
-
-# Nós podemos usar compreensão de listas para mapear e filtrar também
-[soma_10(i) for i in [1, 2, 3]]  #=> [11, 12, 13]
-[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
-
-####################################################
-## 5. Classes
-####################################################
-
-# Para criar uma nova classe, devemos herdar de 'object'
-class Humano(object):
-
-    # Um atributo de classe. Ele é compartilhado por todas as instâncias dessa
-    # classe
-    especie = "H. sapiens"
-
-    # Definimos um inicializador básico
-    def __init__(self, nome):
-        # Atribui o valor de argumento dado a um atributo da instância
-        self.nome = nome
-
-    # Um método de instância. Todos os métodos levam 'self' como primeiro
-    # argumento
-    def diga(self, msg):
-       return "%s: %s" % (self.nome, msg)
-
-    # Um método de classe é compartilhado por todas as instâncias
-    # Eles são chamados passando o nome da classe como primeiro argumento
-    @classmethod
-    def get_especie(cls):
-        return cls.especie
-
-    # Um método estático é chamado sem uma referência a classe ou instância
-    @staticmethod
-    def ronca():
-        return "*arrrrrrr*"
-
-
-# Instancie uma classe
-i = Humano(nome="Ivone")
-print i.diga("oi")     # imprime "Ivone: oi"
-
-j = Human("Joel")
-print j.say("olá")  #prints out "Joel: olá"
-
-# Chame nosso método de classe
-i.get_especie() #=> "H. sapiens"
-
-# Modifique um atributo compartilhado
-Humano.especie = "H. neanderthalensis"
-i.get_especie() #=> "H. neanderthalensis"
-j.get_especie() #=> "H. neanderthalensis"
-
-# Chame o método estático
-Humano.ronca() #=> "*arrrrrrr*"
-
-
-####################################################
-## 6. Módulos
-####################################################
-
-# Você pode importar módulos
-import math
-print math.sqrt(16) #=> 4.0
-
-# Você pode importar funções específicas de um módulo
-from math import ceil, floor
-print ceil(3.7)  #=> 4.0
-print floor(3.7) #=> 3.0
-
-# Você também pode importar todas as funções de um módulo
-# Atenção: isso não é recomendado!
-from math import *
-
-# Você pode usar apelidos para os módulos, encurtando seus nomes
-import math as m
-math.sqrt(16) == m.sqrt(16) #=> True
-
-# Módulos em Python são apenas arquivos Python. Você
-# pode escrever o seu próprio módulo e importá-lo. O nome do
-# módulo será o mesmo que o nome do arquivo.
-
-# Você pode descobrir quais funções e atributos
-# estão definidos em um módulo qualquer.
-import math
-dir(math)
-
-
-```
-
-## Pronto para mais?
-
-### Online e gratuito
-
-* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
-* [Dive Into Python](http://www.diveintopython.net/)
-* [The Official Docs](http://docs.python.org/2.6/)
-* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
-* [Python Module of the Week](http://pymotw.com/2/)
-
-### Livros impressos
-
-* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
-* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
-* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
-
diff --git a/pt-br/pythonlegacy-pt.html.markdown b/pt-br/pythonlegacy-pt.html.markdown
new file mode 100644
index 00000000..82b70117
--- /dev/null
+++ b/pt-br/pythonlegacy-pt.html.markdown
@@ -0,0 +1,509 @@
+---
+language: python
+contributors:
+    - ["Louie Dinh", "http://ldinh.ca"]
+translators:
+    - ["Vilson Vieira", "http://automata.cc"]
+lang: pt-br
+filename: learnpython-pt.py
+---
+
+Python foi criado por Guido Van Rossum no começo dos anos 90. Atualmente é uma
+das linguagens de programação mais populares. Eu me apaixonei por Python, por
+sua clareza de sintaxe. É basicamente pseudocódigo executável.
+
+Comentários serão muito apreciados! Você pode me contactar em
+[@louiedinh](http://twitter.com/louiedinh) ou louiedinh [arroba]
+[serviço de email do google]
+
+Nota: Este artigo usa Python 2.7 especificamente, mas deveria ser aplicável a
+qualquer Python 2.x. Logo haverá uma versão abordando Python 3!
+
+```python
+# Comentários de uma linha começam com cerquilha (ou sustenido)
+""" Strings de várias linhas podem ser escritas
+    usando três ", e são comumente usadas
+    como comentários
+"""
+
+####################################################
+## 1. Tipos de dados primitivos e operadores
+####################################################
+
+# Você usa números normalmente
+3 #=> 3
+
+# Operadores matemáticos são aqueles que você já está acostumado
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+
+# A divisão é um pouco estranha. A divisão de números inteiros arredonda
+# para baixo o resultado, automaticamente
+5 / 2 #=> 2
+
+# Para concertar a divisão, precisamos aprender sobre números de ponto
+# flutuante (conhecidos como 'float').
+2.0     # Isso é um 'float'
+11.0 / 4.0 #=> 2.75 ahhh... muito melhor
+
+# Forçamos a precedência de operadores usando parênteses
+(1 + 3) * 2 #=> 8
+
+# Valores booleanos (ou 'boolean') são também tipos primitivos
+True
+False
+
+# Negamos usando 'not'
+not True #=> False
+not False #=> True
+
+# Testamos igualdade usando '=='
+1 == 1 #=> True
+2 == 1 #=> False
+
+# E desigualdade com '!='
+1 != 1 #=> False
+2 != 1 #=> True
+
+# Mais comparações
+1 < 10 #=> True
+1 > 10 #=> False
+2 <= 2 #=> True
+2 >= 2 #=> True
+
+# As comparações podem ser encadeadas!
+1 < 2 < 3 #=> True
+2 < 3 < 2 #=> False
+
+# Strings são criadas com " ou '
+"Isso é uma string."
+'Isso também é uma string.'
+
+# Strings podem ser somadas (ou melhor, concatenadas)!
+"Olá " + "mundo!" #=> "Olá mundo!"
+
+# Uma string pode ser tratada como uma lista de caracteres
+"Esta é uma string"[0] #=> 'E'
+
+# O caractere % pode ser usado para formatar strings, desta forma:
+"%s podem ser %s" % ("strings", "interpoladas")
+
+# Um jeito novo de formatar strings é usando o método 'format'.
+# Esse método é o jeito mais usado
+"{0} podem ser {1}".format("strings", "formatadas")
+# Você pode usar palavras-chave (ou 'keywords') se você não quiser contar.
+"{nome} quer comer {comida}".format(nome="João", comida="lasanha")
+
+# 'None' é um objeto
+None #=> None
+
+# Não use o operador de igualdade `==` para comparar objetos com 'None'
+# Ao invés disso, use `is`
+"etc" is None #=> False
+None is None  #=> True
+
+# O operador 'is' teste a identidade de um objeto. Isso não é
+# muito útil quando estamos lidando com valores primitivos, mas é
+# muito útil quando lidamos com objetos.
+
+# None, 0, e strings/listas vazias são todas interpretadas como 'False'.
+# Todos os outros valores são 'True'
+0 == False  #=> True
+"" == False #=> True
+
+
+####################################################
+## 2. Variáveis e Coleções
+####################################################
+
+# Imprimir na tela é muito fácil
+print "Eu sou o Python. Prazer em te conhecer!"
+
+
+# Nós não precisamos declarar variáveis antes de usá-las, basta usar!
+alguma_variavel = 5    # A convenção é usar caixa_baixa_com_sobrescritos
+alguma_variavel #=> 5
+
+# Acessar uma variável que não teve nenhum valor atribuído anteriormente é
+# uma exceção.
+# Veja a seção 'Controle' para aprender mais sobre tratamento de exceção.
+outra_variavel  # Gera uma exceção de erro de nome
+
+# 'if' pode ser usado como uma expressão
+"uepa!" if 3 > 2 else 2 #=> "uepa!"
+
+# Listas armazenam sequências de elementos
+lista = []
+# Você pode inicializar uma lista com valores
+outra_lista = [4, 5, 6]
+
+# Adicione elementos no final da lista usando 'append'
+lista.append(1)    # lista é agora [1]
+lista.append(2)    # lista é agora [1, 2]
+lista.append(4)    # lista é agora [1, 2, 4]
+lista.append(3)    # lista é agora [1, 2, 4, 3]
+# Remova elementos do fim da lista usando 'pop'
+lista.pop()        #=> 3 e lista é agora [1, 2, 4]
+# Vamos adicionar o elemento novamente
+lista.append(3)    # lista agora é [1, 2, 4, 3] novamente.
+
+# Acesse elementos de uma lista através de seu índices
+lista[0] #=> 1
+# Acesse o último elemento com índice negativo!
+lista[-1] #=> 3
+
+# Tentar acessar um elemento fora dos limites da lista gera uma exceção
+# do tipo 'IndexError'
+lista[4] # Gera uma exceção 'IndexError'
+
+# Você pode acessar vários elementos ao mesmo tempo usando a sintaxe de
+# limites
+# (Para quem gosta de matemática, isso é um limite fechado/aberto)
+lista[1:3] #=> [2, 4]
+# Você pode omitir o fim se quiser os elementos até o final da lista
+lista[2:] #=> [4, 3]
+# O mesmo para o início
+lista[:3] #=> [1, 2, 4]
+
+# Remova um elemento qualquer de uma lista usando 'del'
+del lista[2] # lista agora é [1, 2, 3]
+
+# Você pode somar listas (obs: as listas originais não são modificadas)
+lista + outra_lista #=> [1, 2, 3, 4, 5, 6]
+
+# Você também pode concatenar usando o método 'extend' (lista será modificada!)
+lista.extend(outra_lista) # Agora lista é [1, 2, 3, 4, 5, 6]
+
+# Para checar se um elemento pertence a uma lista, use 'in'
+1 in lista #=> True
+
+# Saiba quantos elementos uma lista possui com 'len'
+len(lista) #=> 6
+
+
+# Tuplas são iguais a listas, mas são imutáveis
+tup = (1, 2, 3)
+tup[0] #=> 1
+tup[0] = 3  # Isso gera uma exceção do tipo TypeError
+
+# Você pode fazer nas tuplas todas aquelas coisas fez com a lista
+len(tup) #=> 3
+tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6)
+tup[:2] #=> (1, 2)
+2 in tup #=> True
+
+# Você pode 'desempacotar' tuplas (ou listas) em variáveis, associando cada
+# elemento da tupla/lista a uma variável correspondente
+a, b, c = (1, 2, 3)     # a agora é 1, b agora é 2, c agora é 3
+# Tuplas são criadas por padrão, mesmo se você não usar parênteses
+d, e, f = 4, 5, 6
+# Sabendo disso, veja só como é fácil trocar os valores de duas variáveis!
+e, d = d, e     # d agora é 5, e agora é 4
+
+
+# Dicionários armazenam 'mapeamentos' (do tipo chave-valor)
+dicionario_vazio = {}
+# Aqui criamos um dicionário já contendo valores
+dicionario = {"um": 1, "dois": 2, "três": 3}
+
+# Acesse valores usando []
+dicionario["um"] #=> 1
+
+# Retorna uma lista com todas as chaves do dicionário
+dicionario.keys() #=> ["três", "dois", "um"]
+# Nota: A ordem das chaves não é garantida.
+# O resultado no seu interpretador não necessariamente será igual a esse.
+
+# Retorna uma lista com todos os valores do dicionário
+dicionario.values() #=> [3, 2, 1]
+# Nota: A mesma nota acima sobre a ordenação é válida aqui.
+
+# Veja se uma chave qualquer está em um dicionário usando 'in'
+"um" in dicionario #=> True
+1 in dicionario #=> False
+
+# Tentar acessar uma chave que não existe gera uma exceção do tipo 'KeyError'
+dicionario["quatro"] # Gera uma exceção KeyError
+
+# Você pode usar o método 'get' para evitar gerar a exceção 'KeyError'.
+# Ao invés de gerar essa exceção, irá retornar 'None' se a chave não existir.
+dicionario.get("um") #=> 1
+dicionario.get("quatro") #=> None
+# O método 'get' suporta um argumento que diz qual valor deverá ser
+# retornado se a chave não existir (ao invés de 'None').
+dicionario.get("um", 4) #=> 1
+dicionario.get("quatro", 4) #=> 4
+
+# O método 'setdefault' é um jeito seguro de adicionar um novo par
+# chave-valor a um dicionário, associando um valor padrão imutável à uma chave
+dicionario.setdefault("cinco", 5) # dicionario["cinco"] é definido como 5
+dicionario.setdefault("cinco", 6) # dicionario["cinco"] ainda é igual a 5
+
+
+# Conjuntos (ou sets) armazenam ... bem, conjuntos
+# Nota: lembre-se que conjuntos não admitem elementos repetidos!
+conjunto_vazio = set()
+# Podemos inicializar um conjunto com valores
+conjunto = set([1, 2, 2, 3, 4]) # conjunto é set([1, 2, 3, 4]), sem repetição!
+
+# Desde o Python 2.7, {} pode ser usado para declarar um conjunto
+conjunto = {1, 2, 2, 3, 4} # => {1 2 3 4}
+
+# Adicione mais ítens a um conjunto com 'add'
+conjunto.add(5) # conjunto agora é {1, 2, 3, 4, 5}
+
+# Calcule a intersecção de dois conjuntos com &
+outro_conj = {3, 4, 5, 6}
+conjunto & outro_conj #=> {3, 4, 5}
+
+# Calcule a união de dois conjuntos com |
+conjunto | outro_conj #=> {1, 2, 3, 4, 5, 6}
+
+# E a diferença entre dois conjuntos com -
+{1,2,3,4} - {2,3,5} #=> {1, 4}
+
+# Veja se um elemento existe em um conjunto usando 'in'
+2 in conjunto #=> True
+10 in conjunto #=> False
+
+
+####################################################
+## 3. Controle
+####################################################
+
+# Para começar, vamos apenas criar uma variável
+alguma_var = 5
+
+# Aqui está uma expressão 'if'. Veja como a identação é importante em Python!
+# Esses comandos irão imprimir "alguma_var é menor que 10"
+if alguma_var > 10:
+    print "some_var é maior que 10."
+elif some_var < 10:    # Esse 'elif' é opcional
+    print "some_var é menor que 10."
+else:           # Esse 'else' também é opcional
+    print "some_var é igual a 10."
+
+
+"""
+Laços (ou loops) 'for' iteram em listas.
+Irá imprimir:
+    cachorro é um mamífero
+    gato é um mamífero
+    rato é um mamífero
+"""
+for animal in ["cachorro", "gato", "rato"]:
+    # Você pode usar % para interpolar strings formatadas
+    print "%s é um mamífero" % animal
+    
+"""
+A função `range(um número)` retorna uma lista de números
+do zero até o número dado.
+Irá imprimir:
+    0
+    1
+    2
+    3
+"""
+for i in range(4):
+    print i
+
+"""
+Laços 'while' executam enquanto uma condição dada for verdadeira.
+Irá imprimir:
+    0
+    1
+    2
+    3
+"""
+x = 0
+while x < 4:
+    print x
+    x += 1  # Isso é um atalho para a expressão x = x + 1
+
+# Tratamos excessões usando o bloco try/except
+# Funciona em Python 2.6 e versões superiores:
+
+try:
+    # Use 'raise' para gerar um erro
+    raise IndexError("Isso é um erro de índice")
+except IndexError as e:
+    pass    # Pass é um operador que não faz nada, deixa passar.
+            # Usualmente você iria tratar a exceção aqui...
+
+
+####################################################
+## 4. Funções
+####################################################
+
+# Use 'def' para definir novas funções
+def soma(x, y):
+    print "x é %s e y é %s" % (x, y)
+    return x + y    # Retorne valores usando 'return'
+
+# Chamando funções com parâmetros
+soma(5, 6) #=> imprime "x é 5 e y é 6" e retorna o valor 11
+
+# Um outro jeito de chamar funções é especificando explicitamente os valores
+# de cada parâmetro com chaves
+soma(y=6, x=5)   # Argumentos com chaves podem vir em qualquer ordem.
+
+# Você pode definir funções que recebem um número qualquer de argumentos
+# (respeitando a sua ordem)
+def varargs(*args):
+    return args
+
+varargs(1, 2, 3) #=> (1,2,3)
+
+
+# Você também pode definir funções que recebem um número qualquer de argumentos
+# com chaves
+def args_com_chaves(**ch_args):
+    return ch_args
+
+# Vamos chamar essa função para ver o que acontece
+args_com_chaves(pe="grande", lago="Ness") #=> {"pe": "grande", "lago": "Ness"}
+
+# Você pode fazer as duas coisas ao mesmo tempo, se desejar
+def todos_args(*args, **ch_wargs):
+    print args
+    print ch_args
+"""
+todos_args(1, 2, a=3, b=4) imprime:
+    (1, 2)
+    {"a": 3, "b": 4}
+"""
+
+# Quando você chamar funções, pode fazer o oposto do que fizemos até agora!
+# Podemos usar * para expandir tuplas de argumentos e ** para expandir
+# dicionários de argumentos com chave.
+args = (1, 2, 3, 4)
+ch_args = {"a": 3, "b": 4}
+todos_args(*args)  # equivalente a todos_args(1, 2, 3, 4)
+todos_args(**ch_args) # equivalente a todos_args(a=3, b=4)
+todos_args(*args, **ch_args) # equivalente a todos_args(1, 2, 3, 4, a=3, b=4)
+
+# Em Python, funções são elementos de primeira ordem (são como objetos, 
+# strings ou números)
+def cria_somador(x):
+    def somador(y):
+        return x + y
+    return somador
+
+soma_10 = cria_somador(10)
+soma_10(3) #=> 13
+
+# Desta forma, existem também funções anônimas
+(lambda x: x > 2)(3) #=> True
+
+# E existem funções de alta ordem por padrão
+map(soma_10, [1,2,3]) #=> [11, 12, 13]
+filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
+reduce(lambda x, y: x + y, [3, 4, 5, 6, 7]) #=> 25
+
+# Nós podemos usar compreensão de listas para mapear e filtrar também
+[soma_10(i) for i in [1, 2, 3]]  #=> [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
+
+####################################################
+## 5. Classes
+####################################################
+
+# Para criar uma nova classe, devemos herdar de 'object'
+class Humano(object):
+
+    # Um atributo de classe. Ele é compartilhado por todas as instâncias dessa
+    # classe
+    especie = "H. sapiens"
+
+    # Definimos um inicializador básico
+    def __init__(self, nome):
+        # Atribui o valor de argumento dado a um atributo da instância
+        self.nome = nome
+
+    # Um método de instância. Todos os métodos levam 'self' como primeiro
+    # argumento
+    def diga(self, msg):
+       return "%s: %s" % (self.nome, msg)
+
+    # Um método de classe é compartilhado por todas as instâncias
+    # Eles são chamados passando o nome da classe como primeiro argumento
+    @classmethod
+    def get_especie(cls):
+        return cls.especie
+
+    # Um método estático é chamado sem uma referência a classe ou instância
+    @staticmethod
+    def ronca():
+        return "*arrrrrrr*"
+
+
+# Instancie uma classe
+i = Humano(nome="Ivone")
+print i.diga("oi")     # imprime "Ivone: oi"
+
+j = Human("Joel")
+print j.say("olá")  #prints out "Joel: olá"
+
+# Chame nosso método de classe
+i.get_especie() #=> "H. sapiens"
+
+# Modifique um atributo compartilhado
+Humano.especie = "H. neanderthalensis"
+i.get_especie() #=> "H. neanderthalensis"
+j.get_especie() #=> "H. neanderthalensis"
+
+# Chame o método estático
+Humano.ronca() #=> "*arrrrrrr*"
+
+
+####################################################
+## 6. Módulos
+####################################################
+
+# Você pode importar módulos
+import math
+print math.sqrt(16) #=> 4.0
+
+# Você pode importar funções específicas de um módulo
+from math import ceil, floor
+print ceil(3.7)  #=> 4.0
+print floor(3.7) #=> 3.0
+
+# Você também pode importar todas as funções de um módulo
+# Atenção: isso não é recomendado!
+from math import *
+
+# Você pode usar apelidos para os módulos, encurtando seus nomes
+import math as m
+math.sqrt(16) == m.sqrt(16) #=> True
+
+# Módulos em Python são apenas arquivos Python. Você
+# pode escrever o seu próprio módulo e importá-lo. O nome do
+# módulo será o mesmo que o nome do arquivo.
+
+# Você pode descobrir quais funções e atributos
+# estão definidos em um módulo qualquer.
+import math
+dir(math)
+
+
+```
+
+## Pronto para mais?
+
+### Online e gratuito
+
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [The Official Docs](http://docs.python.org/2.6/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [Python Module of the Week](http://pymotw.com/2/)
+
+### Livros impressos
+
+* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
+* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
+* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
+
-- 
cgit v1.2.3


From a3b0585374d69e392fdb724bde30bc4048358d31 Mon Sep 17 00:00:00 2001
From: Simon Shine <shreddedglory@gmail.com>
Date: Wed, 12 Feb 2020 04:54:36 +0100
Subject: Rename Python 3 markdown files into 'python'

```
for f in $(find . -iname "*python3*" | grep -vE 'git'); do
  fnew=$(echo "$f" | sed 's/python3/python/')
  git mv "$f" "$fnew"
done
---
 pt-br/python-pt.html.markdown  | 746 +++++++++++++++++++++++++++++++++++++++++
 pt-br/python3-pt.html.markdown | 746 -----------------------------------------
 2 files changed, 746 insertions(+), 746 deletions(-)
 create mode 100644 pt-br/python-pt.html.markdown
 delete mode 100644 pt-br/python3-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/python-pt.html.markdown b/pt-br/python-pt.html.markdown
new file mode 100644
index 00000000..bc5f801c
--- /dev/null
+++ b/pt-br/python-pt.html.markdown
@@ -0,0 +1,746 @@
+---
+language: python3
+contributors:
+    - ["Louie Dinh", "http://pythonpracticeprojects.com"]
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+    - ["Zachary Ferguson", "http://github.com/zfergus2"]
+translators:
+    - ["Paulo Henrique Rodrigues Pinheiro", "http://www.sysincloud.it"]
+    - ["Monique Baptista", "https://github.com/bfmonique"]
+lang: pt-br
+filename: learnpython3-pt.py
+---
+
+Python foi criada por Guido Van Rossum nos anos 1990. Ela é atualmente uma
+das linguagens mais populares existentes. Eu me apaixonei por
+Python por sua clareza sintática. É praticamente pseudocódigo executável.
+
+Opniões são muito bem vindas. Você pode encontrar-me em
+[@louiedinh](http://twitter.com/louiedinh) ou louiedinh [em]
+[serviço de e-mail do google].
+
+Observação: Este artigo trata de Python 3 especificamente. Verifique
+[aqui](http://learnxinyminutes.com/docs/pt-br/python-pt/) se você pretende
+aprender o velho Python 2.7.
+
+```python
+
+# Comentários em uma única linha começam com uma cerquilha (também conhecido por sustenido).
+
+""" Strings de várias linhas podem ser escritas
+    usando três ", e são comumente usadas
+    como comentários.
+"""
+
+####################################################
+## 1. Tipos de dados primitivos e operadores
+####################################################
+
+# Você usa números normalmente
+3  # => 3
+
+# Matemática é como você espera que seja
+1 + 1   # => 2
+8 - 1   # => 7
+10 * 2  # => 20
+
+# Números são inteiros por padrão, exceto na divisão, que retorna número
+# de ponto flutuante (float).
+35 / 5  # => 7.0
+
+# O resultado da divisão inteira arredonda para baixo tanto para números
+# positivos como para negativos.
+5 // 3       # => 1
+5.0 // 3.0   # => 1.0 # funciona em float também
+-5 // 3      # => -2
+-5.0 // 3.0  # => -2.0
+
+# Quando você usa um float, o resultado é float.
+3 * 2.0  # => 6.0
+
+# operador módulo
+7 % 3  # => 1
+
+# Exponenciação (x**y, x elevado à potência y)
+2**4  # => 16
+
+# Determine a precedência usando parênteses
+(1 + 3) * 2  # => 8
+
+# Valores lógicos são primitivos (Atenção à primeira letra maiúscula)
+True
+False
+
+# negação lógica com not
+not True   # => False
+not False  # => True
+
+# Operadores lógicos
+# Observe que "and" e "or" são sensíveis a maiúsculas e minúsculas
+True and False  # => False
+False or True   # => True
+
+# Observe a utilização de operadores lógicos com números inteiros
+0 and 2     # => 0
+-5 or 0     # => -5
+0 == False  # => True
+2 == True   # => False
+1 == True   # => True
+
+# Igualdade é ==
+1 == 1  # => True
+2 == 1  # => False
+
+# Diferença é !=
+1 != 1  # => False
+2 != 1  # => True
+
+# Mais comparações
+1 < 10  # => True
+1 > 10  # => False
+2 <= 2  # => True
+2 >= 2  # => True
+
+# Comparações podem ser agrupadas
+1 < 2 < 3  # => True
+2 < 3 < 2  # => False
+
+# 'is' verifica se duas variáveis representam o mesmo endereço
+# na memória; '==' verifica se duas variáveis têm o mesmo valor
+a = [1, 2, 3, 4]  # Referência a uma nova lista, [1, 2, 3, 4]
+b = a             # b referencia o que está referenciado por a
+b is a            # => True, a e b referenciam o mesmo objeto
+b == a            # => True, objetos a e b tem o mesmo conteúdo
+b = [1, 2, 3, 4]  # Referência a uma nova lista, [1, 2, 3, 4]
+b is a            # => False, a e b não referenciam o mesmo objeto
+b == a            # => True, objetos a e b tem o mesmo conteúdo
+
+# Strings são criadas com " ou '
+"Isto é uma string."
+'Isto também é uma string.'
+
+# Strings também podem ser somadas! Mas tente não fazer isso.
+"Olá " + "mundo!"  # => "Olá mundo!"
+# Strings podem ser somadas sem usar o '+'
+"Olá " "mundo!"    # => "Olá mundo!"
+
+# Uma string pode ser manipulada como se fosse uma lista de caracteres
+"Isso é uma string"[0]  # => 'I'
+
+# .format pode ser usado para formatar strings, dessa forma:
+"{} podem ser {}".format("Strings", "interpoladas")  # => "Strings podem ser interpoladas"
+
+# Você pode repetir os argumentos para digitar menos.
+"Seja ágil {0}, seja rápido {0}, salte sobre o {1} {0}".format("Jack", "castiçal")
+# => "Seja ágil Jack, seja rápido Jack, salte sobre o castiçal Jack."
+
+# Você pode usar palavras-chave se quiser contar.
+"{nome} quer comer {comida}".format(nome="Beto", comida="lasanha")  # => "Beto quer comer lasanha"
+
+# Se você precisa executar seu código Python3 com um interpretador Python 2.5 ou acima, você pode usar a velha forma para formatação de texto:
+"%s podem ser %s da forma %s" % ("Strings", "interpoladas", "antiga")  # => "Strings podem ser interpoladas da forma antiga"
+
+
+# None é um objeto
+None  # => None
+
+# Não use o operador de igualdade "==" para comparar objetos com None
+# Use "is" para isso. Ele checará pela identidade dos objetos.
+"etc" is None  # => False
+None is None   # => True
+
+# None, 0, e strings/listas/dicionários vazios todos retornam False.
+# Qualquer outra coisa retorna True
+bool(0)   # => False
+bool("")  # => False
+bool([])  # => False
+bool({})  # => False
+
+
+####################################################
+## 2. Variáveis e coleções
+####################################################
+
+# Python tem uma função print
+print("Eu sou o Python. Prazer em conhecer!")  # => Eu sou o Python. Prazer em conhecer!
+
+# Por padrão a função print também imprime o caractere de nova linha ao final.
+# Use o argumento opcional end para mudar o caractere final.
+print("Olá, Mundo", end="!")  # => Olá, Mundo!
+
+# Forma simples para capturar dados de entrada via console
+input_string_var = input("Digite alguma coisa: ") # Retorna o que foi digitado em uma string
+# Observação: Em versões antigas do Python, o método input() era chamado raw_input()
+
+# Não é necessário declarar variáveis antes de iniciá-las
+# É uma convenção usar letras_minúsculas_com_sublinhados
+alguma_variavel = 5
+alguma_variavel  # => 5
+
+# Acessar uma variável que não tenha sido inicializada gera uma exceção.
+# Veja Controle de Fluxo para aprender mais sobre tratamento de exceções.
+alguma_variavel_nao_inicializada  # Gera a exceção NameError
+
+# Listas armazenam sequências
+li = []
+# Você pode iniciar uma lista com valores
+outra_li = [4, 5, 6]
+
+# Adicione conteúdo ao fim da lista com append
+li.append(1)    # li agora é [1]
+li.append(2)    # li agora é [1, 2]
+li.append(4)    # li agora é [1, 2, 4]
+li.append(3)    # li agora é [1, 2, 4, 3]
+# Remova do final da lista com pop
+li.pop()        # => 3 e agora li é [1, 2, 4]
+# Vamos colocá-lo lá novamente!
+li.append(3)    # li agora é [1, 2, 4, 3] novamente.
+
+# Acesse uma lista da mesma forma que você faz com um array
+li[0]   # => 1
+# Acessando o último elemento
+li[-1]  # => 3
+
+# Acessar além dos limites gera um IndexError
+li[4]  # Gera o IndexError
+
+# Você pode acessar vários elementos com a sintaxe de limites
+# Inclusivo para o primeiro termo, exclusivo para o segundo
+li[1:3]   # => [2, 4]
+# Omitindo o final
+li[2:]    # => [4, 3]
+# Omitindo o início
+li[:3]    # => [1, 2, 4]
+# Selecione cada segunda entrada
+li[::2]   # => [1, 4]
+# Tenha uma cópia em ordem invertida da lista
+li[::-1]  # => [3, 4, 2, 1]
+# Use qualquer combinação dessas para indicar limites complexos
+# li[inicio:fim:passo]
+
+# Faça uma cópia profunda de um nível usando limites
+li2 = li[:]  # => li2 = [1, 2, 4, 3] mas (li2 is li) resultará em False.
+
+# Apague elementos específicos da lista com "del"
+del li[2]  # li agora é [1, 2, 3]
+
+# Você pode somar listas
+# Observação: valores em li e other_li não são modificados.
+li + other_li  # => [1, 2, 3, 4, 5, 6]
+
+# Concatene listas com "extend()"
+li.extend(other_li)  # Agora li é [1, 2, 3, 4, 5, 6]
+
+# Verifique se algo existe na lista com "in"
+1 in li  # => True
+
+# Examine  tamanho com "len()"
+len(li)  # => 6
+
+
+# Tuplas são como l istas, mas imutáveis.
+tup = (1, 2, 3)
+tup[0]      # => 1
+tup[0] = 3  # Gera um TypeError
+
+# Observe que uma tupla de tamanho um precisa ter uma vírgula depois do
+# último elemento mas tuplas de outros tamanhos, mesmo vazias, não precisa,.
+type((1))   # => <class 'int'>
+type((1,))  # => <class 'tuple'>
+type(())    # => <class 'tuple'>
+
+# Você pode realizar com tuplas a maior parte das operações que faz com listas
+len(tup)         # => 3
+tup + (4, 5, 6)  # => (1, 2, 3, 4, 5, 6)
+tup[:2]          # => (1, 2)
+2 in tup         # => True
+
+# Você pode desmembrar tuplas (ou listas) em variáveis.
+a, b, c = (1, 2, 3)  # a é 1, b é 2 e c é 3
+# Por padrão, tuplas são criadas se você não coloca parêntesis.
+d, e, f = 4, 5, 6
+# Veja como é fácil permutar dois valores
+e, d = d, e  # d é 5, e é 4
+
+# Dicionários armazenam mapeamentos
+empty_dict = {}
+# Aqui está um dicionário preenchido na definição da referência
+filled_dict = {"um": 1, "dois": 2, "três": 3}
+
+# Observe que chaves para dicionários devem ser tipos imutáveis. Isto é para
+# assegurar que a chave pode ser convertida para uma valor hash constante para
+# buscas rápidas.
+# Tipos imutáveis incluem inteiros, flotas, strings e tuplas.
+invalid_dict = {[1,2,3]: "123"}  # => Gera um TypeError: unhashable type: 'list'
+valid_dict = {(1,2,3):[1,2,3]}   # Já os valores, podem ser de qualquer tipo.
+
+# Acesse valores com []
+filled_dict["um"]  # => 1
+
+# Acesse todas as chaves como um iterável com "keys()". É necessário encapsular
+# a chamada com um list() para transformá-las em uma lista. Falaremos sobre isso
+# mais adiante. Observe que a ordem de uma chave de dicionário não é garantida.
+# Por isso, os resultados aqui apresentados podem não ser exatamente como os
+# aqui apresentados.
+list(filled_dict.keys())  # => ["três", "dois", "um"]
+
+
+# Acesse todos os valores de um iterável com "values()". Novamente, é
+# necessário encapsular ele com list() para não termos um iterável, e sim os
+# valores. Observe que, como foi dito acima, a ordem dos elementos não é
+# garantida.
+list(filled_dict.values())  # => [3, 2, 1]
+
+
+# Verifique a existência de chaves em um dicionário com "in"
+"um" in filled_dict  # => True
+1 in filled_dict      # => False
+
+# Acessar uma chave inexistente gera um KeyError
+filled_dict["quatro"]  # KeyError
+
+# Use o método "get()" para evitar um KeyError
+filled_dict.get("um")      # => 1
+filled_dict.get("quatro")     # => None
+# O método get permite um parâmetro padrão para quando não existir a chave
+filled_dict.get("um", 4)   # => 1
+filled_dict.get("quatro", 4)  # => 4
+
+# "setdefault()" insere em dicionário apenas se a dada chave não existir
+filled_dict.setdefault("cinco", 5)  # filled_dict["cinco"] tem valor 5
+filled_dict.setdefault("cinco", 6)  # filled_dict["cinco"] continua 5
+
+# Inserindo em um dicionário
+filled_dict.update({"quatro":4})  # => {"um": 1, "dois": 2, "três": 3, "quatro": 4}
+#filled_dict["quatro"] = 4        #outra forma de inserir em um dicionário
+
+# Remova chaves de um dicionário com del
+del filled_dict["um"]  # Remove a chave "um" de filled_dict
+
+
+# Armazenamento em sets... bem, são conjuntos
+empty_set = set()
+# Inicializa um set com alguns valores. Sim, ele parece um dicionário. Desculpe.
+some_set = {1, 1, 2, 2, 3, 4}  # some_set agora é {1, 2, 3, 4}
+
+# Da mesma forma que chaves em um dicionário, elementos de um set devem ser
+# imutáveis.
+invalid_set = {[1], 1}  # => Gera um TypeError: unhashable type: 'list'
+valid_set = {(1,), 1}
+
+# Pode definir novas variáveis para um conjunto
+filled_set = some_set
+
+# Inclua mais um item no set
+filled_set.add(5)  # filled_set agora é {1, 2, 3, 4, 5}
+
+# Faça interseção de conjuntos com &
+other_set = {3, 4, 5, 6}
+filled_set & other_set  # => {3, 4, 5}
+
+# Faça união de conjuntos com |
+filled_set | other_set  # => {1, 2, 3, 4, 5, 6}
+
+# Faça a diferença entre conjuntos com -
+{1, 2, 3, 4} - {2, 3, 5}  # => {1, 4}
+
+# Verifique a existência em um conjunto com in
+2 in filled_set   # => True
+10 in filled_set  # => False
+
+
+
+####################################################
+## 3. Controle de fluxo e iteráveis
+####################################################
+
+# Iniciemos um variável
+some_var = 5
+
+# Aqui está uma expressão if. Indentação é significante em python!
+# imprime "somevar é menor que10"
+if some_var > 10:
+    print("some_var é absolutamente maior que 10.")
+elif some_var < 10:    # Esta cláusula elif é opcional.
+    print("some_var é menor que 10.")
+else:                  # Isto também é opcional.
+    print("some_var é, de fato, 10.")
+
+
+"""
+Laços for iteram sobre listas
+imprime:
+    cachorro é um mamífero
+    gato é um mamífero
+    rato é um mamífero
+"""
+for animal in ["cachorro", "gato", "rato"]:
+    # Você pode usar format() para interpolar strings formatadas
+    print("{} é um mamífero".format(animal))
+
+"""
+"range(número)" retorna um iterável de números
+de zero até o número escolhido
+imprime:
+    0
+    1
+    2
+    3
+"""
+for i in range(4):
+    print(i)
+
+"""
+"range(menor, maior)" gera um iterável de números
+começando pelo menor até o maior
+imprime:
+    4
+    5
+    6
+    7
+"""
+for i in range(4, 8):
+    print(i)
+
+"""
+"range(menor, maior, passo)" retorna um iterável de números
+começando pelo menor número até o maior númeno, pulando de
+passo em passo. Se o passo não for indicado, o valor padrão é um.
+imprime:
+    4
+    6
+"""
+for i in range(4, 8, 2):
+    print(i)
+"""
+
+Laços while executam até que a condição não seja mais válida.
+imprime:
+    0
+    1
+    2
+    3
+"""
+x = 0
+while x < 4:
+    print(x)
+    x += 1  # Maneira mais curta para for x = x + 1
+
+# Lide com exceções com um bloco try/except
+try:
+    # Use "raise" para gerar um erro
+    raise IndexError("Isto é um erro de índice")
+except IndexError as e:
+    pass                 # Pass é um não-operador. Normalmente você usa algum código de recuperação aqui.
+except (TypeError, NameError):
+    pass                 # Varias exceções podem ser gerenciadas, se necessário.
+else:                    # Cláusula opcional para o bloco try/except. Deve estar após todos os blocos de exceção.
+    print("Tudo certo!")   # Executa apenas se o código em try não gera exceção
+finally:                 #  Sempre é executado
+    print("Nós podemos fazer o código de limpeza aqui.")
+
+# Ao invés de try/finally para limpeza você pode usar a cláusula with
+with open("myfile.txt") as f:
+    for line in f:
+        print(line)
+
+# Python provê uma abstração fundamental chamada Iterável.
+# Um iterável é um objeto que pode ser tratado como uma sequência.
+# O objeto retornou a função range, um iterável.
+
+filled_dict = {"um": 1, "dois": 2, "três": 3}
+our_iterable = filled_dict.keys()
+print(our_iterable)  # => range(1,10). Esse é um objeto que implementa nossa interface iterável.
+
+# Nós podemos percorrê-la.
+for i in our_iterable:
+    print(i)  # Imprime um, dois, três
+
+# Mas não podemos acessar os elementos pelo seu índice.
+our_iterable[1]  # Gera um TypeError
+
+# Um iterável é um objeto que sabe como criar um iterador.
+our_iterator = iter(our_iterable)
+
+# Nosso iterador é um objeto que pode lembrar o estado enquanto nós o percorremos.
+# Nós acessamos o próximo objeto com "next()".
+next(our_iterator)  # => "um"
+
+# Ele mantém o estado enquanto nós o percorremos.
+next(our_iterator)  # => "dois"
+next(our_iterator)  # => "três"
+
+# Após o iterador retornar todos os seus dados, ele gera a exceção StopIterator
+next(our_iterator)  # Gera StopIteration
+
+# Você pode capturar todos os elementos de um iterador aplicando list() nele.
+list(filled_dict.keys())  # => Retorna ["um", "dois", "três"]
+
+
+####################################################
+## 4. Funções
+####################################################
+
+# Use "def" para criar novas funções.
+def add(x, y):
+    print("x é {} e y é {}".format(x, y))
+    return x + y  # Retorne valores com a cláusula return
+
+# Chamando funções com parâmetros
+add(5, 6)  # => imprime "x é 5 e y é 6" e retorna 11
+
+# Outro meio de chamar funções é com argumentos nomeados
+add(y=6, x=5)  # Argumentos nomeados podem aparecer em qualquer ordem.
+
+# Você pode definir funções que pegam um número variável de argumentos
+# posicionais
+def varargs(*args):
+    return args
+
+varargs(1, 2, 3)  # => (1, 2, 3)
+
+# Você pode definir funções que pegam um número variável de argumentos nomeados
+# também
+def keyword_args(**kwargs):
+    return kwargs
+
+# Vamos chamá-lo para ver o que acontece
+keyword_args(peh="grande", lago="ness")  # => {"peh": "grande", "lago": "ness"}
+
+
+# Você pode fazer ambos simultaneamente, se você quiser
+def all_the_args(*args, **kwargs):
+    print(args)
+    print(kwargs)
+"""
+all_the_args(1, 2, a=3, b=4) imprime:
+    (1, 2)
+    {"a": 3, "b": 4}
+"""
+
+# Quando chamar funções, você pode fazer o oposto de args/kwargs!
+# Use * para expandir tuplas e use ** para expandir dicionários!
+args = (1, 2, 3, 4)
+kwargs = {"a": 3, "b": 4}
+all_the_args(*args)            # equivalente a foo(1, 2, 3, 4)
+all_the_args(**kwargs)         # equivalente a foo(a=3, b=4)
+all_the_args(*args, **kwargs)  # equivalente a foo(1, 2, 3, 4, a=3, b=4)
+
+# Retornando múltiplos valores (com atribuição de tuplas)
+def swap(x, y):
+    return y, x  # Retorna múltiplos valores como uma tupla sem os parêntesis.
+                 # (Observação: os parêntesis foram excluídos mas podem estar
+                 # presentes)
+
+x = 1
+y = 2
+x, y = swap(x, y)     # => x = 2, y = 1
+# (x, y) = swap(x,y)  # Novamente, os parêntesis foram excluídos mas podem estar presentes.
+
+# Escopo de função
+x = 5
+
+def setX(num):
+    # A variável local x não é a mesma variável global x
+    x = num    # => 43
+    print (x)  # => 43
+
+def setGlobalX(num):
+    global x
+    print (x)  # => 5
+    x = num    # variável global x agora é 6
+    print (x)  # => 6
+
+setX(43)
+setGlobalX(6)
+
+
+# Python tem funções de primeira classe
+def create_adder(x):
+    def adder(y):
+        return x + y
+    return adder
+
+add_10 = create_adder(10)
+add_10(3)   # => 13
+
+# Também existem as funções anônimas
+(lambda x: x > 2)(3)                  # => True
+(lambda x, y: x ** 2 + y ** 2)(2, 1)  # => 5
+
+# TODO - Fix for iterables
+# Existem funções internas de alta ordem
+map(add_10, [1, 2, 3])          # => [11, 12, 13]
+map(max, [1, 2, 3], [4, 2, 1])  # => [4, 2, 3]
+
+filter(lambda x: x > 5, [3, 4, 5, 6, 7])  # => [6, 7]
+
+# Nós podemos usar compreensão de lista para interessantes mapas e filtros
+# Compreensão de lista armazena a saída como uma lista que pode ser uma lista
+# aninhada
+[add_10(i) for i in [1, 2, 3]]         # => [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5]  # => [6, 7]
+
+####################################################
+## 5. Classes
+####################################################
+
+
+# Nós usamos o operador "class" para ter uma classe
+class Human:
+
+    # Um atributo de classe. Ele é compartilhado por todas as instâncias dessa
+    # classe.
+    species = "H. sapiens"
+
+    # Construtor básico, é chamado quando esta classe é instanciada.
+    # Note que dois sublinhados no início e no final de uma identificados
+    # significa objetos ou atributos que são usados pelo python mas vivem em
+    # um namespace controlado pelo usuário. Métodos (ou objetos ou atributos)
+    # como: __init__, __str__, __repr__, etc. são chamados métodos mágicos (ou
+    # algumas vezes chamados métodos dunder - "double underscore")
+    # Você não deve usar nomes assim por sua vontade.
+    def __init__(self, name):
+        @ Atribui o argumento ao atributo da  instância
+        self.name = name
+
+    # Um método de instância. Todos os métodos tem "self" como primeiro
+    # argumento
+    def say(self, msg):
+        return "{name}: {message}".format(name=self.name, message=msg)
+
+    # Um método de classe é compartilhado por todas as instâncias
+    # Eles são chamados com a classe requisitante como primeiro argumento
+    @classmethod
+    def get_species(cls):
+        return cls.species
+
+    # Um método estático é chamado sem uma referência a classe ou instância
+    @staticmethod
+    def grunt():
+        return "*grunt*"
+
+
+# Instancie uma classe
+i = Human(name="Ian")
+print(i.say("oi"))     # imprime "Ian: oi"
+
+j = Human("Joel")
+print(j.say("olá"))  # imprime "Joel: olá"
+
+# Chama nosso método de classe
+i.get_species()  # => "H. sapiens"
+
+# Altera um atributo compartilhado
+Human.species = "H. neanderthalensis"
+i.get_species()  # => "H. neanderthalensis"
+j.get_species()  # => "H. neanderthalensis"
+
+# Chama o método estático
+Human.grunt()    # => "*grunt*"
+
+
+####################################################
+## 6. Módulos
+####################################################
+
+# Você pode importar módulos
+import math
+print(math.sqrt(16))  # => 4.0
+
+# Você pode importar apenas funções específicas de um módulo
+from math import ceil, floor
+print(ceil(3.7))   # => 4.0
+print(floor(3.7))  # => 3.0
+
+# Você pode importar todas as funções de um módulo para o namespace atual
+# Atenção: isso não é recomendado
+from math import *
+
+# Você pode encurtar o nome dos módulos
+import math as m
+math.sqrt(16) == m.sqrt(16)  # => True
+
+# Módulos python são apenas arquivos python comuns. Você
+# pode escrever os seus, e importá-los. O nome do
+# módulo é o mesmo nome do arquivo.
+
+# Você pode procurar que atributos e funções definem um módulo.
+import math
+dir(math)
+
+
+####################################################
+## 7. Avançado
+####################################################
+
+# Geradores podem ajudar você a escrever código "preguiçoso"
+def double_numbers(iterable):
+    for i in iterable:
+        yield i + i
+
+# Um gerador cria valores conforme necessário.
+# Ao invés de gerar e retornar todos os valores de uma só vez ele cria um em
+# cada interação. Isto significa que valores maiores que 15 não serão
+# processados em double_numbers.
+# Nós usamos um sublinhado ao final do nome das variáveis quando queremos usar
+# um nome que normalmente colide com uma palavra reservada do python.
+range_ = range(1, 900000000)
+# Multiplica por 2 todos os números até encontrar um resultado >= 30
+for i in double_numbers(range_):
+    print(i)
+    if i >= 30:
+        break
+
+
+# Decoradores
+# Neste exemplo beg encapsula say
+# beg irá chamar say. Se say_please é verdade então ele irá mudar a mensagem
+# retornada
+from functools import wraps
+
+
+def beg(target_function):
+    @wraps(target_function)
+    def wrapper(*args, **kwargs):
+        msg, say_please = target_function(*args, **kwargs)
+        if say_please:
+            return "{} {}".format(msg, "Por favor! Eu sou pobre :(")
+        return msg
+
+    return wrapper
+
+
+@beg
+def say(say_please=False):
+    msg = "Você me paga uma cerveja?"
+    return msg, say_please
+
+
+print(say())                # Você me paga uma cerveja?
+print(say(say_please=True)) # Você me paga uma cerveja? Por favor! Eu sou pobre :(
+```
+
+## Pronto para mais?
+
+### Free Online
+
+* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [Ideas for Python Projects](http://pythonpracticeprojects.com)
+* [The Official Docs](http://docs.python.org/3/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
+* [Python Course](http://www.python-course.eu/index.php)
+* [First Steps With Python](https://realpython.com/learn/python-first-steps/)
+* [A curated list of awesome Python frameworks, libraries and software](https://github.com/vinta/awesome-python)
+* [30 Python Language Features and Tricks You May Not Know About](http://sahandsaba.com/thirty-python-language-features-and-tricks-you-may-not-know.html)
+* [Official Style Guide for Python](https://www.python.org/dev/peps/pep-0008/)
+
+### Dead Tree
+
+* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
+* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
+* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
diff --git a/pt-br/python3-pt.html.markdown b/pt-br/python3-pt.html.markdown
deleted file mode 100644
index bc5f801c..00000000
--- a/pt-br/python3-pt.html.markdown
+++ /dev/null
@@ -1,746 +0,0 @@
----
-language: python3
-contributors:
-    - ["Louie Dinh", "http://pythonpracticeprojects.com"]
-    - ["Steven Basart", "http://github.com/xksteven"]
-    - ["Andre Polykanine", "https://github.com/Oire"]
-    - ["Zachary Ferguson", "http://github.com/zfergus2"]
-translators:
-    - ["Paulo Henrique Rodrigues Pinheiro", "http://www.sysincloud.it"]
-    - ["Monique Baptista", "https://github.com/bfmonique"]
-lang: pt-br
-filename: learnpython3-pt.py
----
-
-Python foi criada por Guido Van Rossum nos anos 1990. Ela é atualmente uma
-das linguagens mais populares existentes. Eu me apaixonei por
-Python por sua clareza sintática. É praticamente pseudocódigo executável.
-
-Opniões são muito bem vindas. Você pode encontrar-me em
-[@louiedinh](http://twitter.com/louiedinh) ou louiedinh [em]
-[serviço de e-mail do google].
-
-Observação: Este artigo trata de Python 3 especificamente. Verifique
-[aqui](http://learnxinyminutes.com/docs/pt-br/python-pt/) se você pretende
-aprender o velho Python 2.7.
-
-```python
-
-# Comentários em uma única linha começam com uma cerquilha (também conhecido por sustenido).
-
-""" Strings de várias linhas podem ser escritas
-    usando três ", e são comumente usadas
-    como comentários.
-"""
-
-####################################################
-## 1. Tipos de dados primitivos e operadores
-####################################################
-
-# Você usa números normalmente
-3  # => 3
-
-# Matemática é como você espera que seja
-1 + 1   # => 2
-8 - 1   # => 7
-10 * 2  # => 20
-
-# Números são inteiros por padrão, exceto na divisão, que retorna número
-# de ponto flutuante (float).
-35 / 5  # => 7.0
-
-# O resultado da divisão inteira arredonda para baixo tanto para números
-# positivos como para negativos.
-5 // 3       # => 1
-5.0 // 3.0   # => 1.0 # funciona em float também
--5 // 3      # => -2
--5.0 // 3.0  # => -2.0
-
-# Quando você usa um float, o resultado é float.
-3 * 2.0  # => 6.0
-
-# operador módulo
-7 % 3  # => 1
-
-# Exponenciação (x**y, x elevado à potência y)
-2**4  # => 16
-
-# Determine a precedência usando parênteses
-(1 + 3) * 2  # => 8
-
-# Valores lógicos são primitivos (Atenção à primeira letra maiúscula)
-True
-False
-
-# negação lógica com not
-not True   # => False
-not False  # => True
-
-# Operadores lógicos
-# Observe que "and" e "or" são sensíveis a maiúsculas e minúsculas
-True and False  # => False
-False or True   # => True
-
-# Observe a utilização de operadores lógicos com números inteiros
-0 and 2     # => 0
--5 or 0     # => -5
-0 == False  # => True
-2 == True   # => False
-1 == True   # => True
-
-# Igualdade é ==
-1 == 1  # => True
-2 == 1  # => False
-
-# Diferença é !=
-1 != 1  # => False
-2 != 1  # => True
-
-# Mais comparações
-1 < 10  # => True
-1 > 10  # => False
-2 <= 2  # => True
-2 >= 2  # => True
-
-# Comparações podem ser agrupadas
-1 < 2 < 3  # => True
-2 < 3 < 2  # => False
-
-# 'is' verifica se duas variáveis representam o mesmo endereço
-# na memória; '==' verifica se duas variáveis têm o mesmo valor
-a = [1, 2, 3, 4]  # Referência a uma nova lista, [1, 2, 3, 4]
-b = a             # b referencia o que está referenciado por a
-b is a            # => True, a e b referenciam o mesmo objeto
-b == a            # => True, objetos a e b tem o mesmo conteúdo
-b = [1, 2, 3, 4]  # Referência a uma nova lista, [1, 2, 3, 4]
-b is a            # => False, a e b não referenciam o mesmo objeto
-b == a            # => True, objetos a e b tem o mesmo conteúdo
-
-# Strings são criadas com " ou '
-"Isto é uma string."
-'Isto também é uma string.'
-
-# Strings também podem ser somadas! Mas tente não fazer isso.
-"Olá " + "mundo!"  # => "Olá mundo!"
-# Strings podem ser somadas sem usar o '+'
-"Olá " "mundo!"    # => "Olá mundo!"
-
-# Uma string pode ser manipulada como se fosse uma lista de caracteres
-"Isso é uma string"[0]  # => 'I'
-
-# .format pode ser usado para formatar strings, dessa forma:
-"{} podem ser {}".format("Strings", "interpoladas")  # => "Strings podem ser interpoladas"
-
-# Você pode repetir os argumentos para digitar menos.
-"Seja ágil {0}, seja rápido {0}, salte sobre o {1} {0}".format("Jack", "castiçal")
-# => "Seja ágil Jack, seja rápido Jack, salte sobre o castiçal Jack."
-
-# Você pode usar palavras-chave se quiser contar.
-"{nome} quer comer {comida}".format(nome="Beto", comida="lasanha")  # => "Beto quer comer lasanha"
-
-# Se você precisa executar seu código Python3 com um interpretador Python 2.5 ou acima, você pode usar a velha forma para formatação de texto:
-"%s podem ser %s da forma %s" % ("Strings", "interpoladas", "antiga")  # => "Strings podem ser interpoladas da forma antiga"
-
-
-# None é um objeto
-None  # => None
-
-# Não use o operador de igualdade "==" para comparar objetos com None
-# Use "is" para isso. Ele checará pela identidade dos objetos.
-"etc" is None  # => False
-None is None   # => True
-
-# None, 0, e strings/listas/dicionários vazios todos retornam False.
-# Qualquer outra coisa retorna True
-bool(0)   # => False
-bool("")  # => False
-bool([])  # => False
-bool({})  # => False
-
-
-####################################################
-## 2. Variáveis e coleções
-####################################################
-
-# Python tem uma função print
-print("Eu sou o Python. Prazer em conhecer!")  # => Eu sou o Python. Prazer em conhecer!
-
-# Por padrão a função print também imprime o caractere de nova linha ao final.
-# Use o argumento opcional end para mudar o caractere final.
-print("Olá, Mundo", end="!")  # => Olá, Mundo!
-
-# Forma simples para capturar dados de entrada via console
-input_string_var = input("Digite alguma coisa: ") # Retorna o que foi digitado em uma string
-# Observação: Em versões antigas do Python, o método input() era chamado raw_input()
-
-# Não é necessário declarar variáveis antes de iniciá-las
-# É uma convenção usar letras_minúsculas_com_sublinhados
-alguma_variavel = 5
-alguma_variavel  # => 5
-
-# Acessar uma variável que não tenha sido inicializada gera uma exceção.
-# Veja Controle de Fluxo para aprender mais sobre tratamento de exceções.
-alguma_variavel_nao_inicializada  # Gera a exceção NameError
-
-# Listas armazenam sequências
-li = []
-# Você pode iniciar uma lista com valores
-outra_li = [4, 5, 6]
-
-# Adicione conteúdo ao fim da lista com append
-li.append(1)    # li agora é [1]
-li.append(2)    # li agora é [1, 2]
-li.append(4)    # li agora é [1, 2, 4]
-li.append(3)    # li agora é [1, 2, 4, 3]
-# Remova do final da lista com pop
-li.pop()        # => 3 e agora li é [1, 2, 4]
-# Vamos colocá-lo lá novamente!
-li.append(3)    # li agora é [1, 2, 4, 3] novamente.
-
-# Acesse uma lista da mesma forma que você faz com um array
-li[0]   # => 1
-# Acessando o último elemento
-li[-1]  # => 3
-
-# Acessar além dos limites gera um IndexError
-li[4]  # Gera o IndexError
-
-# Você pode acessar vários elementos com a sintaxe de limites
-# Inclusivo para o primeiro termo, exclusivo para o segundo
-li[1:3]   # => [2, 4]
-# Omitindo o final
-li[2:]    # => [4, 3]
-# Omitindo o início
-li[:3]    # => [1, 2, 4]
-# Selecione cada segunda entrada
-li[::2]   # => [1, 4]
-# Tenha uma cópia em ordem invertida da lista
-li[::-1]  # => [3, 4, 2, 1]
-# Use qualquer combinação dessas para indicar limites complexos
-# li[inicio:fim:passo]
-
-# Faça uma cópia profunda de um nível usando limites
-li2 = li[:]  # => li2 = [1, 2, 4, 3] mas (li2 is li) resultará em False.
-
-# Apague elementos específicos da lista com "del"
-del li[2]  # li agora é [1, 2, 3]
-
-# Você pode somar listas
-# Observação: valores em li e other_li não são modificados.
-li + other_li  # => [1, 2, 3, 4, 5, 6]
-
-# Concatene listas com "extend()"
-li.extend(other_li)  # Agora li é [1, 2, 3, 4, 5, 6]
-
-# Verifique se algo existe na lista com "in"
-1 in li  # => True
-
-# Examine  tamanho com "len()"
-len(li)  # => 6
-
-
-# Tuplas são como l istas, mas imutáveis.
-tup = (1, 2, 3)
-tup[0]      # => 1
-tup[0] = 3  # Gera um TypeError
-
-# Observe que uma tupla de tamanho um precisa ter uma vírgula depois do
-# último elemento mas tuplas de outros tamanhos, mesmo vazias, não precisa,.
-type((1))   # => <class 'int'>
-type((1,))  # => <class 'tuple'>
-type(())    # => <class 'tuple'>
-
-# Você pode realizar com tuplas a maior parte das operações que faz com listas
-len(tup)         # => 3
-tup + (4, 5, 6)  # => (1, 2, 3, 4, 5, 6)
-tup[:2]          # => (1, 2)
-2 in tup         # => True
-
-# Você pode desmembrar tuplas (ou listas) em variáveis.
-a, b, c = (1, 2, 3)  # a é 1, b é 2 e c é 3
-# Por padrão, tuplas são criadas se você não coloca parêntesis.
-d, e, f = 4, 5, 6
-# Veja como é fácil permutar dois valores
-e, d = d, e  # d é 5, e é 4
-
-# Dicionários armazenam mapeamentos
-empty_dict = {}
-# Aqui está um dicionário preenchido na definição da referência
-filled_dict = {"um": 1, "dois": 2, "três": 3}
-
-# Observe que chaves para dicionários devem ser tipos imutáveis. Isto é para
-# assegurar que a chave pode ser convertida para uma valor hash constante para
-# buscas rápidas.
-# Tipos imutáveis incluem inteiros, flotas, strings e tuplas.
-invalid_dict = {[1,2,3]: "123"}  # => Gera um TypeError: unhashable type: 'list'
-valid_dict = {(1,2,3):[1,2,3]}   # Já os valores, podem ser de qualquer tipo.
-
-# Acesse valores com []
-filled_dict["um"]  # => 1
-
-# Acesse todas as chaves como um iterável com "keys()". É necessário encapsular
-# a chamada com um list() para transformá-las em uma lista. Falaremos sobre isso
-# mais adiante. Observe que a ordem de uma chave de dicionário não é garantida.
-# Por isso, os resultados aqui apresentados podem não ser exatamente como os
-# aqui apresentados.
-list(filled_dict.keys())  # => ["três", "dois", "um"]
-
-
-# Acesse todos os valores de um iterável com "values()". Novamente, é
-# necessário encapsular ele com list() para não termos um iterável, e sim os
-# valores. Observe que, como foi dito acima, a ordem dos elementos não é
-# garantida.
-list(filled_dict.values())  # => [3, 2, 1]
-
-
-# Verifique a existência de chaves em um dicionário com "in"
-"um" in filled_dict  # => True
-1 in filled_dict      # => False
-
-# Acessar uma chave inexistente gera um KeyError
-filled_dict["quatro"]  # KeyError
-
-# Use o método "get()" para evitar um KeyError
-filled_dict.get("um")      # => 1
-filled_dict.get("quatro")     # => None
-# O método get permite um parâmetro padrão para quando não existir a chave
-filled_dict.get("um", 4)   # => 1
-filled_dict.get("quatro", 4)  # => 4
-
-# "setdefault()" insere em dicionário apenas se a dada chave não existir
-filled_dict.setdefault("cinco", 5)  # filled_dict["cinco"] tem valor 5
-filled_dict.setdefault("cinco", 6)  # filled_dict["cinco"] continua 5
-
-# Inserindo em um dicionário
-filled_dict.update({"quatro":4})  # => {"um": 1, "dois": 2, "três": 3, "quatro": 4}
-#filled_dict["quatro"] = 4        #outra forma de inserir em um dicionário
-
-# Remova chaves de um dicionário com del
-del filled_dict["um"]  # Remove a chave "um" de filled_dict
-
-
-# Armazenamento em sets... bem, são conjuntos
-empty_set = set()
-# Inicializa um set com alguns valores. Sim, ele parece um dicionário. Desculpe.
-some_set = {1, 1, 2, 2, 3, 4}  # some_set agora é {1, 2, 3, 4}
-
-# Da mesma forma que chaves em um dicionário, elementos de um set devem ser
-# imutáveis.
-invalid_set = {[1], 1}  # => Gera um TypeError: unhashable type: 'list'
-valid_set = {(1,), 1}
-
-# Pode definir novas variáveis para um conjunto
-filled_set = some_set
-
-# Inclua mais um item no set
-filled_set.add(5)  # filled_set agora é {1, 2, 3, 4, 5}
-
-# Faça interseção de conjuntos com &
-other_set = {3, 4, 5, 6}
-filled_set & other_set  # => {3, 4, 5}
-
-# Faça união de conjuntos com |
-filled_set | other_set  # => {1, 2, 3, 4, 5, 6}
-
-# Faça a diferença entre conjuntos com -
-{1, 2, 3, 4} - {2, 3, 5}  # => {1, 4}
-
-# Verifique a existência em um conjunto com in
-2 in filled_set   # => True
-10 in filled_set  # => False
-
-
-
-####################################################
-## 3. Controle de fluxo e iteráveis
-####################################################
-
-# Iniciemos um variável
-some_var = 5
-
-# Aqui está uma expressão if. Indentação é significante em python!
-# imprime "somevar é menor que10"
-if some_var > 10:
-    print("some_var é absolutamente maior que 10.")
-elif some_var < 10:    # Esta cláusula elif é opcional.
-    print("some_var é menor que 10.")
-else:                  # Isto também é opcional.
-    print("some_var é, de fato, 10.")
-
-
-"""
-Laços for iteram sobre listas
-imprime:
-    cachorro é um mamífero
-    gato é um mamífero
-    rato é um mamífero
-"""
-for animal in ["cachorro", "gato", "rato"]:
-    # Você pode usar format() para interpolar strings formatadas
-    print("{} é um mamífero".format(animal))
-
-"""
-"range(número)" retorna um iterável de números
-de zero até o número escolhido
-imprime:
-    0
-    1
-    2
-    3
-"""
-for i in range(4):
-    print(i)
-
-"""
-"range(menor, maior)" gera um iterável de números
-começando pelo menor até o maior
-imprime:
-    4
-    5
-    6
-    7
-"""
-for i in range(4, 8):
-    print(i)
-
-"""
-"range(menor, maior, passo)" retorna um iterável de números
-começando pelo menor número até o maior númeno, pulando de
-passo em passo. Se o passo não for indicado, o valor padrão é um.
-imprime:
-    4
-    6
-"""
-for i in range(4, 8, 2):
-    print(i)
-"""
-
-Laços while executam até que a condição não seja mais válida.
-imprime:
-    0
-    1
-    2
-    3
-"""
-x = 0
-while x < 4:
-    print(x)
-    x += 1  # Maneira mais curta para for x = x + 1
-
-# Lide com exceções com um bloco try/except
-try:
-    # Use "raise" para gerar um erro
-    raise IndexError("Isto é um erro de índice")
-except IndexError as e:
-    pass                 # Pass é um não-operador. Normalmente você usa algum código de recuperação aqui.
-except (TypeError, NameError):
-    pass                 # Varias exceções podem ser gerenciadas, se necessário.
-else:                    # Cláusula opcional para o bloco try/except. Deve estar após todos os blocos de exceção.
-    print("Tudo certo!")   # Executa apenas se o código em try não gera exceção
-finally:                 #  Sempre é executado
-    print("Nós podemos fazer o código de limpeza aqui.")
-
-# Ao invés de try/finally para limpeza você pode usar a cláusula with
-with open("myfile.txt") as f:
-    for line in f:
-        print(line)
-
-# Python provê uma abstração fundamental chamada Iterável.
-# Um iterável é um objeto que pode ser tratado como uma sequência.
-# O objeto retornou a função range, um iterável.
-
-filled_dict = {"um": 1, "dois": 2, "três": 3}
-our_iterable = filled_dict.keys()
-print(our_iterable)  # => range(1,10). Esse é um objeto que implementa nossa interface iterável.
-
-# Nós podemos percorrê-la.
-for i in our_iterable:
-    print(i)  # Imprime um, dois, três
-
-# Mas não podemos acessar os elementos pelo seu índice.
-our_iterable[1]  # Gera um TypeError
-
-# Um iterável é um objeto que sabe como criar um iterador.
-our_iterator = iter(our_iterable)
-
-# Nosso iterador é um objeto que pode lembrar o estado enquanto nós o percorremos.
-# Nós acessamos o próximo objeto com "next()".
-next(our_iterator)  # => "um"
-
-# Ele mantém o estado enquanto nós o percorremos.
-next(our_iterator)  # => "dois"
-next(our_iterator)  # => "três"
-
-# Após o iterador retornar todos os seus dados, ele gera a exceção StopIterator
-next(our_iterator)  # Gera StopIteration
-
-# Você pode capturar todos os elementos de um iterador aplicando list() nele.
-list(filled_dict.keys())  # => Retorna ["um", "dois", "três"]
-
-
-####################################################
-## 4. Funções
-####################################################
-
-# Use "def" para criar novas funções.
-def add(x, y):
-    print("x é {} e y é {}".format(x, y))
-    return x + y  # Retorne valores com a cláusula return
-
-# Chamando funções com parâmetros
-add(5, 6)  # => imprime "x é 5 e y é 6" e retorna 11
-
-# Outro meio de chamar funções é com argumentos nomeados
-add(y=6, x=5)  # Argumentos nomeados podem aparecer em qualquer ordem.
-
-# Você pode definir funções que pegam um número variável de argumentos
-# posicionais
-def varargs(*args):
-    return args
-
-varargs(1, 2, 3)  # => (1, 2, 3)
-
-# Você pode definir funções que pegam um número variável de argumentos nomeados
-# também
-def keyword_args(**kwargs):
-    return kwargs
-
-# Vamos chamá-lo para ver o que acontece
-keyword_args(peh="grande", lago="ness")  # => {"peh": "grande", "lago": "ness"}
-
-
-# Você pode fazer ambos simultaneamente, se você quiser
-def all_the_args(*args, **kwargs):
-    print(args)
-    print(kwargs)
-"""
-all_the_args(1, 2, a=3, b=4) imprime:
-    (1, 2)
-    {"a": 3, "b": 4}
-"""
-
-# Quando chamar funções, você pode fazer o oposto de args/kwargs!
-# Use * para expandir tuplas e use ** para expandir dicionários!
-args = (1, 2, 3, 4)
-kwargs = {"a": 3, "b": 4}
-all_the_args(*args)            # equivalente a foo(1, 2, 3, 4)
-all_the_args(**kwargs)         # equivalente a foo(a=3, b=4)
-all_the_args(*args, **kwargs)  # equivalente a foo(1, 2, 3, 4, a=3, b=4)
-
-# Retornando múltiplos valores (com atribuição de tuplas)
-def swap(x, y):
-    return y, x  # Retorna múltiplos valores como uma tupla sem os parêntesis.
-                 # (Observação: os parêntesis foram excluídos mas podem estar
-                 # presentes)
-
-x = 1
-y = 2
-x, y = swap(x, y)     # => x = 2, y = 1
-# (x, y) = swap(x,y)  # Novamente, os parêntesis foram excluídos mas podem estar presentes.
-
-# Escopo de função
-x = 5
-
-def setX(num):
-    # A variável local x não é a mesma variável global x
-    x = num    # => 43
-    print (x)  # => 43
-
-def setGlobalX(num):
-    global x
-    print (x)  # => 5
-    x = num    # variável global x agora é 6
-    print (x)  # => 6
-
-setX(43)
-setGlobalX(6)
-
-
-# Python tem funções de primeira classe
-def create_adder(x):
-    def adder(y):
-        return x + y
-    return adder
-
-add_10 = create_adder(10)
-add_10(3)   # => 13
-
-# Também existem as funções anônimas
-(lambda x: x > 2)(3)                  # => True
-(lambda x, y: x ** 2 + y ** 2)(2, 1)  # => 5
-
-# TODO - Fix for iterables
-# Existem funções internas de alta ordem
-map(add_10, [1, 2, 3])          # => [11, 12, 13]
-map(max, [1, 2, 3], [4, 2, 1])  # => [4, 2, 3]
-
-filter(lambda x: x > 5, [3, 4, 5, 6, 7])  # => [6, 7]
-
-# Nós podemos usar compreensão de lista para interessantes mapas e filtros
-# Compreensão de lista armazena a saída como uma lista que pode ser uma lista
-# aninhada
-[add_10(i) for i in [1, 2, 3]]         # => [11, 12, 13]
-[x for x in [3, 4, 5, 6, 7] if x > 5]  # => [6, 7]
-
-####################################################
-## 5. Classes
-####################################################
-
-
-# Nós usamos o operador "class" para ter uma classe
-class Human:
-
-    # Um atributo de classe. Ele é compartilhado por todas as instâncias dessa
-    # classe.
-    species = "H. sapiens"
-
-    # Construtor básico, é chamado quando esta classe é instanciada.
-    # Note que dois sublinhados no início e no final de uma identificados
-    # significa objetos ou atributos que são usados pelo python mas vivem em
-    # um namespace controlado pelo usuário. Métodos (ou objetos ou atributos)
-    # como: __init__, __str__, __repr__, etc. são chamados métodos mágicos (ou
-    # algumas vezes chamados métodos dunder - "double underscore")
-    # Você não deve usar nomes assim por sua vontade.
-    def __init__(self, name):
-        @ Atribui o argumento ao atributo da  instância
-        self.name = name
-
-    # Um método de instância. Todos os métodos tem "self" como primeiro
-    # argumento
-    def say(self, msg):
-        return "{name}: {message}".format(name=self.name, message=msg)
-
-    # Um método de classe é compartilhado por todas as instâncias
-    # Eles são chamados com a classe requisitante como primeiro argumento
-    @classmethod
-    def get_species(cls):
-        return cls.species
-
-    # Um método estático é chamado sem uma referência a classe ou instância
-    @staticmethod
-    def grunt():
-        return "*grunt*"
-
-
-# Instancie uma classe
-i = Human(name="Ian")
-print(i.say("oi"))     # imprime "Ian: oi"
-
-j = Human("Joel")
-print(j.say("olá"))  # imprime "Joel: olá"
-
-# Chama nosso método de classe
-i.get_species()  # => "H. sapiens"
-
-# Altera um atributo compartilhado
-Human.species = "H. neanderthalensis"
-i.get_species()  # => "H. neanderthalensis"
-j.get_species()  # => "H. neanderthalensis"
-
-# Chama o método estático
-Human.grunt()    # => "*grunt*"
-
-
-####################################################
-## 6. Módulos
-####################################################
-
-# Você pode importar módulos
-import math
-print(math.sqrt(16))  # => 4.0
-
-# Você pode importar apenas funções específicas de um módulo
-from math import ceil, floor
-print(ceil(3.7))   # => 4.0
-print(floor(3.7))  # => 3.0
-
-# Você pode importar todas as funções de um módulo para o namespace atual
-# Atenção: isso não é recomendado
-from math import *
-
-# Você pode encurtar o nome dos módulos
-import math as m
-math.sqrt(16) == m.sqrt(16)  # => True
-
-# Módulos python são apenas arquivos python comuns. Você
-# pode escrever os seus, e importá-los. O nome do
-# módulo é o mesmo nome do arquivo.
-
-# Você pode procurar que atributos e funções definem um módulo.
-import math
-dir(math)
-
-
-####################################################
-## 7. Avançado
-####################################################
-
-# Geradores podem ajudar você a escrever código "preguiçoso"
-def double_numbers(iterable):
-    for i in iterable:
-        yield i + i
-
-# Um gerador cria valores conforme necessário.
-# Ao invés de gerar e retornar todos os valores de uma só vez ele cria um em
-# cada interação. Isto significa que valores maiores que 15 não serão
-# processados em double_numbers.
-# Nós usamos um sublinhado ao final do nome das variáveis quando queremos usar
-# um nome que normalmente colide com uma palavra reservada do python.
-range_ = range(1, 900000000)
-# Multiplica por 2 todos os números até encontrar um resultado >= 30
-for i in double_numbers(range_):
-    print(i)
-    if i >= 30:
-        break
-
-
-# Decoradores
-# Neste exemplo beg encapsula say
-# beg irá chamar say. Se say_please é verdade então ele irá mudar a mensagem
-# retornada
-from functools import wraps
-
-
-def beg(target_function):
-    @wraps(target_function)
-    def wrapper(*args, **kwargs):
-        msg, say_please = target_function(*args, **kwargs)
-        if say_please:
-            return "{} {}".format(msg, "Por favor! Eu sou pobre :(")
-        return msg
-
-    return wrapper
-
-
-@beg
-def say(say_please=False):
-    msg = "Você me paga uma cerveja?"
-    return msg, say_please
-
-
-print(say())                # Você me paga uma cerveja?
-print(say(say_please=True)) # Você me paga uma cerveja? Por favor! Eu sou pobre :(
-```
-
-## Pronto para mais?
-
-### Free Online
-
-* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
-* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
-* [Dive Into Python](http://www.diveintopython.net/)
-* [Ideas for Python Projects](http://pythonpracticeprojects.com)
-* [The Official Docs](http://docs.python.org/3/)
-* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
-* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
-* [Python Course](http://www.python-course.eu/index.php)
-* [First Steps With Python](https://realpython.com/learn/python-first-steps/)
-* [A curated list of awesome Python frameworks, libraries and software](https://github.com/vinta/awesome-python)
-* [30 Python Language Features and Tricks You May Not Know About](http://sahandsaba.com/thirty-python-language-features-and-tricks-you-may-not-know.html)
-* [Official Style Guide for Python](https://www.python.org/dev/peps/pep-0008/)
-
-### Dead Tree
-
-* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
-* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
-* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
-- 
cgit v1.2.3


From 95c8b24ebf8b8e0ed02923787a9f793bdf295200 Mon Sep 17 00:00:00 2001
From: Simon Shine <shreddedglory@gmail.com>
Date: Wed, 12 Feb 2020 05:09:13 +0100
Subject: Python 2 'language': Python 2 (legacy)

Instead of listing 'language: python' for Python 2, use

    language: Python 2 (legacy)

```
find . -iname "*pythonlegacy*" -exec \
  sed -i 's/^language: .*/language: Python 2 (legacy)/' {} \;
```
---
 pt-br/pythonlegacy-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/pythonlegacy-pt.html.markdown b/pt-br/pythonlegacy-pt.html.markdown
index 82b70117..399c193a 100644
--- a/pt-br/pythonlegacy-pt.html.markdown
+++ b/pt-br/pythonlegacy-pt.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: python
+language: Python 2 (legacy)
 contributors:
     - ["Louie Dinh", "http://ldinh.ca"]
 translators:
-- 
cgit v1.2.3


From 8f5fac98958098864b86e2a09d8131d6dafaaddd Mon Sep 17 00:00:00 2001
From: Simon Shine <shreddedglory@gmail.com>
Date: Wed, 12 Feb 2020 05:15:29 +0100
Subject: Python 3: 'language: Python'

Instead of listing 'language: python3' for Python 3, use

    language: Python

as #3450 does.

```
find . -iname "python-*.markdown" -exec \
  sed -i 's/language: python3/language: Python/' {} \;
```
---
 pt-br/python-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/python-pt.html.markdown b/pt-br/python-pt.html.markdown
index bc5f801c..d3dfcb23 100644
--- a/pt-br/python-pt.html.markdown
+++ b/pt-br/python-pt.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: python3
+language: Python
 contributors:
     - ["Louie Dinh", "http://pythonpracticeprojects.com"]
     - ["Steven Basart", "http://github.com/xksteven"]
-- 
cgit v1.2.3


From 887cbee8af080034177734b528819491e73a7a16 Mon Sep 17 00:00:00 2001
From: Simon Shine <shreddedglory@gmail.com>
Date: Wed, 12 Feb 2020 05:50:44 +0100
Subject: Change 'filename:' for Python 2 (legacy)

Before renaming, all Python 2 filenames were 'learnpython-*.py'.

This commit renames them to 'learnpythonlegacy-*.py'.

To verify that the filenames were named consistently across
translations prior to this commit, and to change this:

```
find . -name "pythonlegacy*.markdown" -exec ack filename: {} \;

find . -name "pythonlegacy*.markdown" -exec \
  sed -i 's/^filename: learnpython/filename: learnpythonlegacy/' {} \;
```
---
 pt-br/pythonlegacy-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/pythonlegacy-pt.html.markdown b/pt-br/pythonlegacy-pt.html.markdown
index 399c193a..572bb787 100644
--- a/pt-br/pythonlegacy-pt.html.markdown
+++ b/pt-br/pythonlegacy-pt.html.markdown
@@ -5,7 +5,7 @@ contributors:
 translators:
     - ["Vilson Vieira", "http://automata.cc"]
 lang: pt-br
-filename: learnpython-pt.py
+filename: learnpythonlegacy-pt.py
 ---
 
 Python foi criado por Guido Van Rossum no começo dos anos 90. Atualmente é uma
-- 
cgit v1.2.3


From ae848c481fabaca935ffbe33293a43a43434d268 Mon Sep 17 00:00:00 2001
From: Simon Shine <shreddedglory@gmail.com>
Date: Wed, 12 Feb 2020 06:23:31 +0100
Subject: Python 3: Use 'filename: learnpython*.py' (no '3')

Before renaming, Python 3 filenames were 'learnpython3*.py'.

This commit removes the '3' part from the filename.

To verify that the filenames were named consistently across
translations prior to this commit, and to change this:

```
ack -H 'filename:' python.html.markdown
find . -name "python-*.markdown" -exec ack -H 'filename:' {} \;

sed -i 's/^filename: learnpython3/filename: learnpython/' \
  python.html.markdown

find . -name "python-*.markdown" -exec \
  sed -i 's/^filename: learnpython3/filename: learnpython/' {} \;
```
---
 pt-br/python-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/python-pt.html.markdown b/pt-br/python-pt.html.markdown
index d3dfcb23..3f9c54c1 100644
--- a/pt-br/python-pt.html.markdown
+++ b/pt-br/python-pt.html.markdown
@@ -9,7 +9,7 @@ translators:
     - ["Paulo Henrique Rodrigues Pinheiro", "http://www.sysincloud.it"]
     - ["Monique Baptista", "https://github.com/bfmonique"]
 lang: pt-br
-filename: learnpython3-pt.py
+filename: learnpython-pt.py
 ---
 
 Python foi criada por Guido Van Rossum nos anos 1990. Ela é atualmente uma
-- 
cgit v1.2.3


From 5864aba42d2cf57dfe96049568b3a9689ea6a813 Mon Sep 17 00:00:00 2001
From: Leigh Brenecki <l@leigh.net.au>
Date: Thu, 13 Feb 2020 10:38:29 +1030
Subject: Purge my deadname

---
 pt-br/javascript-pt.html.markdown | 6 +++---
 pt-br/yaml-pt.html.markdown       | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/javascript-pt.html.markdown b/pt-br/javascript-pt.html.markdown
index f12d275b..e38804f3 100644
--- a/pt-br/javascript-pt.html.markdown
+++ b/pt-br/javascript-pt.html.markdown
@@ -2,7 +2,7 @@
 language: javascript
 filename: javascript-pt.js
 contributors:
-    - ["Adam Brenecki", "http://adam.brenecki.id.au"]
+    - ["Leigh Brenecki", "https://leigh.net.au"]
     - ["Ariel Krakowski", "http://www.learneroo.com"]
 translators:
     - ["Willian Justen", "http://willianjusten.com.br"]
@@ -20,8 +20,8 @@ que é um projeto que fornece um interpretador baseado no motor V8 do Google
 Chrome e está se tornando cada vez mais famoso.
 
 Feedback são muito apreciados! Você me encontrar em
-[@adambrenecki](https://twitter.com/adambrenecki), ou
-[adam@brenecki.id.au](mailto:adam@brenecki.id.au).
+[@ExcitedLeigh](https://twitter.com/ExcitedLeigh), ou
+[l@leigh.net.au](mailto:l@leigh.net.au).
 
 ```js
 // Comentários são como em C. Comentários de uma linha começam com duas barras,
diff --git a/pt-br/yaml-pt.html.markdown b/pt-br/yaml-pt.html.markdown
index 07903325..21e9b4bb 100644
--- a/pt-br/yaml-pt.html.markdown
+++ b/pt-br/yaml-pt.html.markdown
@@ -1,7 +1,7 @@
 ---
 language: yaml
 contributors:
-  - ["Adam Brenecki", "https://github.com/adambrenecki"]
+  - ["Leigh Brenecki", "https://github.com/adambrenecki"]
 translators:
   - ["Rodrigo Russo", "https://github.com/rodrigozrusso"]
 filename: learnyaml-pt.yaml
-- 
cgit v1.2.3


From 0ecb8264293d852f2ef586279885848b621668d1 Mon Sep 17 00:00:00 2001
From: sumanstats <suman81765@gmail.com>
Date: Wed, 10 Jun 2020 16:33:01 +0545
Subject: Perl6 to Raku and many more

+ As the Perl 6 is renamed to raku, it is good to reflect that https://github.com/Raku/problem-solving/blob/master/solutions/language/Path-to-Raku.md

+ perl6.org is now raku.org
+ change references of perl 6 to raku
+ rename file perl6-pod.html.markdown to raku-pod.html.markdown
+ Perl refers to Perl 5, there is no ambiguity after rename of Perl6 to
  Raku, use Perl only to refer to Perl 5
+ fix links inside raku.html.markdown
---
 pt-br/perl-pt.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/perl-pt.html.markdown b/pt-br/perl-pt.html.markdown
index 217861f9..55a10626 100644
--- a/pt-br/perl-pt.html.markdown
+++ b/pt-br/perl-pt.html.markdown
@@ -10,9 +10,9 @@ translators:
 lang: pt-br
 ---
 
-Perl 5 é, uma linguagem de programação altamente capaz, rica em recursos, com mais de 25 anos de desenvolvimento.
+Perl é, uma linguagem de programação altamente capaz, rica em recursos, com mais de 25 anos de desenvolvimento.
 
-Perl 5 roda em mais de 100 plataformas, de portáteis a mainframes e é adequada tanto para prototipagem rápida, quanto em projetos de desenvolvimento em grande escala.
+Perl roda em mais de 100 plataformas, de portáteis a mainframes e é adequada tanto para prototipagem rápida, quanto em projetos de desenvolvimento em grande escala.
 
 ```perl
 # Comentários de uma linha começam com um sinal de número.
-- 
cgit v1.2.3


From 1aa649ecf3120ab0c2564b597f924c320c0e9f50 Mon Sep 17 00:00:00 2001
From: knopftee <knopftee@gmail.com>
Date: Wed, 22 Jul 2020 20:36:39 -0300
Subject: Update sass-pt.html.markdown

Update in sass-pt markdown file with orthography corrections.
---
 pt-br/sass-pt.html.markdown | 67 +++++++++++++++++++++++----------------------
 1 file changed, 34 insertions(+), 33 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/sass-pt.html.markdown b/pt-br/sass-pt.html.markdown
index 3d91f1ca..28df3c59 100644
--- a/pt-br/sass-pt.html.markdown
+++ b/pt-br/sass-pt.html.markdown
@@ -56,19 +56,19 @@ body {
 }
 
 
-/ * Este é muito mais fácil de manter do que ter de mudar a cor
-cada vez que aparece em toda a sua folha de estilo. * /
+/* Este é muito mais fácil de manter do que ter de mudar a cor
+cada vez que aparece em toda a sua folha de estilo. */
 
 
 
 
-/*Mixins
+/* Mixins
 ==============================*/
 
 
 
-/* Se você achar que você está escrevendo o mesmo código para mais de um
-elemento, você pode querer armazenar esse código em um mixin.
+/* Se você achar que está escrevendo o mesmo código para mais de um
+elemento, você pode armazenar esse código em um mixin.
 
 Use a diretiva '@mixin', além de um nome para o seu mixin. */
 
@@ -87,7 +87,7 @@ div {
 	background-color: $primary-color;
 }
 
-/* Apoś compilar ficaria assim: */
+/* Após compilar ficaria assim: */
 div {
 	display: block;
 	margin-left: auto;
@@ -128,7 +128,7 @@ div {
 
 
 
-/*Funções
+/* Funções
 ==============================*/
 
 
@@ -138,6 +138,7 @@ div {
 
 /* Funções pode ser chamado usando seu nome e passando o
     argumentos necessários */
+    
 body {
   width: round(10.25px);
 }
@@ -156,14 +157,14 @@ body {
   background-color: rgba(0, 0, 0, 0.75);
 }
 
-/* Você também pode definir suas próprias funções. As funções são muito semelhantes aos
-   mixins. Ao tentar escolher entre uma função ou um mixin, lembre-
-   que mixins são os melhores para gerar CSS enquanto as funções são melhores para
-   lógica que pode ser usado em todo o seu código Sass. Os exemplos
-   seção Operadores Math 'são candidatos ideais para se tornar um reutilizável
-   função. */
+/* Você também pode definir suas próprias funções. As funções são muito semelhantes 
+   aos mixins. Ao tentar escolher entre uma função ou um mixin, lembre
+   que mixins são os melhores para gerar CSS enquanto as funções são melhores para
+   lógica que pode ser usado em todo o seu código Sass. Os exemplos na 
+   seção "Operações Math" são candidatos ideais para se tornar um função 
+   reutilizável. */
 
-/* Esta função terá um tamanho de destino eo tamanho do pai e calcular
+/* Esta função terá um tamanho de destino e o tamanho do pai (parent), calcular
    e voltar a percentagem */
 
 @function calculate-percentage($target-size, $parent-size) {
@@ -220,21 +221,21 @@ $main-content: calculate-percentage(600px, 960px);
   border-color: #22df56;
 }
 
-/* Ampliando uma declaração CSS é preferível a criação de um mixin
-   por causa da maneira agrupa as classes que todos compartilham
+/* Ao ampliar uma declaração CSS é preferível a criação de um mixin,
+   por causa da maneira em que agrupa as classes com todos que compartilham
    o mesmo estilo base. Se isso for feito com um mixin, a largura,
    altura, e a borda seria duplicado para cada instrução que
    o chamado mixin. Enquanto isso não irá afetar o seu fluxo de trabalho, será
-   adicionar inchaço desnecessário para os arquivos criados pelo compilador Sass. */
+   adicionado inchaço desnecessário para os arquivos criados pelo compilador Sass. */
 
 
 
-/*Assentamento
+/* Assentamento
 ==============================*/
 
 
 
-/ * Sass permite seletores ninhos dentro seletores * /
+/* Sass permite seletores ninhos dentro seletores */
 
 ul {
 	list-style-type: none;
@@ -245,7 +246,7 @@ ul {
 	}
 }
 
-/* '&' será substituído pelo selector pai. */
+/* '&' será substituído pelo selector pai (parent). */
 /* Você também pode aninhar pseudo-classes. */
 /* Tenha em mente que o excesso de nidificação vai fazer seu código menos sustentável.
 Essas práticas também recomendam não vai mais de 3 níveis de profundidade quando nidificação.
@@ -290,7 +291,7 @@ ul li a {
 
 
 
-/*Parciais e Importações
+/* Parciais e Importações
 ==============================*/
 
 
@@ -313,7 +314,7 @@ ol {
 /* Sass oferece @import que pode ser usado para importar parciais em um arquivo.
    Isso difere da declaração CSS @import tradicional, que faz
    outra solicitação HTTP para buscar o arquivo importado. Sass converte os
-   importadas arquivo e combina com o código compilado. */
+   arquivo importados e combina com o código compilado. */
 
 @import 'reset';
 
@@ -322,7 +323,7 @@ body {
   font-family: Helvetica, Arial, Sans-serif;
 }
 
-/* Compiles to: */
+/* Compila para: */
 
 html, body, ul, ol {
   margin: 0;
@@ -336,14 +337,14 @@ body {
 
 
 
-/*Placeholder Selectors
+/* Placeholder Selectors
 ==============================*/  
 
 
-/* Os espaços reservados são úteis na criação de uma declaração CSS para ampliar. Se você
-   queria criar uma instrução CSS que foi usado exclusivamente com @extend,
-   Você pode fazer isso usando um espaço reservado. Espaços reservados começar com um '%' em vez
-   de '.' ou '#'. Espaços reservados não aparece no CSS compilado. * /
+/* Os Placeholders são úteis na criação de uma declaração CSS para ampliar. Se você
+   deseja criar uma instrução CSS que foi usado exclusivamente com @extend,
+   você pode fazer isso usando um Placeholder. Placeholder começar com um '%' em vez
+   de '.' ou '#'. Placeholder não aparece no CSS compilado. */
 
 %content-window {
   font-size: 14px;
@@ -372,14 +373,14 @@ body {
 
 
 
-/*Operações Math
-============================== * /
+/* Operações Math
+============================== */
 
 
 /* Sass fornece os seguintes operadores: +, -, *, /, e %. estes podem
-   ser úteis para calcular os valores diretamente no seu Sass arquivos em vez
-   de usar valores que você já calculados pela mão. Abaixo está um exemplo
-   de uma criação de um projeto simples de duas colunas. * /
+   ser úteis para calcular os valores diretamente no seu arquivos Sass em vez
+   de usar valores que você já calculados manualmente. O exemplo abaixo é
+   de um projeto simples de duas colunas. */
 
 $content-area: 960px;
 $main-content: 600px;
-- 
cgit v1.2.3


From 05439f454dc63fe3b02610295b38903417bc1b47 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adelar=20da=20Silva=20Queir=C3=B3z?= <adelarsq@gmail.com>
Date: Thu, 17 Sep 2020 12:17:19 -0300
Subject: Create fsharp-pt.html.markdown

---
 pt-br/fsharp-pt.html.markdown | 639 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 639 insertions(+)
 create mode 100644 pt-br/fsharp-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/fsharp-pt.html.markdown b/pt-br/fsharp-pt.html.markdown
new file mode 100644
index 00000000..b5078da0
--- /dev/null
+++ b/pt-br/fsharp-pt.html.markdown
@@ -0,0 +1,639 @@
+---
+language: F#
+filename: learnfsharp-pt.fs
+contributors:
+    - ["Scott Wlaschin", "http://fsharpforfunandprofit.com"]
+    - ["Adelar da Silva Queiróz", "https://adelarsq.github.io"]
+lang: pt-br
+---
+
+F# é uma linguagem de propósito geral funcional e orientada a objetos. É livre, de código aberto e executa em Linux, Mac, Windows e outros.
+
+Possui um sistema de tipagem poderoso que evita muitos erros em tempo de compilação. Para isto utilizando inferência de tipos, o que a faz se comportar como uma linguagem dinâmica.
+
+A sintaxe é diferente das linguagens do estilo C (C, C#, Java, etc):
+
+* Chaves não são usadas para delimitar blocos de código. Ao invés disso é utilizada indentação (semelhante ao Python).
+* Espaços em branco são usados para separar parâmetros, ao invés de vírgulas.
+
+Se você deseja executar o código abaixo, copie e cole em [https://try.fsharp.org](https://try.fsharp.org), que é um REPL online.
+
+```fsharp
+
+// comentários de linhas únicas usam barras duplas
+(* comentários de linhas múltiplas usam o par (* . . . *)
+
+-fim do comentário de linhas múltiplas- *)
+
+// ================================================
+// Sintaxe básica
+// ================================================
+
+// ------ "Variáveis" (mas não exatamente) ------
+// A palavra reservada "let" define um valor imutável
+let myInt = 5
+let myFloat = 3.14
+let myString = "hello"           // note que nenhum tipo é necessário
+
+// ------ Listas ------
+let twoToFive = [2; 3; 4; 5]     // Colchetes criam uma lista com
+                                 // ponto e vírgula como delimitadores
+let oneToFive = 1 :: twoToFive   // :: cria uma lista com um novo primeiro elemento
+// O resultado é [1; 2; 3; 4; 5]
+let zeroToFive = [0; 1] @ twoToFive   // @ concatena duas listas
+
+// IMPORTANTE: vírgulas nunca são usadas como delimitadores, somente ponto e vírgula!
+
+// ------ Funções ------
+// A palavra chave "let" também define nomes para funções.
+let square x = x * x          // Note que não são usados parêntesis
+square 3                      // Agora executando a função. Também sem parêntesis
+
+let add x y = x + y           // Não use add (x,y)! Isto significa algo
+                              // completamente diferente.
+add 2 3                       // Agora execute a função.
+
+// para definir uma função de múltiplas linhas apenas use indentação. Nenhum ponto e vírgula é necessário
+let evens list =
+   let isEven x = x % 2 = 0   // Define "isEven" as a sub function. Note
+                              // that equality operator is single char "=".
+   List.filter isEven list    // List.filter is a library function
+                              // with two parameters: a boolean function
+                              // and a list to work on
+
+evens oneToFive               // Now run the function
+
+// You can use parens to clarify precedence. In this example,
+// do "map" first, with two args, then do "sum" on the result.
+// Without the parens, "List.map" would be passed as an arg to List.sum
+let sumOfSquaresTo100 =
+   List.sum ( List.map square [1..100] )
+
+// You can pipe the output of one operation to the next using "|>"
+// Piping data around is very common in F#, similar to UNIX pipes.
+
+// Here is the same sumOfSquares function written using pipes
+let sumOfSquaresTo100piped =
+   [1..100] |> List.map square |> List.sum  // "square" was defined earlier
+
+// you can define lambdas (anonymous functions) using the "fun" keyword
+let sumOfSquaresTo100withFun =
+   [1..100] |> List.map (fun x -> x * x) |> List.sum
+
+// In F# there is no "return" keyword. A function always
+// returns the value of the last expression used.
+
+// ------ Pattern Matching ------
+// Match..with.. is a supercharged case/switch statement.
+let simplePatternMatch =
+   let x = "a"
+   match x with
+    | "a" -> printfn "x is a"
+    | "b" -> printfn "x is b"
+    | _ -> printfn "x is something else"   // underscore matches anything
+
+// F# doesn't allow nulls by default -- you must use an Option type
+// and then pattern match.
+// Some(..) and None are roughly analogous to Nullable wrappers
+let validValue = Some(99)
+let invalidValue = None
+
+// In this example, match..with matches the "Some" and the "None",
+// and also unpacks the value in the "Some" at the same time.
+let optionPatternMatch input =
+   match input with
+    | Some i -> printfn "input is an int=%d" i
+    | None -> printfn "input is missing"
+
+optionPatternMatch validValue
+optionPatternMatch invalidValue
+
+// ------ Printing ------
+// The printf/printfn functions are similar to the
+// Console.Write/WriteLine functions in C#.
+printfn "Printing an int %i, a float %f, a bool %b" 1 2.0 true
+printfn "A string %s, and something generic %A" "hello" [1; 2; 3; 4]
+
+// There are also sprintf/sprintfn functions for formatting data
+// into a string, similar to String.Format in C#.
+
+// ================================================
+// More on functions
+// ================================================
+
+// F# is a true functional language -- functions are first
+// class entities and can be combined easily to make powerful
+// constructs
+
+// Modules are used to group functions together
+// Indentation is needed for each nested module.
+module FunctionExamples =
+
+    // define a simple adding function
+    let add x y = x + y
+
+    // basic usage of a function
+    let a = add 1 2
+    printfn "1 + 2 = %i" a
+
+    // partial application to "bake in" parameters
+    let add42 = add 42
+    let b = add42 1
+    printfn "42 + 1 = %i" b
+
+    // composition to combine functions
+    let add1 = add 1
+    let add2 = add 2
+    let add3 = add1 >> add2
+    let c = add3 7
+    printfn "3 + 7 = %i" c
+
+    // higher order functions
+    [1..10] |> List.map add3 |> printfn "new list is %A"
+
+    // lists of functions, and more
+    let add6 = [add1; add2; add3] |> List.reduce (>>)
+    let d = add6 7
+    printfn "1 + 2 + 3 + 7 = %i" d
+
+// ================================================
+// Listas e coleções
+// ================================================
+
+// There are three types of ordered collection:
+// * Lists are most basic immutable collection.
+// * Arrays are mutable and more efficient when needed.
+// * Sequences are lazy and infinite (e.g. an enumerator).
+//
+// Other collections include immutable maps and sets
+// plus all the standard .NET collections
+
+module ListExamples =
+
+    // lists use square brackets
+    let list1 = ["a"; "b"]
+    let list2 = "c" :: list1    // :: is prepending
+    let list3 = list1 @ list2   // @ is concat
+
+    // list comprehensions (aka generators)
+    let squares = [for i in 1..10 do yield i * i]
+
+    // A prime number generator
+    // - this is using a short notation for the pattern matching syntax
+    // - (p::xs) is 'first :: tail' of the list, could also be written as p :: xs
+    //   this means this matches 'p' (the first item in the list), and xs is the rest of the list
+    //   this is called the 'cons pattern'
+    // - uses 'rec' keyword, which is necessary when using recursion
+    let rec sieve = function
+        | (p::xs) -> p :: sieve [ for x in xs do if x % p > 0 then yield x ]
+        | []      -> []
+    let primes = sieve [2..50]
+    printfn "%A" primes
+
+    // pattern matching for lists
+    let listMatcher aList =
+        match aList with
+        | [] -> printfn "the list is empty"
+        | [first] -> printfn "the list has one element %A " first
+        | [first; second] -> printfn "list is %A and %A" first second
+        | first :: _ -> printfn "the list has more than two elements, first element %A" first
+
+    listMatcher [1; 2; 3; 4]
+    listMatcher [1; 2]
+    listMatcher [1]
+    listMatcher []
+
+    // recursion using lists
+    let rec sum aList =
+        match aList with
+        | [] -> 0
+        | x::xs -> x + sum xs
+    sum [1..10]
+
+    // -----------------------------------------
+    // Standard library functions
+    // -----------------------------------------
+
+    // mapas
+    let add3 x = x + 3
+    [1..10] |> List.map add3
+
+    // filtros
+    let even x = x % 2 = 0
+    [1..10] |> List.filter even
+
+    // muito mais -- veja a documentação
+
+module ArrayExamples =
+
+    // arrays usam colchetes com barra vertical
+    let array1 = [| "a"; "b" |]
+    let first = array1.[0]        // acesso por índice usando ponto
+
+    // casamento de padrões (pattern matching) para arrays é feito da mesma forma que de listas
+    let arrayMatcher aList =
+        match aList with
+        | [| |] -> printfn "the array is empty"
+        | [| first |] -> printfn "the array has one element %A " first
+        | [| first; second |] -> printfn "array is %A and %A" first second
+        | _ -> printfn "the array has more than two elements"
+
+    arrayMatcher [| 1; 2; 3; 4 |]
+
+    // As funções da biblioteca padrão são as mesmas que para List
+
+    [| 1..10 |]
+    |> Array.map (fun i -> i + 3)
+    |> Array.filter (fun i -> i % 2 = 0)
+    |> Array.iter (printfn "value is %i. ")
+
+
+module SequenceExamples =
+
+    // sequências usam chaves
+    let seq1 = seq { yield "a"; yield "b" }
+
+    // sequências podem usar yield e
+    // podem conter subsequencias
+    let strange = seq {
+        // "yield" adiciona um elemento
+        yield 1; yield 2;
+
+        // "yield!" adiciona uma subsequencia
+        yield! [5..10]
+        yield! seq {
+            for i in 1..10 do
+              if i % 2 = 0 then yield i }}
+    // teste
+    strange |> Seq.toList
+
+    // Sequências podem ser criadas usando "unfold"
+    // Este é um exemplo da série de Fibonacci
+    let fib = Seq.unfold (fun (fst,snd) ->
+        Some(fst + snd, (snd, fst + snd))) (0,1)
+
+    // teste
+    let fib10 = fib |> Seq.take 10 |> Seq.toList
+    printf "first 10 fibs are %A" fib10
+
+
+// ================================================
+// Tipos de dados
+// ================================================
+
+module DataTypeExamples =
+
+    // Todos os dados são imutáveis por padrão
+
+    // Tuplas são uma forma rápida de reprentar n elementos de tipos anônimos
+    // -- Use a vírgula para criar uma tupla
+    let twoTuple = 1, 2
+    let threeTuple = "a", 2, true
+
+    // Casamento de padrões (pattern match) para desconstruir
+    let x, y = twoTuple  // atribui x = 1, y = 2
+
+    // ------------------------------------
+    // O tipo registro possui nomes nos campos
+    // ------------------------------------
+
+    // Use "type" com chaves para definir um registro
+    type Person = {First:string; Last:string}
+
+    // Use "let" com chaves para criar um registro
+    let person1 = {First="John"; Last="Doe"}
+
+    // Casamento de padrões para desconstruir
+    let {First = first} = person1    // atribui first="John"
+
+    // ------------------------------------
+    // Tipos union (variantes) possuem um conjunto de escolhas
+    // Somente um caso pode ser válido por vez.
+    // ------------------------------------
+
+    // Use "type" com barra/pipe para definir um union
+    type Temp =
+        | DegreesC of float
+        | DegreesF of float
+
+    // Use qualquer dos tipos para criar um
+    let temp1 = DegreesF 98.6
+    let temp2 = DegreesC 37.0
+
+    // Casamento de padrões deve cobrir todos os tipos de definidos para desconstruir
+    let printTemp = function
+       | DegreesC t -> printfn "%f degC" t
+       | DegreesF t -> printfn "%f degF" t
+
+    printTemp temp1
+    printTemp temp2
+
+    // ------------------------------------
+    // Tipos recursivos
+    // ------------------------------------
+
+    // Tipos podem ser combinados recursivamente de formas complexas
+    // sem ter que criar subclasses
+    type Employee =
+      | Worker of Person
+      | Manager of Employee list
+
+    let jdoe = {First="John"; Last="Doe"}
+    let worker = Worker jdoe
+
+    // ------------------------------------
+    // Modelando com tipos
+    // ------------------------------------
+
+    // Tipos union são muito bons para modelagem de estados sem usar flags
+    type EmailAddress =
+        | ValidEmailAddress of string
+        | InvalidEmailAddress of string
+
+    let trySendEmail email =
+        match email with // casamento de padrões
+        | ValidEmailAddress address -> ()   // envia
+        | InvalidEmailAddress address -> () // não envia
+
+    // A combinação de tipos union e registros juntos
+    // provê uma grande fundação para DDD (Domain Driven Design).
+    // Você pode criar centenas de pequenos tipos que refletem
+    // exatamente o seu domínio.
+
+    type CartItem = { ProductCode: string; Qty: int }
+    type Payment = Payment of float
+    type ActiveCartData = { UnpaidItems: CartItem list }
+    type PaidCartData = { PaidItems: CartItem list; Payment: Payment}
+
+    type ShoppingCart =
+        | EmptyCart  // nenhum dado
+        | ActiveCart of ActiveCartData
+        | PaidCart of PaidCartData
+
+    // ------------------------------------
+    // Comportamento padrão para tipos
+    // ------------------------------------
+
+    // Tipos padrões possuem um padrão já definido, não precisando de codificação nenhuma.
+    // * Imutáveis
+    // * Impressão formatada para depuração
+    // * Igualdade e comparação
+    // * Serialização
+
+    // Impressão formatada usando %A
+    printfn "twoTuple=%A,\nPerson=%A,\nTemp=%A,\nEmployee=%A"
+             twoTuple person1 temp1 worker
+
+    // Igualdade e comparação padrão.
+    // Um exemplo com cartas:
+    type Suit = Club | Diamond | Spade | Heart
+    type Rank = Two | Three | Four | Five | Six | Seven | Eight
+                | Nine | Ten | Jack | Queen | King | Ace
+
+    let hand = [ Club, Ace; Heart, Three; Heart, Ace;
+                 Spade, Jack; Diamond, Two; Diamond, Ace ]
+
+    // ordenando
+    List.sort hand |> printfn "sorted hand is (low to high) %A"
+    List.max hand |> printfn "high card is %A"
+    List.min hand |> printfn "low card is %A"
+
+
+// ================================================
+// Padrões ativos (Active patterns)
+// ================================================
+
+module ActivePatternExamples =
+
+    // F# possui um tipo especial de casamento de padrões chamado "padrões ativos" ("active patterns")
+    // onde o padrão pode ser interpretado ou detectado dinamicamente.
+
+    // parêntesis e barra são a sintaxe para "padrões ativos"
+
+    // Você pode usar "elif" ao invés de "else if" em expressões condicionais.
+    // Elas são equivalentes em F#
+
+    // por exemplo, defina um "padrão ativo" para tratar tipos de caracteres...
+    let (|Digit|Letter|Whitespace|Other|) ch =
+       if System.Char.IsDigit(ch) then Digit
+       elif System.Char.IsLetter(ch) then Letter
+       elif System.Char.IsWhiteSpace(ch) then Whitespace
+       else Other
+
+    // ... e então use ele para interpretar de forma bem mais simples
+    let printChar ch =
+      match ch with
+      | Digit -> printfn "%c is a Digit" ch
+      | Letter -> printfn "%c is a Letter" ch
+      | Whitespace -> printfn "%c is a Whitespace" ch
+      | _ -> printfn "%c is something else" ch
+
+    // imprima a lista
+    ['a'; 'b'; '1'; ' '; '-'; 'c'] |> List.iter printChar
+
+    // ------------------------------------------------
+    // FizzBuzz usando padrões ativos (active patterns)
+    // ------------------------------------------------
+
+    // É possível criar casamento de padrões parcial também
+    // Apenas use sublinhado para a definição, e retorne Some se casado.
+    let (|MultOf3|_|) i = if i % 3 = 0 then Some MultOf3 else None
+    let (|MultOf5|_|) i = if i % 5 = 0 then Some MultOf5 else None
+
+    // a função principal
+    let fizzBuzz i =
+      match i with
+      | MultOf3 & MultOf5 -> printf "FizzBuzz, "
+      | MultOf3 -> printf "Fizz, "
+      | MultOf5 -> printf "Buzz, "
+      | _ -> printf "%i, " i
+
+    // teste
+    [1..20] |> List.iter fizzBuzz
+
+// ================================================
+// Expressividade
+// ================================================
+
+module AlgorithmExamples =
+
+    // F# possui uma alta razão sinais/ruídos, assim o código
+    // é lido praticamento como se descreve o algoritmo
+
+    // ------ Exemplo: defina uma função que faça soma dos quadrados ------
+    let sumOfSquares n =
+       [1..n]              // 1) pega todos os números de 1 a n
+       |> List.map square  // 2) eleva ao quadrado cada um
+       |> List.sum         // 3) soma os resultados
+
+    // teste
+    sumOfSquares 100 |> printfn "Sum of squares = %A"
+
+    // ------ Examplo: defina uma função de ordenação ------
+    let rec sort list =
+       match list with
+       // Se a lista está vazia
+       | [] ->
+            []                            // retorna a lista vazia
+       // Se a lista não está vazia
+       | firstElem::otherElements ->      // pega o primeiro elemento
+            let smallerElements =         // extrai os elementos menores
+                otherElements             // dos restantes
+                |> List.filter (fun e -> e < firstElem)
+                |> sort                   // e ordena eles
+            let largerElements =          // extrai os elementos maiores
+                otherElements             // dos restantes
+                |> List.filter (fun e -> e >= firstElem)
+                |> sort                   // e ordena eles
+            // Combine as 3 partes em uma nova lista e retorne ela
+            List.concat [smallerElements; [firstElem]; largerElements]
+
+    // teste
+    sort [1; 5; 23; 18; 9; 1; 3] |> printfn "Sorted = %A"
+
+// ================================================
+// Código assíncrono
+// ================================================
+
+module AsyncExample =
+
+    // F# possui suporte a funcionalidades para ajudar a escrever código assíncrono
+    // sem tornar o código difícil de manter ("pyramid of doom")
+    //
+    // O seguinte exemplo efetua download de um conjunto de páginas em paralelo.
+
+    open System.Net
+    open System
+    open System.IO
+    open Microsoft.FSharp.Control.CommonExtensions
+
+    // Obtém o conteúdo de cara página de forma assíncrona
+    let fetchUrlAsync url =
+        async {   // a palavra chave "async" e chaves
+                  // criam um objeto assíncrono
+            let req = WebRequest.Create(Uri(url))
+            use! resp = req.AsyncGetResponse()
+                // use! é uma atribuição assíncrona
+            use stream = resp.GetResponseStream()
+                // "use" dispara automaticamente close()
+                // no recurso no fim do escopo
+            use reader = new IO.StreamReader(stream)
+            let html = reader.ReadToEnd()
+            printfn "finished downloading %s" url
+            }
+
+    // uma lista de sites para fazer download
+    let sites = ["http://www.bing.com";
+                 "http://www.google.com";
+                 "http://www.microsoft.com";
+                 "http://www.amazon.com";
+                 "http://www.yahoo.com"]
+
+    // efetue
+    sites
+    |> List.map fetchUrlAsync  // cria uma lista de tarefas assíncronas
+    |> Async.Parallel          // coloca as tarefas para executarem em paralelo
+    |> Async.RunSynchronously  // inicia cada uma
+
+// ================================================
+// Compatibilidade com .NET
+// ================================================
+
+module NetCompatibilityExamples =
+
+    // F# pode pode fazer praticamente tudo que C# pode fazer, e integra
+    // de forma simples com bibliotecas .NET e Mono
+
+    // ------- usando uma função de uma biblioteca existente -------
+
+    let (i1success, i1) = System.Int32.TryParse("123");
+    if i1success then printfn "parsed as %i" i1 else printfn "parse failed"
+
+    // ------- Implementando interfaces de forma simples! -------
+
+    // cria um novo objeto que implementa IDisposable
+    let makeResource name =
+       { new System.IDisposable
+         with member this.Dispose() = printfn "%s disposed" name }
+
+    let useAndDisposeResources =
+        use r1 = makeResource "first resource"
+        printfn "using first resource"
+        for i in [1..3] do
+            let resourceName = sprintf "\tinner resource %d" i
+            use temp = makeResource resourceName
+            printfn "\tdo something with %s" resourceName
+        use r2 = makeResource "second resource"
+        printfn "using second resource"
+        printfn "done."
+
+    // ------- Código orientado a objetos -------
+
+    // F# também possui suporte a orientação a objetos.
+    // Possui suporte a classes, herança, métodos virtuais, etc.
+
+    // interface com tipo genérico
+    type IEnumerator<'a> =
+        abstract member Current : 'a
+        abstract MoveNext : unit -> bool
+
+    // classe base abstrata com métodos virtuais
+    [<AbstractClass>]
+    type Shape() =
+        // propriedades somente leitura
+        abstract member Width : int with get
+        abstract member Height : int with get
+        // método não virtual
+        member this.BoundingArea = this.Height * this.Width
+        // método virtual com implementação base
+        abstract member Print : unit -> unit
+        default this.Print () = printfn "I'm a shape"
+
+    // classe concreta que herda da classe base e sobrescreve
+    type Rectangle(x:int, y:int) =
+        inherit Shape()
+        override this.Width = x
+        override this.Height = y
+        override this.Print ()  = printfn "I'm a Rectangle"
+
+    // testes
+    let r = Rectangle(2, 3)
+    printfn "The width is %i" r.Width
+    printfn "The area is %i" r.BoundingArea
+    r.Print()
+
+    // ------- métodos de extensão -------
+
+    // Assim como em C#, F# pode extender classes já existentes com métodos de extensão.
+    type System.String with
+       member this.StartsWithA = this.StartsWith "A"
+
+    // testes
+    let s = "Alice"
+    printfn "'%s' starts with an 'A' = %A" s s.StartsWithA
+
+    // ------- eventos  -------
+
+    type MyButton() =
+        let clickEvent = new Event<_>()
+
+        [<CLIEvent>]
+        member this.OnClick = clickEvent.Publish
+
+        member this.TestEvent(arg) =
+            clickEvent.Trigger(this, arg)
+
+    // teste
+    let myButton = new MyButton()
+    myButton.OnClick.Add(fun (sender, arg) ->
+            printfn "Click event with arg=%O" arg)
+
+    myButton.TestEvent("Hello World!")
+
+```
+
+## Mais Informações
+
+Para mais demonstrações de F# acesse [why use F#](http://fsharpforfunandprofit.com/why-use-fsharp/).
+
+Leia mais sobre F# em [fsharp.org](http://fsharp.org/) e [dotnet's F# page](https://dotnet.microsoft.com/languages/fsharp).
-- 
cgit v1.2.3


From 44cbab28aae50c680eee73e3524c11ec1b2ab469 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Valdir=20J=C3=BAnior?=
 <31621712+Valdjr@users.noreply.github.com>
Date: Thu, 24 Sep 2020 13:06:23 -0300
Subject: fix: typo pt-br elixir

---
 pt-br/elixir-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/elixir-pt.html.markdown b/pt-br/elixir-pt.html.markdown
index f8c56101..4ba78f52 100644
--- a/pt-br/elixir-pt.html.markdown
+++ b/pt-br/elixir-pt.html.markdown
@@ -40,7 +40,7 @@ e muitos outros recursos.
 # Tuplas que são guardadas contiguamente em memória.
 {1,2,3} # tupla
 
-# Podemos acessar um elemento de uma tupla om a função `elem`:
+# Podemos acessar um elemento de uma tupla com a função `elem`:
 elem({1, 2, 3}, 0) #=> 1
 
 # Listas que são implementadas como listas ligadas.
-- 
cgit v1.2.3


From 68d5c0a070b5c9eba5a5afd957bfd9fae210a3ca Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adelar=20da=20Silva=20Queir=C3=B3z?= <adelarsq@gmail.com>
Date: Thu, 24 Sep 2020 23:07:33 -0300
Subject: Update missing translations

---
 pt-br/fsharp-pt.html.markdown | 120 +++++++++++++++++++++---------------------
 1 file changed, 60 insertions(+), 60 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/fsharp-pt.html.markdown b/pt-br/fsharp-pt.html.markdown
index b5078da0..55966cda 100644
--- a/pt-br/fsharp-pt.html.markdown
+++ b/pt-br/fsharp-pt.html.markdown
@@ -55,51 +55,51 @@ add 2 3                       // Agora execute a função.
 
 // para definir uma função de múltiplas linhas apenas use indentação. Nenhum ponto e vírgula é necessário
 let evens list =
-   let isEven x = x % 2 = 0   // Define "isEven" as a sub function. Note
-                              // that equality operator is single char "=".
-   List.filter isEven list    // List.filter is a library function
-                              // with two parameters: a boolean function
-                              // and a list to work on
+   let isEven x = x % 2 = 0   // Define "isEven"como uma sub função. Note
+                              // que o operador de igualdade é um simples "=".
+   List.filter isEven list    // List.filter é uma função da biblioteca padrão
+                              // com dois parâmetros: uma função que retorna boolean
+                              // e uma lista para verificar
 
-evens oneToFive               // Now run the function
+evens oneToFive               // Agora executando a função
 
-// You can use parens to clarify precedence. In this example,
-// do "map" first, with two args, then do "sum" on the result.
-// Without the parens, "List.map" would be passed as an arg to List.sum
+// Usando parênteses é possível deixar mais clara a precedência. Neste exemplo,
+// "map" é usado primeiro, com dois argumentos, então executa "sum" no resultado.
+// Sem os parênteses, "List.map" seria passado como uma argumento para List.sum
 let sumOfSquaresTo100 =
    List.sum ( List.map square [1..100] )
 
-// You can pipe the output of one operation to the next using "|>"
-// Piping data around is very common in F#, similar to UNIX pipes.
+// É possível redirecionar a saída de uma operação para a próxima usando pipe ("|>")
+// Redirecimento de dados é algo comum em F#, similar a pipes Unix.
 
-// Here is the same sumOfSquares function written using pipes
+// Aqui é a mesma função sumOfSquares escrita com pipe
 let sumOfSquaresTo100piped =
-   [1..100] |> List.map square |> List.sum  // "square" was defined earlier
+   [1..100] |> List.map square |> List.sum  // "square" foi definido anteriormente
 
-// you can define lambdas (anonymous functions) using the "fun" keyword
+// você pode definir lambdas (funções anônimas) usando a palavra reservada "fun"
 let sumOfSquaresTo100withFun =
    [1..100] |> List.map (fun x -> x * x) |> List.sum
 
-// In F# there is no "return" keyword. A function always
-// returns the value of the last expression used.
+// Em F# não há a palavra chave "return". Funções sempre
+// retornam o valor da última expressão usada.
 
-// ------ Pattern Matching ------
-// Match..with.. is a supercharged case/switch statement.
+// ------ Casamento de padrões (Pattern Matching) ------
+// Match..with.. é um poderoso case/switch.
 let simplePatternMatch =
    let x = "a"
    match x with
     | "a" -> printfn "x is a"
     | "b" -> printfn "x is b"
-    | _ -> printfn "x is something else"   // underscore matches anything
+    | _ -> printfn "x is something else"   // sublinhado combina com qualquer coisa
 
-// F# doesn't allow nulls by default -- you must use an Option type
-// and then pattern match.
-// Some(..) and None are roughly analogous to Nullable wrappers
+// F# não permite null por padrão -- deve-se usar um Option
+// e então efetuar um casamento de padrão.
+// Some(..) e None são análogos a Nullable
 let validValue = Some(99)
 let invalidValue = None
 
-// In this example, match..with matches the "Some" and the "None",
-// and also unpacks the value in the "Some" at the same time.
+// Neste exemplo, match..with casa com "Some" e "None",
+// e também desconstrói o valor em "Some" ao mesmo tempo.
 let optionPatternMatch input =
    match input with
     | Some i -> printfn "input is an int=%d" i
@@ -108,50 +108,50 @@ let optionPatternMatch input =
 optionPatternMatch validValue
 optionPatternMatch invalidValue
 
-// ------ Printing ------
-// The printf/printfn functions are similar to the
-// Console.Write/WriteLine functions in C#.
+// ------ Escrevando na tela ------
+// As funções printf/printfn são similares às
+// Console.Write/WriteLine encontradas no C#.
 printfn "Printing an int %i, a float %f, a bool %b" 1 2.0 true
 printfn "A string %s, and something generic %A" "hello" [1; 2; 3; 4]
 
-// There are also sprintf/sprintfn functions for formatting data
-// into a string, similar to String.Format in C#.
+// Exitem também as funções sprintf/sprintfn para formatação de dados
+// em uma string, semelhante à String.Format do C#.
 
 // ================================================
-// More on functions
+// Mais sobre funções
 // ================================================
 
-// F# is a true functional language -- functions are first
-// class entities and can be combined easily to make powerful
-// constructs
+// F# é uma liguagem verdadeiramente funcional -- funções fazem
+// parte das classes e podem ser combinadas facilmente para criar
+// poderosos construtores
 
-// Modules are used to group functions together
-// Indentation is needed for each nested module.
+// Módulos podem usar um grupo de funções
+// É necessário usar indentação para defini-las.
 module FunctionExamples =
 
-    // define a simple adding function
+    // define uma função de soma
     let add x y = x + y
 
-    // basic usage of a function
+    // básico uso de uma função
     let a = add 1 2
     printfn "1 + 2 = %i" a
 
-    // partial application to "bake in" parameters
+    // aplicação parcial de parâmetros
     let add42 = add 42
     let b = add42 1
     printfn "42 + 1 = %i" b
 
-    // composition to combine functions
+    // composição para combinar funções
     let add1 = add 1
     let add2 = add 2
     let add3 = add1 >> add2
     let c = add3 7
     printfn "3 + 7 = %i" c
 
-    // higher order functions
+    // funções de alta ordem
     [1..10] |> List.map add3 |> printfn "new list is %A"
 
-    // lists of functions, and more
+    // listas de funções e mais
     let add6 = [add1; add2; add3] |> List.reduce (>>)
     let d = add6 7
     printfn "1 + 2 + 3 + 7 = %i" d
@@ -160,37 +160,37 @@ module FunctionExamples =
 // Listas e coleções
 // ================================================
 
-// There are three types of ordered collection:
-// * Lists are most basic immutable collection.
-// * Arrays are mutable and more efficient when needed.
-// * Sequences are lazy and infinite (e.g. an enumerator).
+// Existem três tipos de coleções ordenadas:
+// * Listas são o tipo mais básico de coleção imutável;
+// * Arrays são mutáveis e mais eficientes;
+// * Sequences são lazy e infinitas (semelhante a enumerator).
 //
-// Other collections include immutable maps and sets
-// plus all the standard .NET collections
+// Outras coleções incluem maps e conjuntos imutáveis
+// mais todas as coleções padrões do .NET
 
 module ListExamples =
 
-    // lists use square brackets
+    // listas usam colchetes
     let list1 = ["a"; "b"]
-    let list2 = "c" :: list1    // :: is prepending
-    let list3 = list1 @ list2   // @ is concat
+    let list2 = "c" :: list1    // :: é usado para adicionar um elemento no início da lista
+    let list3 = list1 @ list2   // @ é o operador de concatenação
 
-    // list comprehensions (aka generators)
+    // list comprehensions (generators)
     let squares = [for i in 1..10 do yield i * i]
 
-    // A prime number generator
-    // - this is using a short notation for the pattern matching syntax
-    // - (p::xs) is 'first :: tail' of the list, could also be written as p :: xs
-    //   this means this matches 'p' (the first item in the list), and xs is the rest of the list
-    //   this is called the 'cons pattern'
-    // - uses 'rec' keyword, which is necessary when using recursion
+    // Um gerador de números primos
+    // - este usa a notação custa para casamento de padrões
+    // - (p::xs) significa 'primeiro :: cauda' da lista, e pode ser escrito como p :: xs
+    //   isto significa que casa 'p' (o primeiro item da lista), e xs recebe o resto da lista
+    //   que é chamdo de 'cons pattern'
+    // - usa a palavra chave 'rec', que é necessária quando se usa recursão
     let rec sieve = function
         | (p::xs) -> p :: sieve [ for x in xs do if x % p > 0 then yield x ]
         | []      -> []
     let primes = sieve [2..50]
     printfn "%A" primes
 
-    // pattern matching for lists
+    // casamento de padrões (pattern matching) com listas
     let listMatcher aList =
         match aList with
         | [] -> printfn "the list is empty"
@@ -203,7 +203,7 @@ module ListExamples =
     listMatcher [1]
     listMatcher []
 
-    // recursion using lists
+    // recursão usando listas
     let rec sum aList =
         match aList with
         | [] -> 0
@@ -211,7 +211,7 @@ module ListExamples =
     sum [1..10]
 
     // -----------------------------------------
-    // Standard library functions
+    // Funções da biblioteca padrão
     // -----------------------------------------
 
     // mapas
-- 
cgit v1.2.3


From 22a259ca34a1ff902854d877b15f5bfc28295480 Mon Sep 17 00:00:00 2001
From: Iaan Mesquita <70171075+ianitow@users.noreply.github.com>
Date: Sat, 26 Sep 2020 13:12:18 -0300
Subject: Create lua-pt.html.markdown

Translation to pt-br.
---
 pt-br/lua-pt.html.markdown | 423 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 423 insertions(+)
 create mode 100644 pt-br/lua-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/lua-pt.html.markdown b/pt-br/lua-pt.html.markdown
new file mode 100644
index 00000000..2ec275ac
--- /dev/null
+++ b/pt-br/lua-pt.html.markdown
@@ -0,0 +1,423 @@
+---
+language: Lua
+contributors:
+    - ["Tyler Neylon", "http://tylerneylon.com/"]
+filename: learnlua.lua
+translators:
+  - ["Iaan Mesquita"], "https://github.com/ianitow"]
+lang:pt-br
+---
+
+```lua
+-- Dois hífens começam um comentário de uma linha.
+
+--[[
+     Adicionar dois [  ] (colchetes) criam um comentário
+     de múltiplas linhas.
+--]]
+
+----------------------------------------------------
+-- 1. Variáveis e fluxo de controle.
+----------------------------------------------------
+
+num = 42  -- Todos os números são doubles.
+-- Não se preocupe, doubles de 64-bits contém 52 bits para
+-- armazenar corretamente valores int; a precisão da máquina
+-- não é um problema para ints que são < 52 bits.
+
+s = 'alternados'  -- String são imutáveis, como em Python.
+t = "Aspas duplas também são válidas"
+u = [[ Dois colchetes
+       começam e terminam
+       strings de múltiplas linhas.]]
+t = nil  -- Torna t undefined(indefinido); Lua tem um Garbage Collector.
+
+-- Blocos são representados com palavras do/end:
+while num < 50 do
+  num = num + 1  -- Sem operadores do tipo ++ ou +=
+end
+
+--Cláusula If :
+if num > 40 then
+  print('over 40')
+elseif s ~= 'walternate' then  -- ~= signfica não é igual.
+  -- Para fazer checagem use == como em Python; Funciona para comparar strings também.
+  io.write('not over 40\n')  -- Padrão para saídas.
+else
+  -- Variáveis são globais por padrão.
+  thisIsGlobal = 5  -- Camel case é o comum.
+
+  -- Como fazer variáveis locais:
+  local line = io.read()  -- Leia a proxima linha de entrada.
+
+  -- Para concatenação de strings use o operador .. :
+  print('Winter is coming, ' .. line)
+end
+
+-- Variáveis indefinidas são do tipo nil.
+-- Isso não é um erro:
+foo = anUnknownVariable  -- Agora foo = nil.
+
+aBoolValue = false
+
+-- Apenas nil e false são do tipo falso; 0 e '' são verdadeiros!
+if not aBoolValue then print('twas false') end
+
+-- 'or' e 'and' são operadores lógicos.
+-- Esse operador em C/JS a?b:c , em lua seria o mesmo que:
+ans = aBoolValue and 'yes' or 'no'  --> 'no'
+
+karlSum = 0
+for i = 1, 100 do  -- O intervalo inclui inicio e fim.
+  karlSum = karlSum + i
+end
+
+-- Use "100, 1, -1" para um intervalo que diminui:
+fredSum = 0
+for j = 100, 1, -1 do fredSum = fredSum + j end
+
+-- Em geral, o intervalo é começo, fim[, etapas].
+
+-- Outro construtor de loop:
+repeat
+  print('A estrada do futuro.')
+  num = num - 1
+until num == 0
+
+
+----------------------------------------------------
+-- 2. Funções.
+----------------------------------------------------
+
+function fib(n)
+  if n < 2 then return 1 end
+  return fib(n - 2) + fib(n - 1)
+end
+
+-- Closures e Funções anônimas são permitidas:
+function adder(x)
+  -- O retorno da função é criado quando adder é
+  -- chamado, e ele sabe o valor de x:
+  return function (y) return x + y end
+end
+a1 = adder(9)
+a2 = adder(36)
+print(a1(16))  --> 25
+print(a2(64))  --> 100
+
+-- Retornos, chamadas de funções e atribuições, todos eles trabalham
+-- com listas que podem ter tamanhos incompatíveis.
+-- Receptores incompatpiveis serão nil;
+-- Destinos incompatíveis serão descartados.
+
+x, y, z = 1, 2, 3, 4
+-- Agora x = 1, y = 2, z = 3, e 4 é jogado fora.
+
+function bar(a, b, c)
+  print(a, b, c)
+  return 4, 8, 15, 16, 23, 42
+end
+
+x, y = bar('zaphod')  --> imprime "zaphod  nil nil"
+-- Agora x = 4, y = 8, os valores 15...42 foram descartados.
+
+-- Funções são de primeira-classe, portanto podem ser local/global.
+-- Estes exemplos são equivalentes:
+function f(x) return x * x end
+f = function (x) return x * x end
+
+-- Logo, estes são equivalentes também:
+local function g(x) return math.sin(x) end
+local g; g  = function (x) return math.sin(x) end
+--  'local g' essa declaração de auto-referência é válida.
+
+-- A propósito, as funções de trigonometria trabalham em radianos.
+
+-- Chamadas de função com apenas um parâmetro de string não precisam de parênteses:
+print 'hello'  -- Funciona perfeitamente.
+
+
+----------------------------------------------------
+-- 3. Tabelas.
+----------------------------------------------------
+
+-- Tabelas = A unica estrutura de dados composta em Lua;
+--          elas são matrizes associativas.
+-- Semelhantes aos arrays de PHP ou objetos de javascript, eles são:
+-- hash-lookup(chave:valor) que também podem ser usados como listas.
+
+-- Usando tabelas como dicionário / mapas:
+
+-- Dicionários literais tem strings como chaves por padrão:
+t = {key1 = 'value1', key2 = false}
+
+-- As chaves do tipo string podem usar notação de ponto,semelhante a javascript:
+print(t.key1)  -- Imprime 'value1'.
+t.newKey = {}  -- Adiciona um novo par chave/valor.
+t.key2 = nil   -- Remove key2 da tabela.
+
+-- Qualquer notação literal (não-nulo) pode ser uma chave:
+u = {['@!#'] = 'qbert', [{}] = 1729, [6.28] = 'tau'}
+print(u[6.28])  -- imprime "tau"
+
+-- A correspondência de chave é basicamente o valor para números
+-- e strings, mas por identidade para tabelas.
+a = u['@!#']  -- Agora a = 'qbert'.
+b = u[{}]     -- Nós esperavamso o resultado 1729, mas ele é nil:
+-- b = nil já que a busca falha. Ela falha
+-- porque a chave que usamos não é a mesma que o objeto
+-- como aquele que usamos para guardar o valor original. Por isso
+-- strings & numeros são chaves mais recomendadas.
+
+-- Uma chamada de função de apenas um paramêtro de tabela, não precisa de parênteses:
+
+function h(x) print(x.key1) end
+h{key1 = 'Sonmi~451'}  -- Imprime 'Sonmi~451'.
+
+for key, val in pairs(u) do  -- Iteração de tabela.
+  print(key, val)
+end
+
+-- _G é uma tabela especial que guarda tudo que é global.
+print(_G['_G'] == _G)  -- Imprime 'true'.
+
+-- Usando tabelas como listas / arrays:
+
+-- Listas literais com chaves int implícitas:
+v = {'value1', 'value2', 1.21, 'gigawatts'}
+for i = 1, #v do  -- #v é o tamanho de v
+  print(v[i])  -- Índices começam em 1 !! MUITO LOCO!
+end
+-- Uma 'list' não é um tipo real. v é apenas uma tabela
+-- com chaves int consecutivas, tratando ela como uma lista.
+
+----------------------------------------------------
+-- 3.1 Metatabelas e metamétodos.
+----------------------------------------------------
+
+-- Uma tabela pode ter uma metatabela que fornece à tabela
+-- um compotamento de sobrecarga de operador. Depois veremos
+-- como metatabelas suportam o comportamento do Javascript-prototype.
+
+f1 = {a = 1, b = 2}  -- Representa uma fração de a/b.
+f2 = {a = 2, b = 3}
+
+-- Isso falharia:
+-- s = f1 + f2
+
+metafraction = {}
+function metafraction.__add(f1, f2)
+  sum = {}
+  sum.b = f1.b * f2.b
+  sum.a = f1.a * f2.b + f2.a * f1.b
+  return sum
+end
+
+setmetatable(f1, metafraction)
+setmetatable(f2, metafraction)
+
+s = f1 + f2  -- chama __add(f1, f2) na metatabela de f1
+
+-- f1, f2 não tem chave para sua metatabela, ao contrário de
+-- prototypes em javascript, então você deve recuperá-lo com
+-- getmetatable(f1). A metatabela é uma tabela normal
+-- com chaves que Lua reconhece, como __add.
+
+-- Mas a proxima linha irá falhar porque s não tem uma metatabela:
+-- t = s + s
+-- O padrão de Classes abaixo consertam esse problema.
+
+-- Uma __index em uma metatable sobrecarrega pesquisas de ponto:
+defaultFavs = {animal = 'gru', food = 'donuts'}
+myFavs = {food = 'pizza'}
+setmetatable(myFavs, {__index = defaultFavs})
+eatenBy = myFavs.animal  -- Funciona! obrigado, metatabela.
+
+-- As pesquisas diretas de tabela que falham tentarão pesquisar novamente usando
+-- o __index da metatabela, e isso é recursivo.
+
+-- Um valor de __index também pode ser uma function(tbl, key)
+-- para pesquisas mais personalizadas.
+
+-- Valores do tipo __index,add, .. são chamados de metamétodos.
+-- Uma lista completa com os metamétodos.
+
+-- __add(a, b)                     para a + b
+-- __sub(a, b)                     para a - b
+-- __mul(a, b)                     para a * b
+-- __div(a, b)                     para a / b
+-- __mod(a, b)                     para a % b
+-- __pow(a, b)                     para a ^ b
+-- __unm(a)                        para -a
+-- __concat(a, b)                  para a .. b
+-- __len(a)                        para #a
+-- __eq(a, b)                      para a == b
+-- __lt(a, b)                      para a < b
+-- __le(a, b)                      para a <= b
+-- __index(a, b)  <fn or a table>  para a.b
+-- __newindex(a, b, c)             para a.b = c
+-- __call(a, ...)                  para a(...)
+
+----------------------------------------------------
+-- 3.2 Tabelas como Classes e sua herança.
+----------------------------------------------------
+
+-- Classes não são disseminadas; existem maneiras diferentes
+-- para fazer isso usando tabelas e metamétodos...
+
+-- A explicação para este exemplo está logo abaixo.
+
+Dog = {}                                   -- 1.
+
+function Dog:new()                         -- 2.
+  newObj = {sound = 'woof'}                -- 3.
+  self.__index = self                      -- 4.
+  return setmetatable(newObj, self)        -- 5.
+end
+
+function Dog:makeSound()                   -- 6.
+  print('I say ' .. self.sound)
+end
+
+mrDog = Dog:new()                          -- 7.
+mrDog:makeSound()  -- 'I say woof'         -- 8.
+
+-- 1. Dog atua como uma classe; mas na verdade, é uma tabela.
+-- 2. function tablename:fn(...) é a mesma coisa que
+--    function tablename.fn(self, ...)
+--    O : apenas adiciona um primeiro argumento chamado self.
+--    Leia 7 & 8 abaixo para ver como self obtém seu valor.
+-- 3. newObj será uma instância da classe Dog.
+-- 4. self = a classe que que foi instanciada. Regularmente
+--    self = Dog, mas a herança pode mudar isso.
+--    newObj recebe as funções de self como se tivessimos definido em ambos
+--    a metatabela de newObj e self __index para self.
+-- 5. Lembre-se: setmetatable retorna seu primeiro argumento definido.
+-- 6. O : funciona como em 2, mas desta vez esperamos que
+--    self seja uma instância já instanciada da classe.
+-- 7. Igual a Dog.new(Dog), logo self = Dog no new().
+-- 8. Igual a mrDog.makeSound(mrDog); self = mrDog.
+
+----------------------------------------------------
+
+-- Heranças exemplos:
+
+LoudDog = Dog:new()                           -- 1.
+
+function LoudDog:makeSound()
+  s = self.sound .. ' '                       -- 2.
+  print(s .. s .. s)
+end
+
+seymour = LoudDog:new()                       -- 3.
+seymour:makeSound()  -- 'woof woof woof'      -- 4.
+
+-- 1. LoudDog recebe os metodos e variáveis de Dog.
+-- 2. self tem uma chave 'sound' vindo de new(), veja o 3.
+-- 3. Mesma coisa que LoudDog.new(LoudDog), convertido para
+--    Dog.new(LoudDog) como LoudDog não tem uma chave 'new',
+--    mas tem uma chave __index = Dog na sua metatabela o
+--    resultado será: a metabela de seymour é a LoudDog, e
+--    LoudDog.__index = LoudDog. Então seymour.key será
+--    = seymour.key, LoudDog.key, Dog.key,seja qual for a primeira
+--    chave fornecida.
+-- 4. A chave 'makeSound' foi encontrada em LoudDog; isto
+--    é a mesma coisa que LoudDog.makeSound(seymour).
+
+-- Se precisar de, uma subclasse de new() como uma base:
+function LoudDog:new()
+  newObj = {}
+  -- define newObj
+  self.__index = self
+  return setmetatable(newObj, self)
+end
+
+----------------------------------------------------
+-- 4. Módulos.
+----------------------------------------------------
+
+
+--[[ Estou comentando esta seção, então o resto
+--   desse script é executável.
+```
+
+```lua
+-- Suponhamos que o arquivo mod.lua se pareça com isso:
+local M = {}
+
+local function sayMyName()
+  print('Hrunkner')
+end
+
+function M.sayHello()
+  print('Why hello there')
+  sayMyName()
+end
+
+return M
+
+-- Outro arquivo pode usar as funcionalidades de mod.lua:
+local mod = require('mod')  -- Roda o arquivo mod.lua.
+
+-- require é a forma que usamos para incluir módulos.
+-- require atua como:     (se não for cacheado; veja abaixo)
+local mod = (function ()
+  <contents of mod.lua>
+end)()
+-- É como se mod.lua fosse um corpo de uma função, então
+-- os locais dentro de mod.lua são invisíveis fora dele.
+
+-- Isso irá funcionar porque mod aqui = M dentro de mod.lua:
+mod.sayHello()  -- Diz olá para Hrunkner.
+
+-- Isso aqui é errado; sayMyName existe apenas em mod.lua:
+mod.sayMyName()  -- erro
+
+-- valores retornados de require são armazenados em cache para que um arquivo seja
+-- execute no máximo uma vez, mesmo quando é exigidos várias vezes.
+
+-- Suponhamos que mod2.lua contém "print('Hi!')".
+local a = require('mod2')  -- Imprime Hi!
+local b = require('mod2')  -- Não imprime;pois a=b.
+
+-- dofile é parecido com require, porém sem cacheamento:
+dofile('mod2.lua')  --> Hi!
+dofile('mod2.lua')  --> Hi! (roda novamente)
+
+-- loadfile carrega um arquivo lua, porém não o executa.
+f = loadfile('mod2.lua')  -- Chame f() para executar.
+
+-- loadstring é um loadfile para strings.
+g = loadstring('print(343)')  -- Retorna uma função.
+g()  -- Imprime 343; nada foi impresso antes disso.
+
+--]]
+
+```
+
+## Referências
+
+Fiquei bastante animado para aprender Lua pois consegui fazer jogos
+com a <a href="http://love2d.org/">Love 2D engine de jogos</a>.
+
+Eu comecei com <a href="http://nova-fusion.com/2012/08/27/lua-for-programmers-part-1/">BlackBulletIV's para programadores LUA</a>.
+Em seguida, eu li a documentação oficial <a href="https://www.lua.org/manual/5.1/pt/index.html#contents">Programando em Lua</a>.
+É assim que se começa.
+
+Pode ser útil conferir <a href="http://lua-users.org/files/wiki_insecure/users/thomasl/luarefv51.pdf">Uma pequena referencia sobre LUA</a> em lua-users.org.
+
+Os principais tópicos não cobertos, são as bibliotecas padrões:
+
+- <a href="http://lua-users.org/wiki/StringLibraryTutorial">Biblioteca de strings</a>
+- <a href="http://lua-users.org/wiki/TableLibraryTutorial">Biblioteca de tabelas</a>
+- <a href="http://lua-users.org/wiki/MathLibraryTutorial">Biblioteca de matemática</a>
+- <a href="http://lua-users.org/wiki/IoLibraryTutorial">Biblioteca de entrada/saída</a>
+- <a href="http://lua-users.org/wiki/OsLibraryTutorial">Biblioteca do sistema operacional</a>
+
+A propósito, todo este arquivo é um código LUA válido, salve-o como
+aprenda.lua e rode-o com "lua aprenda.lua" !
+
+Este guia foi escrito pela primeira vez por tylerneylon.com, e agora
+também disponível em <a href="https://gist.github.com/tylerneylon/5853042">github gist</a>. E também em português.
+
+Se divirta com lua
-- 
cgit v1.2.3


From 6902c8cd5d74ab74b20769c0bd34e9eb2014f226 Mon Sep 17 00:00:00 2001
From: Iaan Mesquita <70171075+ianitow@users.noreply.github.com>
Date: Sat, 26 Sep 2020 13:28:57 -0300
Subject: Update lua-pt.html.markdown

---
 pt-br/lua-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/lua-pt.html.markdown b/pt-br/lua-pt.html.markdown
index 2ec275ac..8cf3b4b5 100644
--- a/pt-br/lua-pt.html.markdown
+++ b/pt-br/lua-pt.html.markdown
@@ -4,7 +4,7 @@ contributors:
     - ["Tyler Neylon", "http://tylerneylon.com/"]
 filename: learnlua.lua
 translators:
-  - ["Iaan Mesquita"], "https://github.com/ianitow"]
+    - ["Iaan Mesquita"], "https://github.com/ianitow"]
 lang:pt-br
 ---
 
-- 
cgit v1.2.3


From 062497b84f47748e4c51ca321a580758de9c7c67 Mon Sep 17 00:00:00 2001
From: Iaan Mesquita <70171075+ianitow@users.noreply.github.com>
Date: Sat, 26 Sep 2020 13:37:59 -0300
Subject: fixed header xd

---
 pt-br/lua-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/lua-pt.html.markdown b/pt-br/lua-pt.html.markdown
index 8cf3b4b5..18450d9a 100644
--- a/pt-br/lua-pt.html.markdown
+++ b/pt-br/lua-pt.html.markdown
@@ -4,7 +4,7 @@ contributors:
     - ["Tyler Neylon", "http://tylerneylon.com/"]
 filename: learnlua.lua
 translators:
-    - ["Iaan Mesquita"], "https://github.com/ianitow"]
+    - ["Iaan Mesquita", "https://github.com/ianitow"]
 lang:pt-br
 ---
 
-- 
cgit v1.2.3


From c1bf13488cfef106682c0e5702ffc37e41bd75d5 Mon Sep 17 00:00:00 2001
From: Iaan Mesquita <70171075+ianitow@users.noreply.github.com>
Date: Sat, 26 Sep 2020 13:50:18 -0300
Subject: fix header

omg
---
 pt-br/lua-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/lua-pt.html.markdown b/pt-br/lua-pt.html.markdown
index 18450d9a..0c75da26 100644
--- a/pt-br/lua-pt.html.markdown
+++ b/pt-br/lua-pt.html.markdown
@@ -5,7 +5,7 @@ contributors:
 filename: learnlua.lua
 translators:
     - ["Iaan Mesquita", "https://github.com/ianitow"]
-lang:pt-br
+lang: pt-br
 ---
 
 ```lua
-- 
cgit v1.2.3


From 61cc8acc96e688f775dd68883f38209506816960 Mon Sep 17 00:00:00 2001
From: Victor Bastos <victorwpbastos@gmail.com>
Date: Wed, 30 Sep 2020 12:11:56 -0300
Subject: [typescript/pt-br] Small corrections

---
 pt-br/typescript-pt.html.markdown | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/typescript-pt.html.markdown b/pt-br/typescript-pt.html.markdown
index 6ece02ff..9dffe6dd 100644
--- a/pt-br/typescript-pt.html.markdown
+++ b/pt-br/typescript-pt.html.markdown
@@ -10,11 +10,11 @@ lang: pt-br
 
 Typescript é uma linguagem que visa facilitar o desenvolvimento de aplicações em grande escala escritos em JavaScript.
 Typescript acrescenta conceitos comuns como classes, módulos, interfaces, genéricos e (opcional) tipagem estática para JavaScript.
-É um super conjunto de JavaScript: todo o código JavaScript é TypeScript válido então ele pode ser adicionado diretamente a qualquer projeto. O compilador emite typescript JavaScript.
+É um super conjunto de JavaScript: todo o código JavaScript é TypeScript válido então ele pode ser adicionado diretamente a qualquer projeto. O compilador emite TypeScript JavaScript.
 
-Este artigo irá se concentrar apenas em texto datilografado sintaxe extra, ao contrário de [JavaScript](javascript-pt.html.markdown).
+Este artigo irá se concentrar apenas na sintaxe extra do TypeScript, ao contrário de [JavaScript](javascript-pt.html.markdown).
 
-Para testar compilador do texto datilografado, de cabeça para o [Parque](http://www.typescriptlang.org/Playground), onde você vai ser capaz de escrever código, ter auto conclusão e ver diretamente o JavaScript emitida.
+Para testar o compilador TypeScript, vá para o [Playground](http://www.typescriptlang.org/Playground), onde você vai ser capaz de escrever código, ter auto conclusão e ver diretamente o JavaScript emitido.
 
 ```js
 // Existem 3 tipos básicos no TypeScript
-- 
cgit v1.2.3


From 44f12c934c915e082da7834c70ccf32845acd93b Mon Sep 17 00:00:00 2001
From: Victor Bastos <victorwpbastos@gmail.com>
Date: Wed, 30 Sep 2020 12:18:45 -0300
Subject: [css/pt-br] Small corrections

---
 pt-br/css-pt.html.markdown | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/css-pt.html.markdown b/pt-br/css-pt.html.markdown
index 38937894..e6dea5b8 100644
--- a/pt-br/css-pt.html.markdown
+++ b/pt-br/css-pt.html.markdown
@@ -14,7 +14,7 @@ translators:
 lang: pt-br
 ---
 
-No início da web não havia elementos visuais, apenas texto puro. Mas com maior desenvolvimento de navegadores da web, páginas web totalmente visuais também se tornara comum.
+No início da web não havia elementos visuais, apenas texto puro. Mas com maior desenvolvimento de navegadores da web, páginas web totalmente visuais também se tornaram comuns.
 
 CSS ajuda a manter a separação entre o conteúdo (HTML) e o visual de uma página web.
 
@@ -130,7 +130,7 @@ seletor::after {}
    os elementos */
 * {} /* */ Todos os elementos
 .parent * {} /* */ todos os descendentes
-.parent> * {} /* */ todas as crianças
+.parent> * {} /* */ todos os filhos
 
 /* ####################
    ## PROPRIEDADES
@@ -141,7 +141,7 @@ seletor {
     /* Unidades de comprimento pode ser absoluta ou relativa. */
 
     /* Unidades relativas */
-    width: 50%; /* Percentagem de largura elemento pai */
+    width: 50%; /* Percentagem de largura do elemento pai */
     font-size: 2em; /* Múltiplos de font-size original de elemento */
     font-size: 2rem; /* Ou do elemento raiz font-size */
     font-size: 2vw; /* Múltiplos de 1% da largura da janela de exibição (CSS 3) */
@@ -200,7 +200,7 @@ Salvar uma folha de estilo CSS com a extensão `.css`.
 
 ## Precedência ou Cascata
 
-Um elemento pode ser alvo de vários seletores e pode ter um conjunto de propriedades em que mais de uma vez. Nestes casos, uma das regras tem precedência sobre os outros. Geralmente, uma regra em um seletor mais específico têm precedência sobre um menos específico, e uma regra que ocorre mais tarde na folha de estilo substitui uma anterior.
+Um elemento pode ser alvo de vários seletores e pode ter um conjunto de propriedades em que mais de uma vez. Nestes casos, uma das regras tem precedência sobre as outras. Geralmente, uma regra em um seletor mais específico têm precedência sobre um menos específico, e uma regra que ocorre mais tarde na folha de estilo substitui uma anterior.
 
 Este processo é chamado de cascata, portanto, as Fichas de nome de estilo em cascata.
 
@@ -279,7 +279,7 @@ Muitos smartphones e tablets tentarão renderizar a página como se estivesse nu
 
 ## Compatibilidade
 
-A maior parte dos recursos do CSS 2 (e muitos em CSS 3) estão disponíveis em todos os navegadores e dispositivos. Mas é sempre boa prática para verificar antes de usar um novo recurso.
+A maior parte dos recursos do CSS 2 (e muitos em CSS 3) estão disponíveis em todos os navegadores e dispositivos. Mas é sempre boa prática verificar antes de usar um novo recurso.
 
 ## Recursos
 
-- 
cgit v1.2.3


From c0386806c527d51b82822903a57f7c77cf4c963e Mon Sep 17 00:00:00 2001
From: Victor Bastos <victorwpbastos@gmail.com>
Date: Wed, 30 Sep 2020 12:32:11 -0300
Subject: [groovy/pt-br] Small corrections

---
 pt-br/groovy-pt.html.markdown | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/groovy-pt.html.markdown b/pt-br/groovy-pt.html.markdown
index 1eab9cc3..3acfce21 100644
--- a/pt-br/groovy-pt.html.markdown
+++ b/pt-br/groovy-pt.html.markdown
@@ -14,7 +14,7 @@ Groovy - Uma linguagem dinâmica para a plataforma Java. [Leia mais aqui.](http:
 ```groovy
 
 /*
-  Prepara-se:
+  Prepare-se:
 
   1) Instale a máquina virtual de Groovy - http://gvmtool.net/
   2) Instale o Groovy: gvm install groovy
@@ -104,7 +104,7 @@ tecnologiasOrdenadas = tecnologias.sort( false )
 
 /*** Manipulando listas ***/
 
-//Substitue todos os elementos da lista
+//Substitui todos os elementos da lista
 Collections.replaceAll(tecnologias, 'Gradle', 'gradle')
 
 //Desorganiza a lista
@@ -159,7 +159,7 @@ println devMap.values()
       usará este campo.
 
     * Se você quer uma propriedade private ou protected, você deve prover seus
-      próprios getters e setter, que devem ser declarados como private ou protected.
+      próprios getters e setters, que devem ser declarados como private ou protected.
 
     * Se você acessar uma propriedade dentro da classe e esta propriedade é definida
       em tempo de compilação com 'this', implícito ou explícito (por exemplo,
@@ -236,7 +236,7 @@ assert x.equals("Roberto Grails Groovy ")
 /*
   Operadores
 
-  Sobrecarregamento de Operadores para uma lsita dos operadores comuns que
+  Sobrecarga de Operadores para uma lista dos operadores comuns que
   Grooby suporta:
   http://www.groovy-lang.org/operators.html#Operator-Overloading
 
@@ -254,7 +254,7 @@ def nomeUsuario = usuario?.nomeUsuario
 
 /*
   Closures
-  Um closure, em Grooby, é como um "bloco de código" ou um ponteiro para método.
+  Um closure, em Groovy, é como um "bloco de código" ou um ponteiro para método.
   É um pedação de código que é definido e executado em um momento posterior.
 
   Mais informação em: http://www.groovy-lang.org/closures.html
@@ -269,7 +269,7 @@ clos()
 def soma = { a, b -> println a+b }
 soma(2,4)
 
-//Closdures por referir-se a variáveis que não estão listadas em sua
+//Closures podem referir-se a variáveis que não estão listadas em sua
 //lista de parêmetros.
 def x = 5
 def multiplicarPor = { num -> num * x }
@@ -309,7 +309,7 @@ chamaClosure(3, 4)
 /*
   Expando
 
-  A classe Expando é um bean dinâmico que permite adicionar propriedade e 
+  A classe Expando é um bean dinâmico que permite adicionar propriedades e 
   closures como métodos a uma instância desta classe
 
   http://mrhaki.blogspot.mx/2009/10/groovy-goodness-expando-as-dynamic-bean.html
-- 
cgit v1.2.3


From 7b6a6c96b7108c43ed1aa64afb08e6e5172e60c6 Mon Sep 17 00:00:00 2001
From: Victor Bastos <victorwpbastos@gmail.com>
Date: Wed, 30 Sep 2020 12:40:21 -0300
Subject: [kotlin/pt-br] Small corrections

---
 pt-br/kotlin-pt.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/kotlin-pt.html.markdown b/pt-br/kotlin-pt.html.markdown
index 7c3313fc..bbe8c0d1 100644
--- a/pt-br/kotlin-pt.html.markdown
+++ b/pt-br/kotlin-pt.html.markdown
@@ -70,7 +70,7 @@ fun olaMundo(val nome : String) {
     println(umaStringModelo)
 
     /*
-    Para uma variável receber null deve-se explicitamente declara-la
+    Para uma variável receber null deve-se explicitamente declará-la
     como anulável.
     A declaração de anulável é realizada incluindo uma "?" ao fim do tipo.
     Pode-se acessar uma variável anulável usando o operador "?."
@@ -166,7 +166,7 @@ fun olaMundo(val nome : String) {
 
     /*
     Classes de dados são um modo sucinto de criar classes que servem apenas
-    para guardas informações.
+    para guardar informações.
     Os métodos "hashCode", "equals" e "toString" são gerados automaticamente.
     */
     data class ExemploClasseDados (val x: Int, val y: Int, val z: Int)
-- 
cgit v1.2.3


From ef2cd618d49bbe09c47019c524d93451c9e9d3a2 Mon Sep 17 00:00:00 2001
From: Renan Muliterno Ferreira <45672566+rmuliterno@users.noreply.github.com>
Date: Wed, 30 Sep 2020 14:15:43 -0300
Subject: Typo fix and adding translation on needed lines

A couple of typo fixes, and I saw some lines that were not translated so I went ahead and fixed that on this commit.
---
 pt-br/typescript-pt.html.markdown | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/typescript-pt.html.markdown b/pt-br/typescript-pt.html.markdown
index 6ece02ff..47bcac6a 100644
--- a/pt-br/typescript-pt.html.markdown
+++ b/pt-br/typescript-pt.html.markdown
@@ -44,13 +44,13 @@ function bigHorribleAlert(): void {
 // Funções são cidadãos de primeira classe, apoiar a sintaxe lambda "seta gordura" e
 // Tipo de uso inferência
 
-// A seguir são equivalentes, a mesma assinatura será inferido pelo
-// Compilador, e mesmo JavaScript será emitido
+// A seguir são equivalentes, a mesma assinatura será inferida pelo
+// Compilador, e o mesmo JavaScript será emitido
 var f1 = function(i: number): number { return i * i; }
-// Tipo de retorno inferida
+// Tipo de retorno inferido
 var f2 = function(i: number) { return i * i; }
 var f3 = (i: number): number => { return i * i; }
-// Tipo de retorno inferida
+// Tipo de retorno inferido
 var f4 = (i: number) => { return i * i; }
 // Tipo de retorno inferido, one-liner significa nenhuma palavra-chave retorno necessário
 var f5 = (i: number) =>  i * i;
@@ -88,7 +88,7 @@ class Point {
   // Propriedades
     x: number;
 
-    // Construtor - the public/private keywords in this context will generate
+    // Construtor - as palavras-chave public/private nesse contexto irão gerar
     // o código clichê para a propriedade e a inicialização no
     // construtor.
     // Neste exemplo, "y" será definida como "X" é, mas com menos código
-- 
cgit v1.2.3


From e992ec058421c95154aa3b2126237aa5b9652f54 Mon Sep 17 00:00:00 2001
From: Renan Muliterno Ferreira <45672566+rmuliterno@users.noreply.github.com>
Date: Wed, 30 Sep 2020 14:25:40 -0300
Subject: [language/lang-code] Accentuation fix

---
 pt-br/bash-pt.html.markdown | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/bash-pt.html.markdown b/pt-br/bash-pt.html.markdown
index 86d1a8ea..988e8e7d 100644
--- a/pt-br/bash-pt.html.markdown
+++ b/pt-br/bash-pt.html.markdown
@@ -47,7 +47,7 @@ Variavel = "Alguma string"
 # Ou assim:
 Variavel= 'Alguma string'
 # Bash interpretará 'Alguma string' como um comando e tentará executar e lhe retornará
-# um erro porque o comando não pode ser encontrado. (Nesse caso a a parte 'Variavel=' 
+# um erro porque o comando não pôde ser encontrado. (Nesse caso a a parte 'Variavel=' 
 # é vista com uma declaração de variável válida apenas para o escopo do comando 'Uma string').
 
 # Usando a variável:
@@ -73,7 +73,7 @@ echo ${Foo:-"ValorPadraoSeFooNaoExistirOuEstiverVazia"}
 # Note que isso apenas retornará o valor padrão e não mudará o valor da variável.
 
 # Variáveis internas
-# Tem algumas variáveis internas bem uteis, como
+# Tem algumas variáveis internas bem úteis, como
 echo "O ultimo retorno do programa: $?"
 echo "PID do script: $$"
 echo "Numero de argumentos passados para o script $#"
@@ -165,7 +165,7 @@ echo "#helloworld" | tee output.out > /dev/null
 rm -v output.out error.err output-and-error.log
 
 # Comando podem ser substituídos por outros comandos usando $( ):
-# O comando a seguir mostra o número de arquivos e diretórios no diretorio atual
+# O comando a seguir mostra o número de arquivos e diretórios no diretório atual
 echo "Existem $(ls | wc -l) itens aqui."
 
 # O mesmo pode ser feito usando crase `` mas elas não podem ser aninhadas - dá se 
@@ -248,7 +248,7 @@ sed -i 's/okay/legal/g' file.txt
 # exibe para o stdout todas as linhas do arquivo.txt que encaixam com o regex
 # O exemplo exibe linhas que começam com "foo" e terminam com "bar"
 grep "^foo.*bar$" arquivo.txt
-# passe a opção "-c" para ao invês de imprimir o numero da linha que bate com o regex
+# passe a opção "-c" para ao invés de imprimir o número da linha que bate com o regex
 grep -c "^foo.*bar$" arquivo.txt
 # se você quer literalmente procurar por uma string,
 # e não pelo regex, use fgrep (ou grep -F)
-- 
cgit v1.2.3


From 7b42ba4ad91bb6dc930a7537ee2bd6ba81a20802 Mon Sep 17 00:00:00 2001
From: Michel <michel.ariede@gmail.com>
Date: Wed, 30 Sep 2020 16:55:22 -0300
Subject: [julia/pt-br] Small corrections

---
 pt-br/julia-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/julia-pt.html.markdown b/pt-br/julia-pt.html.markdown
index 11771d96..52675bf5 100644
--- a/pt-br/julia-pt.html.markdown
+++ b/pt-br/julia-pt.html.markdown
@@ -104,7 +104,7 @@ println("Eu sou Julia. Prazer em conhece-lo!")
 ## 2. Variáveis e coleções
 ####################################################
 
-#Você não declara variáveis antes de atribui-lás.
+#Você não declara variáveis antes de atribui-las.
 some_var = 5 # => 5
 some_var # => 5
 
-- 
cgit v1.2.3


From 0442bb51f57584b526cce6aa883cb798b5186f6a Mon Sep 17 00:00:00 2001
From: Michel <miriede@gmail.com>
Date: Wed, 30 Sep 2020 17:02:40 -0300
Subject: [kotlin/pt-br] Small corrections

---
 pt-br/kotlin-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/kotlin-pt.html.markdown b/pt-br/kotlin-pt.html.markdown
index 7c3313fc..4867e7f6 100644
--- a/pt-br/kotlin-pt.html.markdown
+++ b/pt-br/kotlin-pt.html.markdown
@@ -70,7 +70,7 @@ fun olaMundo(val nome : String) {
     println(umaStringModelo)
 
     /*
-    Para uma variável receber null deve-se explicitamente declara-la
+    Para uma variável receber null deve-se explicitamente declará-la
     como anulável.
     A declaração de anulável é realizada incluindo uma "?" ao fim do tipo.
     Pode-se acessar uma variável anulável usando o operador "?."
-- 
cgit v1.2.3


From 62db5e5073c37f4404eb52f828d775f8b4c45943 Mon Sep 17 00:00:00 2001
From: Michel <miriede@gmail.com>
Date: Wed, 30 Sep 2020 17:13:30 -0300
Subject: [self/pt-br] Small corrections

---
 pt-br/self-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/self-pt.html.markdown b/pt-br/self-pt.html.markdown
index 2fb2953b..eb821474 100644
--- a/pt-br/self-pt.html.markdown
+++ b/pt-br/self-pt.html.markdown
@@ -147,7 +147,7 @@ o objeto '10' no slot 'x' e retornará o objeto original"
 
 # Protótipos
 
-Não existem classes em Self. A maneira de obter um objeto é encontrar um protótipo e copia-lo.
+Não existem classes em Self. A maneira de obter um objeto é encontrar um protótipo e copiá-lo.
 
 ```
 | d |
-- 
cgit v1.2.3


From 6c9d43068af3fb3cbf709508b8b7a7466c7c38b3 Mon Sep 17 00:00:00 2001
From: Michel <miriede@gmail.com>
Date: Wed, 30 Sep 2020 17:18:07 -0300
Subject: [matlab/pt-br] Small corrections

---
 pt-br/matlab-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/matlab-pt.html.markdown b/pt-br/matlab-pt.html.markdown
index 5ed6b7ba..fae17bca 100644
--- a/pt-br/matlab-pt.html.markdown
+++ b/pt-br/matlab-pt.html.markdown
@@ -356,7 +356,7 @@ disp(a) % Imprime o valor da variável a
 disp('Olá Mundo') % Imprime a string
 fprintf % Imprime na janela de comandos com mais controle
 
-% Estruturas Condicionais (os parênteses são opicionais, porém uma boa prática)
+% Estruturas Condicionais (os parênteses são opcionais, porém uma boa prática)
 if (a > 15)
 	disp('Maior que 15')
 elseif (a == 23)
-- 
cgit v1.2.3


From 6b5532f4889d18cdab6e9e521082186509644fde Mon Sep 17 00:00:00 2001
From: Michel <miriede@gmail.com>
Date: Wed, 30 Sep 2020 17:27:57 -0300
Subject: [awk/pt-br] Small corrections

---
 pt-br/awk-pt.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/awk-pt.html.markdown b/pt-br/awk-pt.html.markdown
index 9bf770fd..70d0a01c 100644
--- a/pt-br/awk-pt.html.markdown
+++ b/pt-br/awk-pt.html.markdown
@@ -317,8 +317,8 @@ a > 0 {
 
 # Aqui está um exemplo rápido de um script simples, o tipo de coisa que o AWK
 # é perfeito para fazer. Ele irá ler um nome da entrada padrão e depois
-imprimirá a média de idade de todos com esse primeiro nome. Digamos que você
-forneça como argumento o nome de um arquivo com esses dados:
+# imprimirá a média de idade de todos com esse primeiro nome. Digamos que você
+# forneça como argumento o nome de um arquivo com esses dados:
 
 # Bob Jones 32
 # Jane Doe 22
-- 
cgit v1.2.3