Sí, como era de esperar hay paquete para trabajar con Nim en Emacs, se llama nim-mode... vamos por lo fácil: el código.

(use-package nim-mode            ; Modo mayor para NIM
  :defer t)
(use-package flycheck-nim        ; Comprobación del código al vuelo
  :defer t)
(use-package flycheck-nimsuggest ; Comprobación de código utilizando nimsuggest
  :defer t)
(use-package ob-nim              ; Paquete para ~org-babel~
  :defer t)
(add-hook 'nim-mode-hook 'nimsuggest-mode)

Nada complicado de entender, simplemente tener los paquetes en el sistema y añadir un hook para que active el modo nimsuggest-mode cuando se entre en un archivo nim. nimsuggest es una aplicación que viene con el propio Nim y que, como su nombre indica, hace sugerencias al código, tanto para el autocompletado como para la corrección de errores. Los paquetes de Emacs se sirven de él para realizar su trabajo. Sin embargo, en la misma documentación dicen que estos paquetes están en versión alfa y es posible que generen errores al utilizarlos. Yo, de momento, no me he encontrado mayor problema, pero es posible que con otra instalación sí los dé. Si notáis que se enlentece la respuesta de Emacs o se comporta de manera extraña al abrir archivos de Nim, pues tendréis ese bug. De todas formas es buena idea ir guardando el trabajo cada poco, no vayas a hacer tres módulos y 40 funciones, se te congele el editor y pierdas el trabajo de todo el día.

Intenté también instalar lsp pero me da un error al compilar el nimlsp y no he podido solucionarlo. Luego contaré cómo funciona el gestor de paquetes de Nim, que es similar a los de otros lenguajes.

Las teclas que más he utilizado han sido:

• M-.: Para saltar a la definición de algún elemento (procedimiento, variable, tipo...).
• M-,: Para regresar al punto desde el que saltaste con la tecla anterior.
• C-M-i: Llamar a company-nimsuggest para el autocompletado. Normalmente lo hace de manera automática.
• C-c C-c: compila y ejecuta un buffer de Nim.
• C-c C-d: llama a nimsuggest-show-doc, al hacerlo sobre un módulo de la librería general, abre un buffer de nombre *nim-doc* con la documentación de dicha librería.

Otro de los servicios que proporciona nim-mode es una pequeña ayuda o documentación corta que muestra en el minibuffer cuando situamos el cursor sobre algún símbolo o llamada.

Primero un clásico hola mundo algo más complejo que el habitual:

import system
const                # Más sobre variables y constantes más adelante
  a: int = 11
  b: int = 4
  c: float = 6.75
  d: float = 2.25

echo "a = ", a
echo "b = ", b
echo "--------------------"
echo "a + b = ", a + b
echo "a - b = ", a - b
echo "a * b = ", a * b
echo "a / b = ", a / b
echo "a div b = ", a div b
echo "a mod b = ", a mod b
echo "--------------------"
echo "c + d = ", c + d
echo "c - d = ", c - d
echo "c * d = ", c * d
echo "c / d = ", c / d
echo "--------------------"
echo "Hola Mundo!"
echo "--------------------"
echo "Eĥoŝanĝo ĉiuĵaŭde"

Apreciaciones sobre el código anterior:

1. No hay una función main explícita. Ese código se está comportando como si fuera un lenguaje de script, pero es compilado.
2. El indentado de los bloques de código, muy al estilo Python. Se puede apreciar en el bloque de definición de constantes.

3. Se declaran las variables con sus tipos. Se puede dejar al compilador que suponga qué tipo es, pero algunas veces por el valor no es suficiente. Por ejemplo:

   let
     enteroPequeño: int8 = 4
     enteroGrande: int64 = 4
     sinSignoPeque: uint8 = 4
     sinSignoGrande: uint64 = 4
   

   Esas cuatro variables, aunque todas contengan \(4\), son de diferentes tipos.

4. Los comentarios comienzan con el símbolo #. Además se pueden añadir también comentarios que la herramienta de construcción de documentación extraerá del código con ##. También se pueden realizar comentarios de múltiples líneas encerrándolas entre dos marcas #[ y ]#, o su equivalente para añadir documentación ##[ y ]##.
5. La importación de módulos se hace con import y el nombre del módulo. En el ejemplo se podría haber obviado, pues importa un módulo que ya está importado por defecto. Todo constructo público que se encuentre en el módulo será importado directamente.

La compilación y ejecución es sencilla, en el buffer de edición pulsa C-c C-c². Si eres más de línea de comandos o esperas algún error, lo mismo prefieres utilizar la consola de texto:

$ nim c -r holamundo.nim
Hint: used config file '/etc/nim/nim.cfg' [Conf]
Hint: used config file '/etc/nim/config.nims' [Conf]
.........................................................
Hint:  [Link]
Hint: gc: refc; opt: none (DEBUG BUILD, `-d:release` generates faster code)
26666 lines; 0.221s; 31.68MiB peakmem; proj: /home/notxor/proyectos/nim-pruebas/holamundo.nim; out: /home/notxor/proyectos/nim-pruebas/holamundo [SuccessX]
Hint: /home/notxor/proyectos/nim-pruebas/holamundo  [Exec]
a = 11
b = 4
--------------------
a + b = 15
a - b = 7
a * b = 44
a / b = 2.75
a div b = 2
a mod b = 3
--------------------
c + d = 9.0
c - d = 4.5
c * d = 15.1875
c / d = 3.0
--------------------
Hola Mundo!
--------------------
Eĥoŝanĝo ĉiuĵaŭde

La amplitud que proporciona un artículo, de tamaño razonable, no permite extendernos mucho sobre la metaprogramación, que se realiza fundamentalmente de tres maneras: generics, templates y macros.

Las funciones genéricas son funciones que se escriben para ser utilizadas con distintos tipos de datos. Se suele utilizar el tipo genérico T para identificarlos. Por ejemplo:

proc loQueSea[T](i: T): string =
  "El valor de i es: " & $i

echo loQueSea(42)

Los templates lo que hacen es crear plantillas. Lo que hace el ejemplo anterior sería una template pero utilizando también tipos genéricos. Por poner un ejemplo sencillo sin utilizar tipos genéricos podríamos definir un operador, tal que:

template `!=`(a, b: untyped): untyped =
  not (a == b)

assert(5 != 6) # reescribe el código a assert(not (5 == 6))

Y por último los macros son capaces de generar código al estilo de como funcionan los macros de Lisp. En el caso de Lisp el código generado era una cadena que se pueda pasar al intérprete del lenguaje, en el caso de Nim debe generarse un árbol sintáctico. Por ejemplo, a efectos de ver cómo es un árbol sintáctico y cómo se puede representar, copio aquí un ejemplo sencillo tomado del tutorial de la página del lenguaje:

import std/macros

macro myAssert(arg: untyped): untyped =
  echo arg.treeREpr

let a = 1
let b = 2

myAssert(a != b)

Los macros pueden recibir como argumentos bloques de código para hacerlos aún más potentes. Pero toda potencia implica también un poco de responsabilidad y si cualquier funcionalidad puede ser implementada a través de templates o generics, es mejor utilizas éstas y evitar el uso de macros en el código.

Por último, aunque los macros pueden iniciar procesos externos en la shell, no pueden llamar a funciones de C, excepto a las que ya contiene el compilador.

Nim me ha parecido un lenguaje lleno de posibilidades. Encuentro extrañas algunas decisiones de diseño, como el asunto de la equivalencia de nombres de variables y funciones, entre el camel case y el snake case y que se pueda llamar estaVariable o esta_variable indistintamente, dentro del código.

Es un lenguaje muy expresivo y aunque no puedo decir que lo domine, todos los ejemplos que he probado a hacer, especialmente para ir mostrando características mediante código para este artículo, han funcionado muy bien.

He tenido que dejar en el tintero muchas cosas, como la compilación cruzada entre sistemas, la capacidad de utilizar como objetivo procesadores concretos, poder embeber código en ensamblador, etc.

Quizá necesite afianzarlo más con algún proyecto de esos sencillos que me gusta afrontar para ponerme ante el reto de aprender un nuevo lenguaje con más profundidad. Como hice el raytracer en erlang o la implementación del algoritmo de cifrado RSA en Tcl. En estos días, un amigo me sugirió que hiciera algo sobre ajedrez otra de esas cosas que me gustan... así que a lo mejor le hago caso y os cansino un poco con ello.