Azag Thoth - un intérprete para el lenguaje de Algo 2

Bajar

Bajar el intérprete: precompilado para Windows az.zip (~97Kb); fuentes azsrc.zip (~25Kb).

Azag Thoth mediante ejemplos

Ejemplo mínimo

Guardar lo siguiente en un archivo "fact.az".

TAD fact
axiomas:
  fact(n) := if n = 0 then 1 else n * fact(n-1) fi;
Fin TAD

Nota: ¡esto no es un TAD! Pero es mucho más fácil introducir el lenguaje así.

Ejecutar el intérprete dándole "fact" como argumento (sin la extensión): azag fact.

En el intérprete escribir: fact(5). Si el intérprete imprime 120, bien.

Otra nota: por defecto, se exportan todas las funciones de un TAD, por eso no es necesaria la cláusula exportar en este caso.

Restricciones

Como fact no es un constructor ni un observador, las restricciones se ponen en la parte de "otras funciones", así:

TAD fact
funciones:
  fact(n) : nat -> nat          {n >= 0}
axiomas:
  fact(n) := if n = 0 then 1 else n * fact(n-1) fi;
Fin TAD

Notar que: los axiomas llevan punto y coma al final, las signaturas no.

Salir del intérprete (con salir, quit, exit, bye o chau) y empezarlo de nuevo: azag fact.

Probar fact(-1). Ahora debería decir que no se cumple la restricción sobre los argumentos. (Si lo probábamos antes, entraba en un ciclo infinito y terminaba con un error seguramente de lo más feo).

Nota: por cuestiones de pedorridad de implementación, las signaturas son básicamente comentarios. Sólo tienen relevancia: las restricciones (para funciones y observadores) y la aridad (para constructores). Usarlas bien o mal depende del programador, no estoy fanáticamente a favor ni en contra de su buen uso.

Constructores

Definición inductiva de una bola de mocos: una bola de mocos es una bola de mocos vacía, o bien un moco verde pegado a una bola, o bien un moco rojo pegado a una bola.

Crear el archivo bolademocos.az con el siguiente contenido:

TAD bolademocos
exporta: bmvacia, pegaverde, pegarrojo
constructores:
  bmvacia : -> bolademocos
  pegaverde : bolademocos -> bolademocos
  pegarrojo : bolademocos -> bolademocos
Fin TAD

Iniciar el intérprete (azag bolademocos). Probar qué pasa con las expresiones: bmvacia(), pegaverde(bmvacia()), pegarrojo(pegarrojo(pegaverde(bmvacia()))), etc.).

Debería resultar en el mismo texto que se introduce. (Aunque en realidad una es notación para la expresión que construye la bola, y la otra es la notación para mostrar la bola misma).

Nota: los constructores son funciones nularias; bmvacia es el constructor (i.e. la función), para construir es necesario indicar que se llama a esa función: bmvacia()

Observadores

Agregar la cláusula de observadores, y agregarlos como símbolos a exportar, para que el archivo quede así:

TAD bolademocos
exporta: bmvacia, pegaverde, pegarrojo,
	 bmvacia?, primeroverde?, primerorrojo?, otrosmocos
constructores:
  bmvacia : -> bolademocos
  pegaverde : bolademocos -> bolademocos
  pegarrojo : bolademocos -> bolademocos
observadores:
  bmvacia? : bolademocos -> bool
  primeroverde?(b) : bolademocos -> bool        {~bmvacia?(b)}
  primerorrojo?(b) : bolademocos -> bool        {~bmvacia?(b)}
  otrosmocos(b) : bolademocos -> bolademocos    {~bmvacia?(b)}
axiomas:
  bmvacia?(bmvacia()) := true;
  bmvacia?(pegaverde(b)) := false;
  bmvacia?(pegarrojo(b)) := false;

  primeroverde?(pegaverde(b)) := true;
  primeroverde?(pegarrojo(b)) := false;
  
  primerorrojo?(pegaverde(b)) := false;
  primerorrojo?(pegarrojo(b)) := true;

  otrosmocos(pegaverde(b)) := b;
  otrosmocos(pegarrojo(b)) := b;
Fin TAD

Probar algún ejemplo.

Nota: La virgulilla ~ es el "no lógico" (dado true, devuelve false y viceversa).

Otra nota: todas las funciones pueden hacer pattern matching. Sin embargo, entiendo que en Algo 2 la idea es que sólo los observadores hagan pattern matching y el resto de las funciones se definan en base a éstos.

Igualdad observacional

Lo bueno de poner observadores (signaturas con restricciones + funciones) es que la igualdad observacional se define sola.

(Con muuucho cuidado: esto vale solamente cuando los observadores son unarios y el argumento es el elemento del TAD en cuestión; si no, todo depende de cuantificadores universales, difíciles de tratar).

Probar, por ejemplo bmvacia() = bmvacia(), pegarrojo(bmvacia()) = bmvacia(), etc.

Agregando más funciones

Hagamos una función que transforme la bola de mocos en una lista que tenga 1 para los mocos verdes y 2 para los rojos.

Agregar la siguiente cláusula, después de la línea TAD bolademocos:

usa: secuencia

Agregar bola2secu a la lista de símbolos a exportar.

Agregar la cláusula "otras funciones", con la signatura correspondiente:

funciones:
  bola2secu : bolademocos -> secuencia(nat)

Agregar los axiomas que falten:

  bola2secu(b) := if bmvacia?(b) then <>
                  else
		    if primeroverde?(b) then 1 else 2 fi . bola2secu(otrosmocos(b))
	          fi;

¿Quieres seguir por tu cuenta?

Jajaja, qué buena broma.