He comenazado a leerme el manual de introducción a Emacs Lisp, el cual es gratuito y se puede leer online aquí o descargar desde la misma dirección.

Así que voy a ir apuntando por aquí un breve resumen de lo que vaya aprendiendo, aunque no me gusta demasiado como está organizado el libro y voy a intentar solo anotar las cosas que realmente me resulten interesantes o crea que pueden llegar a aportar algo realmente

Listas

Lisp está basado en listas, un ejemplo de lista es el siguiente

  '(rose
    violet
    daisy
    buttercup)

Átomos

Cada uno de los elementos de las listas, separados por espacios en blanco se llama "atom", átomo. En el caso anterior rose, violet, daisy y buttercup serían átomos de la lista. Como buen átomo que se precie no se puede dividir en ningún elemento mas pequeño.

Pocas veces los programadores llaman átomo a los átomos, ya que se suelen referir a ellos por el tipo de átomo que es, por ejemplo string: '("texto entre comillas dobles") el texto entrecomillado con comillas dobles es un átomo de tipo string.

Listas vacías

Así que una lista en Lisp no es mas que una serie de átomos encerrados entre paréntesis. Aunque también podemos tener listas sin átomos, como por ejemplo () . Esto se llama "lista vacía"

Expresiones simbólicas

La representación de átomos o listas es llamada representación simbólica, Symbol Representation también denominada s-expression

Espacios en blanco

Los espacios en blanco no son tenidos en cuenta dentro de una lista, solo se usan como separados de átomos, pero independientemente del número de ellos. Los ejemplos siguientes representan la misma lista:

  '(atom1 atom2 atom3)

  '(atom1
    atom2
    atom3)

  '(atom1          atom2   atom3)

Ejecución de código

Cualquier lista en Lisp es un programa que se puede ejecutar. En la jerga de Lisp: evaluar.

Al evaluar una lista de lisp pueden ocurrir tres cosas:

  1. No hacer nada salvo devolver la propia lista
  2. Devolver un error
  3. Tratar el primer símbolo de la lista como un comando que realiza algo

En los ejemplos en los que hemos visto antes ponía una comilla simple delante de la lista, de está manera: '(lista de elementos) con esto se le dice al intérprete que debe devolver la lista tal cual. En el caso de no poder la comilla el interprete lo que intenta hacer es ejecutar el primer elemento de lista como una función. Como por ejemplo: (+ 2 2) que lo que haría sería sumar 2 + 2, ya que el primer símbolo + es la función de suma en Lisp.

Evaluando expresiones en Emacs

Para evaluar algo en emacs, lo mas sencillo es poner el cursor justo detrás de lo que queremos evaluar y pulsar la combinación de teclas C-x C-e. si por ejemplo tenemos dos listas una dentro de otra o queremos evaluar solamente un elemento de la lista podemos hacerlo colocando el cursor en el punto justo donde deseemos evaluar.

Por ejemplo con la siguiente lista: (+ 2 (+ 3 4)) si evaluamos después del último cierre de paréntesis el resultado devuelto será 9 pero si lo colocamos detrás del penúltimo cierre, el interprete nos devolverá 7 ya que estaremos evaluando solamente la expresión (+ 3 4) . Es mas, si evaluamos justo después del 4 nos devolverá 4, ya que los números se devuelven a si mismo al evaluarse.

Generar mensajes de error

En el ejemplo anterior, si evaluásemos el símbolo + nos devolvería un error. Emacs abriría un nuevo buffer donde podríamos ver la descripción del error.

Variables

Para ver el contenido de una variable no debemos meterla dentro de una lista, se debe evaluar fuera de la lista, por ejemplo en el caso de la variable fill-column que viene ya definida en emacs, para ver el contenido deberíamos evaluarla así fill-column . En el caso de que la evaluemos de la siguiente manera: (fill-column) obtendríamos un error, ya que estaría intentando ejecutar fill-column como si se tratase de una función.

Un par de ejemplo de errores serían los siguientes:

Evaluar una variable como una función

(fill-column)

Esto devolvería un error del tipo:

---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error: (void-function fill-column)
(fill-column)
eval((fill-column) nil)
elisp--eval-last-sexp(nil)
eval-last-sexp(nil)
funcall-interactively(eval-last-sexp nil)
call-interactively(eval-last-sexp nil nil)
command-execute(eval-last-sexp)
---------- Buffer: *Backtrace* ----------

Se puede ver que dice algo así como que no es una función.

Evaluar una función como una variable

Este es justo el caso anterior, en el que intentamos evaluar una función fuera de una lista, como por ejemplo evaluar el símbolo +

+
---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error: (void-variable +)
eval(+)
elisp--eval-last-sexp(nil)
eval-last-sexp(nil)
funcall-interactively(eval-last-sexp nil)
call-interactively(eval-last-sexp nil nil)
command-execute(eval-last-sexp)
---------- Buffer: *Backtrace* ----------

Sería mas o menos que se intenta ejecutar una variable que no lo es o que no está declarada como tal.

Argumentos

Como en muchos lenguajes de programación, a cada elemento que se le pasa a una función se le llama argumento. El numero de elementos puede ser variable y el tipo de elemento también.

Si pasamos un número de elementos erróneo para una función está devolverá un error. Lo mismo pasará cuando el tipo de argumento no sea el correcto. En el caso del tipado el error devolverá el tipo necesario seguido de "-p", esa p viene de predicate. Por ejemplo si requiere una lista dirá "lisp" si debe ser zero nos dirá "zerop"

La función message

Hay una función en emacs llamada message que sirve para pintar en el buffer de echo del editor. Un ejemplo de su uso sería (message "texto a mostrar")

Conclusión

He decidido no publicar mas en este post, no tiene ni todo el capitulo 1 del libro. Personalmente me resulta un tanto caótico, ya que salta de unas cosas a otras y te mete cosas como por ejemplo la función message cuando está hablando de variables, cosa que no comprendo. Así que lo mismo intento publicar posts un poco mas cortos pero mas centrados.