aprendiendo ( Erlang ).

sábado, 12 de marzo de 2011

Estructura de un módulo Erlang

| 0 comentarios |

Según las definiciones que he podido leer: Los módulos de Erlang son un conjunto de atributos y declaraciones de funciones (todos terminados en .). Yo añadiría también los comentarios y la meta información que un módulo conlleva.
%%%-------------------------------------------------------------------
%%% Descripción del módulo
%%%-------------------------------------------------------------------
-module(ejemplo).         %% atributo module
-export([suma/2,suma/3]). %% atributo export

suma(A,B) ->              %% función suma/2
    A + B.                %% finalización de suma/2

suma(A,B,1) ->            %% función suma/3
    suma(A,B);            %%   finalización de clausula para suma/3
suma(A,B,X) ->            %%   comienzo de una nueva clausula para suma/3 
    AB = suma(A,B),       %%   
    AB + suma(A,B,X-1).   %% finalización de clausula y función suma/3


Atributos de módulo
Los atributos del módulo definen determinadas propiedades o características del módulo. Un atributo consiste en un guión seguido de una etiqueta y un valor o conjunto de ellos -tag(valores). Una etiqueta es un átomo mientras que los valores son términos literales.
Todo los atributos son almacenados en la meta información del módulo en el momento de la compilación y puede ser recuperado usando NOMBRE_MÓDULO:module_info.
Por ejemplo, en nuestro caso compilemos el módulo ejemplo.erl anterior y probemos haber que pasa.
Erlang R13B03 (erts-5.7.4) [source] [64-bit] [rq:1] [async-threads:0] [hipe] [kernel-poll:false]

Eshell V5.7.4  (abort with ^G)
1> c(ejemplo).
{ok,ejemplo}
2> ejemplo:module_info(module).
ejemplo
3> ejemplo:module_info().      
[{exports,[{suma,2},
           {suma,3},
           {module_info,0},
           {module_info,1}]},
 {imports,[]},
 {attributes,[{vsn,[35910149820513174633234912078942844236]}]},
 {compile,[{options,[]},
           {version,"4.6.4"},
           {time,{2011,3,9,8,25,46}},
           {source,"/una ruta/ejemplo.erl"}]}]
4>
Este info es de un módulo muy básico y por lo tanto tiene poquita información pero esto no quedara aquí. No voy a entrar a ver cada uno de ellos, por que son suficientemente descriptivos, pero si vemos el exports tenemos dos funciones que no hemos declarado, exactamente las que hemos usado. El compilador se a encargado de insertarlas en nuestro módulo.

Module
Define el nombre del módulo. La sintaxis es -module(NOMBRE). El nombre del módulo es un átomo con el mismo nombre del fichero (sin extensión). Este atributo debe ser el primero del módulo.

Export
Define las funciones del módulo que serán visibles fuera del mismo. La sintaxis es -export(FUNCIONES). Las FUNCIONES es una lista de elementos con el formato nombre_función/aridad donde el nombre_función es un átomo y la aridad un entero que representa el número de parámetros.

Import
Define las funciones importadas de un módulo concreto. La sintaxis es -import(MÓDULO,FUNCIONES). Las funciones incluidas en un atributo import se pueden utilizar como funciones locales, es decir, sin tener que poner el módulo. Se pueden poner tantos atributos imports como se necesiten.

Compile
Son una o una lista de opciones las cuales se pasarán al compilador como directivas a seguir en la compilación. La sintaxis es -compile(OPCIONES).
Una utilidad de este atributo es -compile(export_all) indica al compilador que exporte todas las funciones implementadas. Muy útil a la hora de desarrollar.
compile/3

Versión o vsn
Define la versión del módulo. La sintaxis es -vsn(VERSION). La versión es un literal. Si no se define este atributo Erlang designa una versión por defecto, un checksum MD5.

Behaviour
Este atributo nos permite determinar o indicar al compilador el comportamiento que va tener nuestro módulo. Su sintaxis es -behaviour(COMPORTAMIENTO). Los comportamientos estándares de definidos por OTP son:
  • client-server
  • event-handler
  • gen-server
  • hot-standby
  • keep-me-alive
  • supervision-tree
  • upgrade-handler
  • worker-supervisor
En un futuro veremos cada uno de estos comportamientos profundizando en su cometido. Ahora nos basta con saber que existe y que son implementaciones estándares de comportamiento de servidor, supervisor de otros módulos, ortográficos, etc ...

Registros
Nos permite definir registros que como vimos en el post sobre tipos básicos. Su sintaxis es -record(NOMBRE,CAMPOS). Se trata de una estructura para almacenar un número fijo de elementos CAMPOS (tupla con los nombre asociados a cada campo) asociados a un NOMBRE que debe ser un átomo.
Puede ser definido en cualquier parte del módulo.

Include
Este atributo es utilizado por preprocesador de Erlang y esta pensado para la inclusión de ficheros en el módulo. Su sintaxis es -include("FICHERO"). Normalmente los ficheros de inclusión son .hrl en los cuales podemos definir registros, macros y otros elementos que pueden ser comunes en una aplicación.

Define
También es utilizado por preprocesador y nos permite definir macros al estilo de C. Es decir, que el preprocesador se encargará de incluir el código asociado a la macro en el punto que la utilicemos. Muy útil para definir constantes. Su sintaxis es -define(NOMBRE, CÓDIGO).

File
Esta directiva me queda un poco lejos y no se bien como funciona. Sirve para cambiar los valores de dos macros predefinidas ?FILE y ?LINE. Este atributo es utilizado por Yecc que es un lenguaje de parser o definición BNF en Erlang. NPI ya sabemos ni p.... idea. Su sintaxis es -file(FILE, LINE).

Type
Nos permite realiza definiciones de tipos. Su sintaxis es -type NOMBRE_TIPO :: CUALQUIER_TIPO. Esta basado en la descripción EEP8 para la definición de tipos.

Especificación de función
Define especificaciones de funciones. Su sintaxis es -spec MÓDULO:NOMBRE_FUNCIÓN(TIPO1, ..., TIPON) -> TIPO. También sigue la especificación EEP8.

Comentarios
Con un % tenemos un comentario a hasta el final de la línea.

Atributos definidos por el usuario
Nosotros también podemos definir atributos con el formato estándar -ÁTOMO(VALOR). Nos puede venir bien tener un alguna información en tiempo de ejecución p.e. -programador("alguien"). Si deseamos recuperar la información del atributo sólo tenemos que llamar a la función module_info/1.

Funciones
Una estructura general de función en un módulo puede ser:
función(parámetro11,...,parámetro1N) [when Guarda1] ->
implementación1;
...;
función(parámetrosK1,...,parámetrosKN) [when guardaK] ->
implementaciónK.

Publicar un comentario

0 comentarios:

 
Licencia Creative Commons
Aprendiendo Erlang por Verdi se encuentra bajo una Licencia Creative Commons Atribución-NoComercial-CompartirIgual 3.0 Unported.