Tour of Scala translated to pt-BR

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

@@ -0,0 +1,79 @@
+---
+layout: tutorial
+title: Tipos Abstratos
+
+disqus: true
+
+tutorial: scala-tour
+num: 22
+tutorial-next: compound-types
+tutorial-previous: inner-classes
+language: pt-br
+---
+
+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 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 {
+  type T
+  val element: T
+}
+```
+
+*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`:
+
+```tut
+abstract class SeqBuffer extends Buffer {
+  type U
+  type T <: Seq[U]
+  def length = element.length
+}
+```
+
+[Traits](traits.html) ou [classes](classes.html) com membros de tipo abstratos são frequentemente utilizadas em combinação com instâncias de classe anônimas. Para ilustrar isso, agora analisamos um programa que lida com um buffer de sequência que se refere a uma lista de inteiros:
+
+```tut
+abstract class IntSeqBuffer extends SeqBuffer {
+  type U = Int
+}
+
+object AbstractTypeTest1 extends App {
+  def newIntSeqBuf(elem1: Int, elem2: Int): IntSeqBuffer =
+    new IntSeqBuffer {
+         type T = List[U]
+         val element = List(elem1, elem2)
+       }
+  val buf = newIntSeqBuf(7, 8)
+  println("length = " + buf.length)
+  println("content = " + buf.element)
+}
+```
+
+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:
+
+```tut
+abstract class Buffer[+T] {
+  val element: T
+}
+abstract class SeqBuffer[U, +T <: Seq[U]] extends Buffer[T] {
+  def length = element.length
+}
+object AbstractTypeTest2 extends App {
+  def newIntSeqBuf(e1: Int, e2: Int): SeqBuffer[Int, Seq[Int]] =
+    new SeqBuffer[Int, List[Int]] {
+      val element = List(e1, e2)
+    }
+  val buf = newIntSeqBuf(7, 8)
+  println("length = " + buf.length)
+  println("content = " + buf.element)
+}
+```
+
+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

@@ -0,0 +1,151 @@
+---
+layout: tutorial
+title: Anotações
+
+disqus: true
+
+tutorial: scala-tour
+num: 31
+tutorial-next: default-parameter-values
+tutorial-previous: automatic-closures
+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, 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.
+
+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           |
+|           ------          |          ------          |
+|  [`scala.SerialVersionUID`](http://www.scala-lang.org/api/2.9.1/scala/SerialVersionUID.html)   |  [`serialVersionUID`](http://java.sun.com/j2se/1.5.0/docs/api/java/io/Serializable.html#navbar_bottom) (field)  |
+|  [`scala.cloneable`](http://www.scala-lang.org/api/2.9.1/scala/cloneable.html)   |  [`java.lang.Cloneable`](http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Cloneable.html) |
+|  [`scala.deprecated`](http://www.scala-lang.org/api/2.9.1/scala/deprecated.html)   |  [`java.lang.Deprecated`](http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Deprecated.html) |
+|  [`scala.inline`](http://www.scala-lang.org/api/2.9.1/scala/inline.html) (desde 2.6.0)  | não há equivalente |
+|  [`scala.native`](http://www.scala-lang.org/api/2.9.1/scala/native.html) (desde 2.6.0)  |  [`native`](http://java.sun.com/docs/books/tutorial/java/nutsandbolts/_keywords.html) (keyword) |
+|  [`scala.remote`](http://www.scala-lang.org/api/2.9.1/scala/remote.html) |  [`java.rmi.Remote`](http://java.sun.com/j2se/1.5.0/docs/api/java/rmi/Remote.html) |
+|  [`scala.serializable`](http://www.scala-lang.org/api/2.9.1/index.html#scala.annotation.serializable) |  [`java.io.Serializable`](http://java.sun.com/j2se/1.5.0/docs/api/java/io/Serializable.html) |
+|  [`scala.throws`](http://www.scala-lang.org/api/2.9.1/scala/throws.html) |  [`throws`](http://java.sun.com/docs/books/tutorial/java/nutsandbolts/_keywords.html) (keyword) |
+|  [`scala.transient`](http://www.scala-lang.org/api/2.9.1/scala/transient.html) |  [`transient`](http://java.sun.com/docs/books/tutorial/java/nutsandbolts/_keywords.html) (keyword) |
+|  [`scala.unchecked`](http://www.scala-lang.org/api/2.9.1/scala/unchecked.html) (since 2.4.0) |  não há equivalente |
+|  [`scala.volatile`](http://www.scala-lang.org/api/2.9.1/scala/volatile.html) |  [`volatile`](http://java.sun.com/docs/books/tutorial/java/nutsandbolts/_keywords.html) (keyword) |
+|  [`scala.reflect.BeanProperty`](http://www.scala-lang.org/api/2.9.1/scala/reflect/BeanProperty.html) |  [`Design pattern`](http://docs.oracle.com/javase/tutorial/javabeans/writing/properties.html) |
+
+No exemplo a seguir, adicionamos a anotação `throws` à definição do método `read` para capturar a exceção lançada no código Java.
+
+> Um compilador Java verifica se um programa contém manipuladores para [exceções verificadas](http://docs.oracle.com/javase/specs/jls/se5.0/html/exceptions.html) analisando quais exceções verificadas podem resultar da execução de um método ou construtor. Para cada exceção verificada que é um resultado possível, a cláusula **throws** para o método ou construtor _deve_ mencionar a classe dessa exceção ou uma das superclasses da classe dessa exceção.
+> Como Scala não tem exceções verificadas, os métodos Scala _devem_ ser anotados com uma ou mais anotações `throws`, de forma que o código Java possa capturar exceções lançadas por um método Scala.
+
+
+Exemplo de classe Scala que lança uma exceção do tipo `IOException`:
+
+```
+package examples
+import java.io._
+class Reader(fname: String) {
+  private val in = new BufferedReader(new FileReader(fname))
+  @throws(classOf[IOException])
+  def read() = in.read()
+}
+```
+
+O programa Java a seguir imprime o conteúdo do arquivo cujo nome é passado como o primeiro argumento para o método `main`.
+
+```
+package test;
+import examples.Reader;  // Classe Scala acima declarada!!
+public class AnnotaTest {
+    public static void main(String[] args) {
+        try {
+            Reader in = new Reader(args[0]);
+            int c;
+            while ((c = in.read()) != -1) {
+                System.out.print((char) c);
+            }
+        } catch (java.io.IOException e) {
+            System.out.println(e.getMessage());
+        }
+    }
+}
+```
+
+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
+corresponding try statement
+        } catch (java.io.IOException e) {
+          ^
+1 error
+```
+
+### Anotações Java ###
+
+**Nota:** Certifique-se de usar a opção `-target: jvm-1.5` com anotações Java.
+
+Java 1.5 introduziu metadados definidos pelo usuário na forma de [anotações](http://java.sun.com/j2se/1.5.0/docs/guide/language/annotations.html). Uma característica chave das anotações é que elas dependem da especificação de pares no formato nome-valor para inicializar seus elementos. Por exemplo, se precisamos de uma anotação para rastrear a origem de alguma classe, podemos defini-la como:
+
+```
+@interface Source {
+  public String URL();
+  public String mail();
+}
+```
+
+O uso da anotação Source fica da seguinte forma
+
+```
+@Source(URL = "http://coders.com/",
+        mail = "support@coders.com")
+public class MyClass extends HisClass ...
+```
+
+A uso de anotações em Scala parece uma invocação de construtor, para instanciar uma anotação Java é preciso usar argumentos nomeados:
+
+```
+@Source(URL = "http://coders.com/",
+        mail = "support@coders.com")
+class MyScalaClass ...
+```
+
+Esta sintaxe é bastante tediosa, se a anotação contiver apenas um parâmetro (sem valor padrão), por convenção, se o nome for especificado como `value`, ele pode ser aplicado em Java usando uma sintaxe semelhante a Scala, ou seja parecido com a invocação de um construtor:
+
+```
+@interface SourceURL {
+    public String value();
+    public String mail() default "";
+}
+```
+
+O uso da anotação SourceURL fica da seguinte forma
+
+```
+@SourceURL("http://coders.com/")
+public class MyClass extends HisClass ...
+```
+
+Neste caso, a Scala oferece a mesma possibilidade
+
+```
+@SourceURL("http://coders.com/")
+class MyScalaClass ...
+```
+
+O elemento `mail` foi especificado com um valor padrão, portanto não precisamos fornecer explicitamente um valor para ele. No entanto, se precisarmos fazer isso, não podemos misturar e combinar os dois estilos em Java:
+
+```
+@SourceURL(value = "http://coders.com/",
+           mail = "support@coders.com")
+public class MyClass extends HisClass ...
+```
+
+Scala proporciona mais flexibilidade a respeito disso:
+
+```
+@SourceURL("http://coders.com/",
+           mail = "support@coders.com")
+    class MyScalaClass ...
+```

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

@@ -0,0 +1,54 @@
+---
+layout: tutorial
+title: Sintaxe de Função Anônima
+
+disqus: true
+
+tutorial: scala-tour
+num: 6
+tutorial-next: higher-order-functions
+tutorial-previous: mixin-class-composition
+language: pt-br
+---
+
+Scala fornece uma sintaxe relativamente leve para definir funções anônimas. A expressão a seguir cria uma função sucessor para inteiros:
+
+```tut
+(x: Int) => x + 1
+```
+
+Isso é uma abreviação para a definição de classe anônima a seguir:
+
+```tut
+new Function1[Int, Int] {
+  def apply(x: Int): Int = x + 1
+}
+```
+
+Também é possível definir funções com múltiplos parâmetros:
+
+```tut
+(x: Int, y: Int) => "(" + x + ", " + y + ")"
+```
+
+ou sem parâmetros:
+
+```tut
+() => { System.getProperty("user.dir") }
+```
+
+Há também uma forma muito simples de escrever tipos de funções. Aqui estão os tipos da três funções acima definidas:
+
+```
+Int => Int
+(Int, Int) => String
+() => String
+```
+
+Essa sintaxe é uma abreviação para os seguintes tipos:
+
+```
+Function1[Int, Int]
+Function2[Int, Int, String]
+Function0[String]
+```

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

@@ -0,0 +1,74 @@
+---
+layout: tutorial
+title: Construção Automática de Closures de Tipo-Dependente
+
+disqus: true
+
+tutorial: scala-tour
+num: 30
+tutorial-next: annotations
+tutorial-previous: operators
+language: pt-br
+---
+
+_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:
+
+```tut
+object TargetTest1 extends App {
+  def whileLoop(cond: => Boolean)(body: => Unit): Unit =
+    if (cond) {
+      body
+      whileLoop(cond)(body)
+    }
+  var i = 10
+  whileLoop (i > 0) {
+    println(i)
+    i -= 1
+  }
+}
+```
+
+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 a menos que uma condição seja satisfeita:
+
+```tut
+object TargetTest2 extends App {
+  def loop(body: => Unit): LoopUnlessCond =
+    new LoopUnlessCond(body)
+  protected class LoopUnlessCond(body: => Unit) {
+    def unless(cond: => Boolean) {
+      body
+      if (!cond) unless(cond)
+    }
+  }
+  var i = 10
+  loop {
+    println("i = " + i)
+    i -= 1
+  } unless (i == 0)
+}
+```
+
+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:
+
+```
+i = 10
+i = 9
+i = 8
+i = 7
+i = 6
+i = 5
+i = 4
+i = 3
+i = 2
+i = 1
+```