Erlang é realmente dificil?
-module(tut).
-export([generate/1]).
%%
%% Funcao generate(X)
%% Quando X for 0, retorna [0]
%% Quando X > 0, retorna [X,X-1,...,0]
%% Caso contrario retorna [0,1,2,...,abs(X)]
%%
generate(0) -> [0];
generate(L) when integer(L) -> gera_lista(L).
gera_lista(L) when L > 0 -> gera_lista_direita(L);
gera_lista(L) -> gera_lista_inversa(-L).
gera_lista_direita(L) -> gera_lista_direita(L,[]).
gera_lista_direita(-1,Z) -> Z;
gera_lista_direita( L,Z) ->
%io:format("chamando: gera_lista_direita(~p,Z)~n",[L]),
gera_lista_direita(L - 1,[L | Z]).
gera_lista_inversa(L) -> gera_lista_inversa(L,[]).
gera_lista_inversa(-1,Z) -> Z;
gera_lista_inversa( L,Z) -> gera_lista_inversa(L,0,Z).
gera_lista_inversa(-1,_,Z) -> gera_lista_inversa(-1,Z);
gera_lista_inversa( L,A,Z) ->
%io:format("chamando: h(~p,~p,Z)~n",[L,A]),
h(L - 1, A + 1,[A | Z]).
Ok, dessa forma é dificil. Erlang é uma linguagem funcional, ou seja, suas funções seguem um raciocínio matemático e não imperativo. Vc sente o problema quando quer resolver algo iterativo ou utilizar variaveis de qualquer forma.
Fiz uma pequena função chamada generate, do modulo tut (de
tutorial, uma vez que estou seguindo um). Ela é muito simples, se vc informar 0, ela gera uma lista simples contendo 0. Se vc passar um numero positivo ela gera uma lista de 0 até o número, inclusive. Se o numero for negativo, ele assume que vc quer fazer fazer a lista de forma inversa.
Veja só:
$ erlc tut.erl # compilando o modulo
$ erl
Erlang (BEAM) emulator version 5.5.5 [source] [async-threads:0] [kernel-poll:false]
Eshell V5.5.5 (abort with ^G)
1> c(tut). # carregando o modulo
{ok,tut}
2> tut:generate(0). # invocando modulo:funcao(parametros).
[0]
3> tut:generate(10).
[0,1,2,3,4,5,6,7,8,9,10]
4> tut:generate(-10).
[10,9,8,7,6,5,4,3,2,1,0]
5>
A função
generate chama a função gera_lista se o parametro passado for um número inteiro.
A função
gera_lista chama a função para gerar a lista direita ou inversa, de acordo com o valor do parâmetro.
Veja só a simplicidade:
gera_lista_direita(L) -> gera_lista_direita(L,[]).
gera_lista_direita(-1,Z) -> Z;
gera_lista_direita( L,Z) ->
%io:format("chamando: gera_lista_direita(~p,Z)~n",[L]),
gera_lista_direita(L - 1,[L | Z]).
quando eu chamo gera_lista_direita(10) eu estou, na verdade, chamado a função gera_lista_direita(10,[]), onde eu fico usando uma lista como acumulador.
A operação [L | X] pode ser lida como [ elemento | lista ] , ou seja, eu adiciono um elemento em uma lista. gera_lista_direita(10,[]) vai chamar, então, gera_lista_direita(9,[10]), e depois gera_lista_direita(8,[9, 10]), e assim recursivamente até gera_lista_direita(-1,Z), quando eu retorno a lista. Fica claro se removerem os comentários (%) da frente dos io:format, que é a forma de fazer PPADD (Passei Por Aqui Driven Development) em Erlang.
Erlang precisa de MUITA pratica, principalmente de quem nunca programou em uma linguagem funcional e fica tentado a fazer coisas 'não ortodoxas' ;-)
Ah sim, o google é seu amigo:
http://www.dei.isep.ipp.pt/~paf/orgcdocs/Intro_Erlang.pdf
