Fixed: typos and translations

Author: fforbeck

pt-br/tutorials/tour/abstract-types.md

@@ -11,9 +11,9 @@ tutorial-previous: inner-classes
 language: pt-br
 ---
 
-Em Scala, as classes são parametrizadas com valores (parâmetros de construtor) e com tipos (se [classes genéricas](generic-classes.html)). Por razões de regularidade, só não é possível ter valores como membros de um objeto; tipos juntamente com valores são membros de objetos. Além disso, ambas as formas de membros podem ser concretas e abstratas.
+Em Scala, as classes são parametrizadas com valores (os parâmetros de construtor) e com tipos (se as [classes genéricas](generic-classes.html)). Por razões de regularidade, só não é possível ter valores como membros de um objeto; tipos juntamente com valores são membros de objetos. Além disso, ambas as formas de membros podem ser concretas e abstratas.
 
-Aqui está um exemplo que define uma definição de valor diferido e uma definição de tipo abstrato como membros de uma [trait](traits.html) chamada `Buffer`.
+Aqui está um exemplo que mostra uma definição de valor diferido e uma definição de tipo abstrato como membros de uma [trait](traits.html) chamada `Buffer`.
 
 ```tut
 trait Buffer {
@@ -22,9 +22,9 @@ trait Buffer {
 }
 ```
 
-*Tipos Abstratos* são tipos cuja identidade não é precisamente conhecida. No exemplo acima, só sabemos que cada objeto da classe `Buffer` tem um membro de tipo `T`, mas a definição de classe `Buffer` não revela para qual tipo concreto o membro do tipo `T` corresponde. Como definições de valores, podemos sobrescrever definições de tipos em subclasses. Isso nos permite revelar mais informações sobre um tipo abstrato ao limitar o tipo associado (o qual descreve as possíveis instâncias concretas do tipo abstrato).
+*Tipos Abstratos* são tipos cuja identidade não é precisamente conhecida. No exemplo acima, só sabemos que cada objeto da classe `Buffer` tem um membro de tipo `T`, mas a definição de classe `Buffer` não revela a qual tipo concreto o membro do tipo `T` corresponde. Como definições de valores, podemos sobrescrever definições de tipos em subclasses. Isso nos permite revelar mais informações sobre um tipo abstrato ao limitar o tipo associado (o qual descreve as possíveis instâncias concretas do tipo abstrato).
 
-No seguinte programa temos uma classe `SeqBuffer` que nos permite armazenar apenas as sequências no buffer ao definir que o tipo `-T` precisa ser um subtipo de `Seq[U]` para um novo tipo abstrato `U`:
+No seguinte programa temos uma classe `SeqBuffer` que nos permite armazenar apenas as sequências no buffer ao definir que o tipo `T` precisa ser um subtipo de `Seq[U]` para um novo tipo abstrato `U`:
 
 ```tut
 abstract class SeqBuffer extends Buffer {
@@ -53,7 +53,7 @@ object AbstractTypeTest1 extends App {
 }
 ```
 
-O tipo de retorno do método `newIntSeqBuf` refere-se a uma especialização da trait `Buffer` no qual o tipo `U` é agora equivalente a `Int`. Declaramos um tipo alias semelhante ao que temos na instanciação da classe anônima dentro do corpo do método `newIntSeqBuf`. Criamos uma nova instância de `IntSeqBuffer` na qual o tipo `T` refere-se a `List [Int]`.
+O tipo de retorno do método `newIntSeqBuf` refere-se a uma especialização da trait `Buffer` no qual o tipo `U` é agora equivalente a `Int`. Declaramos um tipo *alias* semelhante ao que temos na instanciação da classe anônima dentro do corpo do método `newIntSeqBuf`. Criamos uma nova instância de `IntSeqBuffer` na qual o tipo `T` refere-se a `List[Int]`.
 
 Observe que muitas vezes é possível transformar os membros de tipo abstrato em parâmetros de tipo de classes e vice-versa. Aqui está uma versão do código acima que usa apenas parâmetros de tipo:
 
@@ -75,5 +75,5 @@ object AbstractTypeTest2 extends App {
 }
 ```
 
-Note que temos que usar [anotação de variância](variances.html) aqui; Caso contrário, não seríamos capazes de ocultar o tipo implementado pela sequência concreta do objeto retornado por `newIntSeqBuf`. Além disso, há casos em que não é possível substituir tipos abstratos com parâmetros de tipo.
+Note que temos que usar [anotação de variância](variances.html) aqui; Caso contrário, não seríamos capazes de ocultar o tipo implementado pela sequência concreta do objeto retornado pelo método `newIntSeqBuf`. Além disso, há casos em que não é possível substituir tipos abstratos com parâmetros de tipo.
 

pt-br/tutorials/tour/annotations.md

@@ -13,11 +13,11 @@ language: pt-br
 
 Anotações associam meta-informação com definições.
 
-Uma cláusula de anotação simples tem a forma `@C` ou `@C(a1,..., an)`. Aqui, `C` é um construtor de uma classe `C`, que deve estar em conformidade com a classe `scala.Annotation`. Todos os argumentos de construtor fornecidos `a1, .., an` devem ser expressões constantes (isto é, expressões em literais numéricos, strings, classe, enumerações Java e matrizes uni-dimensionais).
+Uma cláusula de anotação simples tem a forma `@C` ou `@C(a1,..., an)`. Aqui, `C` é um construtor de uma classe `C`, que deve estar em conformidade com a classe `scala.Annotation`. Todos os argumentos de construtor fornecidos `a1, .., an` devem ser expressões constantes (isto é, expressões em literais numéricos, strings, literais de classes, enumerações Java e matrizes uni-dimensionais).
 
-Uma cláusula de anotação se aplica à primeira definição ou declaração que a segue. Mais de uma cláusula de anotação pode preceder uma definição e uma  declaração. Não importa a ordem em que essas cláusulas são declaradas.
+Uma cláusula de anotação se aplica à primeira definição ou declaração que a segue. Mais de uma cláusula de anotação pode preceder uma definição e uma declaração. Não importa a ordem em que essas cláusulas são declaradas.
 
-O significado das cláusulas de anotação é _implementação-dependente_. Na plataforma Java, as seguintes anotações Scala têm um significado padrão.
+O significado das cláusulas de anotação é _dependente da implementação_. Na plataforma Java, as seguintes anotações Scala têm um significado padrão.
 
 |           Scala           |           Java           |
 |           ------          |          ------          |
@@ -72,7 +72,7 @@ public class AnnotaTest {
 }
 ```
 
-Se comentar a anotação `throws` na classe `Reader` o complidor produz a seguinte mensagem de erro ao compilar o programa principal Java:
+Comentando-se a anotação `throws` na classe `Reader` o compilador produz a seguinte mensagem de erro ao compilar o programa principal Java:
 
 ```
 Main.java:11: exception java.io.IOException is never thrown in body of
@@ -142,7 +142,7 @@ O elemento `mail` foi especificado com um valor padrão, portanto não precisamo
 public class MyClass extends HisClass ...
 ```
 
-A Scala proporciona mais flexibilidade a respeito disso:
+Scala proporciona mais flexibilidade a respeito disso:
 
 ```
 @SourceURL("http://coders.com/",

pt-br/tutorials/tour/anonymous-function-syntax.md

@@ -25,13 +25,13 @@ new Function1[Int, Int] {
 }
 ```
 
-Também é possível definir funções com mútiplos parâmetros:
+Também é possível definir funções com múltiplos parâmetros:
 
 ```tut
 (x: Int, y: Int) => "(" + x + ", " + y + ")"
 ```
 
-or sem parâmetros:
+ou sem parâmetros:
 
 ```tut
 () => { System.getProperty("user.dir") }

pt-br/tutorials/tour/automatic-closures.md

@@ -1,6 +1,6 @@
 ---
 layout: tutorial
-title: Automatic Type-Dependent Closure Construction
+title: Construção Automática de Closures de Tipo-Dependente
 
 disqus: true
 
@@ -11,7 +11,9 @@ tutorial-previous: operators
 language: pt-br
 ---
 
-O Scala permite nomes de funções sem parâmetros como parâmetros de métodos. Quando um tal método é chamado, os parâmetros reais para nomes de função sem parâmetros não são avaliados e uma função nula é passada em vez disso, tal função encapsula a computação do parâmetro correspondente (isso é conhecido por avaliação *call-by-name*).
+_Nota de tradução: A palavra `closure` em pode ser traduzida como encerramento/fechamento, porém é preferível utilizar a notação original_
+
+Scala permite funções sem parâmetros como parâmetros de métodos. Quando um tal método é chamado, os parâmetros reais para nomes de função sem parâmetros não são avaliados e uma função nula é passada em vez disso, tal função encapsula a computação do parâmetro correspondente (isso é conhecido por avaliação *call-by-name*).
 
 O código a seguir demonstra esse mecanismo:
 
@@ -30,11 +32,11 @@ object TargetTest1 extends App {
 }
 ```
 
-A função `whileLoop` tem dois parâmetros `cond` e `body`. Quando a função é aplicada, os parâmetros reais não são avaliados. Mas sempre que os parâmetros formais são usados no corpo de `whileLoop`, as funções nulas criadas implicitamente serão avaliadas em seu lugar. Assim, o nosso método `whileLoop` implementa um while-loop Java-like com um esquema de implementação recursiva.
+A função `whileLoop` recebe dois parâmetros: `cond` e `body`. Quando a função é aplicada, os parâmetros reais não são avaliados. Mas sempre que os parâmetros formais são usados no corpo de `whileLoop`, as funções nulas criadas implicitamente serão avaliadas em seu lugar. Assim, o nosso método `whileLoop` implementa um while-loop Java-like com um esquema de implementação recursiva.
 
 Podemos combinar o uso de [operadores infix/postfix](operators.html) com este mecanismo para criar declarações mais complexas (com uma sintaxe agradável).
 
-Aqui está a implementação de uma instrução que executa loop ao menos que uma condição seja satisfeita:
+Aqui está a implementação de uma instrução que executa loop a menos que uma condição seja satisfeita:
 
 ```tut
 object TargetTest2 extends App {
@@ -54,7 +56,7 @@ object TargetTest2 extends App {
 }
 ```
 
-A função `loop` apenas aceita um corpo de um loop e retorna uma instância da classe` LoopUnlessCond` (que encapsula este objeto de corpo). Note que o corpo ainda não foi avaliado. A classe `LoopUnlessCond` tem um método `unless` que podemos usar como um *operador infix*. Dessa forma, obtemos uma sintaxe bastante natural para nosso novo loop: `loop { <stats> } unless ( <cond> )`.
+A função `loop` aceita apenas um corpo e retorna uma instância da classe` LoopUnlessCond` (que encapsula este objeto de corpo). Note que o corpo ainda não foi avaliado. A classe `LoopUnlessCond` tem um método `unless` que podemos usar como um *operador infix*. Dessa forma, obtemos uma sintaxe bastante natural para nosso novo loop: `loop { <stats> } unless ( <cond> )`.
 
 Aqui está a saída de quando o `TargetTest2` é executado:
 

pt-br/tutorials/tour/case-classes.md

@@ -15,10 +15,10 @@ Scala suporta o conceito de _classes case_. Classes case são classes regulares
 
 * Imutáveis por padrão
 * Decompostas por meio de [correspondência de padrões](pattern-matching.html)
-* Comparadas por igualdade estrututal ao invés de referência
+* Comparadas por igualdade estrutural ao invés de referência
 * Sucintas para instanciar e operar
 
-Aqui um exemplo para hierarquia de tipos de notificação que consiste em uma super classe abstrata `Notification` e três tipos concretos de notificação implementados com classes case `Email`, `SMS`, e `VoiceRecording`.
+Aqui temos um exemplo de hierarquia de tipos para *Notification* que consiste em uma super classe abstrata `Notification` e três tipos concretos de notificação implementados com classes case `Email`, `SMS`, e `VoiceRecording`.
 
 ```tut
 abstract class Notification
@@ -75,7 +75,7 @@ Somos iguais!
 SMS é: SMS(12345, Hello!)
 ```
 
-Com classes case, você pode utilizar **correspondência de padrões** para manipular seus dados. Aqui um exemplo de uma função que escreve como saída diferente mensagens dependendo do tipo de notificação recebida:
+Com classes case, você pode utilizar **correspondência de padrões** para manipular seus dados. Aqui temos um exemplo de uma função que escreve como saída diferente mensagens dependendo do tipo de notificação recebida:
 
 ```tut
 def mostrarNotificacao(notificacao: Notification): String = {
@@ -114,17 +114,17 @@ def mostrarNotificacaoEspecial(notificacao: Notification, emailEspecial: String,
   }
 }
 
-val NUMERO_ESPECIAL = "55555"
-val EMAIL_ESPECIAL = "jane@mail.com"
+val NumeroEspecial = "55555"
+val EmailEspecial = "jane@mail.com"
 val algumSMS = SMS("12345", "Você está aí?")
 val algumaMsgVoz = VoiceRecording("Tom", "voicerecording.org/id/123")
 val emailEspecial = Email("jane@mail.com", "Beber hoje a noite?", "Estou livre depois das 5!")
 val smsEspecial = SMS("55555", "Estou aqui! Onde está você?")
 
-println(mostrarNotificacaoEspecial(algumSMS, EMAIL_ESPECIAL, NUMERO_ESPECIAL))
-println(mostrarNotificacaoEspecial(algumaMsgVoz, EMAIL_ESPECIAL, NUMERO_ESPECIAL))
-println(mostrarNotificacaoEspecial(smsEspecial, EMAIL_ESPECIAL, NUMERO_ESPECIAL))
-println(mostrarNotificacaoEspecial(smsEspecial, EMAIL_ESPECIAL, NUMERO_ESPECIAL))
+println(mostrarNotificacaoEspecial(algumSMS, EmailEspecial, NumeroEspecial))
+println(mostrarNotificacaoEspecial(algumaMsgVoz, EmailEspecial, NumeroEspecial))
+println(mostrarNotificacaoEspecial(smsEspecial, EmailEspecial, NumeroEspecial))
+println(mostrarNotificacaoEspecial(smsEspecial, EmailEspecial, NumeroEspecial))
 
 // Saída: 
 // Você recebeu um SMS de 12345! Mensagem: Você está aí?

pt-br/tutorials/tour/classes.md

@@ -11,7 +11,7 @@ tutorial-previous: unified-types
 language: pt-br
 ---
 
-Classes em Scala são templates estáticos que podem ser instânciados como vários objetos em tempo de execução.
+Classes em Scala são templates estáticos que podem ser instanciados como vários objetos em tempo de execução.
 Aqui uma definição de classe que define a classe `Ponto`:
 
 ```tut
@@ -27,7 +27,7 @@ class Ponto(var x: Int, var y: Int) {
 
 Classes em Scala são parametrizadas com argumentos de construtor. O código acima define dois argumentos de construtor, `x` e `y`; ambos são acessíveis por todo o corpo da classe.
 
-A classe também inclui dois métodos, `move` and `toString`. `move` recebe dois parâmetros inteiros mas não retorna um valor (o tipo de retorno `Unit` equivale ao `void` em linguagens como Java). `toString`, por outro lado, não recebe parâmetro algum mas retorna um valor `String`. Dado que `toString` sobrescreve o método pré-definido `toString`, é marcado com a palavra-chave `override`.
+A classe também inclui dois métodos, `move` and `toString`. `move` recebe dois parâmetros inteiros mas não retorna um valor (o tipo de retorno `Unit` equivale ao `void` em linguagens como Java). `toString`, por outro lado, não recebe parâmetro algum mas retorna um valor `String`. Dado que `toString` sobrescreve o método pré-definido `toString`, o mesmo é marcado com a palavra-chave `override`.
 
 Perceba que em Scala, não é necessário declarar `return` para então retornar um valor. O valor retornado em um método é simplesmente o último valor no corpo do método. No caso do método `toString` acima, a expressão após o sinal de igual é avaliada e retornada para quem chamou a função.
 
@@ -46,7 +46,7 @@ object Classes {
 
 O programa define uma aplicação executável chamada Classes como um [Objeto Singleton](singleton-objects) dentro do método `main`. O método `main` cria um novo `Ponto` e armazena o valor em `pt`. Perceba que valores definidos com o construtor `val` são diferentes das variáveis definidas com o construtor `var` (veja acima a classe `Ponto`), `val` não permite atualização do valor, ou seja, o valor é uma constante.
 
-Aqui a saída do programa:
+Aqui está a saída do programa:
 
 ```
 (1, 2)

pt-br/tutorials/tour/compound-types.md

@@ -46,8 +46,8 @@ def cloneAndReset(obj: Cloneable with Resetable): Cloneable = {
 }
 ```
 
-Os tipos de compostos podem consistir em vários tipos de objeto e eles podem ter um único refinamento que pode ser usado para restrigird a assinatura de membros de objetos existentes.
+Os tipos de compostos podem consistir em vários tipos de objeto e eles podem ter um único refinamento que pode ser usado para restrigir a assinatura de membros de objetos existentes.
 
-A forma geral é: `A com B com C ... { refinamento }`
+A forma geral é: `A with B with C ... { refinamento }`
 
 Um exemplo para o uso de refinamentos é dado na página sobre [tipos abstratos](abstract-types.html). 

pt-br/tutorials/tour/currying.md

@@ -11,7 +11,7 @@ tutorial-previous: nested-functions
 language: pt-br
 ---
 
-_Nota de tradução: Currying é uma técnica de programação funcional nomeada em honra ao matemático e lógico Haskell Curry. Por essa razão a palavra Currying não será traduzida. Entende-se que é uma ação, uma técnica básica de Programação Funcional._
+_Nota de tradução: Currying é uma técnica de programação Funcional nomeada em honra ao matemático e lógico Haskell Curry. Por essa razão a palavra Currying não será traduzida. Entende-se que é uma ação, uma técnica básica de Programação Funcional._
 
 Métodos podem definir múltiplas listas de parâmetros. Quando um método é chamado com uma lista menor de parâmetros, então será retornada uma função que recebe a lista que parâmetros que falta como argumentos.