Erlang Language Tutoriel
Démarrer avec Erlang Language

Remarques

Versions

Bonjour le monde

Il y a deux choses que vous devez savoir lorsque vous écrivez une application "hello world" dans Erlang:

1. Le code source est écrit dans le langage de programmation erlang en utilisant l'éditeur de texte de votre choix
2. L'application est ensuite exécutée dans la machine virtuelle erlang . Dans cet exemple, nous allons interagir avec la machine virtuelle erlang via le shell erlang.

D'abord le code source de l'application:

Créez un nouveau fichier hello.erl contenant les éléments suivants:

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

hello_world() ->
  io:format("Hello, World!~n", []).

Jetons un coup d'œil à ce que cela signifie:

• -module(hello). Toutes les fonctions erlang existent dans un module . Les modules sont ensuite utilisés pour créer des applications, qui constituent un ensemble de modules. Cette première ligne consiste à identifier ce module, à savoir bonjour . Les modules peuvent être comparés aux packages Java
• -export([hello_world/0]). Indique au compilateur qui fonctionne pour rendre "public" (par rapport aux langages OO) et à l' arité de la fonction concernée. L'arité est le nombre d'arguments pris par la fonction. Puisque dans erlang une fonction avec 1 argument est vue comme une fonction différente de celle avec 2 arguments même si le nom peut être exactement le même. C'est-à-dire que hello_world/0 est une fonction complètement différente de hello_world/1 par exemple.
• hello_world() C'est le nom de la fonction. Le -> indique la transition vers l'implémentation (corps) de la fonction. Cela peut être lu comme "hello_world () est défini comme ...". Notez que hello_world() (aucun argument) est identifié par hello_world/0 dans la machine virtuelle et hello_world(Some_Arg) par hello_world/1 .
• io:format("Hello, World!~n", []) Depuis le module io , la fonction format/2 est appelée, qui est la fonction pour la sortie standard. ~n est un spécificateur de format qui signifie imprimer une nouvelle ligne. Le [] est une liste de variables à imprimer indiquée par des spécificateurs de format dans la chaîne de sortie, ce qui dans ce cas n’est rien.
• Toutes les déclarations erlang doivent se terminer par un . (point).

Dans Erlang, le résultat de la dernière instruction d'une fonction est renvoyé.

Maintenant, exécutons notre application:

Démarrez le shell erlang à partir du même répertoire que le fichier hello.erl :

$ erl

Vous devriez recevoir une invite ressemblant à ceci (votre version peut être différente):

Eshell V8.0  (abort with ^G)
1>

Maintenant, entrez les commandes suivantes:

1> c(hello).
{ok,hello}
2> hello:hello_world().
Hello, World!
ok

Parcourons chaque ligne une par une:

• c(hello) - cette commande appelle la fonction c sur un atome hello . Cela dit à Erlang de trouver le fichier hello.erl , de le compiler dans un module (un fichier nommé hello.beam sera généré dans le répertoire) et de le charger dans l’environnement.
• {ok, hello} - c'est le résultat de l'appel de la fonction c ci-dessus. C'est un tuple contenant un atome ok et un atome hello . Les fonctions Erlang renvoient généralement soit {ok, Something} ou {error, Reason} .
• hello:hello_world() - cela appelle une fonction hello_world() du module hello .
• Hello, World! - c'est ce que notre fonction imprime.
• ok - c'est ce que notre fonction est revenue. Comme Erlang est un langage de programmation fonctionnel, chaque fonction retourne quelque chose . Dans notre cas, même si nous n'avons rien hello_world() dans hello_world() , le dernier appel de cette fonction était sur io:format(...) et cette fonction renvoyait ok , ce qui correspond à notre fonction.

Modules

Un module erlang est un fichier avec quelques fonctions regroupées. Ce fichier a généralement l'extension .erl .

Un module "Hello World" nommé hello.erl est présenté ci-dessous

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

hello_world() ->
  io:format("Hello, World!~n", []).

Dans le fichier, il est nécessaire de déclarer le nom du module. Comme indiqué précédemment à la ligne 1. Le nom du module et le nom du fichier avant l'extension .erl doivent être identiques.

Fonction

La fonction est un ensemble d'instructions regroupées. Ces instructions groupées effectuent ensemble certaines tâches. Dans erlang, toutes les fonctions renverront une valeur lorsqu'elles seront appelées.

Voici un exemple d'une fonction qui ajoute deux nombres

add(X, Y)-> X + Y.

Cette fonction effectue une opération d'ajout avec les valeurs X et Y et renvoie le résultat. Fonction peut être utilisé comme ci-dessous

add(2,5).

Les déclarations de fonction peuvent être composées de plusieurs clauses séparées par un point-virgule. Les arguments de chacune de ces clauses sont évalués par correspondance de modèle. La fonction suivante renverra 'tuple' si l'argument est un tuple dans la forme: {test, X} où X peut être n'importe quelle valeur. Il retournera "liste", si l'argument est une liste de la longueur 2 sous la forme ["test", X], et il renverra '{erreur, "raison"} dans tout autre cas:

function({test, X}) -> tuple;
function(["test", X]) -> list;
function(_) -> {error, "Reason"}.

Si l'argument n'est pas un tuple, la deuxième clause sera évaluée. Si l'argument n'est pas une liste, la troisième clause sera évaluée.

Les déclarations de fonction peuvent consister en des «gardes» ou des «séquences de garde». Ces gardes sont des expressions qui limitent l'évaluation d'une fonction. Une fonction avec des gardes n'est exécutée que lorsque toutes les expressions de garde donnent une valeur vraie. Plusieurs gardes peuvent être séparés par un point-virgule.

function_name(Argument) when Guard1; Guard2; ... GuardN -> (...).

La fonction 'nom_fonction' ne sera évaluée que lorsque la séquence de garde est vraie. La fonction suivante renvoie true uniquement si l'argument X est dans la plage correcte (0..15):

in_range(X) when X>=0; X<16 -> true;
in_range(_) -> false.

Compréhension de liste

Les compréhensions de liste sont une construction syntaxique permettant de créer une liste basée sur des listes existantes.
Dans erlang une compréhension de liste a la forme [Expr || Qualifier1, ..., QualifierN] .
Lorsque les qualificateurs sont des générateurs Pattern <- ListExpr ou un filtre comme un integer(X) évalués sur true ou sur false .

L'exemple suivant montre une compréhension de liste avec un générateur et deux filtres.

[X || X <- [1,2,a,3,4,b,5,6], integer(X), X > 3].

Le résultat est une liste contenant uniquement des entiers supérieurs à 3.

[4,5,6]

Démarrer et arrêter la coque Erlang

Commencer la coquille Erlang

Sur un système UNIX, vous démarrez le shell Erlang à partir d’une invite de commande avec la commande erl

Exemple:

$ erl
Erlang/OTP 18 [erts-7.0] [source] [64-bit] [smp:8:8] [async-threads:10] [hipe] [kernel-poll:false]

Eshell V7.0  (abort with ^G)
1> 

Le texte qui s'affiche lorsque vous démarrez le shell vous indique quelles sont les versions d'Erlang que vous utilisez, ainsi que d'autres informations utiles sur le système erlang.

Pour démarrer le shell sous Windows, cliquez sur l'icône Erlang dans le menu Démarrer de Windows.

Arrêter la coquille d'Erlang

Pour une sortie contrôlée de la coque erlang, tapez:

Erlang/OTP 18 [erts-7.0] [source] [64-bit] [smp:8:8] [async-threads:10] [hipe] [kernel-poll:false]

Eshell V7.0  (abort with ^G)
1> q().

Vous pouvez également quitter le shell Erlang en appuyant sur Ctrl + C sur les systèmes UNIX ou sur Ctrl + Break sous Windows, ce qui vous amène à l'invite suivante:

Erlang/OTP 18 [erts-7.0] [source] [64-bit] [smp:8:8] [async-threads:10] [hipe] [kernel-poll:false]

Eshell V7.0  (abort with ^G)
1> 
BREAK: (a)bort (c)ontinue (p)roc info (i)nfo (l)oaded
       (v)ersion (k)ill (D)b-tables (d)istribution

Si vous appuyez ensuite sur (pour annuler), vous quitterez directement le shell.

Voici d'autres façons de quitter le shell erlang: init:stop() qui fait la même chose que q() ou erlang:halt() .

Correspondance de motif

L'une des opérations les plus courantes dans erlang est la correspondance de modèle. Il est utilisé lors de l'affectation d'une valeur à une variable, dans des déclarations de fonctions et dans des structures de contrôle-flux comme les instructions case et receive . Une opération d'appariement de motifs nécessite au moins 2 parties: un motif et un terme correspondant au motif.

Une affectation de variable dans erlang ressemble à ceci:

X = 2.

Dans la plupart des langages de programmation, la sémantique de cette opération est simple: liez une valeur ( 2 ) à un nom de votre choix (la variable - dans ce cas X ). Erlang a une approche légèrement différente: faites correspondre le motif du côté gauche ( X ) au terme du côté droit ( 2 ). Dans ce cas, l’effet est le même: la variable X est maintenant liée à la valeur 2 . Cependant, avec la correspondance de motif, vous pouvez effectuer des affectations plus structurées.

{Type, Meta, Doc} = {document, {author, "Alice"}, {text, "Lorem Ipsum"}}.

Cette opération de correspondance est effectuée en analysant la structure du terme du côté droit et en appliquant toutes les variables du côté gauche aux valeurs appropriées du terme, de sorte que le côté gauche soit égal au côté droit. Dans cet exemple, Type est lié au terme: document , Meta à {author, "Alice"} et Doc à {text, "Lorem Ipsum"} . Dans cet exemple particulier, les variables: Type , Meta et Doc sont supposées être non liées , de sorte que chaque variable puisse être utilisée.

Les correspondances de modèles peuvent également être construites à l'aide de variables liées.

Identifier = error.

La variable Identifier est maintenant liée à l' error valeur. L'opération de correspondance de modèle suivante fonctionne, car la structure correspond et la variable liée Identifier a la même valeur que la partie droite appropriée du terme.

{Identifier, Reason} = {error, "Database connection timed out."}.

Une opération de correspondance de modèle échoue lorsqu'il y a un décalage entre le terme du côté droit et le motif du côté gauche. La correspondance suivante échouera, car Identifier est lié à l' error valeur, qui n'a pas d'expression appropriée du terme du côté droit.

{Identifier, Reason} = {fail, "Database connection timed out."}.
> ** exception error: no match of right hand side value {fail,"Database ..."}