% 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*Xend.% `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*Timesend)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],Nrem2==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)whenX>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)whenis_atom(A),A=:=cat->true;is_cat(A)->false.is_dog(A)whenis_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)whenis_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])->caseP(H)oftrue->[H|filter(P,T)];false->filter(P,T)end;filter(P,[])->[].filter(fun(X)->Xrem2==0end,[1,2,3,4]).% [2, 4]
% Expressões `if`.
max(X,Y)->ifX>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)->trygenerate_exception(N)ofVal->{N,normal,Val}catchthrow: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)->catchgenerate_exception(N).