El lenguaje de programación Gnome Vala

ARTÍCULO EN DESARROLLO

Si quieres colaborar con nosotros completando este apartado o cualquier otra parte del Curso, puedes informarte en el enlace siguiente.

>[Documentación para desarrolladores]

Introducción

Este documento es un resumen de las características del lenguaje de programación Vala. Diseñado para el sistema GObject de GNOME.

Ficheros fuente

No hay restricciones en la escritura del código fuente. Esto significa que se pueden crear tantas clases como se quieran dentro del mismo fichero. En algunos lenguajes de programación hay que cumplir unas reglas: en java, por ejemplo, el nombre del fichero con el código fuente se tiene que corresponder con el nombre de la clase que se está definiendo y los nombres de los directorios se tienen que corresponder con los nombres de los paquetes que se están implementando.

El enfoque quizás sea parecido al que se sigue en el lenguaje de programación C donde todas las funciones de una misma librería se agrupan en un fichero objeto. Por este motivo, para crear un paquete, es necesario compilar a un fichero binario pasando al compilador todos los ficheros fuente necesarios.

Posteriormente es posible incluir ese paquete, al compilar otro fichero, indicándoselo al compilador mediante el parámetro "--pkg".

Operadores

Operadores (separados por comas)

Descripción

=

Operador de asignación: asigna un valor a una variable.

+, -, /, *, %

Operadores aritméticos: suma, resta, división, multiplicación y módulo.

+=, -=, /=, *=, %=

Operadores aritméticos en los que a la izquierda debe haber un operando al que asignar el resultado.

++, --

Incremento y decremento del valor de una variable respectivamente.

|, ^, &, ~

Operadores de comparación a nivel de bit: or, or exclusivo, and y not.

|=, &=, ^=

Modificadores de bits en los que a la izquierda debe haber un operando al que asignar el resultado: or, or exclusivo, and y not.

<<, >>

Modificadores de bits: el resultado de mover hacia la izquierda y hacia la derecha, respectivamente, los bits de una variable. Tantas posiciones como indique el operando de la derecha.

<, >, ==

Operadores lógicos de comparación: menor, mayor e igualdad, respectivamente.

!, &&,

Operadores lógicos: not, and y or, respectivamente.

(expresión)?(valor en verdadero):(valor en falso)

Operador condicional ternario. Evalúa una condición y devuelve el resultado según si la expresión es verdadera o falsa.

??

Operador de prevención de nulo. Establece un valor predeterminado en caso de que una referencia sea nula. Por ejemplo: x = a??b Es equivalente a x = (a != null) ? a : b.

as

Operador de casting de tipo dinámico. Comprueba, en tiempo de ejecución, que el tipo sea correcto. En caso contrario se asigna un valor nulo. Por ejemplo:Button b = widget as Button es equivalente a Button b = (widget is Button) ? (Button) widget : null;.

=>

Expresión lambda para funciones anónimas.

while, do while, for, foreach, switch

Operadores de control.

Tipos de datos

Se diferencian tres tipos de datos:

A continuación los tipos de datos soportados en el lenguaje.

Tipos por valor

Los siguientes tipos son equivalentes a los soportados por compiladores de lenguaje C. Estos tipos pueden tener tamaños diferentes según la arquitectura del computador en el que se vaya a compilar:

En cualquier caso, es posible determinar el tamaño mínimo y máximo de un tipo númerico utilizando los atributos .MIN y .MAX respectivamente: short.MIN.

A continuación los tipos específicos de Vala (y de cualquier lenguaje de alto nivel moderno como Java o C#):

Cadenas de caracteres (Strings)

Señalar que, además del tipo de dato string mencionado anteriormente, también existen tipos de strings más complejos:

Además, es posible partir una cadena de caracteres utilizando la expresión [inicio:fin]. Donde inicio es la posición (incluyente) del primer carácter (empezando en 0) y fin es la posición (excluyente) del último carácter:

string saludo = "hola mundo";
string s1 = saludo[5:11]; // "mundo"

Se puede acceder a un carácter en concreto, teniendo en cuenta que se está utilizando, de forma predeterminada, la codificación UTF8:

unichar c = saludo[7];

Sin embargo, las cadenas de caracteres en Vala son inmutables. Esto significa que no se puede modificar directamente un carácter individual de una cadena. No son simples Arrays. La cadena tiene que ser procesada internamente ya que en UTF8 cada carácter puede ocupar diferentes cantidades de bytes.

Finalmente, decir que la mayoría de los tipos básicos disponen de métodos de conversión a, y desde, string:

bool b = "false".to_bool();
string s1 = true.to_string();
int i = "-52".to_int();
string s2 = 21.to_string();

Arrays

Se pueden definir Arrays de cualquier tipo. Ejemplo de Array unidimensional:

in[] a = new int[10];
int[] b = {2,5,6,1};

Ejemplo de Array multidimensional:

int[,] c = new int[3,4];
int[,] d = {{1,1},{2,2}};

Sólo si el array es local o privado, es posible añadir elementos dinámicamente. Y su tamaño se va incrementando en potencias de 2. Esto se hace con el operador '+=':

int[] e;
e += 12;
e += 5;

El atributo length muestra el número de elementos del array. Que no tiene porque corresponderse con su tamaño interno.

Es posible establecer el tamaño fijo del array en su declaración. Y en este caso no hace falta instanciar el tipo con el operador new():

int f[10];

Por lo visto, todavía no están soportados los arrays multidimensionales irregulares. Donde cada dimensión es de un tamaño diferente:

int[5][3];

Tipos dinámicos

También se pueden utilizar tipos dinámicos declarando las variables con var:

var a = 32;
var b = "hola";

Esto es muy útil para reducir la redundancia en el código. En java, por ejemplo, con la introducción de los tipos genéricos, tendríamos el siguiente código para la instanciación de una clase:

MiAlgo<string, MiOtro<string, int>> algo = new MiAlgo<string, MiOtro<string, int>>();

La misma instanciación podría haber quedado resuelta, utilizando tipos dinámicos, de la siguiente manera (tal como se hace en Groovy):

var algo = new MiAlgo<string, MiOtro<string, int>>();

Funciones

Los nombres de las funciones en Vala (también llamados métodos) siguen la convención de utilizar letras minúsculas y un guión bajo para separar palabras. Se utiliza el guión bajo en vez de la notación en camello porque es más coherente con los nombres de las funciones de las librerías de Vala y GObject.

No existe la sobreescritura de métodos. Esto significa que no pueden existir dos métodos con el mismo nombre aunque éstos tengan distintos parámetros. El motivo es que las funciones escritas en Vala tambén deberían ser usables por programadores de C.

Es posible establecer un valor predeterminado para el argumento de un método. Así se puede simular el uso, común en otros lenguajes como Java, de métodos con el mismo nombre y número creciente de argumentos.

Por ejemplo, en Vala:

void funcion(in x, string s="hola", double z = 0.5){...};

Serviría para hacer lo que en Java sería:

void funcion(int x, string s, double z){...};
void funcion(int x, string s) { funcion(x, s, 0.5}; }
void funcion(int x) { funcion(x, "hola"); }

Vala hace una comprobación básica de valores nulos en los argumentos y devoluciones de los métodos. Por este motivo hay que indicar qué argumentos pueden tener valor nulo. En el siguiente ejemplo, tanto el valor de retorno como los argumentos texto y objeto pueden tener un valor nulo:

string? nombre_funcion (string? texto, Clase? objeto, int entero)

Delegados

Existen tipos delegados (punteros a funciones). Así se pude pasar una función como parámetro a otra función. Por ejemplo:

//definir un tipo delegado
delegate void ejemplo_delegado(int a);

void funcion_1 (int a){...}
void funcion_2 (ejemplo_delegado d, int a){ d(a); }

[...]

funcion2(funcion1, 5);

Funciones anónimas

También existen funciones anónimas (closures). Las funciones anónimas son aquellas que no tienen nombre. Por lo tanto no se definen sino que se escriben directamente en el lugar en el que van a ser utilizadas.

En el siguiente ejemplo se asigna una función anónima a un tipo delegado utilizando una expresión lambda:

delegate void ejemplo_delegado(string saludo);
ejemplo_delegado d1 = (saludo) => { stdout.printf(saludo) }

O directamente como parámetro de un método:

//definición de funciones (una con parámetro delegado)
void funcion_1(ejemplo_delegado d, int a){ d(a); }
void funcion_2 (int a) { stdout.printf("%d\n", a);}

[...]

//pasando la función como parámetro delegado en otra función
f1(f2, 5); 

//utilizando una función anónima en el parámetro delegado.
f1( (a)=>{stdout.printf("hola %i\n", a}, 5 ); 

Una expresión lambda se lleva a cabo a través del operador =>, que significa "apunta a" o "va a". Hay que fijarse en que no se está estableciendo ni el tipo del parámetro ni el tipo de retorno. Éstos se deducen de la definición del tipo delegado que se está utilizando.

Parámetros

En Vala, una función (o también llamado método) tiene una forma predeterminada de recibir los parámetros:

Sin embargo, es posible cambiar este comportamiento a través de los siguientes modificadores:

A continuación un ejemplo de definición de métodos:

void funcion_1 (int a, out int b, ref int c) {...}
void funcion_2 (Object o, out Object p, ref Object q) {...}

Utilizar estos modificadores en tipos por valor hace que en las funciones sean tratados como tipos de referencia. Por ejemplo, según los métodos anteriormente definidos:

int a = 1;
int b;
int c = 3;

funcion_1(a, out b, ref c);

Ahora un ejemplo con parámetros por referencia.

Object o = new Object();
Object p;
Object q = new Object();

funcion_2(o, out p, ref q);

Espacios de nombres

Los espacios de nombre son como los paquetes de java. Y se definen así:

namespace NombreQueSeLeQuieraDar 
{
        ...
}

En este caso sí se están utilizando nombres con notación en camello. Y la primera letra suele ser mayúscula (al contrario que en Java pero igual que en C#).

Otra forma de decir que una clase pertenece a un espacio de nombres (o paquete) es hacerlo utilizando un punto en su declaración:

class EspacioNombres1.EspacioNombres2.clase {...}

El espacio de nombres GLib es importado predeterminadamente. Cualquier cosa que no se ponga en un espacio de nombres concreto se ubicará en el espacio de nombres anónimo global.

Por supuesto, se pueden anidar espacios de nombres. Pero cualquier código externo al mismo debe utilizar el nombre completo de cualquier cosa que pretenda utilizar. Por ejemplo, para utilizar una función de una clase perteneciente a otro espacio de nombres:

NombreDelEspacioDeNombres.clase.funcion(...);

También es posible declarar el espacio de nombres y así poder utilizar, posteriormente, cualquier cosa de la misma. A continuación un ejemplo de declaración del espacio de nombres:

using nombreDelEspacioDeNombres;

Estructuras

Una estructura o tipo compuesto puede contener, de forma limitada, métodos de ejecución. Y los datos son privados. Esto significa que hay que indicar, de forma explícita, qué datos son públicos.

Por ejemplo, una definición de estrcutura o tipo compuesto:

struct NombreEstructura
{
        public int a;
        public float b;
}

Que puede ser utilizada así:

NombreEstructura estructura = NombreEsctructura()
{
        a = 5,
        b = 0.5;
}

Las estructuras, a diferencia de las clases, se comportan como un tipo de datos básico: son manejadas por valor. Esto significa que en cada asignación se produce una copia de todos sus datos.

Clases

En Vala se diferencian tres tipos de clases:

Las clases compactas se definen sin heredar de Glib.Object y utilizando la anotación Compact.

Para definir una clase se utiliza el modificador class. A continuación un ejemplo de definición de clase:

class NombreClase : NombreSuperclase, NombreInterfaz
{ ... }

Modificadores de acceso

Una clase puede ser definida como pública o privada. De forma predeterminada es privada pero si se utiliza el modificador de acceso public, es posible que pueda ser instanciada fuera del fichero en el que se ha definido. En código C equivale a declarar su interfaz en el fichero de cabecera.

Al mismo tiempo, cada atributo y método de una clase, también puede ser definido utilizando los diferentes modificadores de acceso:

Constructores

Por la misma razón por la que no existe sobreescritura de funciones/métodos en Vala, tampoco es posible definir más de un constructor para una clase. Aunque esta limitación puede ser superada utilizando constructores con nombres distintos. Se sabe que la función es un constructor porque en su definición no se ha indicado lo que devuelve.

Por ejemplo:

public class Boton : Object 
{
        public Boton(){...}
        public Boton.con_etiqueta(string etiqueta){...}
}

Y la instanciación:

new Boton();
new Boton.con_etiqueta("pincha");

Es posible ejecutar el constructor de la clase padre a través de la palabra reservada base:

public class Superclase : Glib.Object
{
        public Superclase(int datos){...}
}

public class Subclase : Superclase
{
        public Subclase(){ base(10);}
}

Destructores

Aunque Vala gestiona la memoria por ti, es posible definir un destructor si estamos gestionando la memoria de forma manual (utilizando punteros). El destructor se define igual que el constructor pero utilizando el modificador ~ delante del nombre:

public class Clase : Object
{
        ~Clase()
        {
                stdout.printf("destruyendo...");
        }
}

Y como Vala no utiliza un recolector de basura (al contrario que Java), se puede utilizar un destructor para liberar recursos como conexiones, flujos, etc. La recolección de basura en Java es impredecible y, por lo tanto, impide utilizar destructores para este cometido (en el caso de java la sobreescritura de finally() en Object).

Propiedades

En programación orientada es una práctica habitual ocultar los detalles de implementación a los usuarios de una clase. Por ejemplo: hacer privados los atributos y permitir su uso a través de métodos de acceso. En Vala, como en C#, existe lo que se llama propiedades; que no es más que una forma más eficaz de implementar los típicos métodos de acceso de Java. Por ejemplo:

class Persona : Object
{
        //metiendo un guión bajo como prefijo evitamos 
        //conflictos con la propiedad
        private int _edad = 31;

        //implementación de propiedad de clase
        public int edad
        {
                get { return _edad; }
                set { _edad = value; }
        };
}

Y un ejemplo de utilización:

Persona david = new Persona();
david.edad = david.edad +1;
david.edad ++;

Y un ejemplo de implementación más corta de propiedad de clase:

Class Persona : Object
{
        //propiedad con getter y setter estándar 
        //y valor predeterminado
        public int edad { get; set; default = 32;}

        //propiedad de sólo lectura
        public int peso { get; private set; default 80;}
}

Señales

La librería GLib define señales para las clases que hereden de Object. Las señales son similares a los listeners de Java. Son una forma de establecer funciones externas que deben ejecutarse ante determinados eventos. Una señal es definida como un miembro de la clase. Y tiene el mismo aspecto que un método abstracto (sin implementación). Los manejadores de señales pueden entonces ser registrados utilizando el método connect(). En el siguiente ejemplo se utiliza un método anónimo como manejador de una señal de la clase:

public class Test : GLib.Object
{
        public signal void sig_1(int a);

        public static void main(string[] args)
        {
                //nueva instancia de la clase
                Test t1 = new Test();
        
                //establecer el manejador de la señal
                t1.sig_1.connect( 
                                (t,a) =>
                                {
                                        stdout.printf("%d\n", a);
                                }
                        )

                        //emitir la señal
                        t1.sig_1(5);
                )
        }
}

En este ejemplo, la razón por la que la función anónima recibe dos argumentos es que cuando se emite la señal, se pasa el objeto que lo ha emitido como primer parámetro de la función manejadora. El segundo argumento es el que indica la definición de la señal. No es necesario especificar los tipos de los parámetros en la función anónima porque Vala los deduce directemante de la señal que se está manejando.

Cuando se emite la señal se ejecutan todos los métodos conectados a la misma.

Anotaciones

Las anotaciones se utilizan para indicar al compilador cómo debe funcionar el código en la plataforma para la que se vaya a compilar. En general, no se deben utilizar anotaciones a menos que se esté escribiendo un enlace para una biblioteca externa (binding).

Un ejemplo de anotación (entre corchetes):

[Compact] [Inmutable] public class nombreClase {...}

A través de anotaciones es posible establecer a las propiedades un nombre y una descripción. Éstos se utilizarán, en tiempo de ejecución, por programas como Glade.

Todas las clases que heredan de Glib.Object disponen de una señal que se llama notify, y que es emitida cada vez que se modifica una propiedad. A continuación un ejemplo de cómo registrar una función anónima como manejador de esta señal. Donde s es el origen de la señal y p la propiedad (de tipo ParamSpec):

objeto.notify.connect(
        (s,p) =>
        {
                stdout.printf("La propiedad %s ha sido modificada\n", p.name);
        }
);

Es posible deshabilitar la notificación de cambios en las propiedades utilizando la anotación CCode:

public class MiObjeto : Glib.Object
{
        //propiedad sin notificación
        [CCode (notify = false)]
        public int sin_notificacion (get; set;);
        
        //propiedad con notificación
        public int con_notificacion (get; set;);
}