Introducción

Razor es un Lenguaje de Programacion diseñado para aplicaciones en control e inteligencia artificial como las de robótica.

Razor está inspirado en ideas y conceptos de los lenguajes de progrmación OCCAM, LISP, y ML y los espacios de tuplas, como los impementados en el Lenguaje de Programacion Linda.

Un programa en Razor consiste en una serie de procesos concurrentes que intercambian información a través de un espacio de tuplas.

Siendo Razor un lenguaje creado para este curso y para el cual nunca se han escrito analizadores léxicos, sintácticos, o semánticos, es posible que en cualquier momento la definición del lenguaje contenga omisiones, ambigüedades, u otros errores. Es responsabilidad de estudiantes, preparadores, y profesores llegar a una definición de un lenguaje que sea completo, inamiguo, y libre de errores como parte del proyecto de laboratorio.

Sintaxis

Un programa en Razor consiste en combinaciones de un grupo pequeño expresiones e instrucciones básicas.

Comentarios

Los comentarios en Razor comiencan con la secuencia "//" y continúan hasta el final de la línea.

Expresiones

Las expresiones en Razor son las siguientes:

1. Átomos, que son secuencias de letras, dígitos, y el caracter punto, que comienzan por un dígito o por una letra minúscula, o el átomo especial @, o strings delimitados por comillas sencillas (') o dobles (") usando las secuencias de escape usuales en los lenguajes que heredan la sintaxis del lenguaje C.
2. Variables, que son secuencias de letras, dígitos y el caracter punto que comienzan por una letra mayúscula.
3. Operaciones de concatenación de átomos y strings, concatenación de tuplas, potenciación, producto, división, división, negación aritmética, suma, resta, comparaciones, negación lógica, conjunción, y disyunción, denotadas por los símbolos ++, ::, ^, *, /, -, +, -, ~, &&, ||, ==, /=, >=, y <=. El orden de precedencia de los operadores es el dado.
4. Tuplas, que son secuencias de expresiones encerradas entre corchetes ([ y ]). La tupla unitaria

   [e]

   es equivalente (intercambiable) con la expresión

   e

   .

5. Instrucciones Basicas en Razor sobre canalles y espacios (descritas más adelante).
6. Composición de instrucciones (descrita más adelante).

La variable especial "_"

La variable especial "_" (underscore) puede usarse en cualquier expresión cuando la expresión requiere una variable en cuyo valor no estamos interesados. La variable especial "_" descarta inmediatamente cualquier valor asignado a la misma.

Instrucciones

Las instrucciones básicas en Razor son lecturas y escrituras sobre canales, donde un canal está identificado por un identificador de canal:

Instrucciones básicas

1. Escritura

   canal <- [e1,..,en]

   escribe la tupla al espacio del canal dado. La escritura sobreescribe el contenido del canal.
   

2. Escritura con bloqueo

   canal ! [e1,..,en]

   escribe la tupla al espacio del canal dado y bloquea el proeceso hasta que la tupla sea retirada. La escritura sobreescribe el contenido del canal.
   

3. Escritura aditiva

   canal += [e1,..,en]

   escribe la tupla al espacio del canal dado. Agrega la tupla al canal sin sobreescribir el contenido anterior.
   

4. Lectura

   canal -> [e1,..,en]

   bloquea el proceso hasta que una tupla que concuerde esté disponible en el espacio del canal dado , la lee sin retirarla del espacio, y desbloquea el proceso.
   

5. Lectura con retiro

   canal ? [e1,..,en]

   es tal como la lectura simple excepto que la tupla es retirada del espacio.
   

6. Tamaño. La expresión

   canal#[V]

   también

   canal#V

   retorna el número de tuplas en el canal. Esta expresión nunca bloquea.
   

7. Repetición. Una instrucción precedida del símbolo ++ se repite indefinidamente. El símbolo especial <> detiene la repetición en curso (es equivalente a la instrucción break en Java.
   
8. Asignación

   V = expresión

   es equivalente a:

   @<-[expresión].@?V

   como se explica más adelante.
   Se permite también la forma

   V::R=expresion

   , la cual es equivalente a

   @<-[expresión].@?V::R

   
   

9. Llamada a función

   nombre[e1,...,en]

   . Llama a la función identificada con el átomo nombre.

Expresiones de Escritura

En todas las instrucciones de escritura las expresiones que conforman la tupla escrita deben evaluar a un átomo.

Expresiones de lectura

Las instrucciones de lectura pueden introducir una única variable en cada expresión de la tupla escrita, por ejemplo:

sensor?[Valor >= 10 && Valor <= 20, Hora]

Lecturas parciales

También es posible colocar la cola de una tupla leida en una variable:

lista?[Primero]::Resto
lista<-Resto

Si la variable para la cola se substituye por el símbolo de lectura, el efecto es el mismo que el del ejemplo anterior:

lista?[Primero]::<-

lee el primer elemento de la tupla obtenida del canal, y coloca el resto en el canal, sin bloquear el proceso.

Tuplas vacías

Es posible escribir y leer tuplas vacías:

c![]
c->[]

Instrucciones Vacías

Se permiten las instrucciones vacías. Es buen estilo usar la expresión "()" para dejar la intención clara.

++(c?_.()|c#[_==0].<>) // vaciar un canal

Composición de Instrucciones

Las instrucciones básicas pueden ser compuestas usando los siguientes operadores:

1. Concatenación

   <inst1>;<inst2>

   ejecuta <inst1> seguido de <inst2>. Este es el operador sobre instrucciones de más alta precedencia.

2. Unión

   {<inst1>, <inst2>, ...,<instN>}

   ejecuta las instrucciones en paralelo.

3. Alternativa

   <inst1>|<inst2>|...|<instN>

   ejecuta al azar una y solo una de las instrucciones que no este bloqueada. Si todas las instrucciones están bloqueadas, se ejecuta la primera de ellas que se desbloquee.

4. Las instrucciones pueden agruparse usando paréntesis para resolver indicar la asociatividad deseada en las expresiones.

Funciones

Es posible definir funciones en razor usando la siguiente sintaxis:

nombre[v1,..,vn] :- instrucción

Donde v1,..,vn son variables (incluyendo la variable especial '_'). El resultado de la función es el contenido del canal especial '@'.

La función especial start

La función especial start es usada por el ambiente de ejecución de Razor para darle inicio al programa. Una vez que un programa es cargado, la máquina virtual ejecuta el equivalente a la siguiente instrucción:

donde arg ₁, arg ₂, ..., arg _n son los argumentos pasados al programa en la línea de comandos.

Canales

En Razor los canales son el medio que sirve para:

• Comunicación inter en intra procesos.
• Almacenar y consultar la información almacenada en el espacio de tuplas de cada canal.

Un canal está identificado por cualquier átomo.

El canal especial @

En cada proceso existe un canal especial reservado el cual es denotado por la expresión @. Solo el proceso en contexto tiene acceso a dicho canal. Usando el canal reservado es posible introducir nuevos canales locales sin afectar a otros procesos:

@<-[expresión].@?[expresión]

Sub-canales

Un canal en razor puede contener sub-canales. Se accede a un sub-canal nombrándolo después del super-canal antecedido de ":":

canal:subcanal:sub_sub_canal<-[info]

Las lecturas sobre un canal c también examinan el contenido de todos sus subcanales c:s recursivamente.

Otros canales especiales

Cada implementación de Razor predefine una serie de canales correspondientes bien sea a elementos sujetos a control, o a espacios correspondientes a bases de datos preexistentes.

En todos los casos, se garantiza que por lo menos los siguientes canales están predefinidos:

1. in, el canal correspondiente a la entrada standard. Al inicio del programa el ambiente de ejecución coloca una tupla en el canal con un átomo por caracter en la entrada. Escribir en el canal produce un error en tiempo ejecución.
2. out, el canal correspondiente a la salida standard. Convierte cada átomo la tupla escrita a una secuencia de caracteres y lo escribe a la salida standard. Leer del canal produce un error en tiempo ejecución.
3. err, el canal correspondiente a la salida para errores. Como el canal out.
4. sound, acepta tuplas de la forma [frecuencia, duración] y emite el sonido indicado. Leer del canal produce un error en tiempo ejecución.
5. time, cuaando es leido, regresa la fecha y hora como el número de milisegundos transcurridos desde enero 1, 1970 00:00:00 GMT.

Estructura de un programa Razor

Un programa en Razor consiste en una serie funciones. La función especial start es llamada por el ambiente de ejecución para iniciar el programa.

Ejemplos

Copiar la entrada a la salida.

start[_] :-      // el canal start es escrito por el ambiente de ejecución
 in?T.        // lee la tupla de entrada completa en una variable
 out!T

Copiar la entrada a la salida, un caracter por línea.

start[_] :-
 in?T.
 copia[T]

copia[L] :- 
  @:cp<-L.                 // coloca el valor en un canal local
  (
    @:cp?[]                // si se lee la tupla vacía, terminamos
    |
    (
       @:cp?[C]::Resto.
       out![C,'\n'].
       copia[Resto]       // llamada recursiva
    )
  )

otra versión del mismo programa podría usar:

copia[L] :- 
   @:cp<-L.               
   ++(                    // repetir
      @.cp?[].<>          // rompe el lazo si se lee una tupla vacía
      |
      @:cp?[C]::<-.       // sintaxis especial para lectura y reescritura de la cola
      out![C,'\n']
     )

Emitir un sonido cada vez que la entrada contiene el caracter "!".

bang[L] :-
  @:check<-L.
  ++(              // solo una de las siguientes instrucciones se ejecuta
      @:check?[].<>
      |
      @:check?['!']::<-.sound![100,10]
      |
      @:check?[_ /= '!']::<-
    )

Copiar la entrada a la salida, un caracter por línea, emitiendo un sonido cada vez que se consigue el caracter "!".

start[_] :-
 in?T.
 { copia[T], bang[T] }  // ejecutar ambas escrituras en paralelo
                        // cada canal recibe su propia copia de la tupla

otra versión (no completamente equivalente) del mismo programa sería:

start[_] :- .
 in?T.
 copia[T].bang[T]

Semántica de un programa Razor

En construcción...