No es un lenguaje funcional puro según dice la misma documentación de erlang, sin embargo, es lo más funcional que he visto hasta ahora. De hecho, ni siquiera tiene instrucciones para hacer bucles; nada de while ni de for. Las tareas repetitivas se realizan mediante la recursión sobre listas, por ejemplo. Para no hablar en vacío, pongo un ejemplo sencillo, pero que muestra varias características del lenguaje. Obsérvese el siguiente código:

-module(factorial).
-export([factorial/1]).

factorial(1) ->
    1;
factorial(N) ->
    N * factorial(N-1).

Lo explicaré a continuación, pero vamos a ver cómo trabaja erlang compilando el código y ejecutándolo desde su herramienta interactiva de shell: erl.

$ erl
Erlang/OTP 22 [erts-10.7] [source] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads:1] [hipe]

Eshell V10.7  (abort with ^G)
1> c(factorial).
{ok,factorial}
2> factorial:factorial(5).
120
3> factorial:factorial(-5).
Terminado (killed)
$ _

Vemos que al intentar calcular el factorial de un número negativo, llega un momento en que bloquea y arrastra consigo al prompt interactivo de erlang.

Si observamos el código vemos que los comandos de las primeras líneas comienzan por -. Podríamos considerarlos como la cabecera del módulo. En nuestro caso -module(factorial). lo que hace es definir el fichero de código como un módulo de nombre factorial. También es importante el . al final, pues es lo que delimita las expresiones de erlang: toda expresión en este lenguaje va a terminar con un punto. La segunda línea exporta una lista de funciones del módulo. En nuestro caso sólo tenemos una función factorial/1, pero podemos observar que aún así debemos delimitarlo como una lista [...]. La otra cosa que nos puede llamar la atención es la manera de referirse a una función: el nombre de la misma y separado con una barra el número de argumentos de la misma. Eso nos permite, por ejemplo, si tienen distinto número de parámetros, trabajar con dos funciones con el mismo nombre. Por último, tenemos la expresión que define la función: comienza con factorial(1) y acaba donde está el punto, tres líneas más abajo. Como vemos, está dividida en dos partes según el argumento recibido: si es un 1 devuelve 1 y si no, devuelve el resultado de multiplicar el argumento N por el factorial de N-1... es decir, la típica función recursiva llamándose a sí misma. Pero vemos, que las dos partes de la función están separadas por un carácter ;.

El entorno interactivo que nos presenta erlang es erl, como hemos visto antes. Ahí podemos cargar los módulos que necesitemos y hacer muchas más cosas, pero vamos poco a poco.

En el ejemplo anterior hemos visto que compilábamos el módulo que habíamos creado mediante el comando c(factorial). antes de poder utilizarlo con el comando factorial:factorial(5). y que nos permite analizar cómo son las llamadas en este lenguaje. Para empezar es el nombre del módulo y de la función separado por el carácter :.

Pero de momento, vamos a centrarnos en el eshell:

$ erl
Erlang/OTP 22 [erts-10.7] [source] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads:1] [hipe]

Eshell V10.7  (abort with ^G)
1> _

En la segunda línea nos dice abort with ^G, y puede parecer que C-g (en notación de emacs) lo que haga solamente es parar el proceso de Eshell, pero no es cierto. Si pulsamos esa combinación de teclas nos aparecerá un prompt tal que -->:

$ erl
Erlang/OTP 22 [erts-10.7] [source] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads:1] [hipe]

Eshell V10.7  (abort with ^G)
1> 
User switch command
 --> _

Antes del prompt vemos el mensaje User switch command. Si pulsamos h, o ?, y enter nos mostrará una lista de posibles comandos:

1> 
User switch command
 --> h
  c [nn]            - connect to job
  i [nn]            - interrupt job
  k [nn]            - kill job
  j                 - list all jobs
  s [shell]         - start local shell
  r [node [shell]]  - start remote shell
  q                 - quit erlang
  ? | h             - this message
 --> _

Vamos a utilizar j y enter para ver la lista de trabajos, aunque de momento sólo tenemos nuestro eshell funcionando, así que contestará algo parecido a:

--> j
  1* {shell,start,[init]}
--> _

Y si tenemos nuestra consola ocupada con cálculos complejos y tarda en contestar, por poner un ejemplo, podemos necesitar otra consola, la lanzaremos con s... paralelismo desde la propia línea de comandos:

--> s
--> j
  1  {shell,start,[init]}
  2* {shell,start,[]}
--> _

Bien, vemos que ahora mismo tenemos 2 procesos shell corriendo y estamos enlazados al 2, porque está marcado con el *. Si queremos volver a la consola anterior utilizaremos el comando c 1. Si utilizamos sólo la c conectaremos con la shell a la que estemos enganchados. También, como se puede ver en el listado de comandos se pueden hacer más cosas, como matar un proceso (k), levantar un «nodo» para conexión remota (r), o salir del shell (q).

Como vimos antes, el calcular el factorial de un número negativo producía un bloqueo. Vamos a proteger un poco esa ejecución:

-module(factorial).
-export([factorial/1]).

factorial(1) ->
    1;
factorial(N) when N > 0 ->
    N * factorial(N-1).

El resultado será el siguiente:

$ erl
Erlang/OTP 22 [erts-10.7] [source] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads:1] [hipe]

Eshell V10.7  (abort with ^G)
1> c(factorial).
{ok,factorial}
2> factorial:factorial(5).
120
3> factorial:factorial(-5).
** exception error: no function clause matching factorial:factorial(-5) (factorial.erl, line 4)
4> _

Como vemos la cláusula when establece que se haga el cálculo cuando N > 0, es decir, cuando es un número positivo y cuando es negativo se lanza una excepción porque no hay ninguna cláusula que tenga en cuenta ese caso. Sin embargo, esa excepción no se lleva consigo la ejecución del shell, lo cual es de agradecer y entraría en la filosofía de erlang que dice eso de déjalo que falle.