Vous êtes sur la page 1sur 26

Historique et Paradigme

Type et déclaration
Expression, instructions et gestion des exceptions
Structures des programmes

ERLANG

Groupe 16

7 février 2020

Groupe 16 ERLANG
Historique et Paradigme
Type et déclaration
Expression, instructions et gestion des exceptions
Structures des programmes

LANGAGE ERLANG

Groupe 16 ERLANG
Historique et Paradigme
Type et déclaration
Expression, instructions et gestion des exceptions
Structures des programmes

Sommaire
1 Historique et Paradigme
2 Type et déclaration
Type
Portée
Déclaration et liaison
3 Expression, instructions et gestion des exceptions
Expression et instruction
expressions(booléennes and arithmétiques)
Instruction
gestion d’erreur :try, catch, after, throw
4 Structures des programmes
module
fonctions
utilité du fonctionnel

Groupe 16 ERLANG
Historique et Paradigme
Type et déclaration
Expression, instructions et gestion des exceptions
Structures des programmes

ERLANG est un langage créé par Ericsson (acteur de l’industrie


des télécommunications) en 1986. Il est interprété à module
compilée, basé sur l’unification(pattern matching), générique,à
typage dynamique supportant le paradigme concurrent et
fonctionnel.Il a été influencé par les langages tel que Lisp, PLEX,
Prolog, Smalltalk et a influencé plusieurs autres langages comme
Akka, Dart, Elixir, Scala.

Groupe 16 ERLANG
Historique et Paradigme
Type
Type et déclaration
Portée
Expression, instructions et gestion des exceptions
Déclaration et liaison
Structures des programmes

Type et déclaration
1 Historique et Paradigme
2 Type et déclaration
Type
Portée
Déclaration et liaison
3 Expression, instructions et gestion des exceptions
Expression et instruction
expressions(booléennes and arithmétiques)
Instruction
gestion d’erreur :try, catch, after, throw
4 Structures des programmes
module
fonctions
utilité du fonctionnel

Groupe 16 ERLANG
Historique et Paradigme
Type
Type et déclaration
Portée
Expression, instructions et gestion des exceptions
Déclaration et liaison
Structures des programmes

Type

Erlang comporte les types de base et les types Composites.


Toutes les variables commencent par une lettre majuscule et
sont utilisées pour stocker le résultat des commandes et
toutes les instructions se terminent par un point(.)
En Erlang une variable est liée une seule fois.
Dans la plupart des langages l’opération d’affectation se fait a
l’aide de (=) mais en Erlang (=) désigne une opération
d’unification.

Groupe 16 ERLANG
Historique et Paradigme
Type
Type et déclaration
Portée
Expression, instructions et gestion des exceptions
Déclaration et liaison
Structures des programmes

Type de base
Les types de base rencontrés en Erlang sont :
les chaines de caractères(String)
Une chaine de caractères est une séquence de caractères
enfermée entre quote double (" ")
Remarque : Dans la plupart des langages, les chaine de
caractères peuvent entre les quotes simples (”) ou double ("")
mais en Erlang elles doivent toujours être entre quote double .
Exemple : "Erlang", "maison", "hello world"
les Atomes
un atome est un littéral, une constante avec un nom. Il doit
être placé entre guillemets simples (’ ’) s’il ne commence pas
par une lettre minuscule ou s’il contient d’autres caractères
que des caractères alphanumériques, un Underscore (_) ou @.
exemple :
red, december, cat, meters, yards,’Monday’,’123’
Groupe 16 ERLANG
Historique et Paradigme
Type
Type et déclaration
Portée
Expression, instructions et gestion des exceptions
Déclaration et liaison
Structures des programmes

Types de Base

Entiers
Par défaut, les entiers sont exprimés en base 10 possibilité de
définir un entier dans une base comprise entre 2 et 16 :
Base#Value :
Int = 1234567890
Bin = 2#00110110
Hex = 16# FFA68BA.
les Réels
Ils sont représentes sur 64 bits
Exemple : X = 1.767458.

Groupe 16 ERLANG
Historique et Paradigme
Type
Type et déclaration
Portée
Expression, instructions et gestion des exceptions
Déclaration et liaison
Structures des programmes

Types composites

Tuples un tuple est composé d’un nombre fixe de termes, où


chaque terme est un élément la syntaxe est : {T1,T2,...,Tn}
Exemple :
Pet = { animal , { nom , “Titus ”}, { type , chien } }.
Listes les listes sont utilisées pour stocker un ensemble de
variable potentiellement hétérogène de taille variable
L2 = [ X, Y, toto , titi , 3.7 ].
Remarque
Si T est une liste alors [H|T] est aussi une liste avec H comme
premier élément de la liste et T comme le reste d’éléments de la
liste. La barre verticale (|) sépare donc le premier élément de la
liste(head) au reste (tail).

Groupe 16 ERLANG
Historique et Paradigme
Type
Type et déclaration
Portée
Expression, instructions et gestion des exceptions
Déclaration et liaison
Structures des programmes

Les enregistrements

Un enregistrement est créé à l’aide de l’identifiant


d’enregistrement.
Dans cet identifiant d’enregistrement, vous spécifiez les
différents champs qui constituent l’enregistrement.

Syntaxe
record(nomenregistrement , Champ1,Champ2 ..Champn)

Groupe 16 ERLANG
Historique et Paradigme
Type
Type et déclaration
Portée
Expression, instructions et gestion des exceptions
Déclaration et liaison
Structures des programmes

Exemple Pratique

Exemple
-module(helloworld)
. -export([start/0])
-record(person, name = "", id)
start() -> P = #personname="John",id = 1.

Groupe 16 ERLANG
Historique et Paradigme
Type
Type et déclaration
Portée
Expression, instructions et gestion des exceptions
Déclaration et liaison
Structures des programmes

Portée en Erlang
En Erlang les variables sont non mutable et sont liées qu’une
seule fois lors d’un pattern matching ou unification réussi de ce fait
toutes les variables sont à portée dynamique et ne sont
localesqu’à la fonction dans laquelle elles sont liées .

Groupe 16 ERLANG
Historique et Paradigme
Type
Type et déclaration
Portée
Expression, instructions et gestion des exceptions
Déclaration et liaison
Structures des programmes

Déclaration et liaison

Déclaration et liaison
Erlang n’autorise pas les déclarations et les variables globales
n’existent pas. La liaison entre une variable et sa valeur se fait lors
d’un pattern matching réussi.

Groupe 16 ERLANG
Historique et Paradigme
Type
Type et déclaration
Portée
Expression, instructions et gestion des exceptions
Déclaration et liaison
Structures des programmes

Déclaration et liaison

Remarques sur les variables


Tous les appels de variables se font par valeur
Il n’existe pas d’appel par référence
Les variables sont locales a la fonction dans laquelle elles sont
liées (notion d’environnement)
Pas de variables globales
Pas de declaration
Typage dynamique
Dans le shell on peut utiliser la fonction f() pour délier une
variable

Groupe 16 ERLANG
Historique et Paradigme
Type et déclaration Expression et instruction
Expression, instructions et gestion des exceptions gestion d’erreur :try, catch, after, throw
Structures des programmes

Expressions

Erlang évalue les expressions en appliquant les règles de priorité


des opérateurs et en se basant sur le principe du short circuit
evaluation.
Les opérateurs logiques utilise dans Erlang sont :
not, !, and, &&, or, ||, xor, ==, !=, ...
les Opérateurs arithmetiques utilisés dans Erlang sont :
+, -, .., <, <=, >, >=, *, /, *, div, rem, band, +, -, ++, –

Groupe 16 ERLANG
Historique et Paradigme
Type et déclaration Expression et instruction
Expression, instructions et gestion des exceptions gestion d’erreur :try, catch, after, throw
Structures des programmes

Instructions

En Erlang toutes les instructions se terminent par un point(.) et


les instructions itératives n’existent pas .
comme la plupart des langages de programmation il existe plusieurs
types d’instruction en Erlang, on peut citer entre autres :
le pattern machine(unification)
Dans la plupart des langages (=) représente l’affectation mais
en Erlang il s’agit de l’opération d’unification consistant à lier
une valeur à une variable.
exemple : A = 42 % Unification : Succès
A = 44 % Erreur
les commentaires
les commentaires en Erlang commencent avec le caractère
(%) et les commentaires en block n’existent pas.

Groupe 16 ERLANG
Historique et Paradigme
Type et déclaration Expression et instruction
Expression, instructions et gestion des exceptions gestion d’erreur :try, catch, after, throw
Structures des programmes

Instructions
(IF expression)
Syntaxe :
if
Guard1 -> Expr_seq1 ;
Guard2 -> Expr_seq2 ;
end

Embranchements multiples( CASE...WHEN)


Syntaxe :
case Expression of
Pattern1 [when Guard1] -> Expr_seq1 ;
Pattern2 [when Guard2] -> Expr_seq2 ;
...
end
Groupe 16 ERLANG
Historique et Paradigme
Type et déclaration Expression et instruction
Expression, instructions et gestion des exceptions gestion d’erreur :try, catch, after, throw
Structures des programmes

Instructions

instruction de lecture
Permettant aux programmes d’interagir avec les utilisateurs
io :get_line/1 lit une ligne sur l’entrée standard
io :get_chars/2 lit plusieurs caractères
io :read/1 lit un terme Erlang

Test
io :get_line("une ligne svp :").
io :get_chars(”3 caractères svp :”, 3).
io :read(ün terme Erlang :¨).

Groupe 16 ERLANG
Historique et Paradigme
Type et déclaration Expression et instruction
Expression, instructions et gestion des exceptions gestion d’erreur :try, catch, after, throw
Structures des programmes

Instruction de lecture

io :format/2 :écrit de manière formatée sur la sortie standard.


parametres : chaine de caractères et liste de valeurs à afficher
formats possibles
c̃ : caractère
f̃ : flottant avec 6 décimales
ẽ : flottant en écriture scientifique
w̃ : terme quelconque
B̃ : entier en base 10
ñ : retour à la ligne

Groupe 16 ERLANG
Historique et Paradigme
Type et déclaration Expression et instruction
Expression, instructions et gestion des exceptions gestion d’erreur :try, catch, after, throw
Structures des programmes

gestion d’erreur
Erlang a été initialement conçu pour programmer des systèmes
tolérants aux pannes,des systemes ne devant jamais s’arrêter en
principe et devant gérer les événements exceptionnels(erreurs).
Pour gérer les exception en Erlang on utilise les mots clés :try
,catch,after,throw

syntaxe
try FuncOrExpressionSeq of
Pattern1 [when Guard1] -> Expressions1 ;
Pattern2 [when Guard2] -> Expressions2 ;
... catch ExceptionType1 : ExPattern1 [when ExGuard1] ->
ExExpressions1 ;
ExceptionType2 : ExPattern2 [when ExGuard2] -> ExExpressions2 ;
... after
AfterExpressions
end Groupe 16 ERLANG
Historique et Paradigme
Type et déclaration module
Expression, instructions et gestion des exceptions fonctions
Structures des programmes

Erlang structure les programmes en fonctions et modules.


le point (.) suivi d’un espace ou d’un saut de ligne : marque la fin
d’une expression ou d’une fonction .
le point-virgule :sépare les clauses (par exemple, lors de la
définition d’une fonction)
la virgule :sépare les éléments d’une structure (liste ou tuple, par
exemple) ou les arguments d’une fonction
les modules et les fonctions sont les unités basique permettant de
structurer les programmes en Erlang.Les modules contiennent les
fonctions et les fonctions peuvent être exécutées en parallèle.

Groupe 16 ERLANG
Historique et Paradigme
Type et déclaration module
Expression, instructions et gestion des exceptions fonctions
Structures des programmes

module

Un module (fichier) regroupe des fonctions le nom du fichier doit


être celui du module avec l’extension .erl
Le module doit contenir 2 directives :
-module : pour le nom du module
-export : déclare les fonctions avec leur nombre d’arguments.

exemple de module
-module(test).
-export([add/2]).
add(X, Y) -> X + Y.

Groupe 16 ERLANG
Historique et Paradigme
Type et déclaration module
Expression, instructions et gestion des exceptions fonctions
Structures des programmes

fonctions

Erlang est un langage fonctionnel ce qui signifie que les fonctions


peuvent être utilisé comme argument des fonctions ou comme
valeur de retour d’une autre fonction.
Il existe deux types de fonction : nommée et anonyme.
une fonction est désignée par son nom et son arité (nombre de
paramètres).
deux fonctions de même nom et d’arités différents sont des
fonctions différentes
par convention, les fonctions de même nom et d’arité différent sont
des fonctions auxiliaires.

Groupe 16 ERLANG
Historique et Paradigme
Type et déclaration module
Expression, instructions et gestion des exceptions fonctions
Structures des programmes

fonctions

Définition de fonction
L’entête d’une fonction est composée d’un nom (atome), suivi de
paramètres entre parenthèses, puis de -> le Corps de chaque
clause : plusieurs expressions séparées par des points virgules.
Fonction : ensemble de clauses séparées par des points-virgules.

Exemple
fact(0) -> 1 ;
fact(N) -> N * fact(N-1).

Groupe 16 ERLANG
Historique et Paradigme
Type et déclaration module
Expression, instructions et gestion des exceptions fonctions
Structures des programmes

utilité du fonctionnel
forme générateur

Les listes en compréhension sont les expressions permettant de


créer les liste sans avoir recours a l’utilisation des fonctions
fun, maps.
la notation
F (X )||X < −L
signifie qu’on applique la fonction F à tout élément X de la
liste L .
Exemple
L = [ 1, 2, 3, 4, 5, 6 ].
[ 2 * X || X <- L ].
resultat = [2,4,6,8,10,12]
Groupe 16 ERLANG
Historique et Paradigme
Type et déclaration module
Expression, instructions et gestion des exceptions fonctions
Structures des programmes

utilité du fonctionnel

forme filtrage
[ X || a, X <- [a ,1,b ,2,c ,3,a ,4,hello ,"wow "]]. resultat =
[1,4]
la fonction map
qui applique une fonction F à tous les éléments d’une liste L
L = [1,2,3,4].
lists :map(fun(X) -> 2*X end, L).

Groupe 16 ERLANG