Erlang

Un article de Agora2ia.


Sommaire

Présentation

LangageDeProgrammation orienté réseau, ProgrammationDistribuée.


Structure

Exemple

Un fichier source nommé hello_world.erl (dans "D:\dev\erlang\hello-world") :

-module(hello_world).
-export([run/0]).

run() ->
  io:fwrite("Hello world.~n",[]).

Ce qui donne à l'éxécution :

1> cd("D:/dev/erlang/hello-world").
D:/dev/erlang/hello-world
ok
2> c(hello_world).
{ok,hello_world}
3> hello_world:run().
Hello world.
ok


Le Module

  • Ensemble d'attributs (en-tête du module) et de fonctions (corps).
  • == OO.classe
  • Le compilateur Erlang impose de mettre un module par fichier (du même nom) avec l'extension .erl.
  • Unité fonctionnelle facilitant le travail collaboratif, la maintenance et la réutilisabilité.
  • Un module est un espace de nom : 2 modules peuvent contenir 2 fonctions publiques de même signature sans conflit.
  • Commentaires possibles dans l'ensemble d'un module : %%.
  • Fichiers d'inclusion :
    • Extension en .hrl et utilisation avec -include("nom_fichier.hrl").
    • Contient des définitions de constantes, de types et de macros.

Les attributs de module

  • Expressions commençant par un tiret.
  • -module, -export, -include, -record, -define, -behaviour (cf. framework OTP).

Les fonctions

  • == OO.méthode
  • Portée publique (inter) ou privée (intra-module).
  • Définit au niveau des attributs du module.
  • Regroupe des instructions.
  • Exporter (respecte l'interface publique) mais ne pas importer.
  • La compilation signale les fonctions non utilisées.

Les intructions

  • En Erlang, les intructions se terminent toujours par un point.


Symbole, variable et chasse

  • Les symboles commencent par une minuscule.
  • Les noms de variable commencent par une majuscule.


Processus et communication

  • En Erlang, les objets s'échangent des messages.
  • Référencer un processus par un atome : register(my_module_atome, spawn(my_module,a_function,[the_parameter])). puis l'appel se fait ainsi : my_module_atome ! Amessage.
  • Les noms de process enregistrés à l'aide de la fonction register/2 sont visibles par tous les process d'un même node.
  • global:register_name(counter, spawn(counter, loop, [21])).
  • global:registered_names().
  • Counter = global:send(counter, increment)..
  • net_adm:ping(beethoven@pcwilliams).

Les noeuds Erlang

  • Chaque instance de machine virtuelle s'appelle un noeud (node).
  • register/2, register/0, node/0 et nodes/0.


Types de données

Les types élémentaires

  • Contrairement à Erlang, dans les langages de bas niveau, typer d'une variabble permet de determiner son occupation mémoire.
  • Dans Erlang, la gestion mémoire est faire par un ramasse miette.
  • Il existe 5 types :
    1. entier,
    2. réel,
    3. atomes,
    4. PID,
    5. références.
  • Les opérations :
    1. +, -, *, /
    2. div et rem,
    3. and, or, xor, not.

Les Atomes

  • Les fonctions de traitement des string ne s'appliquent pas aux atomes.
  • La mémoire allouée aux atomes n'est pas récupérée par le ramasse miettes : attention aux fuites,
  • Mais est moins volumineuse que les strings.
  • Convention de deéveloppement Erlang recommandent l'utilisation de certains atomes.
  • Par exemple, la notion de boulean, est réalisée par le couple d'atomes true/false : le type boolean n'existe pas en Erlang.

Les PID

  • Ce ne sont pas des strings, mais un véritable type à part entière.
  • Obtention par création ou par convertion.
  • Quelques fonctions : i(), spawn/3, list_to_pid/1.
  • Disposer d'un PID permet de contrôler le processus en question : notion de pribvilèges et de sécurité sous-jacente, surtout dans un contexte de programmation concurente et réseau.

Les références

  • make_ref/1

Les types composés

Les listes

  • [ ]
  • Peut être vide, sans limite de taille (si ce n'est celle de la mémoire), hétérogène.
  • Une liste peut donc contenir d'autres listes : cela donne accès aux structures en tableaux et arborescentes.
  • C'est une structure prépomdérante en Erlang, surtout alliée à la récursivité (toute aussi importante en Erlang) : [PremierElement | LesElementsRestants] ou head/1 et tail/1
  • Nommage et pluriel : préférer [Personne|Personnes] à [Head|Tail] même si c'est pas le cas dans beaucoup de code Erlang.

Les tuples

  • { }, hétérogène.
  • A utiliser quand on connait à l'avance la quantité et la qualité des éléments.
  • Taguer le tuple par sécurité : typage.
  • Accès via la fonction element/2.
  • L'atome undefined (Cf. les records).

Les structures (ou record)

  • Facilite la maintenance, améliore la lisibilité.
  • Définition via l'expression -record/2.
  • Utilisation d'un fichier partagé (.hrl) via -include/1.
  • A la compilation le record est transformé en tuple : on ne peut donc pas utiliser les records dans l'interpréteur.
  • L'affectation d'un record est assimilable à l'instanciation en POO.
  • L'accès : Lavariable#nom_structure.nom_champ : on obtient une érreur à la compilation en cas de non exsitance (cf. ci dessus).
  • Création sans préciser de valeur : la valeur par défaut personnalisée est utilisée, sinon undefined.
  • A l'instanciation : valeurs par défaut identiques et nom de champ générique ('_').
  • Modification d'une structure : Variable2 = Variable1#nom_structure{champ_i=expression_i}.
  • Accès multiple : #nom_structure{champ_i = Variable_i} = Structure_j.
  • Traitement conditionnel en remplaçcant Variable_i par un atome.

Le type binaire

  • Dans les versions récentes uniquement.
  • Parfois utilisé pour remplacer le type chaine de caractères, car:
    • consomme moins que les listes,
    • Traitements plus perrformants,
    • Le passage en paramètre d'un bianire n'entraine pas de duplication contrairement à certains types.

Ressources