Programación en Erlang/Ejemplos pequeños del lenguaje

Para entender mejor el lenguaje que mejor manera que con los ejemplos comunes de todos los lenguajes. Y así notar la diferencia entre Erlang y el resto.

factorial.erl

     -module(factorial).
     -export([factorial/1]).
     
     factorial(N) when N == 0 -> 1;
     factorial(N) when N > 0 -> N * factorial(N-1).

     1> c(factorial).
       {ok,factorial}
     2> factorial:factorial(20).
       2432902008176640000
     3> 

Lo importante de este caso es ver el modo como funciona factorial en Erlang. Las comparaciones que se realizan en Erlang son descritas en la siguiente tabla:

Operador	Descripción	Tipo
X > Y	X es mayor que Y	Coerce
X < Y	X es menor que Y	Coerce
X =< Y	X es igual o menor que Y	Coerce
X >= Y	X es igual o mayor que Y	Coerce
X == Y	X es igual a Y	Coerce
X /= Y	X no es igual a Y	Coerce
X =:= Y	X es igual a Y	Exact
X =/= Y	X no es igual a Y	Exact

La diferencia entre ‘Exact’ y ‘Coerce’ es inmensa. Por ejemplo en ‘Coerce’ cuando comparamos 2 números solo compara magnitudes tal como 5.0 == 4+1. Sin embargo ‘Exact’ lo que hace es decir que no son iguales porque 5.0 no es igual a 5 ya que un entero no es similar a un punto flotante.

Los casos tipos if, else y case se verán aplicados al mismo factorial para entender la diferencia.

Tipo If y Else

   -module(factorial2).
   -export([factorial/1]).
   
   factorial(N) ->
   	if
   		N == 0 -> 1;
   		N > 0 -> N*factorial(N-1)
   	end.

Si se puede observar esto es como condición instrucción terminada en ‘;’ excepto la condición final.

Tipo Case

   -module (factorial3).
   -export ([factorial/1]).
   
   
   factorial(N) ->
       case N of
   	    0 -> 1;
   	    N when N > 0 ->
   	        N * factorial(N - 1)
       end.

Si se observa de este código tenemos que podemos hacer condiciones dentro del mismo case. Para demostrar un programa fácil pero con un poco más de complejidad haremos el cifrado de César con rotación 13.

Cifrado Cesar (Rotación 13)

El cifrado de cesar con rotación 13 mueve una letra 13 posiciones más adelante.

  -module (cesar).
  -export ([cifrar/1, descifrar/1]).
  
  cifrar(String) -> 
  	list_to_atom([X+13 || X <- String]).
  
  descifrar(String) ->
  	list_to_atom([X-13 || X <- String]).

Al compilar:

 1> c(cesar).
    {ok, cesar}
 2> cesar:cifrar("hola").
    'u|yn'
 3> cesar:descifrar("u|yn").
    hola

Lo que aquí se aprecia es un nuevo tipo de instrucción. EL cual Erlang permite usar una lista y aplicarle una función a todos los elementos de la lista. De ahí la instrucción list_to_atom devuelve la lista de enteros como una lista de caracteres es decir una cadena.