fix names in pt-br

1 files changed, 0 insertions, 412 deletions

diff --git a/pt-br/elixir.html.markdown b/pt-br/elixir.html.markdown
deleted file mode 100644
index f8c56101..00000000
--- a/pt-br/elixir.html.markdown
+++ /dev/null
@@ -1,412 +0,0 @@
----
-language: elixir
-contributors:
-    - ["Joao Marques", "http://github.com/mrshankly"]
-    - ["Dzianis Dashkevich", "https://github.com/dskecse"]
-translators:
-    - ["Rodrigo Muniz", "http://github.com/muniz95"]
-lang: pt-br
-filename: learnelixir-pt.ex
----
-
-Elixir é uma linguagem funcional moderna construída no topo da Erlang VM.
-É totalmente compatível com Erlang, porém conta com uma sintaxe mais padronizada
-e muitos outros recursos.
-
-```elixir
-
-# Comentários de linha única começam com um símbolo de número.
-
-# Não há comentários de múltiplas linhas,
-# mas você pode empilhar os comentários.
-
-# Para usar o shell do elixir use o comando `iex`.
-# Compile seus módulos com o comando `elixirc`.
-
-# Ambos devem estar em seu path se você instalou o Elixir corretamente.
-
-## ---------------------------
-## -- Tipos Básicos
-## ---------------------------
-
-# Há números
-3    # integer
-0x1F # integer
-3.0  # float
-
-# Atoms, que são literais, uma constante com nome. Elas começam com `:`.
-:hello # atom
-
-# Tuplas que são guardadas contiguamente em memória.
-{1,2,3} # tupla
-
-# Podemos acessar um elemento de uma tupla om a função `elem`:
-elem({1, 2, 3}, 0) #=> 1
-
-# Listas que são implementadas como listas ligadas.
-[1,2,3] # lista
-
-# Podemos acessar a primeira posição (head) e o resto (tail) de uma lista como a seguir:
-[head | tail] = [1,2,3]
-head #=> 1
-tail #=> [2,3]
-
-# Em elixir, bem como em Erlang, o sinal `=` denota pattern match,
-# e não uma atribuição.
-#
-# Isto significa que o que estiver à esquerda (pattern) é comparado com o que
-# estiver à direita.
-#
-# É assim que o exemplo acima de acesso à head e tail de uma lista funciona.
-
-# Um pattern match retornará erro quando os lados não conferem, como neste exemplo
-# onde as tuplas tem diferentes tamanhos.
-# {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}
-
-# Também há binários
-<<1,2,3>> # binary
-
-# Strings e char lists
-"hello" # string
-'hello' # char list
-
-# Strings de múltiplas linhas
-"""
-Strings
-de múltiplas
-linhas.
-"""
-#=> "Strings\nde múltiplas\nlinhas"
-
-# Strings são sempre codificadas em UTF-8:
-"héllò" #=> "héllò"
-
-# Strings são de fato apenas binários, e char lists apenas listas.
-<<?a, ?b, ?c>> #=> "abc"
-[?a, ?b, ?c]   #=> 'abc'
-
-# `?a` em elixir retorna o valor ASCII para a letra `a`
-?a #=> 97
-
-# Para concatenar listas use `++`, para binários use `<>`
-[1,2,3] ++ [4,5]     #=> [1,2,3,4,5]
-'hello ' ++ 'world'  #=> 'hello world'
-
-<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>
-"hello " <> "world"  #=> "hello world"
-
-# Ranges são representados como `início..fim` (ambos inclusivos)
-1..10 #=> 1..10
-menor..maior = 1..10 # Pattern matching pode ser usada em ranges também
-[lower, upper] #=> [1, 10]
-
-## ---------------------------
-## -- Operadores
-## ---------------------------
-
-# Matemática básica
-1 + 1  #=> 2
-10 - 5 #=> 5
-5 * 2  #=> 10
-10 / 2 #=> 5.0
-
-# Em elixir o operador `/` sempre retorna um float.
-
-# Para divisão de inteiros use `div`
-div(10, 2) #=> 5
-
-# Para obter o resto da divisão use `rem`
-rem(10, 3) #=> 1
-
-# Há também operadores booleanos: `or`, `and` e `not`.
-# Estes operadores esperam um booleano como primeiro argumento.
-true and true #=> true
-false or true #=> true
-# 1 and true    #=> ** (ArgumentError) argument error
-
-# Elixir também fornece `||`, `&&` e `!` que aceitam argumentos de qualquer tipo.
-# Todos os valores exceto `false` e `nil` serão avaliados como true.
-1 || true  #=> 1
-false && 1 #=> false
-nil && 20  #=> nil
-!true #=> false
-
-# Para comparações temos: `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` e `>`
-1 == 1 #=> true
-1 != 1 #=> false
-1 < 2  #=> true
-
-# `===` e `!==` são mais estritos ao comparar integers e floats:
-1 == 1.0  #=> true
-1 === 1.0 #=> false
-
-# Podemos comparar também dois tipos de dados diferentes:
-1 < :hello #=> true
-
-# A regra de ordenação no geral é definida abaixo:
-# number < atom < reference < functions < port < pid < tuple < list < bit string
-
-# Ao citar Joe Armstrong nisto: "A ordem de fato não é importante,
-# mas que uma ordem total esteja bem definida é importante."
-
-## ---------------------------
-## -- Fluxo de Controle
-## ---------------------------
-
-# expressão `if` 
-if false do
-  "Isso nunca será visto"
-else
-  "Isso será"
-end
-
-# Também há `unless`
-unless true do
-  "Isso nunca será visto"
-else
-  "Isso será"
-end
-
-# Lembra do patter matching? Muitas estruturas de fluxo de controle em elixir contam com ela.
-
-# `case` nos permite comparar um valor com muitos patterns:
-case {:um, :dois} do
-  {:quatro, :cinco} ->
-    "Isso não corresponde"
-  {:um, x} ->
-    "Isso corresponde e vincula `x` a `:dois`"
-  _ ->
-    "Isso corresponde a qualquer valor"
-end
-
-# É comum vincular o valor a `_` se não precisamos dele.
-# Por exemplo, se apenas a head de uma lista nos interessa:
-[head | _] = [1,2,3]
-head #=> 1
-
-# Para melhor legibilidade podemos fazer o seguinte:
-[head | _tail] = [:a, :b, :c]
-head #=> :a
-
-# `cond` nos permite verificar várias condições ao mesmo tempo.
-# Use `cond` em vez de aninhar vários `if`'s.
-cond do
-  1 + 1 == 3 ->
-    "Nunca serei visto"
-  2 * 5 == 12 ->
-    "Nem eu"
-  1 + 2 == 3 ->
-    "Mas eu serei"
-end
-
-# É comum definir a última condição igual a `true`, que sempre irá corresponder.
-cond do
-  1 + 1 == 3 ->
-    "Nunca serei visto"
-  2 * 5 == 12 ->
-    "Nem eu"
-  true ->
-    "Mas eu serei (isso é essencialmente um else)"
-end
-
-# `try/catch` é usado para capturar valores que são lançados, também suporta uma
-# cláusula `after` que é invocada havendo um valor capturado ou não.
-try do
-  throw(:hello)
-catch
-  message -> "Deu #{mensagem}."
-after
-  IO.puts("Sou o after.")
-end
-#=> Sou o after
-# "Deu :hello"
-
-## ---------------------------
-## -- Módulos e Funções
-## ---------------------------
-
-# Funções Anônimas (repare o ponto)
-square = fn(x) -> x * x end
-square.(5) #=> 25
-
-# Elas também aceitam várias cláusulas e guards.
-# Guards permitem ajustes finos de pattern matching,
-# sendo indicados pela palavra `when`:
-f = fn
-  x, y when x > 0 -> x + y
-  x, y -> x * y
-end
-
-f.(1, 3)  #=> 4
-f.(-1, 3) #=> -3
-
-# Elixir também fornece várias funções embutidas.
-# Estas estão disponíveis no escopo atual.
-is_number(10)    #=> true
-is_list("ola") #=> false
-elem({1,2,3}, 0) #=> 1
-
-# Você pode agrupar algumas funções em um módulo. Dentro de um módulo use `def`
-# para definir suas funções.
-defmodule Math do
-  def sum(a, b) do
-    a + b
-  end
-
-  def square(x) do
-    x * x
-  end
-end
-
-Math.sum(1, 2)  #=> 3
-Math.square(3) #=> 9
-
-# Para compilar o módulo Math salve-o como `math.ex` e use `elixirc`
-# em seu terminal: elixirc math.ex
-
-# Dentro de um módulo podemos definir funções com `def` e funções privadas com `defp`.
-# Uma função definida com `def` pode ser invocada por outros módulos,
-# já uma função privada pode ser invocada apenas localmente.
-defmodule PrivateMath do
-  def sum(a, b) do
-    do_sum(a, b)
-  end
-
-  defp do_sum(a, b) do
-    a + b
-  end
-end
-
-PrivateMath.sum(1, 2)    #=> 3
-# PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError)
-
-# Declarações de funções também suportam guards cláusulas múltiplas:
-defmodule Geometry do
-  def area({:rectangle, w, h}) do
-    w * h
-  end
-
-  def area({:circle, r}) when is_number(r) do
-    3.14 * r * r
-  end
-end
-
-Geometry.area({:rectangle, 2, 3}) #=> 6
-Geometry.area({:circle, 3})       #=> 28.25999999999999801048
-# Geometry.area({:circle, "not_a_number"})
-#=> ** (FunctionClauseError) no function clause matching in Geometry.area/1
-
-# Devido à imutabilidade, recursão é uma grande parte do elixir
-defmodule Recursion do
-  def sum_list([head | tail], acc) do
-    sum_list(tail, acc + head)
-  end
-
-  def sum_list([], acc) do
-    acc
-  end
-end
-
-Recursion.sum_list([1,2,3], 0) #=> 6
-
-# Módulos do elixir suportam atributos, hpa atributos embutidos e você
-# pode também adicionar os seus próprios.
-defmodule MyMod do
-  @moduledoc """
-  Este é um atributo embutido em um módulo de exemplo.
-  """
-
-  @my_data 100 # Este é um atributo customizado.
-  IO.inspect(@my_data) #=> 100
-end
-
-## ---------------------------
-## -- Structs e Exceptions
-## ---------------------------
-
-# Structs são extensões no topo de mapas que trazem valores padrão,
-# garantias em tempo de compilação e polimorfismo para o Elixir.
-defmodule Pessoa do
-  defstruct nome: nil, idade: 0, peso: 0
-end
-
-joe_info = %Pessoa{ nome: "Joe", idade: 30, peso: 180 }
-#=> %Pessoa{idade: 30, peso: 180, nome: "Joe"}
-
-# Acessa o valor de nome
-joe_info.name #=> "Joe"
-
-# Atualiza o valor de idade
-older_joe_info = %{ joe_info | idade: 31 }
-#=> %Pessoa{idade: 31, peso: 180, nome: "Joe"}
-
-# O bloco `try` com a palavra `rescue` é usado para manipular exceções
-try do
-  raise "algum erro"
-rescue
-  RuntimeError -> "resgatado um erro em tempo de execução"
-  _error -> "isso resgatará qualquer erro"
-end
-
-# Toda exceção possui uma mensagem
-try do
-  raise "algum erro"
-rescue
-  x in [RuntimeError] ->
-    x.message
-end
-
-## ---------------------------
-## -- Concorrência
-## ---------------------------
-
-# Elixir conta com o modelo de ator para concorrência. Tudo o que precisamos para
-# escrever programas concorrentes em elixir são três primitivos: spawning processes,
-# sending messages e receiving messages.
-
-# Para iniciar um novo processo usamos a função `spawn`, a qual leva uma função
-# como argumento.
-f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
-spawn(f) #=> #PID<0.40.0>
-
-# `spawn` retorna um pid (process identifier), você pode usar esse pid para enviar
-# mensagens ao processo. Para envio de mensagens usamos o operador `send`.
-# Para tudo isso ser útil precisamos estar aptos a receber mensagens. Isto é
-# realizado com o mecanismo `receive`:
-defmodule Geometry do
-  def area_loop do
-    receive do
-      {:rectangle, w, h} ->
-        IO.puts("Area = #{w * h}")
-        area_loop()
-      {:circle, r} ->
-        IO.puts("Area = #{3.14 * r * r}")
-        area_loop()
-    end
-  end
-end
-
-# Compile o módulo e crie um processo que avalie `area_loop` no shell
-pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0>
-
-# Envia uma mensagem ao `pid` correspondente a um pattern na declaração de recebimento
-send pid, {:rectangle, 2, 3}
-#=> Area = 6
-#   {:rectangle,2,3}
-
-send pid, {:circle, 2}
-#=> Area = 12.56000000000000049738
-#   {:circle,2}
-
-# O shell também é um processo, você pode usar `self` para obter o pid atual
-self() #=> #PID<0.27.0>
-```
-
-## Referências
-
-* [Getting started guide](http://elixir-lang.org/getting_started/1.html) da [página do elixir](http://elixir-lang.org)
-* [Elixir Documentation](http://elixir-lang.org/docs/master/)
-* ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) por Dave Thomas
-* [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
-* ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) por Fred Hebert
-* ["Programming Erlang: Software for a Concurrent World"](https://pragprog.com/book/jaerlang2/programming-erlang) por Joe Armstrong