Seré breve. Encontré un paquete en Melpa que se llama plisp-mode y otro para autocompletado company-plisp. Los instalé los dos siguiendo sus correspondientes documentaciones. El código es sencillo:

(use-package plisp-mode
  :defer t
  :init
  (require 'inferior-plisp)
  :custom
  (plisp-documentation-unavailable t))
(use-package company-plisp
  :defer t
  :after company)
(add-to-list 'auto-mode-alist '("\\.l$" . plisp-mode))

Hay que tener en cuenta las siguientes aclaraciones. Tengo la instalación de PicoLisp de manera local. El paquete plisp-mode busca la documentación de manera global así que me aparecía constantemente un error por no encontrarla y desactivé la búsqueda de la misma activando la variable plisp-documentation-unavailable. También hice otras pruebas creando los enlaces necesarios para convertir la instalación local en global y seguía sin encontrar la documentación. Sin embargo, en la línea de comandos la documentación está disponible cuando inicias PicoLisp en modo debug.

Para leer la documentación desde línea de comandos, por tanto, hay que lanzar el REPL en modo depuración. El sistema leerá los html que componen la documentación utilizando el navegador w3m. Por ejemplo, llamando a la función (doc 'de), nos mostrará el contenido de la documentación de dicha función, llamando a dicho navegador de modo texto. w3m es, por tanto, una dependencia si quieres acceder a la documentación desde pil.

Por último, la convención dice que el código de PicoLisp se encuentra en archivos con extensión .l y añado dicha extensión, asociándola a plisp-mode en la lista de modos.

Es evidente la sintaxis de tipo Lisp con sus paréntesis en danza, pero para un programador de este tipo de lenguajes tiene pocas más semejanzas y hacerse una idea de lo que hace le obliga a utilizar su imaginación. Algunas funciones parecen sonar setq, loop... pero de en lugar de define, que admite una lista de parámetros con el formato Lst en lugar del habitual (...). Variables que comienzan con *, como *Name, mientras que otras no, como Lst. Es decir, hay un montón de idiosincrasias que hay que tener en cuenta.

La primera bofetada fue por su forma de establecer las variables. Lo de utilizar la primera letra en mayúsculas, por convención, pues tampoco es que me llame mucho la atención, o utilizar * para señalar las variables globales mediante un prefijo simple. Pero quizá algún programador de Lisp o Scheme entenderá mejor lo que quiero decir con este código:

: (setq A '(Este es su valor))
-> (Este es su valor)
: (put 'A 'clave1 'valor1)
-> valor1
: (put 'A 'clave2 'valor2)
-> valor2
: (show 'A)
A (Este es su valor)
   clave2 valor2
   clave1 valor1
-> A 

Sí, se pueden meter pares clave-valor como parte de cualquier «variable». Se introducen con put y se extraen con get. Más adelante veremos que tiene que ver con cómo se definen los símbolos dentro de la máquina virtual. Pero de primeras me sonó marciano.

Se puede apreciar que la definición de variables se utiliza setq, también las podemos definir con de, aunque con su propia idiosincrasia:

: (de ho "hola")
-> ho
: ho
-> ("hola")
: (ho)
-> NIL
: (de ho . "hola")
# ho redefined
-> ho
: ho
-> "hola"

La primera versión de ho, en ese código, puede no ser la deseada. De momento me ciño a utilizar setq para las variables y de para las funciones, para no liarme.

Luego me llevé otra bofetada aún más gorda con los números. Leí, así de pasada, que soportaba sólo operaciones de coma fija, por lo que hay que especificar el número de decimales cuando los necesitas. Bueno, no es algo extraño y ya lo había vivido en otro tipo de sistemas, como la calculadora de línea de comandos bc, pero el choque con la realidad fue un poco más traumático.

? (+ (* 3 4) 1)
-> 13
? 
: (/ @ 3)
-> 4
: (scl 3)
-> 3
: (+ (* 3.0 4.0) 1)
-> 12000001

¿Cómo? ¿Qué está ocurriendo? Pues sí, a los números hay que darles un poco más de cariño.

La cantidad de decimales se almacena en una variable global que se llama *Scl y podemos establecerlos con la función scl, como se aprecia en el código anterior. Pero se puede ver que internamente 3.0 se convierte en 3000 y 4.0 en 4000, al establecerse tres posiciones decimales. Y, por esto mismo, al multiplicar los números el resultado es 12.000.000, o expresado de otro modo: al multiplicar \(3 \cdot 10^3 \times 4 \cdot 10^3\) el resultado es \(12 \cdot 10^6\). Es decir, PicoLisp no tiene en cuenta automáticamente los decimales, sino que mantiene los enteros, pero escalados.

Con las sumas y restas no hay problema, porque los números cuando tienen una escala, se mantienen dentro de la escala, pero en las multiplicaciones y divisiones hay que compensar la escala. Para ello se utiliza la función */, que recibe tres parámetros numéricos y multiplica los dos primeros para luego dividir el resultado por el tercero. Por lo tanto, se utiliza la multiplicación o división por 1.0 para mantener la escala en orden:

: (+ (*/ 3.0 4.0 1.0) 1.0)
-> 13000
: (*/ 1.0 13.0 4.0)
-> 3250
: (format (*/ 1.0 13.0 4.0))
-> "3250"
: (format (*/ 1.0 13.0 4.0) *Scl)
-> "3.250"
: (format "3.25" *Scl)
-> 3250
: 

Después, se puede contar con la función format para convertir números en cadenas y cadenas en números.

Al principio, toda esta movida me parecía un sindiós. Luego, me puse a mirar cómo funciona el chismático y encontré los porqués y las explicaciones a todas estas idiosincrasias. Aunque estuvieron a punto de echarme para atrás.

Puesto que las primeras aproximaciones fueron un poco frustrantes, lo siguiente que hice es echar un vistazo a la documentación buscando por qué estaba pasando lo que pasaba. Os hago un resumen de lo que encontré y cómo funciona la máquina virtual de PicoLisp, que soporta los siguientes tipos de datos:

En base a la definición básica de cell, soporta:

• Los tres tipos de datos básicos: Números, símbolos y listas.
• Los tres tipos de símbolos: Internal, Transient y External.
• El símbolo especial NIL.

Un tipo de dato cell se define, como se ve en la siguiente imagen, en un conjunto de CAR y CDR. Algo que es común en los lenguajes Lisp.

El código se guarda en símbolos internos. Una definición de una función lo que hace es crear un símbolo cuyo valor es el código. No hay, por tanto, diferencia entre el tratamiento del código y de los datos, son equivalentes.

Para definir una función se utiliza normalmente una llamada a la función de:

: (de hola ()
   (prinl "¡Hola Mundo!"))
-> hola
: (hola)
¡Hola Mundo!
-> "¡Hola Mundo!"
: 

Pero el resultado sería idéntico si utilizamos setq:

: (setq hola '(() (prinl "¡Hola Mundo!")))
-> (NIL (prinl "¡Hola Mundo!"))
: (hola)
¡Hola Mundo!
-> "¡Hola Mundo!"
: 

Otro de los problemas, que me encuentro frecuentemente al escribir código, es el interpretar el ' como en Lisp o en Scheme. En PicoLisp el quote se aplica a toda la lista, no sólo al primer elemento. Esto me desconcertó un poco al principio y aún no me he acostumbrado del todo. Aunque también he aprendido que se puede forzar la evaluación de alguna expresión interna utilizando el carácter ~.

: '(1 (+ 2 3) 4)
-> (1 (+ 2 3) 4)
: '(1 ~(+ 2 3) 4)
-> (1 5 4)
: 

No hay macros explícitas, porque cualquier función puede devolver una cadena de texto, que si mantiene la sintaxis de PicoLisp, está generando código como lo haría una macro. Si vas a utilizar metaprogramación es conveniente que le eches un ojo antes a cómo evalúa el código la máquina virtual de PicoLisp.

Tampoco hay una expresión lambda, pues, como hemos visto al utilizar una función setq para definir una lambda, se puede generar una función anónima simplemente con quote:

(setq hola (quote () (prinl "¡Hola Mundo!")))

O por ejemplo:

: ('((X) (* X X)) 3)
-> 9
: ((quote (X) (* X X)) 9)
-> 81
: (setq f '((X) (* X X) ) )
-> ((X) (* X X))
: (f 3)
-> 9
: 

Si te molestan mucho los paréntesis los puedes agrupar utilizando [ y ]. Por ejemplo, la definición anterior la podríamos haber definido también como:

: (setq f '((X) (* X X]
-> ((X) (* X X))
: (f 3)
-> 9

Estos son los ladrillos básicos de PicoLisp. Algunos me ha costado cierto trabajo digerirlos, sin embargo, ha sido más por tener los procesos mentales acostumbrados a otro tipo de sistemas. Aún cometo muchos errores cuando escribo código, precisamente por esto. Aunque comencé estrellándome, confiado en mi conocimiento de Common Lisp y de Scheme, al mirar cómo está hecha la máquina virtual y «los ladrillos» de este sistema, me fue más fácil interiorizar cómo funcionan la cosas y cometer menos errores.

A partir de estos chismáticos básicos, PicoLisp proporciona algunas características interesantes, que dejo para futuros artículos:

• Soporte nativo de Programación Orientada a Objetos.
• Base de Datos orientada a almacenar objetos POO.
• Lenguaje de consulta de la BD basado en Prolog.
• GUI basado en html y su correspondiente servidor de aplicaciones.
• Sistema de debug incorporado
• Editor de código interno basado en vi.