Al instalar Chicken Scheme nos encontraremos dos binarios fundamentales¹ y algunos otros auxiliares. El comando csi llama al intérprete de Chicken Scheme:

> csi
CHICKEN
(c) 2008-2021, The CHICKEN Team
(c) 2000-2007, Felix L. Winkelmann
Version 5.3.0 (rev e31bbee5)
linux-unix-gnu-x86-64 [ 64bit dload ptables ]

Type ,? for help.
#;1> 42
42
#;2> e

Error: unbound variable: e
#;2> 

Además de poder trabajar directamente en el prompt interactivo, podemos escribir el código en un archivo de texto plano con nuestro editor favorito. Tradicionalmente, los archivos de código de Scheme llevan la extensión .scm. También es tradicional, para crear el primer programa, utilizar el famoso hola mundo, pero como estoy un poco harto de él, vamos a hacer otra cosa: ¡vamos a jugar a la ruleta!². Para ello creamos un nuevo fichero con el nombre ruleta.scm en el editor y escribimos el siguiente código:

(import (chicken random))

(define (ruleta)
  (pseudo-random-integer 37))

Hay algunos puntos que, supongo, necesitan un poco más de aclaración: import nos permite importar a nuestro programa paquetes, módulos o librerías que nos simplifican el trabajo. Aquellos módulos que vienen junto con Chicken³ se importan mediante la forma (chicken [módulo]). En el caso de nuestro ejemplo: (chicken random) importa un módulo que nos permite generar números pseudoaleatorios. Es decir, nos va a permitir utilizar la función pseudo-random-integer, que nos devolverá un número entero entre 0 y el rango máximo especificado (37 en nuestro caso).

La macro define permite definir tanto variables como funciones. No hay distinción entre ambas cosas, pues para Scheme no hay distinción entre código y datos⁴. Es decir, el sistema, al evaluar ruleta evaluará lo que contenga, que puede ser un valor o algo que se evalúe hasta encontrar un valor.

En el código se puede apreciar, que los nombres de entidades compuestos por varias palabras, dichas palabras se separan mediante un guión simple. Es una costumbre de todos los Lisp y derivados, no utilizar el CamelCase, puesto que para Lisp en origen todos los nombres se traducen a mayúsculas, y tampoco se utiliza el guión bajo —o la barra baja, si prefieres llamarlo así—.

El código de nuestro primer ejemplo está pidiendo poder ejecutarse como un programa independiente desde un terminal. Para convertirlo en un ejecutable, necesitamos dos cosas:

1. Recibir parámetros desde la línea de comandos.
2. Establecer una función que será la entrada de la ejecución del binario. Tradicionalmente en C y otros lenguajes de programación, esta función se llama main.

Para cumplir con el primer requisito necesitamos importar un módulo interno de Chicken que se llama process-context. En este módulo se define commond-line-arguments, que devuelve una lista de cadenas que representan los parámetros que se escriben en la línea de comandos.

Empecemos por lo fácil. La función principal, la podemos escribir de la siguiente manera:

(define (principal args)
  (print (apostar-ruleta (string->number (car args)))))

A los que tienen un poco de reparo con los paréntesis, quizá les resultaría más fácil de entender la función si la escribimos así:

(define (principal args)
  (print
   (apostar-ruleta
    (string->number
     (car args)
    )
   )
  )
)

Evaluando el código de dentro hacia afuera nos encontramos:

1. (car args) devuelve el primer parámetro recibido en la función.
2. Puesto que el parámetro es una cadena y apostar-ruleta está pidiendo un número, debemos convertir la cadena en número con la función string->number.
3. apostar-ruleta toma el número que le pasamos con el parámetro y lo compara con el número que ha salido en la ruleta.
4. print muestra por pantalla el número obtenido en la ruleta al llamar a apostar-ruleta.

Lo que nos falta es decirle al compilador qué función es la que debe tomar como entrada del ejecutable. Eso lo hacemos con el siguiente código:

(cond-expand
  ((and chicken compiling)
   (principal (command-line-arguments)))
  (else #f))

cond-expand es un condicional, como indica su nombre. Lo que hace es que mientras se ejecuta el compilador de Chicken se añada una llamada a principal con la lista de argumentos y que no haga nada en caso contrario.

Al compilarlo desde la línea de comandos comprobamos si funciona.

> csc ruleta.scm
> ./ruleta 13
¡Has perdido! Ha salido el 2
>  

En este caso, al compilador csc lo llamo sólo pasándole el archivo que debe compilar sin ningún parámetro adicional. Eso genera el binario ruleta y se le llama desde línea de comandos como a cualquier otro programa.

El código completo del ejemplo es el siguiente:

(import (chicken random)
        (chicken process-context))

(define (ruleta)
  (pseudo-random-integer 37))

(define (comparar-apuesta resultado num-apostado)
  (if (= resultado num-apostado)
      (display "¡Has ganado! Ha salido el ")
      (display "¡Has perdido! Ha salido el "))
  resultado)

(define (apostar-ruleta num-apostado)
  (comparar-apuesta (ruleta) num-apostado))

(define (principal args)
  (print (apostar-ruleta (string->number (car args)))))

;; Ejecutar 'principal' cuando se compila como ejecutable
(cond-expand
  ((and chicken compiling)
   (principal (command-line-arguments)))
  (else #f))

Igualmente podemos seguir compilando este código como si fuera una librería. Lo único que sucederá es que al cargar la librería binaria en el intérprete, éste se quejará porque no le pasamos un parámetro por línea de comandos. Sin embargo el código sigue funcionando:

> csc -s ruleta.scm
> csi
CHICKEN
(c) 2008-2021, The CHICKEN Team
(c) 2000-2007, Felix L. Winkelmann
Version 5.3.0 (rev e31bbee5)
linux-unix-gnu-x86-64 [ 64bit dload ptables ]

Type ,? for help.
#;1> ,l ruleta.so
; loading ruleta.so ...

Error: (car) bad argument type: ()

        Call history:

        ruleta.scm:22: chicken.process-context#command-line-arguments	 
        ruleta.scm:22: principal	 
        ruleta.scm:17: scheme#string->number	 	<--
#;1> (apostar-ruleta 13)
¡Has perdido! Ha salido el 30
#;2> 

Chicken Scheme proporciona también una aplicación que nos ayuda a depurar el código. Dicha aplicación depende de Tcl/Tk y debes tener instalado en tu sistema dicho entorno. Además, cuando compilamos, debemos establecer también el nivel de depurado:

> csc -d3 ruleta.scm
> feathers ruleta 13

Habitualmente se abre sólo la ventana de código, pero al pulsar <F3>, como se aprecia en la imagen, también podemos inspeccionar el valor de las variables.

Chicken Scheme es un sistema muy flexible y rápido. Proporciona herramientas sencillas de manejar y de poner a prueba y cuenta con una documentación bastante amplia. Muchas veces, mi forma de trabajar es ir haciendo pruebas al estilo REPL.

Mi entorno de trabajo es Emacs con el paquete Geiser y con eso me es suficiente. Pero hay quien necesita herramientas externas y un lsp⁶ que llevarse al editor. Chicken Scheme cuenta con la posibilidad de instalar su lsp. Sólo hay que ejecutar el comando:

> chicken-install lsp-server

Una vez instalado el servidor debes configurarlo para que funcione en tu editor favorito.