Índice

Finalmente, exemplos verdadeiramente práticos. É a hora de “rodar” exemplos. Confesso que demorei um pouco pra chegar à ERL, a Shell do Erlang, mas a prática é a parte mais fácil do aprendizado.

Nos artigos anteriores, mostrei onde, como e quando devemos e podemos utilizar Erlang. Mostrei que antes de ser criada pela Ericsson, foram feitos diversos testes com outras linguagens (como Prolog), e se viu que a criação de uma nova linguagem com as características que a Erlang tem, seria indispensável.

Capítulo III – A Shell

I. O que é?

A Shell nada mais é que um ambiente onde você pode executar instruções e chamar programas Erlang em tempo de execução (real).

II. Instalando

Você pode fazer o download direto do site, acessando http://erlang.org/download.html.

Eu estou usando Ubuntu/Linux, caso você esteja usando alguma distribuição Linux, tente utilizar o seu gerenciador de pacotes para instalar, por exemplo, no Ubuntu ou Debian:

apt-get install erlang

III. Iniciando a Shell

No Linux/Unix vá até o terminal e digite erl. No Windows, procure pela shell do Erlang no menu iniciar, ou tente tente achar o executável werl.exe, provavelmente localizado em: C:\Program Files\erl5.6\bin\werl.exe.

caio@emx:~$ erl
Erlang (BEAM) emulator version 5.6.3 [source] [async-threads:0] [kernel-poll:false]

Eshell V5.6.3  (abort with ^G)
1> "Oi Mundo".
"Oi Mundo"
2> 2 + 2.
4
3> halt().
caio@emx:~$

Veja acima que realizei alguns testes na shell, primeiro exibi uma string “Oi Mundo”, em seguida fiz um cálculo simples e em seguida encerrei a shell utilizando o comando halt().

Repare que as instruções terminam em “.”, isso se deve pois a instrução só é executada quando encontra o “.”.

1> 2
1> +
1> 2
1> .
4
2>

Os números a esquerda servem como contadores de instruções.

IV. Testando os tipos de dados

  • Caractere 
    2> $A.
65
  • Valor sobre base 
    3> 16#FF.
255
  • Número 
    4> 10.
10
5> 10.5.
10.5
  • String 
    6> [$o,$l,$a].
"ola"
7> "ola".
"ola"
  • Átomo 
    8> sim.
sim
9> nao.
nao
10> 'um atomo'.
'um atomo'
  • Binário 
    11> Bin = <<"abc">>.
<<"abc">>
12> <<V1:8, V2:16>> = Bin.
<<"abc">>
13> V1.
97
14> <<V3:8, V4:8>> = <<V2:16>>.
<<"bc">>
15> V3.
98
16> V4.
99
  • Fun 
    17> Dobro = fun(X) -> X * 2 end.
#Fun<erl_eval.6.13229925>
18> Dobro(2).
4
19> Dobro(3).
6
  • Tuplas 
    20> V = {centimetros, 10}.
{centimetros,10}
21> {X, Y} = V.
{centimetros,10}
22> X.
centimetros
23> Y.
10
  • Listas 
    24> T = [1, 2, 3].
[1,2,3]
25> [A|B] = T.
[1,2,3]
26> A.
1
27> B.
[2,3]
  • Boleano 
    28> 1 < 2.
true
29> 1 > 2.
false

Não poderei demonstrar o tipo Record, pois ele não é interpretado pela Shell, e deve ser utilizado através de um programa compilado, como demonstrarei. Uma explicação sobre os tipos de dados você pode ver no artigo anterior.

V. Compilando o primeiro programa

-module(exercicio2).
-export([canal/1]).

canal(2) ->
	"Globo";

canal(13) ->
	"SBT";

canal(X) ->
	X, % para evitar warning: unused variable
	"Canal Desconhecido".

Este é um programa bem simples, para demonstrar que toda função em Erlang é formada por blocos. Veja que os dois primeiros blocos canal(2) e canal(13) terminam em “;” (ponto-e-vírgula), e o último bloco sempre deve terminar em “.” (ponto).

Para compilar, salve o conteúdo acima em um arquivo nomeado exercicio2.erl. Vá até a pasta e execute na shell as instruções para compilação:

1> c(exercicio2).
{ok,exercicio2}
2> exercicio2:canal(2).
"Globo"
3> exercicio2:canal(13).
"SBT"
4> exercicio2:canal(4).
"Canal Desconhecido"

Um outro exemplo legal seria o famoso Fibonacci.

-module(fibonacci).
-export([fibo/1]).
fibo(0) -> 0 ;
fibo(1) -> 1 ;
fibo(N) when N > 0 -> fibo(N-1) + fibo(N-2).

% fibo(2)
% fibo(2-1) + fibo(2-2)
% fibo(1) + fibo(0)
% 1 + 0
% 1

Repare na instrução “when”. fibo(N) só será chamado *quando* N > 0. As linhas iniciadas em % indicam comentário, explicação de como ocorre o cálculo fibonacci.

Para testar este programa na shell, salve o código em um arquivo qualquer (fibonacci.erl por exemplo), e chame a shell na mesma pasta do arquivo:

caio@emx:~$ erl

Compile o arquivo, e chame a função através da sintaxe módulo:função:

1> c(fibonacci.erl).
{ok,fibonacci}
2> fibonacci:fibo(2).
1
4> fibonacci:fibo(0).
0
5> fibonacci:fibo(4).
3
6>

Na shell, basicamente é isso. Agora para fechar a shell utilize o comando halt().

6> halt().
caio@emx:~$

Este documento esta sob licença GFDL – GNU Free Documentation License. Saiba mais.