Erlang – exemple 03

Cet exemple propose quelques fonctions manipulant des listes, des atomes, des uplets et des variables.

-module(listes).
-export([combien/1, afficher/1, afficher/2, convertir/3, max_elem/1]).

combien([]) ->
   0;
combien([_ | Queue]) ->
   1 + combien(Queue).

afficher([]) ->
   [];
afficher([Tete | Queue]) ->
   io:format("~w~n", [Tete]),
   afficher(Queue).

afficher(celsius,{Lieu,Temp}) ->
   io:format("Température sur ~w : ~w~n", [Lieu, Temp]);
afficher(fahrenheit,{Lieu,Temp}) ->
   afficher(celsius,{Lieu, convertir(fahrenheit,celsius,Temp)}).
	
convertir(fahrenheit,celsius,Temp) ->
   (Temp - 32) * 5 / 9;
convertir(celsius,fahrenheit,Temp) ->
   9 / 5 * Temp + 32.

%% point d'entrée: max_elem/1
max_elem([Tete|Queue]) ->
   max_elem(Queue, Tete).
%% le travail se fait dans max_elem/2
max_elem([], Res) ->
    Res;
max_elem([Tete|Queue], SoFar) when Tete > SoFar ->
    max_elem(Queue, Tete);
max_elem([_|Queue], SoFar) ->
    max_elem(Queue, SoFar).

Il y a plusieurs considérations intéressantes dans ce module :

• Une liste vide s'exprime []
• Un paramètre signifiant peu importe s'exprime _
• La logique de combien/1 est que le nombre d'éléments d'une liste vide est 0, et que le nombre d'éléments d'une liste faite d'une tête et d'une queue est 1 (la tête) plus le nombre d'éléments de la queue. C'est une logique récursive
• La fonction combien/1 montre entre autres comment une fonction d'une arité donnée peut se décliner en plusieurs formes distinctes. Ici, combien([]) sera privilégiée si la fonction est invoquée avec une liste vide, alors que combien([_|Queue]) sera privilégiée dans les cas où la liste n'est pas vide. L'écriture est faite d'une suite de déclinaisons de la même fonction, mais avec différents Patterns de paramètres, et le plus approprié sera choisi pour chaque appel
• La fonction combien/1, dans sa deuxième déclinaison, décrit une liste ayant une tête et une queue, mais n'utilise que la queue; il aurait été possible de décrire le Pattern attendu par [Tete|Queue] mais cela aurait fait émettre un avertissement au compilateur (variable Tete non utilisée), alors le Pattern [_|Queue] qui utilise le symbole _ (pour peu importe) est utilisé
• Des idées semblables sous-tendent afficher/1, afficher/2 et convertir/3
• Le code de max_elem/1 est une devanture publique pour le code de max_elem/2. Souvenons-nous que l'arité d'une fonction est partie intégrante de sa signature. Vous noterez que max_elem/2 procède par élimination en manipulant une liste et une valeur candidate, et cherche à en arriver avec une liste vide et la valeur maximale qui serait alors le résultat du calcul
• Remarquez la structure de max_elem/2 :
  • dans le cas où la liste à analyse est vide, la valeur candidate est le résultat attendu
  • dans le cas où la liste est une liste [Tete|Queue] et où la valeur candidate est la variable SoFar, une condition spéciale (un gardien, ou Guard, en terminologie Erlang) est évalué. Si Tete > SoFar, alors on invoque max_elem/2 avec Queue et Tete puisque SoFar n'est plus une valeur candidate (Tete ayant une valeur plus élevée), ce qui réduit au passage la taille de la liste sous analyse
  • enfin, le cas général manipule [_|Queue] et SoFar (Tete n'étant pas plus grand que SoFar à ce stade) ce qui exclut la tête et poursuit le raisonnement sur la queue

Quelques exemples d'invocation de ces fonctions suivent.

Erlang R14B (erts-5.8.1.1) [smp:2:2] [rq:2] [async-threads:0]
Eshell V5.8.1.1  (abort with ^G)
1> [A, B, C] = [ yo, man ].   
** exception error: no match of right hand side value [yo,man]
2> [A, B | C] = [ yo, man ].
[yo,man]
3> C.
[]
4> A.
yo
5> c(listes).
{ok,listes}
6> listes:combien([j_aime,mon,prof]).
3
7> listes:afficher([j_aime,mon,prof]).
j_aime
mon
prof
[]
8> listes:afficher(celsius,{montreal,10}). 
Température sur montreal : 10
ok
9> listes:afficher(fahrenheit,{montreal,10}).
Température sur montreal : -12.222222222222221
ok
10> listes:max_elem([1,2,3,4,5,6,7,8,7,6,5,4,3,2,1]).
8
11> 

Quelques concepts :

• Comme c'est le cas avec la majorité des langages fonctionnels, surtout ceux qui penchent vers la pureté du modèle foncitonnel, les variables en Erlang ne changent pas d'état une fois liées à une valeur ou (dans ce cas-ci) à un Pattern. Ainsi, les itérations au sens usuel dans les langages impératifs (une boucle for avec un compteur, par exemple) ne sont pas une option, faute d'avoir des compteurs. Ainsi, on utilisera massivement la récursivité comme le montre entre autres combien/1
• Comme c'est aussi souvent le cas dans les langages qui exploitent beaucoup la récursivité, un compilateur Erlang réalisera certaines optimisations basées sur des façons de faire bien connues. Ainsi, si la récursivité s'effectue dans la dernière expression d'une fonction, ce qu'on nomme du Tail Recursion, le compilateur constatera que les valeurs retournées ne peuvent pas servir à des expressions subséquentes, et remplacera l'appel récursif par un saut inconditionnel (un goto) silencieux, ce qui économisera la pile des appels
• Il est possible en Erlang d'avoir plusieurs incarnations d'une fonction de même signature (même nom, même arité) mais qui peuvent être distinguées l'une de l'autre en fonction du Pattern des paramètres. Ceci s'apparente à la sélection statique de certains templates en métaprogrammation
• Une variante pour des fonctions de même signature et de même Pattern est l'ajout de conditions d'aiguillage, ou gardiens, qui permettemt de discriminer entre divers appels en fonction de l'évaluation des conditions en question. La fonction max_elem/2 contient un exemple de cette pratique
• Enfin, un autre cas particulier de sélection en fonction des Patterns est la sélection reposant sur des atomes, comme dans le cas de conversion/3 ci-dessus, qui s'apparente à de l'aiguillage par types