You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
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.
14
+
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.
15
15
16
-
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`.
16
+
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`.
17
17
18
18
```tut
19
19
trait Buffer{
@@ -22,9 +22,9 @@ trait Buffer{
22
22
}
23
23
```
24
24
25
-
*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).
25
+
*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).
26
26
27
-
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`:
27
+
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`:
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]`.
56
+
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]`.
57
57
58
58
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:
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.
78
+
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.
Copy file name to clipboardExpand all lines: pt-br/tutorials/tour/annotations.md
+5-5Lines changed: 5 additions & 5 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -13,11 +13,11 @@ language: pt-br
13
13
14
14
Anotações associam meta-informação com definições.
15
15
16
-
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).
16
+
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).
17
17
18
-
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.
18
+
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.
19
19
20
-
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.
20
+
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.
21
21
22
22
| Scala | Java |
23
23
| ------ | ------ |
@@ -72,7 +72,7 @@ public class AnnotaTest{
72
72
}
73
73
```
74
74
75
-
Se comentar a anotação `throws` na classe `Reader` o complidor produz a seguinte mensagem de erro ao compilar o programa principal Java:
75
+
Comentando-se a anotação `throws` na classe `Reader` o compilador produz a seguinte mensagem de erro ao compilar o programa principal Java:
76
76
77
77
```
78
78
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
142
142
public class MyClass extends HisClass ...
143
143
```
144
144
145
-
A Scala proporciona mais flexibilidade a respeito disso:
145
+
Scala proporciona mais flexibilidade a respeito disso:
Copy file name to clipboardExpand all lines: pt-br/tutorials/tour/automatic-closures.md
+7-5Lines changed: 7 additions & 5 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -1,6 +1,6 @@
1
1
---
2
2
layout: tutorial
3
-
title: Automatic Type-Dependent Closure Construction
3
+
title: Construção Automática de Closures de Tipo-Dependente
4
4
5
5
disqus: true
6
6
@@ -11,7 +11,9 @@ tutorial-previous: operators
11
11
language: pt-br
12
12
---
13
13
14
-
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*).
14
+
_Nota de tradução: A palavra `closure` em pode ser traduzida como encerramento/fechamento, porém é preferível utilizar a notação original_
15
+
16
+
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*).
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.
35
+
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.
34
36
35
37
Podemos combinar o uso de [operadores infix/postfix](operators.html) com este mecanismo para criar declarações mais complexas (com uma sintaxe agradável).
36
38
37
-
Aqui está a implementação de uma instrução que executa loop ao menos que uma condição seja satisfeita:
39
+
Aqui está a implementação de uma instrução que executa loop a menos que uma condição seja satisfeita:
38
40
39
41
```tut
40
42
object TargetTest2 extends App{
@@ -54,7 +56,7 @@ object TargetTest2 extends App{
54
56
}
55
57
```
56
58
57
-
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> )`.
59
+
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> )`.
58
60
59
61
Aqui está a saída de quando o `TargetTest2` é executado:
Copy file name to clipboardExpand all lines: pt-br/tutorials/tour/case-classes.md
+9-9Lines changed: 9 additions & 9 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -15,10 +15,10 @@ Scala suporta o conceito de _classes case_. Classes case são classes regulares
15
15
16
16
* Imutáveis por padrão
17
17
* Decompostas por meio de [correspondência de padrões](pattern-matching.html)
18
-
* Comparadas por igualdade estrututal ao invés de referência
18
+
* Comparadas por igualdade estrutural ao invés de referência
19
19
* Sucintas para instanciar e operar
20
20
21
-
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`.
21
+
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`.
22
22
23
23
```tut
24
24
abstract class Notification
@@ -75,7 +75,7 @@ Somos iguais!
75
75
SMS é: SMS(12345, Hello!)
76
76
```
77
77
78
-
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:
78
+
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:
Classes em Scala são templates estáticos que podem ser instânciados como vários objetos em tempo de execução.
14
+
Classes em Scala são templates estáticos que podem ser instanciados como vários objetos em tempo de execução.
15
15
Aqui uma definição de classe que define a classe `Ponto`:
16
16
17
17
```tut
@@ -27,7 +27,7 @@ class Ponto(var x: Int, var y: Int){
27
27
28
28
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.
29
29
30
-
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`.
30
+
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`.
31
31
32
32
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.
33
33
@@ -46,7 +46,7 @@ object Classes{
46
46
47
47
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.
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.
49
+
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.
50
50
51
-
A forma geral é: `A com B com C ...{refinamento }`
51
+
A forma geral é: `A with B with C ...{refinamento }`
52
52
53
53
Um exemplo para o uso de refinamentos é dado na página sobre [tipos abstratos](abstract-types.html).
_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._
14
+
_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._
15
15
16
16
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.
0 commit comments