[PT] Update lesson translations (#1493)

* [PT] Update Collections translation for 1.2.3

* [EN] Gardening Collections lesson 🌻

* [EN] Gardening Enum lesson 🌻

* [PT] Update Enum lesson translation

* [EN] Gardening Pattern Matching lesson 🌻

* [PT] Update Pattern Matching lesson translation

* [EN] Gardening Functions lesson 🌻

* [PT] Update Functions lesson translation

en/lessons/basics/collections.md

@@ -22,14 +22,13 @@ Elixir implements list collections as linked lists.  This means that accessing t
 iex> list = [3.14, :pie, "Apple"]
 [3.14, :pie, "Apple"]
 # Prepending (fast)
-iex> ["π"] ++ list  
+iex> ["π"] ++ list
 ["π", 3.14, :pie, "Apple"]
 # Appending (slow)
 iex> list ++ ["Cherry"]
 [3.14, :pie, "Apple", "Cherry"]
 ```
 
-
 ### List Concatenation
 
 List concatenation uses the `++/2` operator:
@@ -83,7 +82,7 @@ iex> tail
 
 ## Tuples
 
-Tuples are similar to lists, but are stored contiguously in memory.  This makes accessing their length fast but modification expensive; the new tuple must be copied entirely to memory.  Tuples are defined with curly braces:
+Tuples are similar to lists, but are stored contiguously in memory.  This makes accessing their length fast but modification expensive; the new tuple must be copied entirely to memory. Tuples are defined with curly braces:
 
 ```elixir
 iex> {3.14, :pie, "Apple"}
@@ -120,7 +119,7 @@ For these reasons, keyword lists are most commonly used to pass options to funct
 
 ## Maps
 
-In Elixir, maps are the "go-to" key-value store. Unlike keyword lists, they allow keys of any type and are un-ordered.  You can define a map with the `%{}` syntax:
+In Elixir, maps are the "go-to" key-value store. Unlike keyword lists, they allow keys of any type and are un-ordered. You can define a map with the `%{}` syntax:
 
 ```elixir
 iex> map = %{:foo => "bar", "hello" => :world}

en/lessons/basics/enum.md

@@ -152,7 +152,7 @@ iex> Enum.filter([1, 2, 3, 4], fn(x) -> rem(x, 2) == 0 end)
 
 ### reduce
 
-With `reduce/3` we can distill our collection down into a single value.  To do this we supply an optional accumulator (`10` in this example) to be passed into our function; if no accumulator is provided the first element in the enumerable is used:
+With `reduce/3` we can distill our collection down into a single value. To do this we supply an optional accumulator (`10` in this example) to be passed into our function; if no accumulator is provided the first element in the enumerable is used:
 
 ```elixir
 iex> Enum.reduce([1, 2, 3], 10, fn(x, acc) -> x + acc end)

en/lessons/basics/functions.md

@@ -3,7 +3,7 @@ version: 1.1.0
 title: Functions
 ---
 
-In Elixir and many functional languages, functions are first class citizens.  We will learn about the types of functions in Elixir, what makes them different, and how to use them.
+In Elixir and many functional languages, functions are first class citizens. We will learn about the types of functions in Elixir, what makes them different, and how to use them.
 
 {% include toc.html %}
 
@@ -180,7 +180,7 @@ iex> Greeter.hello("Sean", "es")
 "Hola, Sean"
 ```
 
-When we combine our guard example with default arguments, we run into an issue.  Let's see what that might look like:
+When we combine our guard example with default arguments, we run into an issue. Let's see what that might look like:
 
 ```elixir
 defmodule Greeter do

en/lessons/basics/pattern-matching.md

@@ -3,7 +3,7 @@ version: 1.0.2
 title: Pattern Matching
 ---
 
-Pattern matching is a powerful part of Elixir.  It allows us to match simple values, data structures, and even functions.  In this lesson we will begin to see how pattern matching is used.
+Pattern matching is a powerful part of Elixir. It allows us to match simple values, data structures, and even functions.  In this lesson we will begin to see how pattern matching is used.
 
 {% include toc.html %}
 

pt/lessons/basics/collections.md

@@ -1,5 +1,5 @@
 ---
-version: 1.2.1
+version: 1.2.3
 title: Coleções
 ---
 
@@ -16,13 +16,15 @@ iex> [3.14, :pie, "Apple"]
 [3.14, :pie, "Apple"]
 ```
 
-Elixir implementa listas como listas encadeadas. Isso significa que acessar a profundidade da lista é uma operação `O(n)`. Por essa razão, é normalmente mais rápido inserir um elemento no início do que no final.
+Elixir implementa listas como listas encadeadas. Isso significa que acessar o tamanho da lista é uma operação que rodará em tempo linear (`O(n)`). Por essa razão, é normalmente mais rápido inserir um elemento no início (`prepending`) do que no final (`appending`):
 
 ```elixir
 iex> list = [3.14, :pie, "Apple"]
 [3.14, :pie, "Apple"]
+# Prepending (rápido)
 iex> ["π"] ++ list
 ["π", 3.14, :pie, "Apple"]
+# Appending (lento)
 iex> list ++ ["Cherry"]
 [3.14, :pie, "Apple", "Cherry"]
 ```
@@ -36,7 +38,7 @@ iex> [1, 2] ++ [3, 4, 1]
 [1, 2, 3, 4, 1]
 ```
 
-Uma pequena nota sobre o formato de nome (`++/2`) usado acima. Em Elixir (e Erlang, sobre o qual Elixir é construído), o nome de uma função ou operador tem dois componentes: o nome em si (neste caso `++`) e sua _aridade_. Aridade é uma parte central quando se fala sobre código Elixir (e Erlang). Indica o número de argumentos que uma dada função aceita (dois, nesse nosso exemplo). Aridade e o nome são combinados com uma barra. Iremos falar mais sobre isto mais tarde; este conhecimento irá ajudá-lo a entender a notação por enquanto.
+Uma pequena nota sobre o formato de nome (`++/2`) usado acima. Em Elixir (e Erlang, sobre o qual Elixir é construído), o nome de uma função ou operador tem dois componentes: o nome em si (neste caso `++`) e sua _aridade_. Aridade é uma parte central quando se fala sobre código Elixir (e Erlang). Indica o número de argumentos que uma dada função aceita (dois, nesse nosso exemplo). Aridade e o nome são combinados com uma barra. Falaremos mais sobre isto mais tarde; este conhecimento irá ajudá-lo a entender a notação por enquanto.
 
 ### Subtração de listas
 
@@ -58,7 +60,7 @@ iex> [1,2,2,3,2,3] -- [1,2,3,2]
 
 ### Topo / Cauda
 
-Quando usamos listas é comum trabalhar com o topo e o fim da lista. O topo é o primeiro elemento da lista e a cauda são os elementos restantes. Elixir provê funções úteis, `hd` e `tl`, para trabalhar com essas partes:
+Quando usamos listas é comum trabalhar com o topo e o fim da lista. O topo é o primeiro elemento da lista e a cauda são os elementos restantes. Elixir provê duas funções bem úteis, `hd` e `tl`, para trabalhar com essas partes:
 
 ```elixir
 iex> hd [3.14, :pie, "Apple"]
@@ -67,7 +69,7 @@ iex> tl [3.14, :pie, "Apple"]
 [:pie, "Apple"]
 ```
 
-Além das funções citadas, pode-se usar [pattern matching](../pattern-matching) e o operador cons `|` para dividir a lista em topo e cauda; veremos este padrão em futuras lições:
+Além das funções citadas, pode-se usar [pattern matching](../pattern-matching) e o operador cons (`|`) para dividir a lista em topo e cauda; veremos este padrão em futuras lições:
 
 ```elixir
 iex> [head | tail] = [3.14, :pie, "Apple"]
@@ -80,7 +82,7 @@ iex> tail
 
 ## Tuplas
 
-As tuplas são similares às listas porém são armazenadas de maneira contígua em memória. Isto permite acessar a sua profundidade de forma rápida porém sua modificação é custosa; a nova tupla deve ser armazenada inteira na memória. As tuplas são definidas com chaves.
+As tuplas são similares às listas porém são armazenadas de maneira contígua em memória. Isto permite acessar seu tamanho de forma rápida porém sua modificação é custosa; a nova tupla deve ser armazenada inteira na memória. As tuplas são definidas com chaves.
 
 ```elixir
 iex> {3.14, :pie, "Apple"}

pt/lessons/basics/enum.md

@@ -1,5 +1,5 @@
 ---
-version: 1.3.0
+version: 1.4.0
 title: Enum
 ---
 
@@ -35,7 +35,7 @@ Para obter uma lista completa de funções, visite a documentação oficial do [
 
 ### all?
 
-Quando usando `all?/2`, e muitas das funções de `Enum`, provemos uma função para aplicar nos elementos da nossa coleção. No caso do `all?/2`, a coleção inteira deve ser avaliada como `true`, em outros casos `false` será retornado:
+Ao usar `all?/2`, e muitas das funções de `Enum`, provemos uma função para aplicar nos elementos da nossa coleção. No caso do `all?/2`, a coleção inteira deve ser avaliada como `true`, caso contrário `false` será retornado:
 
 ```elixir
 iex> Enum.all?(["foo", "bar", "hello"], fn(s) -> String.length(s) == 3 end)
@@ -75,7 +75,7 @@ iex> Enum.chunk_by(["one", "two", "three", "four", "five", "six"], fn(x) -> Stri
 
 ### map_every
 
-Algumas vezes quebrar uma coleção não é o suficiente para fazer exatamente o que você precisa. Se este é o caso, `map_every/3` pode ser muito útil para tratar apenas itens específicos da sua coleção (`nth`), sempre atingindo o primeiro:
+Algumas vezes quebrar uma coleção em blocos não é o suficiente para fazer exatamente o que você precisa. Nesse caso, `map_every/3` pode ser muito útil para tratar apenas itens específicos da sua coleção (`nth`), sempre atingindo o primeiro:
 
 ```elixir
 # Apply function every three items
@@ -140,7 +140,7 @@ iex> Enum.max([], fn -> :bar end)
 
 ### filter
 
-A função `filter/2` nos permite filtrar uma coleção para incluir apenas os elementos que são avaliados como `true` usando uma função provida.
+A função `filter/2` nos permite filtrar uma coleção para incluir apenas os elementos que são avaliados como `true` provendo uma função como argumento.
 
 ```elixir
 iex> Enum.filter([1, 2, 3, 4], fn(x) -> rem(x, 2) == 0 end)
@@ -164,7 +164,7 @@ iex> Enum.reduce(["a","b","c"], "1", fn(x,acc)-> x <> acc end)
 
 ### sort
 
-Ordenar nossas coleções é fácil com uma das funções de ordenação.
+Ordenar nossas coleções é fácil não só com uma, mas com duas funções de ordenação.
 
 `sort/1` usa a funcionalidade de ordenação do Erlang para determinar a ordem:
 

pt/lessons/basics/functions.md

@@ -1,9 +1,9 @@
 ---
-version: 1.0.1
+version: 1.1.0
 title: Funções
 ---
 
-Em Elixir e em várias linguagens funcionais, funções são cidadãos de primeira classe. Nós iremos aprender sobre os tipos de funções em Elixir, qual a diferença, e como usar elas.
+Em Elixir e em várias linguagens funcionais, funções são cidadãos de primeira classe. Nós aprenderemos sobre os tipos de funções em Elixir, qual a diferença, e como utilizá-las.
 
 {% include toc.html %}
 
@@ -21,7 +21,7 @@ iex> sum.(2, 3)
 
 ### A & taquigrafia
 
-Na utilização de funções anônimas é uma prática comum em Elixir, utilizando a abreviação para fazê-lo:
+Utilizar funções anônimas é uma prática comum em Elixir, há uma taquigrafia para fazê-lo:
 
 ```elixir
 iex> sum = &(&1 + &2)
@@ -35,11 +35,12 @@ Como você provavelmente já adivinhou, na versão abreviada nossos parâmetros
 
 Pattern matching não é limitado a apenas variáveis em Elixir, isto pode ser aplicado a assinaturas de funções como veremos nesta seção.
 
-Elixir utiliza pattern matching para identificar o primeiro conjunto de parâmetros associados e invoca seu respectivo corpo.
+Elixir utiliza pattern matching para verificar todas as possíveis opções de match e identificar o primeiro conjunto de parâmetros associados para executar seu respectivo corpo.
 
 ```elixir
 iex> handle_result = fn
 ...>   {:ok, result} -> IO.puts "Handling result..."
+...>   {:ok, _} -> IO.puts "This would be never run as previous will be matched beforehand."
 ...>   {:error} -> IO.puts "An error has occurred!"
 ...> end
 
@@ -91,7 +92,7 @@ iex> Length.of [1, 2, 3]
 
 ### Nomear Funções e a Aridade
 
-Mencionamos anteriormente que as funções são nomeadas pela combinação do nome e aridade(quantidade dos argumentos) das funções. Isto significa que você pode fazer o seguinte.
+Mencionamos anteriormente que as funções são nomeadas pela combinação do nome e aridade (quantidade dos argumentos) das funções. Isto significa que você pode fazer coisas como essa:
 
 ```elixir
 defmodule Greeter2 do
@@ -109,11 +110,11 @@ iex> Greeter2.hello("Fred", "Jane")
 "Hello, Fred and Jane"
 ```
 
-Nós temos listado os nomes das funções nos comentários acima. A causa que a primeira implementação não recebe argumentos, é conhecido como `hello/0`; a segunda função recebe um argumento, portanto será conhecido como `hello/1` e assim por diante. E ao contrário de sobrecargar funções como outros idiomas, estas são pensadas como funções diferentes entre um ao outro. (Pattern matching, o a combinação de padrões, descrita só um momento atrás, aplica-se quando várias definiçoes são fornecidas com a mesma quantidade de argumentos.)
+Nós listamos os nomes das funções nos comentários acima. A primeira implementação não recebe argumentos, é conhecida como `hello/0`; a segunda função recebe um argumento, portanto será conhecido como `hello/1` e assim por diante. E, ao contrário de sobrecargar funções como em outras linguagens de programação, estas são pensadas como funções _diferentes_ entre uma e outra. (Pattern matching, ou combinação de padrões, descrita agora há pouco, apenas se aplica quando várias definições são fornecidas com a _mesma_ quantidade de argumentos.)
 
 ### Funções privadas
 
-Quando não quisermos que outros módulos acessem uma função, nós podemos usar funções privadas, que só podem ser chamadas dentro de seus módulos. Nós podemos definir elas em Elixir com `defp`:
+Quando não quisermos que outros módulos acessem uma função específica, nós podemos torná-la uma função privada, que só podem ser chamadas dentro de seus módulos. Nós podemos defini-las em Elixir com `defp`:
 
 ```elixir
 defmodule Greeter do
@@ -131,7 +132,7 @@ iex> Greeter.phrase
 
 ### Guards
 
-Nós cobrimos brevemente guards nas lições de [Estruturas Condicionais](../control-structures), agora nós iremos ver como podemos aplicá-los em funções nomeadas. Uma vez que Elixir tem correspondência em uma função, qualquer guard existente irá ser testado.
+Nós cobrimos brevemente guards nas lições de [Estruturas Condicionais](../control-structures), agora veremos como podemos aplicá-los em funções nomeadas. Uma vez que Elixir tem correspondência em uma função, qualquer guard existente irá ser testado.
 
 No exemplo a seguir nós temos duas funções com a mesma assinatura, contamos com guards para determinar qual usar com base no tipo do argumento:
 
@@ -165,7 +166,7 @@ defmodule Greeter do
   end
 
   defp phrase("en"), do: "Hello, "
-  defp phrase("pt"), do: "Oi, "
+  defp phrase("pt"), do: "Olá, "
 end
 
 iex> Greeter.hello("Sean", "en")
@@ -175,7 +176,7 @@ iex> Greeter.hello("Sean")
 "Hello, Sean"
 
 iex> Greeter.hello("Sean", "pt")
-"Oi, Sean"
+"Olá, Sean"
 ```
 
 Quando combinamos nosso exemplo de guard com argumento padrão, nos deparamos com um problema. Vamos ver o que pode parecer:
@@ -193,7 +194,7 @@ defmodule Greeter do
   end
 
   defp phrase("en"), do: "Hello, "
-  defp phrase("pt"), do: "Oi, "
+  defp phrase("pt"), do: "Olá, "
 end
 
 ** (CompileError) iex:31: definitions with multiple clauses and default values require a header. Instead of:
@@ -211,7 +212,7 @@ def hello/2 has multiple clauses and defines defaults in one or more clauses
     iex:31: (module)
 ```
 
-Elixir não gosta de argumentos padrões em multiplas funções, pode ser confuso. Para lidar com isto, adicionamos funções com nosso argumento padrão:
+Elixir não gosta de argumentos padrões em múltiplas funções, pode ser confuso. Para lidar com isto, adicionamos funções com nosso argumento padrão:
 
 ```elixir
 defmodule Greeter do
@@ -228,12 +229,12 @@ defmodule Greeter do
   end
 
   defp phrase("en"), do: "Hello, "
-  defp phrase("pt"), do: "Oi, "
+  defp phrase("pt"), do: "Olá, "
 end
 
 iex> Greeter.hello ["Sean", "Steve"]
 "Hello, Sean, Steve"
 
 iex> Greeter.hello ["Sean", "Steve"], "pt"
-"Oi, Sean, Steve"
+"Olá, Sean, Steve"
 ```

pt/lessons/basics/pattern-matching.md

@@ -1,5 +1,5 @@
 ---
-version: 1.0.1
+version: 1.0.2
 title: Pattern Matching
 ---
 
@@ -39,7 +39,7 @@ iex> [1 | tail] = list
 [1, 2, 3]
 iex> tail
 [2, 3]
-iex> [2|_] = list
+iex> [2 | _] = list
 ** (MatchError) no match of right hand side value: [1, 2, 3]
 
 # Tuplas
@@ -94,4 +94,8 @@ iex> greet.("Hello", "Sean")
 "Hi Sean"
 iex> greet.("Mornin'", "Sean")
 "Mornin', Sean"
+iex> greeting
+"Hello"
 ```
+
+Note que no exemplo `"Mornin'"`, a reassociação de `greeting` para `"Mornin'"` só acontece dentro de uma função. Fora da função, `greeting` continua sendo `"Hello"`.