5.6.2 Funciones y variables para las estructuras

Variable global: structures ¶

structures es la lista que contiene las estructuras definidas por el usuario con defstruct.

Función: defstruct (S(a_1, ..., a_n)) ¶

Función: defstruct (S(a_1 = v_1, ..., a_n = v_n)) ¶

Define una estructura, la cual es una lista de nombres de campos a_1, ..., a_n asociados a un símbolo S. Todo individuo de una estructura dada consiste en una expresión con operador S y exactamente n argumentos. La sentencia new(S) crea un nuevo individuo con estructura S.

Un argumento consistente en un símbolo a especifica el nombre de un campo. Un argumento consistente en una ecuación a = v especifica el nombre del campo a junto con su valor por defecto v. El valor por defecto puede ser cualquier tipo de expresión.

La llamada a defstruct añade S a la lista de estructuras definidas por el usuario, structures.

La sentencia kill(S) borra S de la lista de estructuras definidas por el usuario y elimina la definición de la estructura.

Ejemplos:

(%i1) defstruct (foo (a, b, c));
(%o1)                    [foo(a, b, c)]
(%i2) structures;
(%o2)                    [foo(a, b, c)]
(%i3) new (foo);
(%o3)                     foo(a, b, c)
(%i4) defstruct (bar (v, w, x = 123, y = %pi));
(%o4)             [bar(v, w, x = 123, y = %pi)]
(%i5) structures;
(%o5)      [foo(a, b, c), bar(v, w, x = 123, y = %pi)]
(%i6) new (bar);
(%o6)              bar(v, w, x = 123, y = %pi)
(%i7) kill (foo);
(%o7)                         done
(%i8) structures;
(%o8)             [bar(v, w, x = 123, y = %pi)]

Función: new (S) ¶

Función: new (S (v_1, ..., v_n)) ¶

new crea nuevos individuos de estructuras declaradas.

La sentencia new(S) crea un nuevo individuo de estructura S en el que cada campo toma su valor por defecto, si este fue definido, o sin valor alguno en caso de que no se haya fijado un valor por defecto en la definición de la estructura.

La sentencia new(S(v_1, ..., v_n)) crea un nuevo individuo de estructura S en el que los campos adquieren los valores v_1, ..., v_n.

Ejemplos:

(%i1) defstruct (foo (w, x = %e, y = 42, z));
(%o1)              [foo(w, x = %e, y = 42, z)]
(%i2) new (foo);
(%o2)               foo(w, x = %e, y = 42, z)
(%i3) new (foo (1, 2, 4, 8));
(%o3)            foo(w = 1, x = 2, y = 4, z = 8)

Operador: @ ¶

@ es el operador para acceder a los campos de las estructuras.

La expresión x@ a hace referencia al valor del campo a del individuo x de una estructura dada. El nombre del campo no se evalúa.

Si el campo a de x no tiene valor asignado, x@ a se evalúa a sí mismo; es decir, devuelve la propia expresión x@ a tal cual.

La sentencia kill(x@ a) elimina el valor del campo a de x.

Ejemplos:

(%i1) defstruct (foo (x, y, z));
(%o1)                    [foo(x, y, z)]
(%i2) u : new (foo (123, a - b, %pi));
(%o2)           foo(x = 123, y = a - b, z = %pi)
(%i3) u@z;
(%o3)                          %pi
(%i4) u@z : %e;
(%o4)                          %e
(%i5) u;
(%o5)            foo(x = 123, y = a - b, z = %e)
(%i6) kill (u@z);
(%o6)                         done
(%i7) u;
(%o7)              foo(x = 123, y = a - b, z)
(%i8) u@z;
(%o8)                          u@z

El nombre del campo no se evalúa.

(%i1) defstruct (bar (g, h));
(%o1)                      [bar(g, h)]
(%i2) x : new (bar);
(%o2)                       bar(g, h)
(%i3) x@h : 42;
(%o3)                          42
(%i4) h : 123;
(%o4)                          123
(%i5) x@h;
(%o5)                          42
(%i6) x@h : 19;
(%o6)                          19
(%i7) x;
(%o7)                    bar(g, h = 19)
(%i8) h;
(%o8)                          123