Tour of Scala translated to pt-BR #649
Conversation
fforbeck
force-pushed
the
translation-pt-br
branch
from
c4d8853 to
5d18cde
Compare
fforbeck
changed the title
|
🎉🍻🍾 woooohooo!! @SethTisue should we just merge? Or should we try to find someone to review? |
|
THANK YOU @fforbeck!!! |
|
you're welcome @heathermiller. Let me know if you guys need any change, I'll be working on a pt-br translation for scala-for-java-programmers. |
|
we should at least try to find a reviewer, I think. I just asked on Gitter, https://gitter.im/scala/scala?at=5873f67bdec171b811c8eb63 |
|
We have a Brazilian scala group called Scaladores. I'll check if there's someone available to review this PR. |
|
|
||
| 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. | ||
|
|
||
| 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`. |
There was a problem hiding this comment.
suggestion to avoid define/definição repetition:
define => mostra
|
|
||
| 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. |
There was a problem hiding this comment.
implementation-dependent could be translated to ... de anotação é dependente da implementação. Or ... de anotação depende da implementação. The latter seems more common in portuguese.
| } | ||
| ``` | ||
|
|
||
| Se comentar a anotação `throws` na classe `Reader` o complidor produz a seguinte mensagem de erro ao compilar o programa principal Java: |
| public class MyClass extends HisClass ... | ||
| ``` | ||
|
|
||
| A Scala proporciona mais flexibilidade a respeito disso: |
There was a problem hiding this comment.
maybe nitpicking: I think you can drop the "A" before Scala. Sounds more natural, at least to me.
| } | ||
| ``` | ||
|
|
||
| Também é possível definir funções com mútiplos parâmetros: |
| (x: Int, y: Int) => "(" + x + ", " + y + ")" | ||
| ``` | ||
|
|
||
| or sem parâmetros: |
| 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*). |
There was a problem hiding this comment.
Following the nitpicking above: You can drop the "O" before Scala.
There was a problem hiding this comment.
In the original it says: Scala allows parameterless function names as parameters of methods. I don't understand why the phrase needs the "name" part. WDYT? Could we drop "nomes" in Scala permite nomes de funções sem parâmetros como parâmetros de métodos?
There was a problem hiding this comment.
Yup. We can drop nomes.
| } | ||
| ``` | ||
|
|
||
| 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. |
There was a problem hiding this comment.
bit nitpicking: It's good to have , or : after dois parâmetros.
|
|
||
| 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: |
There was a problem hiding this comment.
I think ao menos que should be a menos que.
| } | ||
| ``` | ||
|
|
||
| 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> )`. |
There was a problem hiding this comment.
nitpicking: ...aceita apenas... seems more common in portuguese.
There was a problem hiding this comment.
I think ...de um loop... can be removed
A função `loop` aceita apenas um corpo e retorna uma...
| 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. |
There was a problem hiding this comment.
(os parâmetros do construtor). Logo após, (se as classes são genéricas).
| } | ||
| ``` | ||
|
|
||
| *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 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). | ||
|
|
||
| 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]`. |
There was a problem hiding this comment.
Não sei se temos uma boa tradução para alias. Se você manter a palavra em inglês melhor colocar a palavra em itálico. Ainda mais que o leitor pode se confundir com aliás.
| } | ||
| ``` | ||
|
|
||
| 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. |
|
|
||
| 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, classe, 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. |
| } | ||
| ``` | ||
|
|
||
| Se comentar a anotação `throws` na classe `Reader` o complidor produz a seguinte mensagem de erro ao compilar o programa principal Java: |
|
Wow, this is amazing! Thanks for the quick action @dberg @felipehummel @fwbrasil! Happy to merge whenever you guys say it's ready to go! |
| @@ -0,0 +1,72 @@ | |||
| --- | |||
| layout: tutorial | |||
| title: Automatic Type-Dependent Closure Construction | |||
There was a problem hiding this comment.
Eita, isso deve soar estranho em português. Construção Automática de Closures de Tipo-Dependente? Não sei se existe uma boa tradução para closure.
There was a problem hiding this comment.
Acredito que podemos manter como closure mesmo, mas o título fica estranho 😕
| } | ||
| ``` | ||
|
|
||
| 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. |
|
|
||
| * 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 estrututal 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`. |
There was a problem hiding this comment.
Aqui temos um exemplo de hierarquia de tipos para notificação.... Talvez seja melhor não traduzir Notification.
| 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: |
| 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. |
There was a problem hiding this comment.
Isso é um chute mas instanciado provavelmente não tem acento circunflexo.
There was a problem hiding this comment.
Eita. Não tem mesmo. Eu que viajei.
|
|
||
| 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`. |
|
|
||
| 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: |
| } | ||
| ``` | ||
|
|
||
| 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 restrigird a assinatura de membros de objetos existentes. | ||
|
|
||
| A forma geral é: `A com B com C ... { refinamento }` |
There was a problem hiding this comment.
Provavelmente é melhor deixar a palavra with.
| 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._ |
There was a problem hiding this comment.
Boa idéia adicionar esse comentário. Minor issue though, Funcional.
| language: pt-br | ||
| --- | ||
|
|
||
| Ao desenvolver um software extensível, às vezes é útil declarar explicitamente o tipo do valor `this`. Para ilustrar isso, criaremos uma pequena representação extensível de uma estrutura de dados de grafo em Scala. |
There was a problem hiding this comment.
Graphy Theory = Teoria dos grafos. TIL ;)
| language: pt-br | ||
| --- | ||
|
|
||
| Em Scala, padrões podem ser definidos independentemente de classes case. Para este fim, um método chamado `unapply` é definido para retorna o extrator. Um extrator pode ser pensado como um método especial que inverte o efeito da aplicação de um determinado objeto em algumas entradas. Seu objetivo é "extrair" as entradas que estavam presentes antes da operação `apply`. Por exemplo, o código a seguir define um [objeto] (singleton-objects.html) extrator chamado Twice. |
|
|
||
| Existem duas convenções sintáticas em ação aqui: | ||
|
|
||
| O padrão `case Twice (n)` causa a invocação do método `Twice.unapply`, que é usado para fazer o match de qualquer número par; O valor de retorno de `unapply` indica se houve match ou não, e quaisquer sub-valores que possam ser utilizados para um seguinte match. Aqui, o sub-valor é `z/2`. |
There was a problem hiding this comment.
A tradução de match é realmente complicada nesse contexto. Combinar pode dar alusão a combinatorics. Comparar? que é usado para fazer a comparação de qualquer número... indica se a comparação falhou ou não... para uma seguinte comparação.?
| --- | ||
|
|
||
| Semelhante ao Java 5 (aka. [JDK 1.5](http://java.sun.com/j2se/1.5/)), Scala tem suporte nativo para classes parametrizadas com tipos. Essas classes genéricas são particularmente úteis para o desenvolvimento de classes collection. | ||
| Aqui um exemplo que demonstra isso: |
There was a problem hiding this comment.
Soa um pouco melhor (pelo menos pra mim) se mantermos o verbo to be. Aqui temos um...
| } | ||
| ``` | ||
|
|
||
| A classe `Stack` modela uma pila mutável que contém elementos de um tipo arbitrário `T`. Os parâmetros de tipo garantem que somente os elementos legais (que são do tipo `T`) são inseridos na pilha. Da mesma forma, com os parâmetros de tipo podemos expressar que o método `top` retorna somente elementos de um único tipo de dado, no caso, `T`. |
| 97 | ||
| 1 | ||
| ``` | ||
| _Nota: subtipos de tipos genéricos são *invariantes*. Isto significa que se tivermos uma pilha de caracteres do tipo `Stack [Char]` então não pode ser usado como uma pilha de inteiros do tipo `Stack [Int]`. Isso seria incorreto porque ele nos permitiria inserir inteiros verdadeiros na pilha de caracteres. Para concluir, `Stack [T]` é um subtipo de de `Stack [S]` se e somente se `S = T`. Como isso pode ser bastante restritivo, Scala oferece um [mecanismo de anotação de parâmetro de tipo](variances.html) para controlar o comportamento de subtipo de tipos genéricos._ |
| language: pt-br | ||
| --- | ||
|
|
||
| Scala permite definir funções de ordem superior. Tais funções _recebem outras como parâmetros_, as quais _o resultado é outra função_. Por exemplo, a função `apply` recebe outra função `f` e um valor `v` então aplica a função `f` em`v`: |
There was a problem hiding this comment.
Melhor ser explícito, _recebem outras funções como.... Ficou faltando adicionar a tradução de or ou o exemplo não condiz com a explicação. ou resultam em uma função.
|
|
||
| * Primeira, são elegíveis todos os identificadores x que podem ser acessados no ponto da chamada do método sem um prefixo e que denotam uma definição implícita ou um parâmetro implícito. | ||
|
|
||
| * Segunda, são elegíveis também todos os membros dos módulos acompanhates do tipo do parâmetro implícito que são rotulados marcados como `implicit`. |
|
|
||
| * Segunda, são elegíveis também todos os membros dos módulos acompanhates do tipo do parâmetro implícito que são rotulados marcados como `implicit`. | ||
|
|
||
| No exemplo a seguir, definimos um método `sum` que calcula a soma de uma lista de elementos usando as operações `add` e `unit` do monóide. Observe que valores implícitos não podem ser de nível superior, eles precisam ser membros de um modelo. |
There was a problem hiding this comment.
Essa eu tive que olhar na wikipedia. Parece que monoide não tem acento.
| } | ||
| ``` | ||
|
|
||
| Observe que em Java a última linha no programa do exemplo anterior é válida. Para nós de ambos os grafos, o Java atribuiria o mesmo tipo `Graph.Node`; isto é, `Node` é prefixado com a classe `Graph`. Em Scala, esse tipo também pode ser expresso, e é escrito `Graph#Node`. Se quisermos ser capazes de conectar nós de diferentes grafos, temos que mudar a definição inicial da nossa implementação do grafo da seguinte maneira: |
There was a problem hiding this comment.
Acho melhor remover o o. Apenas, Java atribuiria....
| tutorial-previous: traits | ||
| language: pt-br | ||
| --- | ||
| _Nota de tradução: A palavra `mixin` pode ser traduzida como mescla, porém é preferível utilizar a notação original_ |
There was a problem hiding this comment.
Inspirado na tradução ES :)
There was a problem hiding this comment.
A lot of minor changes. After these I think this is good to go.
We may need to come up with better translations for some expressions or just use the original one to avoid confusion (typeclasses, pattern matching, for compreehensions...). But I think this can be done in a future PR.
| } | ||
| ``` | ||
|
|
||
| A classe `DirectedGraph` estende a classe `Graph` fornecendo uma implementação parcial. A implementação é apenas parcial porque gostaríamos de poder ampliar o `DirectedGraph`. Portanto, esta classe deixa todos os detalhes de implementação abertos e assim, tanto as arestas e os nós são definidos como abstrato. No entanto, a classe `DirectedGraph` revela alguns detalhes adicionais sobre a implementação do tipo das arestas ao restringir o limite de tipo para a classe `EdgeImpl`. Além disso, temos algumas implementações preliminares de arestas e nós representados pelas classes `EdgeImpl` e `NodeImpl`. Uma vez que é necessário criar novos objetos nó e aresta dentro da nossa implementação de grafo, também temos que adicionar os métodos de construção `newNode` e `newEdge`. Os métodos `addNode` e `connectWith` são ambos definidos em termos destes métodos de construção. Uma análise mais detalhada da implementação do método `connectWith` revela que, para criar uma aresta, temos que passar a auto-referência `this` para o método de construção `newEdge`. Mas a `this` é atribuído o tipo `NodeImpl`, por isso não é compatível com o tipo `Node` que é exigido pelo método de construção correspondente. Como consequência, o programa acima não é bem-formado e o compilador Scala irá emitir uma mensagem de erro. |
There was a problem hiding this comment.
tanto as arestas e os nós são definidos como abstrato => tanto as arestas quanto os nós são definidos como abstratos
| } | ||
| ``` | ||
|
|
||
| Nesta nova definição de classe `NodeImpl`, `this` tem o tipo `Node`. Como o tipo `Node` é abstrato e, portanto, ainda não sabemos se `NodeImpl` é realmente um subtipo de `Node`, o sistema de tipo Scala não nos permitirá instanciar esta classe. Mas, no entanto, declaramos com a anotação de tipo explícito que, em algum ponto, (uma subclasse de) `NodeImpl` precisa denotar um subtipo de tipo `Node` para ser instantiável. |
There was a problem hiding this comment.
In Mas, no entanto, ... you can drop Mas or no entanto otherwise it's redundant.
|
|
||
| * Se é somente um teste, retorne `Boolean`. Por exemplo `case even()` | ||
| * Se retorna um único sub valor to tipo `T`, retorne `Option[T]` | ||
| * Se você quer retornar vários sub valores `T1,...,Tn`, agrupe todos em uma tupla opcional como `Option[(T1,...,Tn)]`. |
There was a problem hiding this comment.
sub valor => subvalor
sub valore => subvalores
Same thing below
| language: pt-br | ||
| --- | ||
|
|
||
| Semelhante ao Java 5 (aka. [JDK 1.5](http://java.sun.com/j2se/1.5/)), Scala tem suporte nativo para classes parametrizadas com tipos. Essas classes genéricas são particularmente úteis para o desenvolvimento de classes collection. |
There was a problem hiding this comment.
- I think
de classes collectionscan be better expressed as something like:... para o desenvolvimento de classes representando coleções de dados
|
|
||
| A classe `Stack` modela uma pilha mutável que contém elementos de um tipo arbitrário `T`. Os parâmetros de tipo garantem que somente os elementos legais (que são do tipo `T`) são inseridos na pilha. Da mesma forma, com os parâmetros de tipo podemos expressar que o método `top` retorna somente elementos de um único tipo de dado, no caso, `T`. | ||
|
|
||
| Aqui mais alguns exemplo de uso: |
| ## Scala é orienta a objetos ## | ||
| Scala é uma linguagem puramente orientada a objetos no sentido que [todo valor é um objeto](unified-types.html). Tipos e comportamentos de objetos são descritos por [classes](classes.html) e [traits](traits.html). Classes são estendidas por subclasses e por um flexível mecanismo [de composição mesclada](mixin-class-composition.html) como uma alternativa para herança múltipla. | ||
|
|
||
| ## Scala is functional ## |
| ## Scala is functional ## | ||
| Scala é também uma linguagem funcional no sentido que [toda função é um valor](unified-types.html). Scala fornece uma [sintaxe leve](anonymous-function-syntax.html) para definir funções anônimas, suporta [funções de primeira ordem](higher-order-functions.html), permite funções [aninhadas](nested-functions.html), e suporta [currying](currying.html). As [case classes](case-classes.html) da linguagem Scala e o suporte embutido para [correspondência de padrões](pattern-matching.html) modelam tipos algébricos utilizados em muitas linguagens de programação funcional. [Objetos Singleton](singleton-objects.html) fornecem uma alternativa conveniente para agrupar funções que não são membros de uma classe. | ||
|
|
||
| Além disso, a noção de correspondência de padrões em scala se estende naturalmente ao [processamento de dados de um XML](xml-processing.html) com a ajuda de [expressões regulares](regular-expression-patterns.html), por meio de uma extensão via [objetos extratores](extractor-objects.html). Nesse contexto, [compreensões de sequência](sequence-comprehensions.html) são úteis para formular consultas. Essas funcionalidades tornam Scala ideal para desenvolver aplicações como serviços web. |
|
|
||
| ## Scala é estensível ## | ||
|
|
||
| Na prática, o desenvolvimento de uma aplicaçãoes de um determinado domínio geralmente requer uma linguagem de domínio específico. Scala fornece uma combinação única de mecanismos de linguagem que facilitam a adição suave de novas construções de linguagem na forma de bibliotecas: |
There was a problem hiding this comment.
Typo: ...de uma aplicaçãoes... => de aplicações
| } | ||
| ``` | ||
|
|
||
| O programa declare uma aplicação chamada `TiposUnificados` em forma de um [objeto Singleton](singleton-objects.html) que estende `App`. A aplicação define uma variável local `set` que se refere à uma instância da classe `LinkedHashSet[Any]`. As demais linhas adicionam vários elementos à variável set. Tais elementos devem estar em conformidade com o tipo `Any` que foi declarado para o set. Por fim, são escritas as representações em string de todos os elementos adicionados ao set. |
There was a problem hiding this comment.
typo: declare => declara
à uma => a uma
| language: pt-br | ||
| --- | ||
|
|
||
| Em scala, [parâmetros de tipos](generic-classes.html) e [tipos abstratos](abstract-types.html) podem ser restringidos por um limitante de tipo. Tal limitante de tipo limita os valores concretos de uma variável de tipo e possivelmente revela mais informações sobre os membros de determinados tipos. Um _limitante superiror de tipos_ `T <: A` declare que a variável tipo `T` refere-se a um subtipo do tipo `A`. |
fforbeck
force-pushed
the
translation-pt-br
branch
from
5d739e6 to
394f27d
Compare
fforbeck
force-pushed
the
translation-pt-br
branch
from
394f27d to
2120648
Compare
fforbeck
force-pushed
the
translation-pt-br
branch
from
2120648 to
f843b31
Compare
|
For me it's a 👍 to merge. @SethTisue @heathermiller |
|
🎉 Woohoo! 🎉 |
|
@heathermiller I couldn't find where to enable the pt-br lang in the layout to display with the other languages. Do you know where I can change that? |
|
Ah yes, good question @fforbeck. (There's a crazy answer 😉) You have to add Brazilian Portuguese to the list of languages for which there is a full translation. And for some reason (don't ask) that list is in the front matter on this page here: https://github.com/scala/scala.github.com/blob/master/tutorials/tour/abstract-types.md |
|
@fforbeck great job! |
Happy to contribute with the translation of Scala tutorials Tour of Scala to Brazilian Portuguese.