Hola, mundo!

Despacito es un lenguaje de programación basado en la cultura latinoamericana, de código libre y open source (licencia BSD). Despacito es turing-completo, compilado, estáticamente tipado, y tiene soporte de arreglos, funciones y recursión.

El compilador de Despacito se encuentra implementado en Python 3 en poco más de 1000 líneas de código, sin utilizar librerías externas ni expresiones regulares. El código fuente está en GitHub:

https://github.com/Despacito-Lang/Despacito

Introducción

La mejor forma de introducir el lenguaje es con el clásico programa Hola, Mundo!:

ay Esto es un comentario!

despacito ProgramaHolaMundo
bailar
    respirar
    firmar ("Hola, mundo!\n")

Similar al lenguaje Python, la identación de código es parte del lenguaje. Un bloque de código comienza con bailar y debe tener al menos una sentencia. La sentencia respirar no hace nada, y es equivalente al pass de Python.

El lenguaje Despacito es compilado y estáticamente tipado, y por el momento el compilador de referencia produce código C. Entonces, para ejecutar programas Despacito hace falta un compilador del lenguaje C. Por ejemplo con gcc:

$ ./despacito.py ejemplos/helloworld.despacito > hello.c
$ gcc -Wall -Wextra -o hello hello.c 
$ ./hello 
Hola, mundo!

acuerdate (variables)

Las variables hace falta declararlas con un tipo de datos adecuado mediante un bloque de acuerdate, el nombre de la variable, el uso de la palabra clave conmigo seguido del tipo de datos. El tipo de datos entero es un alias de un int en C, pero tambien es posible usar los mismos del lenguaje C. Al momento, los nombres de operadores, variables, tipos de datos y nombres de funciones no permiten acentos.

La asignación de valores se hace con el operador es, y los operadores aritméticos son: mas, menos, por, div y mod, y siguen las reglas clásicas de precedencia.

ay programa uno.despacito

despacito ProgramaUno
acuerdate
    x conmigo entero

bailar
    x es 10 mas 5 por (1 mas 1)
    firmar ("El valor de x es %d\n", x)

La salida del programa uno.despacito:

$ ./despacito.py uno.despacito > uno.c
$ gcc -Wall -o uno uno.c 
$ ./uno 
El valor de x es 20

arreglos

Para crear un arreglo hace falta indicar su tamaño mediante el uso de paréntesis. Los arreglos, al igual que en el lenguaje C, comienzan con el índice cero.

ay programa dos.despacito

despacito ProgramaDos
acuerdate
    x conmigo entero(10)

bailar
    x(3) es 1234
    firmar ("El valor de x(1) es %d, y x(3) es %d\n", x(1), x(3))

La salida del programa dos.despacito:

$ ./despacito.py dos.despacito > dos.c
$ gcc -Wall -o dos dos.c
$ ./dos
El valor de x(1) es 0, y x(3) es 1234

quiero

La estructura de selección (o sea, el if de Python) se hace con quiero, seguido de la condición, seguido del código identado. Cuando la condición es verdadera, el bloque se ejecuta. Usando sino es posible indicar el caso contrario, ya sea con una expresión, o sin ninguna expresión. Los operadores condicionales son: igual, mayor, y menor.

ay programa tres.despacito

despacito ProgramaTres
acuerdate
    i conmigo entero

bailar
    i es 2020
    quiero (i mod 3) igual 0
        firmar ("i es divisible por 3\n")
    sino (i mod 2) igual 0 
        firmar ("i es divisible por 2\n")
    sino
        firmar ("i es: %d\n", i)

La salida del programa tres.despacito:

$ ./despacito.py tres.despacito > tres.c
$ gcc -o tres tres.c 
$ ./tres
i es divisible por 2

pasito

Para repetir un bloque de código una cantidad limitada de veces se puede usar la estructura pasito con una expresión de tipo entero. La expresión se evalúa una sola vez al comenzar el bloque:

ay programa cuatro.despacito

despacito ProgramaCuatro
bailar
    pasito 10
        firmar ("hola, ")

La salida del programa cuatro.despacito:

$ ./despacito.py cuatro.despacito > cuatro.c
$ gcc -Wall -o cuatro cuatro.c 
$ ./cuatro
hola, hola, hola, hola, hola, hola, hola, hola, hola, hola,

repetir

Para repetir un bloque de código mientras una condición sea verdadera se puede usar la estructura mientras con una expresion de tipo booleana. La expresión se evalúa siguiendo las reglas normales de un while.

ay programa cinco.despacito

despacito ProgramaCinco
acuerdate
    i conmigo entero
bailar
    i es 0
    mientras i menor 10
        firmar ("hola %d, ", i)
        i es i mas 1

La salida del programa cinco.despacito:

$ ./despacito.py cinco.despacito > cinco.c 
$ gcc -Wall -o cinco cinco.c 
$ ./cinco 
hola 0, hola 1, hola 2, hola 3, hola 4, hola 5, hola 6, hola 7, hola 8, hola 9,

mirada (funciones)

Para modularizar el código se hace con la palabra clave mirada, seguido del tipo de datos de retorno de la funcion y opcionalmente los parámetros de la mirada separados por comas:

ay Implementacion de FACTORIAL

despacito Factorial

mirada entero fact x conmigo entero
bailar
    quiero x mayor 1
        fact es x por fact(x menos 1)
    sino
        fact es 1

bailar
    firmar ("%d\n", fact(6))

La salida del programa factorial.despacito:

$ ./despacito.py factorial.despacito > factorial.c
$ gcc -Wall -Wextra -o factorial factorial.c 
$ ./factorial 
720