Erlang Language Tutorial
Empezando con Erlang Language

Observaciones

Versiones

Hola Mundo

Hay dos cosas que debe saber al escribir una aplicación "hola mundo" en Erlang:

1. El código fuente está escrito en el lenguaje de programación erlang usando el editor de texto de su elección
2. La aplicación se ejecuta en la máquina virtual erlang . En este ejemplo, interactuaremos con el erlang VM a través del shell erlang.

Primero el código fuente de la aplicación:

Cree un nuevo archivo hello.erl contenga lo siguiente:

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

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

Echemos un vistazo rápido a lo que esto significa:

• -module(hello). Todas las funciones erlang existen dentro de un módulo . Los módulos se utilizan para crear aplicaciones, que son una colección de módulos. Esta primera línea es para identificar este módulo, a saber, hola . Los módulos se pueden comparar a los paquetes de Java
• -export([hello_world/0]). Indica al compilador qué funciones hacer "públicas" (en comparación con los idiomas OO) y la aridad de la función relevante. La aridad es el número de argumentos que toma la función. Dado que en erlang, una función con 1 argumento se ve como una función diferente a una con 2 argumentos, aunque el nombre puede ser exactamente el mismo. Es decir, hello_world/0 es una función completamente diferente a hello_world/1 por ejemplo.
• hello_world() Este es el nombre de la función. El -> indica la transición a la implementación (cuerpo) de la función. Esto se puede leer como "hello_world () se define como ...". Tenga en cuenta que hello_world() (sin argumentos) se identifica por hello_world/0 en la máquina virtual, y hello_world(Some_Arg) como hello_world/1 .
• io:format("Hello, World!~n", []) Desde el módulo io , se llama a la función format/2 function, que es la función para la salida estándar. ~n es un especificador de formato que significa imprimir una nueva línea. La [] es una lista de variables para imprimir indicadas por especificadores de formato en la cadena de salida, que en este caso no es nada.
• Todas las declaraciones erlang deben terminar con a . (punto).

En Erlang, se devuelve el resultado de la última instrucción en una función.

Ahora, vamos a ejecutar nuestra aplicación:

Inicie el shell erlang desde el mismo directorio que el archivo hello.erl :

$ erl

Debería recibir un mensaje que se parece a esto (su versión puede ser diferente):

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

Ahora ingrese los siguientes comandos:

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

Vayamos a través de cada línea una por una:

• c(hello) : este comando llama a la función c en un átomo hello . Esto le indica a Erlang que busque el archivo hello.erl , lo compile en un módulo (se generará un archivo llamado hello.beam en el directorio) y lo carga en el entorno.
• {ok, hello} - este es el resultado de llamar a la función c arriba. Es una tupla que contiene un átomo ok y un átomo hello . Las funciones de Erlang generalmente devuelven {ok, Something} o {error, Reason} .
• hello:hello_world() : esto llama a una función hello_world() desde el módulo hello .
• Hello, World! - Esto es lo que imprime nuestra función.
• ok - esto es lo que devolvió nuestra función. Dado que Erlang es un lenguaje de programación funcional, cada función devuelve algo . En nuestro caso, aunque no hello_world() nada en hello_world() , la última llamada en esa función fue io:format(...) y esa función devolvió ok , que a su vez es lo que nuestra función devolvió.

Módulos

Un módulo erlang es un archivo con un par de funciones agrupadas. Este archivo usualmente tiene la extensión .erl .

A hello.erl se muestra un módulo "Hello World" con el nombre hello.erl

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

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

En el archivo, se requiere declarar el nombre del módulo. Como se muestra antes en la línea 1. El nombre del módulo y el nombre del archivo antes de la extensión .erl deben ser iguales.

Función

La función es un conjunto de instrucciones, que se agrupan. Estas instrucciones agrupadas realizan ciertas tareas. En erlang, todas las funciones devolverán un valor cuando sean llamadas.

A continuación se muestra un ejemplo de una función que suma dos números.

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

Esta función realiza una operación de adición con valores X e Y y devuelve el resultado. La función se puede utilizar como a continuación

add(2,5).

Las declaraciones de funciones pueden constar de varias cláusulas, separadas por un punto y coma. Los argumentos en cada una de estas cláusulas se evalúan mediante la coincidencia de patrones. La siguiente función devolverá 'tupla' si el Argumento es una tupla en el Formulario: {prueba, X} donde X puede ser cualquier valor. Devolverá 'lista', si el Argumento es una lista de la longitud 2 en la forma ["prueba", X], y devolverá '{error, "Razón"}' en cualquier otro caso:

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

Si el argumento no es una tupla, se evaluará la segunda cláusula. Si el argumento no es una lista, la tercera cláusula será evaluada.

Las declaraciones de funciones pueden consistir en los llamados 'Guardias' o 'Secuencias de Guardias'. Estos guardias son expresiones que limitan la evaluación de una función. Una función con Guardias solo se ejecuta cuando todas las Expresiones de Guard producen un valor verdadero. Los guardias múltiples se pueden separar por un punto y coma.

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

La función 'function_name' solo se evaluará cuando la secuencia de guarda sea verdadera. La función de seguimiento devolverá verdadero solo si el argumento X está en el rango apropiado (0..15):

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

Comprensión de lista

Las comprensiones de listas son una construcción sintáctica para crear una lista basada en listas existentes.
En erlang una lista de comprensión tiene la forma [Expr || Qualifier1, ..., QualifierN] .
Donde los calificadores son generadores Pattern <- ListExpr o filtro como integer(X) evaluándose como true o false .

El siguiente ejemplo muestra una lista de comprensión con un generador y dos filtros.

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

El resultado es una lista que contiene sólo números enteros mayores que 3.

[4,5,6]

Comenzando y deteniendo la cáscara de Erlang

Comenzando la cáscara de Erlang

En un sistema UNIX, inicia el shell Erlang desde un símbolo del sistema con el comando erl

Ejemplo:

$ 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> 

El texto que se muestra cuando inicia el shell le brinda información sobre la versión de Erlang que está ejecutando, así como otra información útil sobre el sistema erlang.

Para iniciar el shell en Windows, haga clic en el ícono Erlang en el menú de inicio de Windows.

Deteniendo la concha de Erlang

Para una salida controlada del shell erlang escribe:

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().

También puede salir del shell Erlang presionando Ctrl + C en sistemas UNIX o Ctrl + Break en Windows, lo que le lleva al siguiente indicador:

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 luego presiona a (para abortar), saldrá de la shell directamente.

Otras formas de salir del shell erlang son: init:stop() que hace lo mismo que q() o erlang:halt() .

La coincidencia de patrones

Una de las operaciones más comunes en erlang es la coincidencia de patrones. Se usa cuando se asigna un valor a una variable, en declaraciones de funciones y en estructuras de flujo de control como las declaraciones de case y receive . Una operación de coincidencia de patrones necesita al menos 2 partes: un patrón y un término con el cual se empareja el patrón.

Una asignación de variable en erlang se ve así:

X = 2.

En la mayoría de los lenguajes de programación, la semántica de esta operación es sencilla: vincule un valor ( 2 ) al nombre que elija (la variable, en este caso X ). Erlang tiene un enfoque ligeramente diferente: haga coincidir el patrón en el lado izquierdo ( X ) con el término en el lado derecho ( 2 ). En este caso, el efecto es el mismo: la variable X ahora está vinculada al valor 2 . Sin embargo, con la coincidencia de patrones puede realizar tareas más estructuradas.

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

Esta operación de coincidencia se realiza analizando la estructura del término del lado derecho y aplicando todas las variables del lado izquierdo a los valores apropiados del término, de modo que el lado izquierdo sea igual al lado derecho. En este ejemplo, Type está vinculado al término: document , Meta a {author, "Alice"} y Doc a {text, "Lorem Ipsum"} . En este ejemplo particular, se asume que las variables: Type , Meta y Doc están unidas , por lo que se puede usar cada variable.

Los emparejamientos de patrones también se pueden construir, utilizando variables encuadernadas.

Identifier = error.

El Identifier variable ahora está vinculado al error valor. La siguiente operación de coincidencia de patrones funciona, porque la estructura coincide y el Identifier variable enlazada tiene el mismo valor que la parte derecha apropiada del término.

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

Una operación de coincidencia de patrón falla, cuando hay una discrepancia entre el término del lado derecho y el patrón del lado izquierdo. La siguiente coincidencia fallará, porque el Identifier está vinculado al error valor, que no tiene una expresión adecuada en el término del lado derecho.

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