learnxinyminutes-docs/pt-br/erlang.md

---
filename: learnerlang-pt.erl
contributors:
    - ["Giovanni Cappellotto", "http://www.focustheweb.com/"]
translators:
    - ["Guilherme Heuser Prestes", "http://twitter.com/gprestes"]
---

```erlang
% Símbolo de porcento começa comentários de uma linha.

%% Dois caracteres de porcento devem ser usados para comentar funções.

%%% Três caracteres de porcento devem ser usados para comentar módulos.

% Nós usamos três tipos de pontuação em Erlang.
% Vírgulas (`,`) separam argumentos em chamadas de função, construtores de
% dados, e padrões.
% Pontos finais (`.`) separam totalmente funções e expressões no prompt.
% Ponto e vírgulas (`;`) separam cláusulas. Nós encontramos cláusulas em
% vários contextos: definições de função e em expressões com `case`, `if`,
% `try..catch` e `receive`.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% 1. Variáveis e casamento de padrões.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

Num = 42.  % Todos nomes de variáveis devem começar com uma letra maiúscula.

% Erlang tem atribuição única de variáveis, se você tentar atribuir um valor
% diferente à variável `Num`, você receberá um erro.
Num = 43. % ** exception error: no match of right hand side value 43

% Na maioria das linguagens, `=` denota um comando de atribuição. Em Erlang, no
% entanto, `=` denota uma operação de casamento de padrão. `Lhs = Rhs` realmente
% significa isso: avalia o lado direito (Rhs), e então casa o resultado com o
% padrão no lado esquerdo (Lhs).
Num = 7 * 6.

% Número de ponto flutuante.
Pi = 3.14159.

% Átomos são usados para representar diferentes valores constantes não
% numéricos. Átomos começam com letras minúsculas seguidas por uma sequência de
% caracteres alfanuméricos ou sinais de subtraço (`_`) ou arroba (`@`).
Hello = hello.
OtherNode = example@node.

% Átomos com valores alfanuméricos podem ser escritos colocando aspas por fora
% dos átomos.
AtomWithSpace = 'some atom with space'.

% Tuplas são similares a structs em C.
Point = {point, 10, 45}.

% Se nós queremos extrair alguns valores de uma tupla, nós usamos o operador `=`.
{point, X, Y} = Point.  % X = 10, Y = 45

% Nós podemos usar `_` para ocupar o lugar de uma variável que não estamos interessados.
% O símbolo `_` é chamado de variável anônima. Ao contrário de variáveis regulares,
% diversas ocorrências de _ no mesmo padrão não precisam se amarrar ao mesmo valor.
Person = {person, {name, {first, joe}, {last, armstrong}}, {footsize, 42}}.
{_, {_, {_, Who}, _}, _} = Person.  % Who = joe

% Nós criamos uma lista colocando valores separados por vírgula entre colchetes.
% Cada elemento de uma lista pode ser de qualquer tipo.
% O primeiro elemento de uma lista é a cabeça da lista. Se removermos a cabeça
% da lista, o que sobra é chamado de cauda da lista.
ThingsToBuy = [{apples, 10}, {pears, 6}, {milk, 3}].

% Se `T` é uma lista, então `[H|T]` também é uma lista, com cabeça `H` e cauda `T`.
% A barra vertical (`|`) separa a cabeça de uma lista de sua cauda.
% `[]` é uma lista vazia.
% Podemos extrair elementos de uma lista com uma operação de casamento de
% padrão. Se temos uma lista não-vazia `L`, então a expressão `[X|Y] = L`, onde
% `X` e `Y` são variáveis desamarradas, irá extrair a cabeça de uma lista para
% `X` e a cauda da lista para `Y`.
[FirstThing|OtherThingsToBuy] = ThingsToBuy.
% FirstThing = {apples, 10}
% OtherThingsToBuy = {pears, 6}, {milk, 3}

% Não existe o tipo string em Erlang. Strings são somente listas de inteiros.
% Strings são representadas dentro de aspas duplas (`"`).
Name = "Hello".
[72, 101, 108, 108, 111] = "Hello".


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% 2. Programação sequencial.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Módulos são a unidade básica de código em Erlang. Todas funções que
% escrevemos são armazenadas em módulos. Módulos são armazenados em arquivos
% com extensão `.erl`.
% Módulos devem ser compilados antes que o código possa ser rodado. Um módulo
% compilado tem a extensão `.beam`.
-module(geometry).
-export([area/1]). % lista de funções exportadas de um módulo.

% A função `area` consiste de duas cláusulas. As cláusulas são separadas por um
% ponto e vírgula, e a cláusula final é terminada por um ponto final.
% Cada cláusula tem uma cabeça em um corpo; a cabeça consiste de um nome de
% função seguido por um padrão (entre parêntesis), e o corpo consiste de uma
% sequência de expressões, que são avaliadas se o padrão na cabeça é um par bem
% sucedido dos argumentos da chamada. Os padrões são casados na ordem que
% aparecem na definição da função.
area({rectangle, Width, Ht}) -> Width * Ht;
area({circle, R})            -> 3.14159 * R * R.

% Compila o código no arquivo geometry.erl.
c(geometry).  % {ok,geometry}

% Nós precisamos incluir o nome do módulo junto com o nome da função de maneira
% a identificar exatamente qual função queremos chamar.
geometry:area({rectangle, 10, 5}).  % 50
geometry:area({circle, 1.4}).  % 6.15752

% Em Erlang, duas funções com o mesmo nome e diferentes aridades (números de
% argumentos) no mesmo módulo representam funções totalmente diferentes.
-module(lib_misc).
-export([sum/1]). % exporta a função `sum` de aridade 1 aceitando um argumento: lista de inteiros.
sum(L) -> sum(L, 0).
sum([], N)    -> N;
sum([H|T], N) -> sum(T, H+N).

% Funs são funções "anônimas". Elas são chamadas desta maneira por que elas não
% têm nome. No entanto podem ser atribuídas a variáveis.
Double = fun(X) -> 2*X end. % `Double` aponta para uma função anônima com referência: #Fun<erl_eval.6.17052888>
Double(2).  % 4

% Funções aceitam funs como seus argumentos e podem retornar funs.
Mult = fun(Times) -> ( fun(X) -> X * Times end ) end.
Triple = Mult(3).
Triple(5).  % 15

% Compreensão de lista são expressões que criam listas sem precisar usar funs,
% maps, ou filtros.
% A notação `[F(X) || X <- L]` significa "a lista de `F(X)` onde `X` é tomada
% da lista `L`."
L = [1,2,3,4,5].
[2*X || X <- L].  % [2,4,6,8,10]
% Uma compreensão de lista pode ter geradores e filtros que selecionam
% subconjuntos dos valores gerados.
EvenNumbers = [N || N <- [1, 2, 3, 4], N rem 2 == 0]. % [2, 4]

% Sentinelas são contruções que podemos usar para incrementar o poder de
% casamento de padrão. Usando sentinelas, podemos executar testes simples e
% comparações nas variáveis em um padrão.
% Você pode usar sentinelas nas cabeças das definições de função onde eles são
% introduzidos pela palavra-chave `when`, ou você pode usá-los em qualquer
% lugar na linguagem onde uma expressão é permitida.
max(X, Y) when X > Y -> X;
max(X, Y) -> Y.

% Um sentinela é uma série de expressões sentinelas, separadas por
% vírgulas (`,`).
% O sentinela `GuardExpr1, GuardExpr2, ..., GuardExprN` é verdadeiro se todas
% expressões sentinelas `GuardExpr1, GuardExpr2, ...` forem verdadeiras.
is_cat(A) when is_atom(A), A =:= cat -> true;
is_cat(A) -> false.
is_dog(A) when is_atom(A), A =:= dog -> true;
is_dog(A) -> false.

% Uma `sequência sentinela` é um sentinela ou uma série de sentinelas separados
% por ponto e vírgula (`;`). A sequência sentinela `G1; G2; ...; Gn` é
% verdadeira se pelo menos um dos sentinelas `G1, G2, ...` for verdadeiro.
is_pet(A) when is_dog(A); is_cat(A) -> true;
is_pet(A) -> false.

% Registros provêem um método para associar um nome com um elemento particular
% em uma tupla.
% Definições de registro podem ser incluídas em arquivos fonte Erlang ou em
% arquivos com extensão `.hrl`, que então são incluídos em arquivos fonte Erlang.
-record(todo, {
  status = reminder,  % Default value
  who = joe,
  text
}).

% Nós temos que ler definições de registro no prompt antes que possamos definir
% um registro. Nós usamos a função de prompt `rr` (abreviação de read records)
% para fazer isso.
rr("records.hrl").  % [todo]

% Criando e atualizando registros:
X = #todo{}.
% #todo{status = reminder, who = joe, text = undefined}
X1 = #todo{status = urgent, text = "Fix errata in book"}.
% #todo{status = urgent, who = joe, text = "Fix errata in book"}
X2 = X1#todo{status = done}.
% #todo{status = done,who = joe,text = "Fix errata in book"}

% Expressões `case`.
% A função `filter` retorna uma lista de todos elementos `X` em uma lista `L`
% para qual `P(X)` é verdadeiro.
filter(P, [H|T]) ->
  case P(H) of
    true -> [H|filter(P, T)];
    false -> filter(P, T)
  end;
filter(P, []) -> [].
filter(fun(X) -> X rem 2 == 0 end, [1, 2, 3, 4]). % [2, 4]

% Expressões `if`.
max(X, Y) ->
  if
    X > Y -> X;
    X < Y -> Y;
    true -> nil;
  end.

% Aviso: pelo menos um dos sentinelas na expressão `if` deve retornar
% verdadeiro; Caso contrário, uma exceção será levantada.


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% 3. Exceções.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Exceções são levantadas pelo sistema quando erros internos são encontrados ou
% explicitamente em código pela chamada `throw(Exception)`, `exit(Exception)`
% ou `erlang:error(Exception)`.
generate_exception(1) -> a;
generate_exception(2) -> throw(a);
generate_exception(3) -> exit(a);
generate_exception(4) -> {'EXIT', a};
generate_exception(5) -> erlang:error(a).

% Erlang tem dois métodos para capturar uma exceção. Uma é encapsular a chamada
% para a função que levanta uma exceção dentro de uma expressão `try...catch`.
catcher(N) ->
  try generate_exception(N) of
    Val -> {N, normal, Val}
  catch
    throw:X -> {N, caught, thrown, X};
    exit:X -> {N, caught, exited, X};
    error:X -> {N, caught, error, X}
  end.

% O outro é encapsular a chamada em uma expressão `catch`. Quando você captura
% uma exceção, é convertida em uma tupla que descreve o erro.
catcher(N) -> catch generate_exception(N).
```

## Referências

* ["Learn You Some Erlang for great good!"](http://learnyousomeerlang.com/)
* ["Programming Erlang: Software for a Concurrent World" by Joe Armstrong](http://pragprog.com/book/jaerlang2/programming-erlang)
* [Erlang/OTP Reference Documentation](http://www.erlang.org/doc/)
* [Erlang - Programming Rules and Conventions](http://www.erlang.se/doc/programming_rules.shtml)